The loop I run now...

CLAUDE CODE · AGENT WORKFLOWS

I did not lose evenings to Claude Code because the model was weak. I lost them because nothing in the session was allowed to be finished.

A feature would start as a sentence. Then a second sentence to correct the first. Then a 400-line diff I skimmed the way you skim a terms-of-service page. By midnight I had a branch named after the idea and no commit I trusted.

The missing piece was not a better prompt. It was a written contract for what “done” meant — and a way to hand that contract to more than one agent.

The prompt is a request. The spec is a contract.

A prompt lives in one session. A spec lives in the repo.

Once the acceptance criteria are in a file, you can stop re-explaining the feature every time context fills up. You can also split the work:

  • one agent writes the spec
  • one implements only what the spec allows
  • one reviews the diff against the spec, not against the implementer’s story
  • one writes and runs tests that prove the behavior

That last point matters more than the tooling. A reviewer that watched the code get written will defend the approach. A reviewer that only sees the spec and the diff has a job: find the gap.

Try this tonight before you buy anything. Write a one-page spec for a real ticket. Open session A and say: implement only what this file allows, in small commits. Open session B with a fresh context and say: review this diff against the spec and list gaps. That two-session split is the whole idea.

Four jobs, not one overloaded chat

Spec — Define the problem, clarify requirements, and plan the smallest shippable slice. If it is not in the spec, it is not in the PR.

Build — Implement only that slice. Clean, boring code. No drive-by refactors. No “while I was here.”

Review — Fresh context. Compare the diff to the contract. Flag scope creep, missing edge cases, and standard violations.

QA — Tests, regressions, and the checks you skip at 1 a.m. when the model sounds confident.

/spec → /build → /review → /qa → /ship

Routing is part of the design. Mechanical work does not need the expensive model. Design and adversarial review do. You keep the human where judgment still belongs: accepting the spec, reading the review, and pressing ship.

Why wiring this yourself takes longer than the files suggest

GitHub is full of free subagent markdown. The files are short. The opinions inside them are the work.

What actually burned my time:

  • getting four agents to hand off through one spec file instead of a pile of chat summaries
  • slash commands that drive the sequence in order, not as four disconnected macros
  • hooks that block destructive commands without firing on false positives
  • deciding what lives in project memory versus feature memory so context loads instead of being retyped

If you enjoy that kind of systems work, build it. Measure it with /cost. Keep what saves you commits, delete what does not.

If you would rather start from a pipeline that already has those opinions baked in, that is the kit I packaged after running this on my own iOS and tooling work.

What Ship It Solo actually is

Disclosure: I made this. It is a one-time download, not a subscription, and it will not replace your review. It only makes the review smaller.

Ship It Solo is a 30-file Claude Code kit that installs as one system:

  • Four subagents — Spec, Build, Review, QA. Each has a single job and a shared spec as the contract.
  • Five slash commands — /spec, /build, /review, /qa, /ship. Same sequence every feature.
  • Four guard and automation hooks — plus a paste-ready settings fragment. The installer never writes your settings.json for you.
  • Layered CLAUDE.md memory — templates, a worked example, and a split between project memory and feature memory.
  • Five playbooks — exact command sequences for a new feature, a bug hunt, a refactor, a test backfill, and a release.

The installer is idempotent, supports --dry-run, and backs up anything it touches as .bak. There is an INSTALL.md if you do not want to run a stranger’s shell script — a completely reasonable position. There is also a WHEN-THIS-FAILS.md, because it will fail on some repos and I would rather tell you where than pretend otherwise.

$26 · one-time · install in about 10 minutes · current price checked September 2026.

Get Ship It Solo →

Who should skip it

Do not buy this if:

  • you do not already use Claude Code
  • you want a no-code “agent team” that ships without you reading diffs
  • you already have a pipeline you trust and you are only collecting kits
  • you expect subagents to replace human review

The kit shrinks the surface you have to babysit. It does not delete the babysitting.

A useful test before you spend $26

Pick one ticket you have been bouncing between sessions. Write the spec first. Force the implementer to stay inside it. Give the reviewer a clean context. If that already feels like a different job than “keep prompting,” you understand the product.

If you want the commands, hooks, memory split, and playbooks instead of assembling them on a Sunday, the kit is here:

https://zerix1.gumroad.com/l/ship-it-solo

Your turn: what do you re-explain to Claude every session that should have been a file by now?

About this post. I am Jerry PM. I build iOS apps by day and small developer tools at night. Related reading: Prompts Don’t Ship on Medium, and the other Claude Code notes on this site. Questions about the kit belong on the Gumroad page so other buyers can see them.