Seven days. Then the real thing.
Give us one narrow problem. In seven days you get a working slice, built by the fleet and reviewed by a person, with the build log public.
After that, if the slice earned it, a production-grade product in four to six weeks, built the way a small company can build this year: agents do the volume, a senior engineer owns the architecture, and you own everything.
Free. Application-gated, a few a month. You agree to a public build log.
- gate
- application, capped at a few a month
- build log
- public, your name and product withheld if you prefer
- you keep
- the URL, the repo, the runbook, either way
One narrow problem, one working slice.
Founders with a real problem and a decision to make soon. You bring the problem. We pick the slice small enough that seven days is honest: one workflow, one integration, or one screen.
It is free because it is also how we show the machine working. The build log is public, with your name and product withheld if you prefer, and it includes the parts that went badly.
It is application-gated and capped at a few a month, because a free build that is not scoped well is a favor to nobody. Not every application is accepted, and we say why when it is not.
A call. We agree the one problem, the one screen or workflow, and what done means. Written down before anything is built.
The fleet builds in parallel, each agent in its own bay with a cost printed on it. A senior engineer reads every diff. Commits land in the public log as they happen.
Deployed where you can use it. Tests in the repo. The runbook written.
A call. What we built, what we found, what we would build next and what it would cost. You keep everything either way.
Seven days counts from the first call, and it assumes you answer messages.
A URL, a repo, and a runbook.
Whether or not you continue, the slice is yours. The repo is yours. The build log stays public because that was the deal.
- One workflow, one integration, or one screen, deployed where you can use it.
- The fleet's task log, test results, and cost per task on a public build page.
- A follow-up call where we tell you what we would build next and what it would cost.
- Application-gated and capped at a few a month. Not every application is accepted.
- You agree to a public build log, with your name and product withheld if you prefer.
- Not a full product. A slice with an end, chosen so that seven days is honest.
A production-grade product in four to six weeks: the fleet does the volume, a senior engineer owns the architecture, and you own everything.
Pre-seed to Series A founders who need to ship and then keep shipping without hiring five engineers.
Quoted after Sprint Zero or a 7-day build, when the scope is honest. The quote is fixed, the scope is written, and the non-goals are written next to it.
Then, if you want it, a standing slice of the machine to keep shipping after launch, at $5k to $15k a month.
Tell us the product in two sentences. A human engineer reads every message and replies within one business day, Pacific time. You get a scope and a price, or the two questions we need first.
- time
- four to six weeks, a plan with dates
- the volume
- the fleet, in parallel bays, metered
- the architecture
- a senior engineer, who reads every diff
- deployed on
- your infrastructure; you own everything
- Product spec and a design system you can extend.
- A full-stack build with evals and CI, deployed on your infrastructure.
- Analytics, a security baseline, and the house standard: evals, observability, a runbook, a 30-day fix warranty.
- Then, if you want it, a standing slice of the machine to keep shipping.
- No fixed quote without a spec. Sprint Zero is how the spec gets written.
- No guaranteed launch date. A plan with dates, and the truth on the day one moves.
- Not everything in the roadmap. The first version your customers asked for.
Every load ships with the house standard: evals, observability, a runbook, a 30-day fix warranty.
Evals
A test or eval harness that defines done in a way a machine can check, kept in the repo.
- lives in
- the repo
- checked by
- a machine, before merge
Observability
Logs, metrics, and an error monitor you can open without us.
- you get
- logs, metrics, an error monitor
- opened by
- you, without us
Runbook
A written runbook: how to deploy, how to roll back, what pages whom, what the bill is.
- covers
- deploy, roll back, who gets paged
- states
- what the bill is
30-day fix warranty
Anything we shipped that breaks within 30 days, we fix without a new quote.
- window
- 30 days from handover
- cost
- no new quote
The fleet does the volume. A person owns the shape.
You describe the product. 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 coding 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. Nothing reaches production without a person who would be embarrassed if it broke.
Coding agents write most of the code. They also write most of the bugs. We keep the first and catch the second.
The fleet
The typing: scaffolding, screens, tests, the first draft of everything, in parallel, all night, metered.
A senior engineer
The architecture, the data model, the review of every diff, and the decision about what to trust.
You
Everything. The repo, the infrastructure, the runbook, the domain. There is no license and no lock-in to us.
Watch the fleet to see what that looks like on a real job.
Bring the problem.
Two sentences: what it is, who it is for, what should be true in seven days. A human engineer reads every message and replies within one business day, Pacific time.
Free. Application-gated. Public build log.
Fixed price, $3.5k to $7.5k. Credits to a retainer if you continue.