We’re handed an airplane, but most of us still drive it like a car—sticking to familiar roads instead of learning how to fly.

Generative AI has introduced powerful new capabilities into software engineering, but many of us are still applying old patterns to new tools. In this post, I want to unpack one specific belief I've been sharing for a while: production code has become cheap. That statement might sound abstract or even provocative, so let’s break it down—especially in the context of how AI is changing the way we write and think about code.

Production code isn’t the same anymore

Let’s narrow our scope a bit: generative AI affects many parts of the software lifecycle, but here, I want to focus purely on code. The stuff that gets deployed to production.

Any time there’s a major technological shift, we’re forced to revisit how we do things. And right now, I believe we’re still in the early stages of that reflection. We’re using AI, sure—but mostly to go faster at what we already do, not to fundamentally rethink how we do it.

It reminds me of that Henry Ford quote:

“If I had asked people what they wanted, they would have said faster horses.”

That’s where we are. We’ve been given a plane, and most of us are still asking for it to be a better car.

Why was production code expensive in the first place?

Historically, writing robust production systems required time, talent, and experience. Building something predictable and maintainable wasn’t trivial—it demanded years of practice and intuition. That investment in skill is what made production code “expensive.”

As a result, engineering culture evolved with certain patterns:

• Senior engineers were expected to focus on production code. Anything else was often considered a distraction.

• Code that didn’t ship (like test code or internal tooling) was deprioritized because it didn’t “deliver value to customers.”

• Separate QA teams were introduced to verify correctness—less expensive talents doing the checking, while more expensive engineers did the building.

This also created a kind of gatekeeping: production code became a proving ground. If you weren’t working on it, your work was often undervalued.

But that world "has" changed

AI has flipped the equation. Tasks that once demanded rare expertise can now be done by a tool in seconds. The premium is no longer on writing code, but on knowing what to build, how to guide the system, and how to verify and evolve it.

Many leaders still think of production code as sacred. But here’s the thing: code that gets shipped is only useful if it does what it’s supposed to do. That includes being testable, observable, maintainable, and aligned with real customer needs.

In a world where code generation is free or near-free, the bottlenecks shift elsewhere. Context, clarity, correctness, and intent become the real currency.

What this means for engineers

We need to re-evaluate how we think about value in software engineering.

Production code is no longer the bottleneck. The hard part is designing robust systems, asking the right questions, and interpreting fuzzy requirements into something that can evolve. AI speeds up execution, but judgment, intuition, and systemic thinking are still very much human.

So yes—production code has become “cheap.” But that doesn’t mean engineering is any less valuable. It just means the value has moved.

The sooner we stop using this plane like a car, the faster we can actually start flying. (I'll share how this shift plays out in my own workflow. Tools, habits, and what I’ve had to unlearn in a follow-up.)