How the machine works
A few engineers. A lot of agents. Your repo.
We run Claude Code sessions in parallel, each in its own git worktree, metered and reviewed. The agents do the typing. The humans decide what ships.
Seven stages. People hold four of them.
The numbers below are a real order, which is the only reason they are numbered. Every stage leaves an artifact in your repo, and the artifact is how you check that the stage happened.
stage 01the crew Spec
You describe the task. One of us turns it into a spec with a definition of done that a machine can check.
- you get
- A written spec with explicit non-goals, which you sign.
stage 02the fleet The fleet builds
Many Claude Code sessions in parallel, each in its own bay, each with a cost printed on it. Narrow scopes, so the bays do not collide.
- you get
- Branches. You see commits as they land.
stage 03the fleet Tests at the seam
Every branch comes back with tests and a diff. The tests run before a person spends a minute on it.
- you get
- A test run you can read, in the repo.
stage 04the crew A person reads every diff
A senior engineer reads the diff, runs it, and either merges it or sends it back with notes. If that engineer would be embarrassed by it in production, it goes back.
- you get
- Review notes on the branch.
stage 05the crew Merge
Nothing merges because a model said it was fine. A person merges it, with their name on the merge.
- you get
- A merge commit with a human author.
stage 06the crew Ship
A person deploys it and watches it. The fleet cannot deploy on its own. Then we stay for the warranty window.
- you get
- A URL, a repo, and a deploy log.
stage 07both, in the repo The runbook
How it is deployed, where the secrets live, what pages you when it breaks, and what to do when it does. Written for the person who inherits it.
- you get
- A runbook in the repo, plus the evals and dashboards it refers to.
You describe the task. One of us turns it into a spec with a definition of done that a machine can check. The fleet takes it from there: many Claude Code sessions in parallel, each in its own git worktree, each with a cost printed on it.
Every branch comes back with tests and a diff. A senior engineer reads the diff, runs it, and either merges it or sends it back with notes. You see commits as they land. Nothing reaches production without a person who would be embarrassed if it broke.
Six words carry most of that, and they are used the same way on every page of this site.
- the machine
- The studio as a whole, people and agents together. When we say the machine is running, there is a live fleet counter behind it.
- the fleet
- The orchestrated Claude Code agents, each in its own git worktree, metered. It does the typing.
- the crew
- The senior human engineers who review, own production, and sign releases.
- the seam
- Where an agent's work crosses into human review. Every diff crosses it. Nothing merges on the far side without a person.
- a bay
- One agent's isolated worktree. One unit of work in flight, with a cost printed on it.
- a load
- One scoped unit of your work, with a definition of done. One load, one price, one shipping date.
Four things, every time.
Every paid load ships with the same four things, whether it is a Sprint Zero or a month of retainer. They are not add-ons and they are not optional, because they are what makes the work ours to stand behind.
A test or eval harness that defines done, in the repo, run at the seam on every branch.
Logs, error tracking, and a dashboard your bookkeeper trusts. If it breaks, it says so.
Deploy, secrets, on-call, and rollback, written down for whoever comes after us.
Our promise: if something we shipped breaks in the thirty days after handover, we fix it. No invoice.
Four refusals.
Positioning is a set of refusals. These are ours, and any of them can be checked by asking.
We do not rent a head to your team by the hour. We ship a load with a definition of done, and you pay for the load.
A price before the spec is a guess with a signature on it. Sprint Zero exists so the price for the rest is not a guess.
We read the code before we quote a rescue. The scan comes first, then the ranked list of what can hurt you, then the number.
The fleet cannot merge, deploy, or delete on its own. Anything irreversible waits for a person. That rule is why we can put the fleet on your repo at all.
What it runs on.
Nothing exotic. If your product already runs on something else, we work in that. The list is here so you can check it against what you have.
- Claude Code
- The agents. Each session is one bay with one scoped task.
- git worktrees
- The bays. One checkout per agent, so branches cannot trample each other.
- Railway
- Hosting for the things we ship, including this site. Deploy logs you can read.
- Postgres
- The database, unless yours is already something else.
- Next.js
- The web framework for products and for this site.
- Playwright
- The browser tests that run at the seam, and the screenshots a person looks at before merge.
Who owns the code?
You do, from day one. The repo is in your account and we work in it. When we step back, nothing has to be handed over because you already have it.
Can I watch the work?
Yes. You see commits as they land, and the fleet page shows the job queue and what it costs. Ask on the call and we will add you to the board.
What happens when an agent writes something wrong?
It happens on most jobs. The tests catch some of it and a person catches the rest at the seam, and the branch goes back with notes. It does not reach your users.
Do you sign NDAs?
Yes, before you send the repo. Read-only access is enough for a rescue estimate.
How is it priced?
Fixed price per load, never hourly. Sprint Zero is $3.5k to $7.5k depending on scope and credits toward a retainer if you continue. Retainers run $5k to $15k a month. Rescue is quoted after we read the code.
What happens after you ship?
Our 30-day fix warranty on what we shipped, the runbook in your repo, and a retainer if you want the machine on your roadmap every week. If you do not, you keep everything and we go.
Does the fleet train on my code?
No. The agents work in your repo for your job, and we do not use your code to train anything. The fleet runs on accounts whose training setting is off, and we will confirm that setting in writing on request.