The Old Rules of Building Software Are Dead

For 20 years, building a software product meant the same thing. Hire a team. Write a spec. Sit through standups. Wait months. Spend six figures. Hope it works.

That playbook is dead.

Not dying. Not evolving. Dead. And most founders haven’t realized it yet. They’re still hiring teams of 20, still running sprints, still budgeting $500k for an MVP, still waiting six months to find out if anyone cares. They’re playing by rules that no longer apply, and it’s costing them more than they think.

I know because I spent 18 years inside that system. I built and led teams from zero to 80 people. I hired over 800 engineers and designers. I ran the old playbook so well that I built a company around it, scaled it, I was good at the old game.

Then the game changed.

What actually changed

This isn’t about AI doing your job for you. That’s the lazy take. The real shift is subtler and more profound.

What changed is the ratio between thinking and execution. Building software used to be 20% deciding what to do and 80% doing it. Managing that 80% is what created the entire industry of project managers, scrum masters, QA teams, design-to-dev handoffs, and six-figure agency retainers.

That ratio flipped. Today, building software is 80% deciding what to do and 20% doing it. The execution layer compressed so dramatically that the infrastructure built around it, the teams, the processes, the timelines, the budgets, stopped making sense almost overnight.

A feature that used to take a team of three two weeks to ship can now be done by one person in an afternoon. Not a crappy version. A production-ready, well-designed, properly tested version.

That’s not an exaggeration. I’ve been living it every day.

The old model vs. what’s possible now

Here’s what the old model looked like for a typical founder building an MVP:

The old way:

• Hire 3-5 people (or an agency)
• Spend 4-6 months building
• Ship something that may or may not match what you had in mind
• Realize half the features were wrong
• Spend another 2-3 months iterating
• Total time to something real: 9-12 months, if you’re lucky

What’s possible now:

• A handfull of key people with the right experience and tools
• Ship a working product in weeks, not months
• Budget measured in thousands, not hundreds of thousands
• Product in your hands matches what’s in your head, because nothing got lost in translation
• Iterate in days, not months, because the feedback loop is radically shorter

I’m not talking about a prototype. I’m not talking about a demo. I shipped five products in six weeks recently. Two of them are already profitable. Different tech stacks, different users, different business models. All running in production with real users paying real money.

The old model would have required five separate teams, a year of work, and over a million dollars. And at least two of those five would have been killed in committee before they ever launched.

Why this matters for founders

If you’re building a product right now, you’re probably making decisions based on assumptions that are no longer true.

“I need to raise money to build my product.” Maybe not. The cost of building just dropped by an order of magnitude. What used to require a $500k seed round might now cost $10-20k. The economics completely changed, which means the fundraising calculus changed too.

“I need to hire a large team.” Not yet. Maybe eventually. But the first version of your product should not require a team. If it does, you’re either building too much or building the wrong way. Teams should scale what works. They shouldn’t be how you find out what works.

“Building takes 6 months.” It doesn’t. Not anymore. If someone tells you your MVP will take 6 months, they’re either scoping too much, building the old way, or both.

“I should hire an agency.” An agency gives you a project manager, a designer, two developers, and weekly status calls. What you’re actually paying for is coordination overhead. The value isn’t in the output, it’s in the translation layer between what you want and what gets built. When one person holds the full picture, that translation layer disappears, and so does most of the cost.

The dangerous middle

The trickiest part of this shift is what I call the dangerous middle. It’s where most founders are right now.

They’ve seen the demos. They’ve played with Cursor or Bolt or Replit. Maybe they’ve even built a prototype. And now they think they understand what’s possible.

But they don’t. Not really.

A prototype isn’t a product. A demo isn’t a business. What AI tools give you today is the ability to generate code fast. What they don’t give you is judgment about what code to write, how to design something people will actually use, how to scope so you’re building the smallest thing that matters, or how to turn a working prototype into something that scales, handles edge cases, and makes money.

That judgment gap is where products die. And it’s widening, because the tools keep getting better at execution while the bar for judgment stays exactly where it’s always been.

This is why I see more products launching than ever and fewer of them succeeding. Speed without taste is just faster failure.

What the new rules actually are

The old rules were about managing complexity. Big teams, long timelines, detailed specs, handoff processes. All of that existed because building was hard and slow.

The new rules are about something different entirely.

Taste matters more than speed. Everyone can build fast now. The differentiator is knowing what to build and what to cut. Judgment about what matters, what users actually need, and what’s just noise. This was always important. Now it’s the only thing that matters.

Hold the full picture. The old model separated strategy, design, and engineering into different roles. That made sense when each one took months of specialized work. It doesn’t anymore. The product in your head and the product on screen should be the same thing. Every handoff is a place where quality gets lost.

Ship, then learn. Don’t plan, then build. The old model front-loaded planning because changes were expensive. Changes aren’t expensive anymore. The fastest way to find out if something works is to build it and put it in front of real people. Not a wireframe. Not a survey. The actual thing.

Validate in days, not months. The old validation playbook (customer interviews, surveys, landing pages, waitlists) was built for a world where building the wrong thing cost you six months. When building the right thing takes two weeks, the validation loop compresses to match.

Small is an advantage, not a limitation. A single person who holds strategy, design, and code in their head will outship a team of 10 that needs to coordinate between specialists. This isn’t because that person is better at each individual skill. It’s because the coordination cost is zero. Nothing gets lost in translation. Decisions happen instantly.

Who wins in the new world

Not everyone benefits equally from this shift.

Founders who win: Those who understand that the bottleneck moved from execution to judgment. They invest in getting the strategy, design, and scoping right, then let AI-native workflows handle the execution. They stay lean on purpose, not because they can’t afford a team, but because small and fast beats big and slow.

Founders who lose: Those who use AI to build more, faster, without the judgment to build less. They ship bloated products. They mistake activity for progress. They think the answer is more features when the answer is better features. Or fewer.

Teams that win: Small groups of people with real range. Three or four people who can each operate across strategy, design, and code, amplified by AI. Not specialists connected by process. Generalists connected by shared taste.

Teams that lose: Traditional squads of 8-12 people running sprints. Not because those people aren’t talented. Because the model itself is built for a constraint that no longer exists. Coordinating 10 people to do what one person can now do alone isn’t just slow. It’s expensive, it introduces errors, and it kills the product instinct that makes things great.

What to do about it

If you’re a founder sitting on an idea, stop planning and start building. Not in six months. Now. The cost of finding out if your idea works just dropped to almost zero. The only thing stopping you is old assumptions.

If you’re a founder running a team the old way, start asking hard questions. Does every person on this team need to be here? Could three people with AI-native workflows outperform the current ten? What would it take to find out?

If you’re a founder who built an AI prototype and is now stuck, you’re in the dangerous middle. The gap between your prototype and a real product is smaller than you think. But it’s a gap of judgment, not execution. You need someone who can tell you what to keep, what to cut, and how to turn what you have into something that works.

If you’re a founder who hasn’t started yet, there has never been a better time. The barrier to getting from idea to real product is the lowest it’s ever been. The risk isn’t that building is hard. The risk is building the wrong thing. Get that right and everything else falls into place.

The old rules are dead. The founders who figure out the new ones first will have a head start that compounds. The ones who keep playing by the old playbook will wonder why everything takes so long and costs so much while someone else ships the same thing in a fraction of the time.

The game changed. The question is whether you’ve caught up.

I write about what building looks like now, and I advise founders who are ready to operate in the new reality. If you want to see what’s possible, subscribe to my newsletter or get in touch.