Most people use a powerful model like a smart typewriter: type a prompt, get a paragraph. It works, but it starts from zero every time. The next session doesn't remember the last one. Quality drifts — sharp today, sloppy tomorrow. Verification gets skipped because it "looks done." That's not a problem with the model. It's the absence of an operating system around it.
A skill closes exactly that gap. A skill is a named, reusable procedure that the agent recognizes and picks up automatically the moment the situation calls for it. Not "a prompt you have to remember and paste in," but a built-in reflex: see the trigger, run the procedure the same way you did last time. One skill is one discipline. A stack of skills is an operating system.
The difference between a chatbot and an operating system isn't that the model is smarter. It's that there are repeatable procedures around it that you don't have to reinvent every time.
This piece isn't about a specific tool, and it's not an ad. It's an architectural map: what categories of skills exist, why each one matters, and how to build your own stack out of things you're already doing by hand every day. At the end there's an interactive catalog of our real stack, combed down to patterns (with our internal plumbing scrubbed out), so you can steal the structure instead of copying someone else's infrastructure.
01 · Anatomy of a skill: why it's not just a prompt
A saved prompt is passive. It sits in a note waiting for you to remember to pull it out. Half the time you don't — and it's exactly when you need it most (under pressure, at 1am, when "close enough" starts sounding fine). A skill is active. It has three parts:
- Trigger — the condition that switches the skill on by itself: "a new session is starting," "the change touches the UI," "the owner sent a second correction on the same task." The agent watches for triggers instead of waiting for a command.
- Procedure — the concrete steps, the same every time. This is where quality actually lives: not "try to check it," but "open the page in a browser, take a screenshot, confirm zero console errors."
- Done criterion — the point at which the procedure counts as complete. Without it, the agent stalls out at "probably fine."
There's no magic here. A skill is a self-triggering checklist. But the self-triggering part is what makes the difference: it moves discipline out of your memory and into the system. And the system doesn't get tired or rush at 1am.
02 · Five floors of the operating stack
Skills naturally sort into five layers. That's the whole frame — fill in each floor for your own work, and you have an operating system instead of a pile of prompts.
| Floor | What it does | Problem it closes | When it fires |
|---|---|---|---|
| Session | Start, memory, planning, self-check | The "amnesia tax": relearning context every time | start / end of work |
| Quality | Gate before anything goes out the door | Quality drift; "looks done" ≠ done | before shipping / deploy |
| Ship | Get the artifact live and unbroken | "Works locally" ≠ "works in prod" | release |
| Evolve | Makes every next session a bit better | Same rake, once a week | weekly / autonomous |
| Content | Economics of producing long-form text | An expensive model doing cheap work | writing long-form |
The order isn't arbitrary. Session and Quality are the foundation: without them, everything else stands on sand. Ship is the hands. Evolve is what separates a system that's frozen from one that grows. Content is the applied layer on top (for us that's writing; for you it might be code, design, analytics).
03 · Live catalog: our stack, combed down to patterns
Below are the real skills we use every day, grouped by the five floors. Descriptions are generalized to patterns: infrastructure, client names, and internal paths are stripped out — what's left is the shape, which you can transplant onto any stack. Filter by floor or search by keyword.
Stack by floor
Each card: what it does · when to reach for it. Click a floor or type a query (e.g. "memory," "browser," "night").
04 · How to build your own stack in a week
You don't need to sit down and design a system from scratch — that's the same perfectionism that kills the start. A stack grows from the bottom, out of pain. A practical recipe:
- Spend a week catching repeats. Every time you catch yourself thinking "I already explained this to the agent" or "I forgot to check again" — write it down. By the end of the week you'll have 5–10 candidates. Those are your first skills: the pain already showed you where they're needed.
- Start with two floors. Session (one bootstrap skill that loads context at the start) and Quality (one gate that forces a check before "done"). These two give you 80% of the effect.
- Write a procedure, not a wish. Not "check the quality" — concrete steps with a done criterion. A skill is worth exactly as much as the specificity in its procedure.
- Add a trigger. Describe in words when the skill should switch on by itself. That's what turns a note into a reflex.
- Let the stack grow. Once a week, 15 minutes: what worked, what's missing, what new pain has become a skill. That's the Evolve floor in action.
Honesty and limits
A few honest caveats so this doesn't sound like a silver bullet:
- A skill isn't a guarantee. A badly written procedure produces badly done work — reliably and fast. A skill amplifies discipline if it already exists; it doesn't create it from nothing.
- A stack has maintenance cost. Twenty skills nobody revisits quietly rot: triggers go stale, steps reference things that no longer exist. The Evolve floor isn't a luxury — it's the condition that keeps the rest from turning into a museum.
- Our stack isn't a template. It grew around specific work (writing, publishing, client deliverables). Copying our skills verbatim is pointless — copy the taxonomy and fill it in around your own pain.
- The numbers here come from our own experience M, not a controlled study. "2–3× the quality" is an observation from our own sessions, not a lab metric. Your mileage depends on how concrete your own procedures are.
But the direction is solid H: the difference between people who "use AI" and those for whom AI actually multiplies output isn't access to the model (that's the same for everyone) — it's the operating system built around it. Skills are the cheapest way to build that system.