# The Solo Builder's AI Agent Workflow, From Idea to Release

> A repeatable workflow for building software alone with AI agents like Claude Code: idea, plan, phases, sessions, review and release — without losing the thread.

- URL: https://shotmatic.app/blog/ai-agent-project-workflow
- Category: AI Agent Workflow
- Published: 2026-09-27
- Author: Tu Nguyen

## Key takeaways

- With AI agents, typing code is no longer the bottleneck — remembering where every project stands is.
- A good agent workflow has six steps: capture the idea, write a short plan, split it into phases, run one session per task, review, then release a small version.
- Keep the project's memory in files committed to the repo, not in chat history, so any new session can pick up the work.
- Decide in writing what you will not build; agents add scope unless told not to.

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:

1. Deciding **what** to build and, just as important, what not to build.
2. Writing it down so an agent can act on it.
3. Reviewing what came back.
4. 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](https://shotmatic.app/blog/brainstorm-app-ideas-with-ai).

## 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](https://shotmatic.app/blog/wont-do-list-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](https://shotmatic.app/blog/phases-not-todo-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:

```text
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](https://shotmatic.app/blog/memory-lives-in-files).
- **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](https://shotmatic.app/blog/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](https://shotmatic.app/blog/run-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.

## FAQ

**What is an AI agent workflow for software development?**

It is the repeatable path a project takes from idea to release when an AI coding agent does most of the typing: a written plan, work split into phases, one agent session per task, a human review, and small releases. The human decides; the agent executes.

**Do I need a special tool to follow this workflow?**

No. Everything here works with plain Markdown or JSON files in your repo and the Claude Code CLI. ShotMatic only makes the state of many repos visible on one screen and turns resuming a session into one click.

**How big should one agent task be?**

Small enough to finish and review in one sitting — usually one screen, one endpoint or one chapter. If you cannot describe the finished state in one sentence, split it.