Before you build anything you need the lay of the land: where to start, what you need, and what order to move in. This book runs in the exact sequence you build real software, each stage producing what the next one requires. Read it in order, run the prompts as you go, and you will never be stuck starting a stage without what it takes to finish it.
Fifteen Stages, One Path
Every chapter is a stage of a production lifecycle, ending with something real in your codebase:
- Set Up: A working agent, a chosen stack, and a running foundation app.
- Plan: A structured spec your AI agent can build from cleanly.
- Architect: A modular codebase layout that grows without rewrites.
- Build: Your application features, delivered in reviewable slices.
- Inspect: The core skill to open files, recognize patterns, and judge quality.
- Amplify: Real intelligence and agentic workflows integrated into your product.
- Debug: The systemic skill to unstick your agent when it loops.
- Test: An automated safety net that catches failures before users do.
- Automate: The operating system you and your agents run everything from.
- Harden: The rough edges rounded off into a complete product.
- Secure: An application that actively defends its data, endpoints, and users.
- Protect: User data handled responsibly, securely, and legally.
- Ship: Your software deployed live on real production infrastructure.
- Operate: A running system you can observe, monitor, and keep healthy.
- Scale: Growth without bottlenecks, knowing your system limits.
The first ten stages are free end to end. The final five, Secure through Scale, are the premium operations playbook: each opens with a free chapter, and the full suite unlocks together.
Each stage feeds the next, which is why the order is non-negotiable. You have a running application by the end of stage one, and every prompt after that operates on a real, evolving system.
All You Need Is a Computer and an Agent
This handbook assumes a completely fresh computer. Editors, keys, and cloud accounts arrive only when you actually need them. You need two things to start:
- A computer running macOS, Linux, or Windows.
- An AI coding agent. Stage 1 guides you through selecting and setting one up.
Your agent is the execution engine; this book is the supervisory judgment. It teaches what to demand, what prompts to run, and how to verify the output is solid.
Already have something half-built? A weekend app, a template, a project you inherited: you are not starting over. Stage 1 has a chapter that surveys what you own, scores it against these fifteen stages, and hands back a shortened reading list.
Follow the Stages in Order
Work through the handbook sequentially on your first pass. Because every prompt relies on the architecture built in previous steps, jumping ahead leaves your AI agent without necessary context.
One thing is not a stage at all. Your AI operating system, the rules, records, and agents that keep the app alive, is defined on your first day and gains a piece in almost every stage after:
| Stage | What it adds to your system |
|---|---|
| Set Up | Its definition, the standing rules, the work loop |
| Plan, Architect | The spec, the layout, the reasons |
| Build, Test | Gates that block bad work unattended |
| Automate | The crew, the board, the log, the schedule |
| Ship, Operate | Version stamps, verdicts on what worked |
So you never skip ahead to get it. Automation is only safe once you have done the work by hand and can judge what comes back.
After your first complete build, use this book as an operational manual. When a deploy fails or a database bottlenecks, jump straight to that chapter for the diagnostic prompt.
What to Build Now vs. What to Defer
One golden rule decides what to add: defer what is cheap to add later, invest now in what is brutal to retrofit.
If you could wire a component in an afternoon once users demand it, defer it. Building it early is over-engineering: solving problems you do not yet have. If skipping a practice now forces a painful rewrite later, set a baseline today.
- Defer: CI/CD, multi-region clusters, microservices, complex caching, all before real traffic.
- Invest now: Automated testing, modular boundaries, clear specs, version control, basic security defaults.
The Side-by-Side Workflow
Keep your agent open right next to this handbook. You read on the same screen where it runs, so each prompt goes straight into your repository as you finish a section, and your codebase advances in lockstep with your reading.
Prompts Are Starting Points, Not Gospel
Every prompt is a battle-tested template, not a rigid script. Copy it, then adapt the wording to your product and architecture; the judgment inside it stays constant.
The same holds for recommended stacks and tools: reliable defaults. When your agent suggests a better fit, trust the judgment taught here and adapt.
Short by Design, Deep on Demand
This book is intentionally lean: you no longer need 800 pages of syntax your AI can explain in seconds.
It concentrates on direction, architecture choices, and supervisory judgment. For deeper context on anything here, feed the chapter to your agent and ask follow-ups until it clicks.
