How it works
From a conversation to a company that is running
Five stages. You are in three of them. Nothing is generated before you approve a spec, and nothing reaches you before it has passed four verification stages.
Last updated
| # | Stage | What happens | Who decides |
|---|---|---|---|
| 01 | Intake session | You describe the business in a chat session: what it sells, who buys, how money comes in. No software is generated at this stage. | You. Every answer is yours. |
| 02 | Spec | The session turns your answers into a written specification — the data model, the workflows, the functions to cover first. | You approve it before anything is built. |
| 03 | Verified build | Generation runs in a per-project isolated sandbox, starting from pre-built, tested scaffolds. Then typecheck, tests, production build, smoke test — in that order. | Automatic. A failure triggers a repair loop, not a message to you. |
| 04 | Agents deployed | The agent workforce is deployed into the application: sales and outbound, customer support, marketing and content, back-office operations. Trained models are deployed alongside them. | You set the thresholds. Nothing above them moves. |
| 05 | Running company | Agents execute continuously. Each morning a report shows what was done, what needs you, and what the models predict. | You, for about fifteen minutes a morning. |
What do you actually approve before anything is built?
A specification, in writing, derived from your intake answers. It states the data model, the workflows, and which functions the agent workforce covers first. Generation does not start until you have read it. This is the point at which a wrong assumption is cheap to fix.
The reason this stage exists is that the expensive failure in generated software is not a bug — it is building the wrong thing correctly. A spec you can read in five minutes catches that. A finished application does not.
Why does newc0 start from a scaffold instead of an empty directory?
Because a model asked to invent project structure from nothing invents a different structure every time, and most of them do not build. Generation begins from pre-built, tested scaffolds, so the model modifies working software rather than producing a plausible arrangement of files that has never run.
That is also what makes the verification chain fast enough to run on every build. The starting point already compiles, so the work being checked is your business logic, not whether the project was assembled correctly.
How does the model change the code without breaking it?
It does not touch the code directly. The model proposes structured file-edit operations; a deterministic executor validates them and applies them atomically. The model never touches a filesystem or a network. If an edit is malformed, it is rejected before it is applied, not after.
Builds are immutable and content-hashed, so every version of your application is a fixed, addressable thing. Rolling back is a pointer change rather than a rebuild — which is why it takes effect immediately and cannot half-succeed.
The verification chain that runs after every edit is described in full on how an application is verified before it ships.
Where does the founder sit once the company is running?
At the approval gate. Agents execute continuously and queue anything that is binding, irreversible, above your spend threshold, or a matter of pricing or positioning. Realistically that is about fifteen minutes a morning — a typical morning, not a guarantee.
The full list of what agents run and what they never do without you is on the agent workforce page.
Questions people ask at this stage
How long does it take to get a working application?
- newc0 does not publish a build time, because the honest answer depends on what you asked for. What is measured is the verification chain that runs on every build: 37 seconds end to end on the marketing-site scaffold in a network-less sandbox. That is one scaffold, not a promise about yours.
What happens if the build fails?
- You do not see it. A failure at any of the four verification stages triggers an automatic repair loop, and the application reaches you only once typecheck, tests, production build and smoke test have all passed. An error message on your screen is not one of the outcomes.
Can I change the application after it is built?
- Yes, and you should — a company that never changes its software is not operating. Changes go through the same generation and verification path as the first build, and builds are immutable and content-hashed, so going back to a previous one is a pointer change rather than a rebuild.