Learning path map
🧬 Anatomy of a skill
Procedure × Ability
🫥 Skill context cost
When to hide
🎓 The Teach skill under the hood
Skill with memory
🌳 Teaching that sticks
ZPD + recall
🔬 Grill-me & adversarial skills
Interview me
🔗 Chain skills + human DRY
Thinking pipeline
Detailed content
🧬 Anatomy of a skill
Every skill has two doors: procedure (you invoke it) and ability (the model invokes it). Knowing which one to use changes everything.
A package of instructions and processes that teaches the agent to do something in a specific way.
It’s the reusable unit: you write it once, and the agent repeats it correctly.
Skill = packaged knowledge + process.
Frontmatter (name, description, flags) at the top; body with the actual instructions.
The description is what the model sees to decide whether to invoke; the body is what it executes.
Description = trigger; body = execution.
A skill that only runs when you explicitly call it — you decide when.
Procedures don't expose descriptions and keep you in control of the flow.
Procedure = human invocation, fixed process.
A skill that the model itself decides to activate when it recognizes the situation in the description.
Abilities automate tasks, but require context — their descriptions are always loaded.
Ability = model invocation, autonomy.
The same skill can be exposed as a procedure or an ability—only the trigger changes.
Choosing the right door balances control, automation, and context cost.
Two doors to the same content.
Simple rule: do you want to trigger it manually (procedure) or let the model recognize it (ability)?
Keeps you from paying for context for automation you don’t even use.
Control → procedure; recognition → ability.
🫥 Skill context cost
Each skill costs context through its description. Knowing when to hide a skill is harness hygiene.
Every skill the model can invoke leaks its description into the context window, even when it's not used.
Context is finite; every loaded description takes up space and attention.
Description = fixed context overhead.
A hundred skills become a hundred descriptions competing for space in context.
Accumulating skills "just in case" degrades the performance of all of them.
More skills = more noise in the context.
`disable model invocation: true` → the skill only runs when you call it, without leaking its description.
Lets you keep the skill available without paying its context cost.
Hidden procedure = zero cost when idle.
Knowing which skills you have and when to call them can live in you, not in the context.
You become the living index of skills, freeing up the context window.
Human memory > loaded description.
Short, direct skills—minimal descriptions, focused content—cost less and trigger more reliably.
Too many instructions clog the context and confuse the model.
Less is more in the description and body.
Periodically review which skills are always loaded and cut the idle ones.
Auditing keeps the context clean and performance high.
Audit → hide → trim.
🎓 The Teach skill under the hood
The Teach skill is stateful: it stores local state and remembers you between sessions. See how it works under the hood.
A stateless skill starts from scratch every time; a stateful one keeps state between sessions.
Teaching that sticks requires memory—without state, there’s no continuity.
State = continuity between sessions.
A file that defines the learning mission: what you want to learn and why.
It gives the skill direction — every session knows where it's headed.
mission.md = persistent learning target.
A record of what you’ve learned, gotten right, and gotten wrong over the course of the sessions.
Lets the skill adapt the pace and review what hasn't stuck.
Learning history guides the next step.
The skill generates lessons in HTML — navigable material tailored to you.
Concrete, revisitable content beats an ephemeral chat explanation.
Lesson as a durable artifact.
State lives in local files—it doesn’t depend on the context window to remember.
Memory on disk survives resets and doesn’t use up context.
Disk = cheap, durable memory.
The Teach skill pattern — mission + log + lessons + state — works for any skill with memory.
You can recreate the concept for your own stateful skills.
Reusable skill recipe with state.
🌳 Teaching that sticks
Teaching effectively requires science: the zone of proximal development, knowledge as a graph, and active recall.
The space between what you already know and what you still can’t do on your own—where learning happens.
Teaching within the ZPD keeps you challenged without frustrating you.
ZPD = calibrated difficulty.
Knowledge is a network of concepts with prerequisites, not a linear list.
Mapping the graph reveals what to teach before what.
Nodes = concepts; edges = prerequisites.
The skill chooses a linear path through the graph: an order that respects prerequisites.
A good sequence prevents gaps and overload.
Graph → teachable linear route.
Questions that force active recall—remembering takes effort, which is why it sticks.
Active recall leads to much better retention than rereading.
Testing yourself > passively reviewing.
Review at increasing intervals, just when you’d almost forget.
It’s the most efficient method for long-term memory.
Spacing out reviews helps combat forgetting.
The skill adjusts the pace, examples, and reviews to your individual history.
Adapted instruction improves retention more than generic content.
Adapt to the student > one size fits all.
🔬 Grill-me & adversarial skills
The grill-me interviews you before coding—a short, powerful skill that replaces plan mode.
A game-changing skill: the agent interviews you, asking questions until it understands what you want.
Draws out the details you’re missing before the code comes out wrong.
AI asks; you answer; understanding improves.
Pocock uses grill-me instead of plan mode—an interview before any plan.
A plan based on wrong assumptions is worse than no plan.
Interview > plan in the dark.
The grill-me fits in 4-5 sentences—it’s tiny, yet it transforms the workflow.
Prove that a good skill doesn't need to be long; it needs to be precise.
Power through focus, not size.
The interview aligns you and the AI on the goal before a single line is written.
Correcting understanding at the start costs minutes; at the end, it costs rework.
Aligning early is cheap.
The result of grill-me is a shared understanding of the problem between you and the agent.
A shared understanding is what makes delegation work.
Same target image on both sides.
Because it’s so short, the grill-me is easy to adapt to your project and style.
A skill you customize becomes part of your personal harness.
Small = easy to customize.
🔗 Chain skills + human DRY
Chained skills become a thought pipeline—and anything you repeat 3 times should become a skill.
A pipeline: the grill-me extracts the vision, turns it into a PRD, which turns into actionable issues.
Each step delivers the next one ready — from idea to backlog without friction.
Interview → specification → tasks.
The output of one procedure feeds the next—skills fit together like links in a chain.
Chaining procedures creates reliable, repeatable workflows.
Procedures as links in a chain.
Between each procedure in the pipeline, you review and adjust before moving on.
The human at the right points keeps the pipeline on track.
Human checkpoints between stages.
If you’ve given the same instructions 3 times, it’s time to package them into a skill.
DRY (don't repeat yourself) applies to your own process, not just code.
Repetition = a missing skill signal.
A packaged skill can be shared so the whole team can use it the same way.
Skills become the team’s executable institutional knowledge.
Skill = shareable process.
Useful skills can be published and improved by the community (mattpocock/skills, aihero.dev).
You benefit from other people's skills and share your own.
Open source of skills composes.