AI is making the cost of coding drop fast, toward zero, and the effort it takes is approaching nothing, and this is happening more quickly than most people have caught up to. When I look back over my own last two years, the time to code a software project has compressed from two weeks to two days to two hours, driven by AI getting better at coding and by its growing ability to carry out long, agentic tasks on its own.
And as that cost falls away, the engineer’s judgment only matters more.
It helps to remember how much coding used to ask of a person. You needed deep fluency across several layers at once. You needed syntax and language mastery, the kind you only get from textbooks and exercises and a lot of hours, understanding a language at a fundamental level. You needed ecosystem knowledge across libraries, frameworks, and tooling, and you needed it as something close to muscle memory, because stopping to look things up mid-build wasn’t really workable for production code. You needed to know not just what worked but what worked well, the gotchas and anti-patterns and the patterns that quietly save you from future pain. And you needed the cultural layer too, the idioms, the internal style guides, the community conventions, because code never lives in isolation and always has to survive review by other engineers.
That learning curve was steep. At a company like Twitter, an engineer would typically spend six months ramping up, learning Scala, absorbing the distributed systems infrastructure, internalizing the internal style guides, all before they were really productive.
But underneath all of that coding sits software engineering, which is the work of making the decisions that determine what a system actually is. These are the choices that shape performance, quality, security, and scalability, the ones that either enable or quietly constrain everything built on top of them. Hash map or linked list. Schema or unstructured data. SQL or NoSQL. Strict event ordering or unordered processing. SSO or magic-link authentication. Which frontend framework. Mutable or immutable.
And these choices have consequences that spread outward. Pick the wrong database and you get scaling failures down the line, outages when the system can’t handle growth, or an expensive infrastructure bill to paper over the mistake. Get authentication wrong and you’ve either opened a security hole or blocked an entire enterprise sale on compliance grounds. Good decisions work the same way in reverse, creating real user value, the way Apple’s obsession with performance engineering is what delivers the high frame rates that make their devices feel alive in your hand. None of that is a coding problem. It’s architecture and systems thinking.
For a long time, education and careers bundled coding and engineering together as if they were one thing. Computer science programs teach algorithms right alongside syntax, and job descriptions blur implementation and design into a single role. And that made sense, because back when coding itself demanded so much of a person, the two skills naturally grew up together.
What AI is doing is severing that link. Once coding becomes free, there’s no longer any reason the two have to come bundled.
And that unbundling makes software engineers more valuable, not less. When the friction of writing code disappears, an engineer can pour far more attention into the decisions that actually matter, the ones that decide whether a system scales gracefully, whether its security holds under real pressure, whether the product is genuinely usable.
It’s worth remembering that engineering is an old craft, with roots running back thousands of years through the Egyptian pyramids and the Roman aqueducts. Computer science, by contrast, only emerged as a discipline in the 1950s and 60s, which makes it about seventy years old. The bundling of coding skill with engineering judgment happened during that rapid early formation, when you genuinely needed both, but the pairing was always more circumstantial than essential.
Because at its core, engineering is about understanding the tools you have, recognizing the constraints you’re under, making the tradeoffs honestly, and pushing on the boundary of what’s possible. And that draws on something that’s still uniquely human, which is empathy, the ability to understand what users actually need, to anticipate how a system will fail, to hold competing priorities in tension and balance them well. All of that comes out of human experience.
Engineering also feeds the research that creates better tools in the first place. Building systems and improving the tools that make those systems possible push on each other in a loop, and that loop needs human insight to keep turning.
So this is why coding is becoming free while software engineering is becoming more important. As AI takes over the implementation, the premium moves onto judgment, systems thinking, and empathy, and the engineers who see that shift coming and build those muscles now are the ones who will matter most.
Engineering, in the end, is about solving hard problems and deciding what systems should do for people. The craft stays human. The AI writes the code, but a person still has to decide what to build and how it ought to work. We’ll always hold the advantage in empathy when we’re building products for other people, and as coding gets cheaper, that empathy is the thing that becomes irreplaceable.