For years, the software industry behaved as if writing code was the hardest part of building technology. Today, with AI generating thousands of lines of code in seconds, we are finally forced to confront a reality many experienced engineers already knew:

Code was never the real bottleneck.

The difficult parts of building software have always lived somewhere else. And AI is starting to making that clearer than ever.

The Illusion: Software = Code

When people think about software development, they imagine developers typing furiously, solving complex problems through clever code. But modern development has not worked like that for a long time. Frameworks like Rails, Laravel, Spring, and .NET already automated huge portions of the development process. Cloud platforms removed infrastructure complexity. Low-code platforms made it possible to build applications without writing code at all.

Even before AI, writing code had become one of the easiest part of building software. Yet many still measured progress in lines of code produced. AI has accelerated that illusion.

Code Is Cheap Now

With modern AI tools:

• Entire APIs can be generated in minutes
• UI prototypes appear in seconds
• Boilerplate disappears almost completely
• Refactoring can happen automatically

The marginal cost of producing code is approaching zero. This continues to impress the heck out me as a technologist and to most of us at first glance appears as pure upside. But removing friction changes how people behave.

Friction Forces Good Decisions

When implementing a a product feature takes weeks, teams have to ask hard questions:

• Do we actually need this feature?
• Is the design correct?
• What will the maintenance cost be?
• Will this introduce security or operational risk?

Because implementation is expensive, bad ideas (have to) die early. Constraints force discipline. They force clarity and prioritization.

When the cost of building something drops to almost nothing, that discipline disappears. Why debate a feature when AI can generate 4 different versions in ten minutes?

And that is where the real problem begins.

The Explosion of Software Complexity

Lower friction does not reduce complexity. In fact it multiplies it. You have felt it, you are five prompt deep into a project and you brain switches off and you end up in a death prompting cycle of “make secure, built with no error, check you work, blah blah”.

Economists call this Jevons Paradox: when something becomes more efficient to produce, we do not use less of it — we find more ways to use it.

The same will happen with software. More teams will build internal tools, more departments will automate workflows and more experimental products will be launched. And many of them will never be properly designed, governed, or maintained.

Side note here: Think about the explosion of low-code platforms like Power Platform just a few years ago where thousands of little apps were developed with little thought about the entire lifecycle of software development (and this was just on a single banking customer we worked with).

We will not get less software. We will get more software, faster — and often worse.

The Hard Parts Were Never Code

The difficult parts of building software have always been:

• Understanding the real problem
• Defining the right system boundaries
• Designing data models
• Thinking through failure scenarios

Then during implementation:

• Architecture design
• Distributed systems thinking
• Identity, security, and permission models

And finally designing systems that survive change.

These require deep thinking, not code generation and structured process. AI can help write functions — and increasingly even generate impressive applications – but it cannot replace judgment.

The Hidden Risk: The Loss of Learning

There is another subtle danger. When developers write code themselves, they simulate the system in their heads:

• What happens if this fails?
• What assumptions does this function make?
• How does this data move through the system?

That mental simulation is the real training. If developers rely entirely on generated code, they risk skipping the thinking step. The result is a small number of experienced engineers end up responsible for understanding and fixing the systems everyone else generates. The same small team of people who always carried the complexity will now carry even more of it.

The Real Bottlenecks of Software

(And we haven’t even reached the business layer yet)

Even if AI makes code generation nearly free, the real constraints remain:

• Product vision
• Architecture
• Security
• Governance
• User trust
• Distribution
• Adoption
• Change Management

The Apple App Store and Google Play Store together contain more than four million applications. Yet industry analyses consistently show that the majority of those apps receive fewer than a thousand downloads. A tiny fraction of products capture most user attention while millions quietly sit unused. AI will not solve discovery, it will simply make it easier to create more unused software.

The Future of Engineers

This brings us to question – what happens to the software development job? Why all the layoffs? Ironically, if this all plays out it most likely means more engineer will be needed in the long term, not less.

But crucially roles will shift.

The most valuable engineers will not be those who produce the most code. They will be the ones who can:

• Understand complex systems
• Design resilient architectures
• Make strong product decisions
• Govern technology responsibly

In a world where code is cheap, thinking becomes the scarce resource.

A Paradox Emerging in the Industry

Interestingly, some early patterns in the industry reinforce this idea. Across the technology sector we see a surprising paradox:

Narrative	Reality
AI replaces developers	Companies hire more engineers
Coding becomes automated	Architecture becomes more important
Productivity skyrockets	Complexity explodes
Junior roles disappear	Companies realize they must rebuild the talent pipeline

For example, IBM recently announced plans to triple its entry-level hiring, including software engineers. Their leadership warned that companies that stop hiring junior engineers today risk creating future shortages of experienced technical leaders.

At the same time, Anthropic — the company behind Claude Code, one of the most advanced AI coding systems — is aggressively hiring engineers, with reports suggesting more than 100 open roles. Despite building tools designed to automate coding, they still need engineers to design systems, evaluate AI output, and maintain architecture.

Another interesting signal is compensation. AI companies are offering some of the highest engineering salaries in history, with reports of median compensation around $570k and some packages approaching $700k.

We are also seeing companies announce layoffs while still hiring technical talent. For example, Block reduced its workforce but continues hiring AI engineers to expand its capabilities. (Interestingly this might also be because of other pressure, but the AI efficiency narrative is a much better public announcement.)

The pattern is becoming clear: AI may automate parts of coding, but the need for engineers who can design systems, govern complexity, and make sound technical decisions is only increasing.

Final Thoughts

In the end, there remains a noticeable disconnect between the public narrative and what is actually happening inside the industry. Headlines often suggest a future where AI replaces developers and software builds itself. Yet at the same time, companies are hiring engineers, investing in junior talent, and paying record salaries for technical expertise.

Reality rarely behaves like a perfectly predictable system — but neither are we living inside the chaos of the three-body problem where outcomes are impossible to understand. The signals are visible if we look carefully.

Time will ultimately tell how far AI will reshape software development. But for now, one thing is clear: the story being told in public and the decisions being made inside organizations do not entirely match. And that gap may be one of the most interesting signals of all.