Phase 0, 1 and 2
Ask an AI agent to plan a feature and, unless you tell it otherwise, you often get something like this back:
“We can build and deploy this in three phases, starting with phase 0 this week, then phases 1 and 2 over the next two weeks.”
Ten pull requests. Three weeks. Feature flags to hold the half-built parts apart, environment variables for the in-between states, a migration that gets rewritten twice.
I look at the task and I know that this was a good plan three years ago. Today, by the time I am done prompting in two hours, phases 0 to 2 will be built, tested and ready to deploy. So I write back: please just bundle it all in one PR.
The agent is not being stupid. It learned how software gets built from millions of pages written before agents existed: books on Scrum, blog posts about small pull requests, a decade of advice to slice everything thin. You can see the same thing in its time estimates. Ask how long something will take and it still answers in human days and weeks, for work it will finish before your coffee is cold. It plans for a world where a person types every line, because that is the world it read about.
And for that world, the advice was good. For most of the history of our industry, software was incredibly expensive to build. Humans had to write every line, it took a long time, and coordinating all the people with shovels was a job in itself. We have seen it go wrong at every scale: small projects inside our own organisations that ran months late, and national health platforms and government IT systems that ran years over schedule and vastly over budget.
Almost every modern way of working came out of those failures. Scrum, Shape Up, the MVP, small pull requests: they are all ways to make expensive, risky work smaller, so that each mistake costs less. They served a real purpose, because building software was that hard.
That plan is right for a world that is gone. I wrote about that kind of rule in It Wasn’t Wrong. This post is about what replaces it.
Two Ways to Make a Statue
The name is not mine. My brother Johan, who co-founded AutoUncle and now builds in our codebase, told me a few weeks ago that he wanted to try a new way of working with his team next quarter. He called it sculpturing, and he showed me the three drawings at the top of this page. I told him I was going to steal it. This is me stealing it.
It stuck with me because it finally gave me a picture for something I have been arguing for a long time, without a good name.
There are two ways to make a statue. The first is casting. You make a mould for the arm, cast it, let it cure. Then the torso, then the head. Then you glue the parts together and hope they fit. Each part is small and safe on its own. Most of the time goes into the moulds and the joints, not the statue.
That is how we have built software for twenty years. User stories sliced thin, a minimum viable product, small increments, each one a mould. Each made sense on its own. Together they made a process where most of the effort went into the scaffolding between the pieces.
The second way is carving. You bring out the whole block of stone and take away everything that isn’t the statue. The figure is there from the first day. It is rough, but all of it is there, and every hour of work makes all of it better at once.
The first pull request is no longer a micro-increment. It is the whole block of stone.
Step One: The Rough Block
In sculpturing, the first pull request holds the full vision. Not the whole thing polished. The whole thing roughed out: every screen, every model, every integration, in a shape you can run and look at.
It is also why I keep pushing back on the MVP. Its purpose is still right: get something real in front of people fast and learn from it. But when building gets this much faster, “minimum” can be far more ambitious than it used to be. At Future Product Days this autumn I put it on a slide as MVP → full vision, then validate. One of our projects went from idea to seventy thousand lines of production-ready code in two weeks. That is not a minimum viable product. It is a block of stone.
Why the Agent Gets the Block Right
This only works because of how agents build, and it is the part people find hardest to believe.
A human developer can hold a few files in their head at once. That is why we sliced work thin: each slice had to fit in one person’s working memory, and in one reviewer’s attention span. An agent has no such limit. It can hold the whole feature in its context at once: the data model, the screens, the API, the tests, the edge cases, and how they all touch each other.
Give it the whole vision and it designs every part knowing what the others need. Feed it one slice at a time and it has to guess. It builds the mould for the arm without knowing what the body looks like, and then you spend the next two phases sanding down the joints. The joints are where things break.
This is not just my experience. Anthropic has been saying the same thing about their own models for a while now: stop micro-instructing, set the goal, and let a capable agent work out the steps. Their prompting guide tells you to prefer general instructions over prescriptive steps, because the model’s reasoning often goes further than the plan a human would write for it. Their guide to better prompts has a section called “State the outcome, not the steps”: tell it what you want and why, and let it figure out where.
Slicing a feature into phases is micro-instruction at the level of the whole project. You are writing the step-by-step plan for the agent, in the shape of ten tickets. Sculpturing is the same advice applied to how we plan work: give it the statue, not the arm.
Give the agent the statue, not the arm.
Step Two: Carve It Live
Look at the middle drawing. The sculptor is in a hoodie, with a laptop on a crate next to him, and there is dust everywhere. This is where the work happens.
Once the block exists, you stop adding parts and start shaping. You use it, ship it to a few people, watch what happens and reshape it. Most of the moves are subtractions: this screen is not needed, this setting confuses people, this whole branch of the flow can go. Some are reshaping: the arm is in the wrong place, move it. Each change is quick, because the agent does the chiselling and you decide where the chisel goes.
This is only possible because software has become cheap. If you build something you don’t need, you throw it away and build something else. Software is turning into something you build, throw away and rebuild, and that changes how you should plan it.
Carving is far faster than the alternative: sitting down up front and making sure you have thought of every aspect of a product through careful planning. We never managed that anyway. That is the whole reason MVPs exist. Things always change once we start building, and again once users start using what we built. The MVP’s answer was to give users less, so the wrong guesses were cheap. When building is this cheap, the wrong guesses are cheap anyway. So why not give users a fuller experience up front, learn from how they use all of it, and carve away what doesn’t hold up?
At Future Product Days I described this with a different picture: AI is not a bigger shovel, it is an excavator that comes with its own driver. Your job is no longer to dig. It is to direct. In sculpturing, your job is no longer to cast the arm. It is to see the statue in the stone and keep pointing at what is not the statue yet.
It also changes where people spend their attention. Humans stop reviewing diffs and start reviewing the shape: is this the right thing, is it in the right place, what should go? Our automated checks take care of whether each line is correct. I wrote about why that trade works in Don’t Tell It. Enforce It.
Step Three: The Finished Statue
The third drawing is the statue. The block is still behind it, which I like. You never use all of the stone, and that is fine.
The point is not that carving is more elegant. It is that it gets you to the finished statue faster. When you cast in parts, the first time you see the whole thing is at the end, and the first time users see it is later still. When you carve, you see the whole thing on day one and every pass after that is a pass over all of it. Feedback lands on the real product, not on a fragment of it.
It also kills a lot of work that only existed to hold the parts together: the compatibility shims between phase 1 and phase 2, the flags for half-finished states, the migration that had to work for a version of the model nobody ever used. That scaffolding was always risk too. It just didn’t look like risk, because it came in small PRs.
“But Big Pull Requests Are Risky”
I recently asked our engineers whether they were still doing small incremental PRs, or had started making bigger increments with AI. The pushback came fast, and it was good pushback. Every PR carries risk, and a bigger PR carries more of it. Continuous delivery exists so that changes fail fast and fail small. Automated reviewers may pay less attention per line on a huge diff. And getting part of a solution into production early can teach you something that changes the rest of the design.
I argued that line count was no longer a risk measure. Others argued it still was. Then someone did the sensible thing and stopped the argument by pulling our own numbers: 2,380 merged pull requests over twelve months, mostly written by agents and reviewed automatically. A PR counted as a problem if it was reverted, or if a later PR within two weeks fixed something it broke.
- Per line of code, bigger was far better. PRs under 100 lines had about 46 problems per 100,000 lines changed. PRs over 5,000 lines had 0.4.
- For the same amount of work, one big PR beat many small ones. At those rates, ten 1,000-line PRs bring about 0.5 problems. One 10,000-line PR brings about 0.1.
- All 17 reverted PRs were under 1,800 lines. Most of them touched shared infrastructure or performance paths: caching, loaders, health checks, deploy config.
- Big PRs don’t get reverted, they get fixed forward. Nearly half of the largest ones included a database migration, so a revert was never really on the table.
Any single big PR is somewhat more likely to need a follow-up fix than any single small one. But nobody builds a feature in one 50-line PR. Measured on the same work, the big block came out ahead by a wide margin.
Why would that be? Here I want to be clear that this is my theory. I can’t prove it yet. But it fits very well with what I have seen building software AI-natively for more than a year.
I think the reason is the one from earlier. The big PRs were built by an agent that had the whole feature in its context from the start. It designed the parts together, so there were no joints to get wrong. The small PRs were slices, each built with only part of the picture, and the slices had to be glued to each other and to whatever was already there. That is where the problems came from.
The sample of very large PRs is still small, under a hundred, and I will keep checking it as it grows. The one thing the data does not change is where the real risk sits. Problems clustered in changes to shared paths, whatever their size. So the rule is not “never split”. It is this:
Split by risk type, not by time phase.
Dependency upgrades, schema and data migrations, and changes to shared infrastructure get their own PRs and land first, because those are the parts a revert can’t undo or that can take everything down. Everything else, the block itself, goes in as one piece, behind a flag when the blast radius calls for it.
Teach Your Agent to Sculpt
Knowing all this does not stop the agent from proposing phase 0, 1 and 2 again tomorrow. Its habits come from its training, so you have to tell it, once, in the place it reads every time. For Claude Code that is CLAUDE.md, for Cursor its rules files, and most agents have something similar.
Something like this does the job:
## How we plan and ship work We work in big, complete increments. Agents write most of our code and can hold a whole feature in context, so a feature should be built in one go, not sliced into phases. - Build the whole feature in one pull request, even a large one. Do not propose phase 0, 1 and 2, or split work across PRs to keep them small. - Split out only what carries a different kind of risk, and land it first: dependency upgrades, schema or data migrations, and changes to shared infrastructure. - Put new surfaces behind a feature flag when the blast radius calls for it, instead of splitting the PR. - Estimate in agent time, not human time. If you will finish the work in this session, say so instead of quoting days or weeks.
Notice what the instruction does. It does not tell the agent how to build anything. It tells it what kind of result we want, and why, and leaves the steps to the agent. That is the same advice Anthropic gives about prompting, applied one level up: to how we plan the work itself.
I don’t expect this instruction to be needed for long. My prediction is that within a year or two, the models will have learned enough from the new reality, from code and writing produced the way we work now, that they change their habits on their own. Until then, tell them.
What It Replaces, and What It Keeps
Sculpturing is not a new religion. It replaces some of Scrum and some of Shape Up, and keeps the parts of both that matter more now than before.
From Scrum, the sprint goes, and with it estimation. I used to spend an hour agreeing whether a button change was a 3 or a 5, and I was proud of how good we were at it. That ritual existed to coordinate many people digging one big hole by hand. Slicing work into stories that fit a sprint goes too. What stays is the short loop between building and showing it to someone.
Shape Up is closer to sculpturing than Scrum is, and I keep more of it. Shaping stays, and matters more than ever: someone has to decide what statue is in the stone before anyone picks up a chisel. The appetite stays too: how much is this worth to us? What goes is the six-week cycle as the unit of building. When the rough block takes a day or two, six weeks is a lot of carving.
Continuous integration stays, more than ever. Every pass of the chisel goes through the same tests and checks. That is what makes it safe to carve fast.
And no, this is not waterfall with a nicer name. Waterfall spent six months on the block and showed it to users once, at the end, when it was too late to carve. Sculpturing gets the block in days and spends the rest of the time carving with feedback. It is the most iterative way of working I know. It just iterates on the whole statue instead of on one part at a time. Carving is only as good as the eyes on the stone, which is why I care so much about the feedback loop.
Some of Us Already Carve
Not all of us work like this yet. But some of us have started, and what I see from them is the next level of impact. No matter how I measure it, merged pull requests, lines of code changed, or the number of products a person makes an impact on, more and more people are shipping larger and larger projects, with a dramatic effect on their productivity.
It is not because they didn’t use AI before. They did, heavily. What changed is how they use it. They stopped micro-instructing the agent and started setting goals. And they gained the confidence to ship what it built, so they ship bigger.
Permission to Carve
At our last engineering town hall, I shared my hypotheses for why some of us move much faster with the same tools than others. Two of them were “it has to come from the list” and “I have to be sure it’s right before I ship”. Both made perfect sense when writing code was expensive. You sliced the work small and checked every slice, because a wrong guess cost you a week.
Sculpturing is partly a way of working and partly permission. Permission to hand the agent the whole vision instead of the next safe slice. Permission to put something rough but complete in front of people. And permission to throw away half of it on Tuesday, because the block cost an afternoon.
It matters now, not later. Every week we carve at full speed is a week we turn into data, customers and brand, the things that are left when software is no longer a moat. Teams that are still casting arms will catch up eventually. The window is now.
Johan’s team starts next quarter. I am going to push the rest of us in the same direction. If you try it, or if you think the block is a terrible idea, I would love to hear how it goes.
