The toolkit: Agent Skills from this series
Every Agent Skill from the engineering-agents series, grouped by step, on one page.
Six steps. Thirteen principles. Thirteen Agent Skills.
This is part 07/7, and it has one job: put every skill on a single page, grouped by the step it belongs to, so you can find the right one in ten seconds.
It all started with 01/7 — Why fundamentals still matter: your agents aren’t dumb, they’re amnesiac. Every session starts from zero. Sixty years of software engineering lessons don’t load themselves. The skills below are how you hand that memory back.
The catalog, by step
1. Why fundamentals → 01/7
No skill here: this step is why the thirteen below exist. Encode lessons in the environment, not the prompt.
2. Start right → 02/7 — Start right
agent-kiss-thin-slice: the task is big and vague. Ship one thin, working slice before anything else.agent-unix-compose: one agent is doing everything. Split it into small single-purpose steps that pass text.agent-no-premature-opt: an agent wants to “optimize” something. No benchmark, no optimization.
3. Make wrong code impossible → 03/7 — Make wrong code impossible
agent-structured-control-flow: a function is growing nested branches, hidden returns, or flag variables. Flatten it.agent-deep-modules: a change in one place keeps breaking another. Hide the details behind a narrow interface.agent-design-by-contract: data crosses a boundary or a type allows nonsense. Encode the invariants so invalid states can’t exist.
4. Verify → 04/7 — Verify
agent-tdd-mutation-gate: an agent reports green tests and high coverage. Write the test first, then prove it with mutation testing.agent-independent-review: code is “done.” Have a fresh agent, with no shared context, review it against a checklist.
5. Scale without chaos → 05/7 — Scale without chaos
agent-brooks-law: you’re behind and tempted to spawn more agents. Check coordination cost first.agent-conway-law: you’re deciding how to split work across agents. Match the split to the architecture you want.agent-lehman-complexity: the codebase keeps growing and nobody is pruning. Budget complexity and schedule cleanup.
6. Don’t break what works → 06/7 — Don’t break what works
agent-chesterton-hyrum: an agent wants to delete “useless” code or change observable behavior. Find out why it’s there and who depends on it.agent-supply-chain-deps: an agent wants to add a dependency. Treat it as a security decision, not a convenience.
How to use them
Don’t load all thirteen at once. That’s the super-agent mistake from 02/7, wearing a different hat.
Pick by moment:
- Before writing code: thin slice, Conway, Brooks.
- While writing code: structured control flow, deep modules, contracts, Unix composition.
- Before merging: independent review, mutation gate, Chesterton and Hyrum, supply chain.
- Every few weeks: Lehman complexity, and a hard look at any “optimization” that slipped in.
Takeaways
- Agents don’t remember. Skills are how you make principles persistent.
- One skill, one principle, one trigger. If you can’t say when to use it, it won’t get used.
- Gates beat advice: a mutation score or a benchmark in the PR is worth more than a paragraph of guidance.
- The author shouldn’t be the reviewer, for humans or for agents.
- Start with three skills that match your current pain, not all thirteen.
Share this post