There is a lot of talk now about "builders".
AI has made software development faster, broader, and more accessible, so suddenly every company wants people who can take an idea and turn it into something real. People who can understand the product, design the workflow, write the backend, build the interface, deploy it, measure it, and iterate.
That sounds new only because we gave it a new name.
We used to call those people full-stack developers.
The old role was already the right one
A full-stack developer is not someone who knows a little frontend and a little backend. That definition was always too weak.
A full-stack developer is someone who can deliver a feature end to end. From the first conversation about the problem to the version running in production. They can move through the whole system without waiting for the work to be handed from one specialist to another.
That skill has always mattered.
I wrote years ago about why splitting small teams into backend and frontend developers was a bad idea. My view has not changed much. Either you are a web developer or you are not. You cannot be half a web developer and expect the team to move quickly without creating queues, handoffs, and translation work.
The difference now is that AI has made the cost of that old mistake impossible to ignore.
AI exposes bad team design
When development was slower, specialization looked efficient.
The backend person owned the data model and APIs. The frontend person owned the screens. The product person wrote the spec. The designer prepared the flows. Everyone had a clear lane.
Clear lanes feel organized. They also create waiting.
The frontend developer waits for the endpoint. The backend developer waits for the final UI. The product person waits for the estimates. The designer waits for feedback from implementation. By the time the whole loop closes, the original idea has already passed through too many hands.
AI changes the economics of that loop.
If one developer can explore the data model, build the interface, write the migration, generate the tests, and prepare a working prototype in a few hours, then a team structure built around handoffs becomes the bottleneck. The limitation is no longer typing the code. The limitation is how many people need to coordinate before anything real can be tested.
That is why full-stack developers see the biggest productivity increase from AI. Their existing advantage gets amplified. They already understand the whole path from idea to production, and AI gives them leverage at every stage of that path.
Smaller teams are the new advantage
The default product team of six to eight people is starting to look too heavy.
Not always. Some domains need more people, more review, more process, and more specialization. But for a lot of web product work, a large team now adds more coordination cost than delivery capacity.
The sweet spot is smaller:
- One product-minded designer.
- One or two full-stack developers.
That is enough to understand the problem, design the workflow, build the feature, test alternatives, ship, measure, and adapt.
This is where the productivity gains become visible. Not because each individual types code faster, but because the team has fewer internal boundaries. The designer and developers can sit close to the problem, try ideas quickly, and throw away weak approaches before they become expensive.
A small team with full-stack capability can make decisions with working software instead of meetings.
Prototypes are no longer fake
One of the most important changes is that testing different approaches is now cheap.
You can let users explore different workflows. You can try three versions of the same onboarding. You can test a new UI before committing to a full implementation. You can create a working prototype in hours and put it in front of people while the idea is still fresh.
This is the real AI advantage. Not "we shipped the same thing two days earlier", but "we tried three better things before choosing what to ship".
I wrote more about this in Experiments are the AI superpower nobody is using. AI makes credible alternatives cheap. A good web stack makes those alternatives easy to test. Together, they change how teams should make product decisions.
The goal is not speed
Shipping faster is nice. It will probably happen as a side effect.
But it should not be the goal.
The goal is to increase the quality of the features you deliver.
That happens when a focused team can understand the problem deeply, explore different approaches, and adapt quickly. AI helps because it reduces the cost of exploration. Full-stack developers help because they remove the boundaries between exploration and implementation.
This also means you can think bigger.
When every idea required weeks of coordination, teams learned to reduce scope early. They had to. Large ideas were risky because the cost of being wrong was high.
Now the scope has changed. You can try more. You can build more complete workflows. You can test ideas that would have been too expensive to even discuss before. The opportunity is not to do the same work faster. The opportunity is to raise the ambition of the work.
Product people need to evolve too
This does not remove the need for product people. It changes the job.
When experimentation is expensive, product work tends to become detailed planning. Every feature needs a long implementation document because the team wants to reduce uncertainty before development starts.
That made sense when building was slow.
It makes less sense when the team can create working options quickly.
Product people should spend less time specifying every detail of the solution and more time defining the problem clearly. They need to set the scope, describe the user need, define the boundaries, explain the business constraints, and decide what kind of evidence will matter.
Then they need to let the team work.
Not disappear. Steer when needed. Protect the scope. Keep the team honest about the user and the business. But do not turn a cheap experiment into a slow planning process.
In this model, product leadership becomes more about direction than prescription.
Summary
"Builder" is a new title for an old role.
The people getting the most from AI are the same people who were already valuable before AI: full-stack developers who can take responsibility for the whole feature, not just one layer of it.
Teams should be redesigned around that reality. Smaller groups. Fewer handoffs. Strong designer-developer collaboration. Product people setting direction instead of writing exhaustive implementation plans.
AI does not make half-developers whole. It makes whole developers more powerful.
