Progressive Disclosure of Skills for AI Agents
I wanted to talk a bit about skills as they apply to AI agents.
Over the last few weeks (AI moves very fast), there’s been a lot of talk about Claude code skills. Skills are essentially specialized techniques you can write in plain text, which agents can then pick up and reuse.
What Is a “Skill” in This Context?
A skill is a reusable pattern or technique that encodes how to do something specific.
For example, if you’re creating a database in an exchange app using Prisma ORM with PostgreSQL, there are always a few minor annoyances an engineer has to fix every time a new project is set up. These are repetitive, low-level fixes that don’t really need to be rediscovered for every new setup. That’s a good candidate for a skill.
Another example: you might have your own backend that works in a very specialized way. Connecting to that backend requires specific knowledge and steps. That’s another skill.
As you move into larger organizations and enterprises, the number of such skills—embedded deep inside the organizational knowledge graph—is vast and largely untapped.
Why Progressive Disclosure Matters
Skills today are part of what’s called progressive disclosure for AI agents. This is fundamentally a context management problem.
Agents ultimately run on top of LLMs, and LLMs have limited context windows. Context sizes have grown a lot in the last couple of years, but models still tend to hallucinate or at least drift when working with very large contexts.
For example, if you give an LLM a very large file to fix, it may not get it right immediately because the relevant parts are too spread out in the context. What agents do well is manage that context: they hone in on the specific lines of code that need to be changed and only pass those into the LLM’s inner loops (the ReAct loops, etc.).
Progressive disclosure helps with this. Instead of dumping everything into one giant prompt—“You are a great engineer, here are 50 techniques you should always use…”—you disclose skills only when they’re needed. Even with good context management, a massive, monolithic prompt just doesn’t fit or work well.
Claude Code started with this idea, and now almost all CLI agentic tools have adopted some form of skills.
The Unsolved Problem: Rating and Surfacing Skills
There’s still a big open problem: who rates the skills, and how?
There are community projects where people share common skills, but I believe there is an extremely large set of skills lying untapped inside large enterprises. That’s where I’ve been experimenting.
Instead of a simple skills.md file, I’ve been moving toward a repository of skills that gets built up over time as the agent works.
For example, if the agent struggles with a piece of code and has to iterate a few times, it learns something in that process. Can that learning be captured and saved as a skill? Then, the next time the agent encounters a similar problem, it can look up that skill and say, “I already know how to do this; let me do it right from the start.”
Auto-Building a Skills Repository
In my setup, I can point my B-Book system at a broad codebase and say:
“Go ahead and start building up skills just by looking at this repository.”
From there, it can build hundreds or even thousands of skills for very large projects, and then reuse them when needed.
This already works to some extent, but there’s still a long way to go—in how we:
- Discover skills automatically
- Rate and prioritize them
- Surface the right ones at the right time
I mostly wanted to share this line of thinking and where my experiments are headed.