Make Your First Task a Tracer Bullet
Build the skinny version through every layer first. Finishing one whole layer — the entire schema, or the whole API surface — feels like progress, but you haven't proven the one thing that matters: that a request can travel from the UI, through the API, into the database, and back. A tracer bullet does that on the first day, with almost no code.
What a tracer bullet actually is
The term comes from Andy Hunt and Dave Thomas in The Pragmatic Programmer: a tracer bullet is "a skeleton application in which one thin line of execution goes end to end." You pick one complete, demoable capability — "a user creates an account," "a message shows up in the feed" — and wire the thinnest possible path through every layer that feature touches: schema, API, UI, and a test that exercises the whole thing.
It only does one small thing. But every layer is connected, the deploy pipeline runs, and you can watch real behavior instead of imagining it.
Tracer bullet ≠ prototype
This is the distinction people miss. Both are small, but they have opposite fates:
| Tracer bullet | Prototype | |
|---|---|---|
| Code fate | Kept — becomes the skeleton of the real system | Thrown away after it answers a question |
| Scope | One feature, all layers, wired for real | One layer or one question, "all facade" |
| Purpose | Prove the path works end to end | Explore feasibility, performance, design |
| Quality | Production-lean, but real | Deliberately over-engineered is a waste |
A prototype is the reconnaissance you do before you fire. The tracer bullet is the first real round — you keep it and build the rest of the system around it.
Why it's the right first task for an agent
A vertical slice is the cleanest possible handoff. When the first task is a tracer bullet, every layer already has a working example: a migration to copy, an endpoint to mirror, a UI component that fetches and renders, a test that shows how the layers connect. An agent — or a teammate — can grab that pattern and finish the next feature without a design conversation. A half-built horizontal layer gives them nothing to imitate and a dozen unanswered integration questions.
Power moves
- Aim, then fire for effect. If the tracer misses — the auth boundary is wrong, the data shape doesn't fit the UI — you find out while the codebase is nearly empty and the fix is cheap. Late-discovered integration problems are the expensive ones.
- Make it automatically build, deploy, and test. Alistair Cockburn's "walking skeleton" is the same idea framed around infrastructure: the first slice should run through your real CI/CD, so the hard infrastructural problems get solved first, while there's still time.
- Widen the cut once the path is proven. After the skeleton walks, each new feature is just another thin slice through the same proven layers. You're no longer guessing whether the architecture holds — you're filling it in.
- Write the tracer as the first line item in the plan. For an agentic workflow, phrase task #1 as "one end-to-end capability, all layers," not "build the data model." The first framing produces a demo; the second produces a stall.
Resources
- Tracer Bullets vs. Prototypes — Andy Hunt & Dave Thomas (Artima)
- Tracer Bullets — The Pragmatic Programmer (chapter notes)
- Start with a Walking Skeleton — 97 Things Every Software Architect Should Know
Shipping with AI agents? Yeda AI designs, audits, and ships production LLM systems.