Every few weeks, someone declares that coding is solved. If they mean turning a well-specified problem into runnable code, they’re increasingly right. But was writing runnable code ever the whole problem?

Language models have solved software engineering to the extent that word processors solved journalism: they made producing the output easier. Ask one to build a REST API or implement a React component, and work that used to take hours now takes minutes. Remarkable. But organizations need an answer to a harder question. Can AI solve the problems they actually have?

Demo apps are startups in miniature

The easiest way to convince yourself that coding is solved is to build a demo app, like a to-do list, a weather app, or a personal dashboard. The requirements are clear, there are hardly any constraints, and you’re free to invent the architecture as you go. You build on a blank canvas.

Now compare that to a mature organization. The task might sound like add a button, but before you write a line of code, you need to answer:

• Which service owns this functionality?
• Is there already an API we should use?
• Why wasn’t this implemented before?
• What security requirements apply?
• Which architectural patterns are acceptable?
• Which team owns this area?
• How will this affect downstream systems?
• What business constraints are we optimizing for?

How many of these questions are about writing code? Very few. Most require you to understand the organization.

That’s why the same model that feels magical on a weekend project can feel merely helpful inside an enterprise. While the programming problem is similar, the environment makes it harder.

We mistook the bottleneck for the discipline

For decades, writing code was one of the most expensive parts of software development, so we started equating software engineering with implementation. AI is making implementation dramatically cheaper and moving the bottleneck elsewhere.

Automation changes what becomes scarce. As implementation becomes abundant, our attention shifts to the next layer of abstraction. Software engineering has always involved several layers:

Each layer answers a different question:

• Business objective: What problem are we trying to solve?
• Product design: How should users experience the solution?
• Solution design: How should the system realize that experience?
• Implementation: How do we express that in code?

Today’s models are becoming exceptionally good at the bottom layer. The rest of the stack is still there. We’re finally noticing how much work sits above implementation.

Organizations run on context

One thing separates hobby projects from enterprise software: context. More specifically, organizational context.

An organization already knows its architecture and domain language. It has historical decisions, engineering conventions, ownership boundaries, security requirements, business priorities. Years of building software have also created countless assumptions that nobody wrote down.

This context influences every step. Strategy and regulation shape business decisions. Customer expectations and established UX patterns shape product decisions. Existing platforms and services constrain solution design. Coding standards, frameworks, and deployment pipelines guide implementation.

A startup creates this context as it grows. An enterprise inherits decades of it. Asking a language model to build a greenfield application is fundamentally different from asking it to extend a ten-year-old production system. The hard part is making good decisions within an existing landscape.

AI is climbing the abstraction ladder

Every generation of development tools automates the most concrete layer of software engineering. Compilers automated machine code. Higher-level languages automated low-level programming. Frameworks automated infrastructure. Now language models are automating implementation. Each breakthrough feels revolutionary until the next layer becomes the bottleneck. That’s exactly what’s happening today.

The better AI gets at producing code, the more our conversations move towards understanding the business problem and designing the right experience. We spend more time fitting solutions into existing systems and making sound decisions within organizational constraints.

Code was always the medium

AI can write code. The mistake is assuming that writing code was ever the whole job. Organizations pay engineers to solve business problems. Code is the medium, not the outcome. So, is coding solved? If you mean translating a clear specification into working software, we’re getting close.

Software engineering covers the whole stack. Every generation of tools makes one layer cheaper and reveals the next. AI is revealing what software engineering was all along.