Principles
Twenty-three engineering principles, each a short rule with a test the agent runs on its own work. Name one to steer.
The engineer skill carries 23 principles, one file each, and the operating manual indexes them by name. You don't invoke them. You use their names to steer, because each name points at a complete rule the agent has already read. When a principle changes a decision, Kevin says which decision; a principle cited with no decision behind it is name-dropping.
you > apply laziness protocol. delete the obsolete adapters first.
you > prove it works. run the real import and show me the written rows.
you > separate before serializing shared state. own worktree per attempt, no locks.Core
| Principle | The rule |
|---|---|
| Laziness protocol | Prefer deletion and the smallest change that solves the problem; keep call chains flat |
| Foundational thinking | Get the data structures right first, and scaffold before features |
| Redesign from first principles | Fold a new requirement in as if it had been there on day one |
| Attack the premise | After two failed fixes on one premise, write the premise down and count who holds the imbalance |
| Subtract before you add | Remove dead weight first, then build on the simpler base |
| Minimize reader load | Fewer layers and less hidden state; "where does X come from?" in 30 seconds |
| Outcome-oriented execution | Converge on the end state instead of preserving throwaway intermediate ones |
| Experience first | The user, the caller, and the next maintainer beat implementation convenience |
| Exhaust the design space | With no precedent, build two or three whole shapes and compare |
| Build the lever | Script the edit or the proof, so a reviewer can rerun it |
Architecture
| Principle | The rule |
|---|---|
| Model the domain | A state machine, table, or typed model instead of scattered conditionals |
| Boundary discipline | Validate at the edges, trust types inside, keep logic pure |
| Type system discipline | Make illegal states unrepresentable, brand ids, exhaust every variant |
| Make operations idempotent | Safe to run twice, and safe again after a crash halfway |
| Migrate callers, then delete legacy APIs | Move every internal caller and drop the old API in one wave |
| Separate before serializing shared state | Give each concurrent writer its own target before reaching for a lock |
Verification
| Principle | The rule |
|---|---|
| Prove it works | Check the real artifact, and say how far up the proof ladder you got |
| Fix root causes | Reproduce, ask why, and never add a guard that silences the crash |
| Sequence verifiable units | Each small unit ends green before the next; the failing test lands before the fix |
| Test behavior, not implementation | A test that still passes when every import returns undefined gets rewritten or deleted |
Delegation
| Principle | The rule |
|---|---|
| Guard the context window | Bulk reading goes to subagents; only summaries come back |
| Never block on the human | Reversible work proceeds and gets shown; anything irreversible or outward-facing still waits for you |
Meta
| Principle | The rule |
|---|---|
| Encode lessons in structure | A rule needed twice becomes a type, a test, a lint, or a hook |
The principles are adapted from pstack (MIT).
Skill
One skill routes every kind of code task to a playbook, pull requests included, applies the engineering principles, and runs a comment pass before you see the diff.
Design and review
How much design a change deserves, and the tools for each rung: architect, arena, swarm, interrogate, and a second model on your work.