Kierian

It was an uncomfortable thought at first.

Writing code — the thing I spent years getting good at, the thing I take pride in — is now trivial.

You open an editor, describe what you want, and something that looks production-ready appears almost instantly. Not perfect, but close enough that the gap between idea and implementation has essentially collapsed.

For a while, that felt… destabilizing.

If code is the thing I’m best at, and code is becoming cheap, where does that leave me?

The realization

It took a bit of time, but eventually something clicked:

AI makes code cheap, but it does not make systems easy.

And those two things were never the same.

Code is the artifact.
Systems are the behavior.

And behavior is where all the real complexity lives.

Where things actually break

You can generate a service in minutes now.

That part is solved.

What isn’t solved is everything around it.

Because building a real product isn’t a single decision.
It’s hundreds — sometimes thousands — of small, interdependent ones:

Where does this logic live?
How do we model this data so it still makes sense in 6 months?
What do we optimize for now vs later?

None of these have one “correct” answer.

They exist in a space of many valid choices, where some are just slightly better than others.

And that’s the trap.

The compounding effect of “almost right”

If you make one slightly-wrong decision, nothing breaks.

If you make ten, things get awkward.

If you make a hundred, the system starts fighting you.

That’s what makes building products hard.

Not any individual decision, but the compounding effect of making the right kind of decision, over and over again, across time.

AI is very good at producing something that works.

It is not (yet) good at consistently choosing:

The right abstraction boundary
The right trade-off for your specific constraints
The right simplification at the right time

Because those decisions depend on:

Context that isn’t fully specified
Constraints that evolve
Trade-offs that only become obvious later

The real skill isn’t writing code

It’s sequencing decisions.

Good products come from:

Making reasonable decisions early
Not overcommitting too soon
Leaving room for change where needed
Locking things down where it matters

And most importantly:

Making decisions that still make sense after the next 50 decisions are made.

That’s the part that doesn’t get generated.

This is a team skill, not an individual one

This isn’t just about individual ability.

The skill of sequencing decisions correctly — again and again over time — is something that emerges from teams of experienced product owners and engineers working together.

It shows up as:

Shared intuition about trade-offs
A consistent sense of what “good” looks like
The ability to challenge decisions before they compound
Knowing when to slow down, and when to move

This kind of judgment is built through:

Shipping real systems
Seeing them fail
Living with the consequences of past decisions

It’s not something you can prompt into existence.

And it’s not something you get from a single pass of generated code.

Why “vibe coding” hits a wall

This is where the idea of “anyone can vibe-code entire systems” starts to break down.

You can absolutely get something working.

But sustaining it requires:

Consistency in decisions
Alignment in mental models
Awareness of second and third-order effects

Without that, what you get is:

A system that technically works
But eventually collapses under its own contradictions

The shift people are missing

Once you look at it this way, a lot of the “AI will kill SaaS” takes start to fall apart.

Because they assume the hard part was building the software.

It wasn’t.

The hard part was making the right decisions, consistently, over time.

SaaS is not dead.

What’s actually happening is simpler:

The cost of producing code has collapsed
The cost of building good systems has not

The real competition isn’t:

SaaS vs AI

It’s:

Reliable, well-designed systems vs quickly generated, loosely held-together ones

The new bar

If a company can have an intern generate a tool in a day, then a SaaS product has to be:

More reliable
More predictable
Easier to operate
Better integrated into real workflows
Less cognitively expensive to use and maintain

Because the hidden cost of “just building it yourself” isn’t writing the code — it’s everything else.

Conclusion

Code is cheap now.

That’s a real shift, and it’s not going away.

But systems are still hard.

The engineers and teams who win won’t be the ones who generate the most code.

They’ll be the ones who can build systems that solve for more — while costing less.