Building with an AI agent feels fast for the first week. Then you have four projects, eleven half-finished Claude sessions, three repos you haven’t pushed since Tuesday, and every morning starts with “wait, where was I?”
The agent is not the bottleneck anymore. Your head is. This post is the workflow we use — and that ShotMatic is built around — to keep shipping when an agent writes most of the code and you run more than one project at a time.
It is the first part of a short series, The ShotMatic Method. Each step below links to a deeper post.
The shift: from writing code to steering work
When you code by hand, the plan lives in your head because you are the one executing it line by line. When an agent executes, the plan has to live outside your head — somewhere the agent can read it, and somewhere you can read it back after a weekend away.
That changes the job. A solo builder with agents spends their time on four things:
- Deciding what to build and, just as important, what not to build.
- Writing it down so an agent can act on it.
- Reviewing what came back.
- Keeping track of many of these loops at once.
The rest of this workflow is about making those four cheap.
Step 1 — Capture the idea in one paragraph
Before any session starts, write one paragraph: who it is for, the one problem it solves, and what “done” looks like for a first version. If you cannot write that paragraph, the idea is not ready for an agent yet — it is ready for a brainstorming session.
Step 2 — Write a short plan, including a “won’t do” list
A plan for an agent is not a spec document. It is a page with:
- Goal — the paragraph from step 1.
- Phases — 4 to 10 named stages from empty repo to release.
- Won’t do — features you deliberately leave out of this version.
The last section matters more than it looks. Agents are eager; ask for a login screen and you may get password reset, OAuth and a settings page. A written won’t-do list stops that scope creep before it starts.
Step 3 — Split the work into phases, not a to-do pile
A flat to-do list tells you what is left. A phase tells you where you are: Phase 5/9 · build EPUB
is something you can read in half a second across ten projects. We go deeper on this in
Phases, not to-do lists.
For each phase, keep exactly one next step written down. That single line is what you — or the agent — act on next time.
Step 4 — One task, one session, one state file
Give every task its own agent session, and make the session start by reading a state file in the repo:
Read plan/state.md first. We are on Phase 5/9 (build EPUB).
Next step: fix the broken table of contents links in chapter 7.
Update plan/state.md when you finish.Two rules make this robust:
- The file is the source of truth, the chat is a convenience. Sessions get lost, machines change, context windows fill up. The file in the repo survives all of that. See Memory lives in files, not chats.
- The agent updates the file, not you. End every task by asking the agent to write the new phase and next step. You review it like any other diff.
Step 5 — Review like an editor, not a typist
Your review is short but not optional: run it, read the diff, check the state file says something true.
If the agent claims a phase is finished, ask what you would check to prove it — “npm test passes”,
“the store listing has five screenshots” — and check that.
Mark the task done only after the check. Undoing a wrong “done” is cheap; discovering it two weeks later is not.
Step 6 — Release small, then carry the rest forward
Ship a version as soon as it does one useful thing. Whatever is unfinished moves into the next version’s plan instead of blocking this one. Ship small versions covers the release rhythm, changelogs and how to carry work forward without losing it.
Doing this across many projects
One project with this workflow is easy. Five is where it breaks — not because any single loop is hard, but because you now have to remember five phases, five next steps, five sessions and five git states.
That is the problem running 10 projects in parallel is about, and it is the reason ShotMatic exists: every repo’s phase and next step on one screen, the exact Claude session for each task one click away, and every dirty repo visible before you close the laptop.
The workflow on one card
| Step | You write | The agent does | Lives in |
|---|---|---|---|
| Idea | One paragraph | — | plan/idea.md |
| Plan | Goal, phases, won’t-do | Suggests phases | plan/plan.md |
| Phase | Next step | Executes it | progress.json / state.md |
| Session | Starting prompt | Reads state, works, updates state | Claude session |
| Review | The check | Fixes what fails | git diff |
| Release | Version notes | Drafts changelog | CHANGELOG.md |
File names are only examples — use whatever your repos already have. What matters is that each row has a home that is not your memory.
