Software teams have operated on one core assumption for decades: writing code is expensive.
If code costs 10/10 effort to write, you can justify spending 9/10 worth of effort in meetings and planning to make sure you don't write the wrong code. This shaped everything - waterfall specs, endless meetings and reviews, layers of process.
These processes had real benefits. Checks and balances prevented huge mistakes. But the economic assumption they were built on just broke.
AI collapsed the cost of code generation to near-zero. Yet most people have kept running the same playbook.
The reality is that actually writing code was only ever a very small part of the product development lifecycle. Traditionally, it took up the majority of time, but it was always surrounded by planning, design, deliberation, review.
AI agents can take that coding work and collapse it down significantly, but that's only one piece.
What actually happens: PM has an idea. There are pre-meetings and pre-prioritization discussions where you have to build the case internally for why this probably makes sense. Then come prioritization meetings around should we even do this versus that - because we're so used to the cost being so high, we have to strenuously pick one over another. We deliberate, we meet and repeat.
Design creates mockups. Meetings happen about the designs. Design by committee ensues. Then there's a tech spec and people need to review that. Requirements get written. Things sit in backlogs waiting. Engineering builds - and yeah, this part is a lot faster now.
Between each of these steps, there's waiting. Waiting in queues, waiting for the designer to be able to take a look, waiting for the person to be able to review. Each of these wait times adds up to slow down the entire process tremendously.
Then comes code review. Design redlines. QA. More changes. Another review cycle.
Time goes into coordination, review, and wait times. Teams bounce work between individuals in linear flows. PM waits for design. Design waits for eng. Eng waits for QA. QA finds issues and waits for eng to be available again.
Here's the pattern: Most companies responded to AI by adding tools - code generation tools, code review tools, documentation tools, testing tools. They slotted these into existing workflows without changing the underlying process.
The tools made individual steps faster, but the system stayed slow.
The bottleneck moved. It's not code generation anymore. It's review and coordination.
Companies that are succeeding didn't just add tools. They changed their systems.
The fastest-moving startups put one person on a feature. They are the end-to-end delivery machine - an engineer sees a problem, uses AI to solve it, gets quick internal feedback, and ships it. Crazy fast. Cycles that take a larger company weeks can happen in one day.
Larger teams look at this and say "we can't work like a startup." But you can, more than you think. The constraint isn't complexity - you can prompt Cursor or Claude Code on the world's largest, most complex codebase and still see the same pattern. For a wide range of use cases, you can just prompt and get something.
The real constraint now is people and processes for product development.
Humans give much higher quality feedback and input on things they can put their hands on, compared to speculative words on documents.
You can create the world’s best document of the world’s best feature and then watch as your customers fall completely flat trying to use it in every way no one expected.
One thing I see so many people fantasizing about is how entrepreneurs can just build things from scratch so fast. Entrepreneurs build fast because they're molding - iterating rapidly based on feedback. Time to customer feedback is their #1 metric, far ahead of universal internal alignment. And if you build software from scratch with AI, you've probably experienced a version of this molding too. You give a prompt and you get something visceral back quickly - where you can play the role of the customer and experience iterations for the first time much like they would.
And as a team, you can have a much more meaningful thought process and discussion with something in your hands versus wireframes and documents where you're trying to imagine what you're looking at.
What's starting to emerge is production-grade prototypes. Not throwaway demos in no-code tools. Real implementations using your actual codebase and design system.
You can get an 80% done version of a thing faster than you could even have a meeting about which things to prioritize. That's the huge fundamental change.
Then your discussions change fundamentally. They turn into reactions. You can even involve reactions from your users by sharing a link to a version that they can try and give real feedback on.
This moves the goal post from "writing code is the holy thing" to "merging code is the holy thing." Writing isn’t a concern anymore, whats a concern is making sure what gets merged is high quality and meets your users needs.
Here's a core truth: a huge portion of your awesome ideas that you have full alignment on and make perfect sense to everyone fail once shipped.
Sometimes they fail in totally obvious ways. You see what's built, put it in your hands, and go "oh crap, this has problems." Or you get your first customer using it and that thing you've been working on for months suddenly falls flat.
The most effective way to figure out what will make users happy is to put manifestations of the product in users' hands, gather their feedback, do another iteration, put the next version in their hands, and repeat until users are happy. Honestly, it’s not rocket science.
Where product development breaks down is when we make those loops of getting back to the user long, complex, or when we convince ourselves that other ways are better. We do other ways because we fundamentally believe writing code is expensive and slow.
But writing code is not expensive and slow anymore.
The unit cost that matters shifted. Not cost per line of code - AI demolished that.
The metric is cost per happy user.
When code becomes cheap, speculation becomes expensive. That's the bottleneck worth optimizing.
Builder.io visually edits code, uses your design system, and sends pull requests.
Builder.io visually edits code, uses your design system, and sends pull requests.
Connect a Repo
