All 27, on one page
The system in eight steps, then one rule from each lesson. Made to be printed, or kept open while you work.
Print this pageThe same as plain textGive it to your agent
The system
- 1
Ask before building. The agent reads what exists, asks the blocking questions together, and records my decisions.
- 2
Create one source of truth. The PRD defines the product, its users, its limits, and the decisions only I can make.
- 3
Prove one complete user journey. A thin path through the interface, the logic and the database, before anything is made wider.
- 4
Split the project into slices. Each slice owns one end-to-end outcome. The repository carries verified state between fresh chats.
- 5
Coordinate specialist work. One lead agent assigns bounded tasks to builders and reviewers. Shared state records scope, diff, evidence, status and budget.
- 6
Run safely while I am away. A written contract sets permissions, permanent fences, exit tests, and the point where a person is needed.
- 7
Move through production gates. Review, automated checks, database readiness, deployment and a live check. Deployment alone proves nothing.
- 8
Turn failures into controls. Each serious failure is written up, then pushed as far toward a test, a permission, a hook or a database control as it will go.
One rule from each lesson
1Choose the problem
- 01Settle the unclear parts before building, and record the answers somewhere that outlives the conversation.
- 02Write one PRD for the project, keep it under version control, and start every agent from it.
- 03Cut work by what a user can do, never by technical layer.
- 04Build one thin, complete journey and test it end to end before you build wider.
2Assign the work
- 05Write the takeover packet after the work is verified, and write it for someone who knows nothing.
- 06Make the unit of work a verified outcome in the repository, so any fresh agent can continue from it.
- 08Give every agent one task and one owner, and keep the one who built it away from the one who approves it.
- 09Reach for the simple shape first.
- 10If several agents share a task, write down the state they all read from.
- 12Use a checklist when a checklist does the job.
- 26Route by how much it costs to be wrong.
3Set the boundaries
- 07Replace watching with writing. What you would have caught by looking has to be caught by a rule.
- 11Decide before you leave what the agent may never do, and make it stop when it gets there.
- 13Design the run so the most it can do without you is prepare a decision, or carry out one you granted in writing before you left.
- 16Assume anything an agent can print, it can read.
- 17Give agents a full copy of the shape of production and no route to the real thing.
- 18Check where a tool is pointing before it speaks, and fail loudly if the answer is not what its name promises.
- 19Database first, code second, and never rewrite a migration that has already run.
4Judge the result
- 14Make the thing you review small, single-purpose and tied to one exact commit.
- 15Treat "it works here", "it is deployed" and "it works for users" as three different claims.
- 20Use review that the builder does not control, and make it look at the running product.
- 21Measure at the boundary where the money is spent, and believe the party that sends the bill.
- 22Test for the thing that should happen. Silence is not a result.
5Make it stick
6What stays mine
What stays human
- Merging into the main branch
- Changing the production database
- Publishing
These three are mine. A low-risk internal prototype may need fewer. A product that handles money, personal data or public claims may need more.