I'm writing a book on the economics of software engineering. I started in October. Our COO read an early draft and came back with one question: "The world of software engineering has changed so much since you started writing this. Are the concepts in your book still valid, or do you need to rethink everything with AI in mind?"

It's a fair question. And my answer surprised him.

Nothing changed. Well, almost nothing.

Let me explain. Writing code got faster. Dramatically faster. I won't pretend otherwise. Tools like Claude can produce working code in seconds. That's real. But here's the uncomfortable truth: producing code was never the expensive part.

Today during a semester review, one of our engineers shared something that perfectly illustrates this. He's working with a team that programmes in a language they're not familiar with. They use AI to generate code. And on the surface, it looks fine. It does what it needs to do. The pull requests keep coming.

But he's drowning.

The code ignores the fundamentals of the framework they're using. It doesn't follow the conventions. It reinvents things the framework already provides. Every pull request looks acceptable at first glance, but it's slowly poisoning the codebase. They're creating legacy code in real time.

You might say that doesn't matter. That it works, so who cares. But anyone who's maintained a codebase longer than six months knows what happens next. The more polluted the source code, the harder everything becomes. Every new feature takes longer. Every bug gets harder to trace. The system fights you at every turn.

This is exactly what the economics of software engineering are about. The cost of a bug. The cost of technical debt. The cost of context switching. The cost of onboarding someone into a messy codebase. None of that changed because we got faster at typing.

I saw someone on LinkedIn today who shares this feeling. The speed of producing code shifted. Everything surrounding it did not. The architecture decisions still matter. Understanding your framework still matters. Code review still matters. Knowing why you're building something a certain way still matters.

If anything, AI made the economics more relevant, not less. When producing code was slow and expensive, it acted as a natural brake. You thought before you wrote. You discussed before you committed. Now that brake is gone. Teams can generate enormous amounts of code without understanding what they're generating. The output looks professional. It compiles. It passes basic tests. But it carries hidden costs that compound over time.

So yes, the cost of engineering went down. That's the one thing that genuinely changed. But the cost of engineering was never just the cost of writing code. It's the cost of understanding, maintaining, evolving, and debugging that code over its entire lifetime.

My book didn't need a rewrite. If anything, it needed a sharper point. The economics of software engineering aren't threatened by AI. They're amplified by it.