Code is the easy part

For forty years, the main constraint in software engineering was translation.

The Bottleneck has moved

You had a mental model of a system. Your job was manually translating it into syntax a compiler would accept. The hard part was the "how". How to reverse the list. How to center the div. How to query the database without killing the server.

That era is over.

AI drove the cost of syntax to zero. If you want a function, an agent gives it to you. If you want a boilerplate backend, it appears in seconds. But when you remove one constraint in a system, the bottleneck moves to the next hardest step.

The new bottleneck is verification.

It is significantly harder to read code than to write it. (See Joel Spolsky, “Things You Should Never Do, Part I.”)

When you write code by hand, you build a mental model line by line. You understand the logic because you created it. When an AI writes code, you don't have that history. You get a block of logic that looks correct and runs correctly most of the time. But it might fail in ways you never anticipated.

We moved from a world limited by how fast we could type valid syntax to a world limited by how fast we can audit generated logic.

The specification trap

This changes the developer from a builder into a specifier.

Before, vague requirements were solved by human context. You filled in the unwritten rules while you coded. You realized the edge cases simply because you knew the business.

Now, ambiguity is dangerous. If you ask an agent to "process the user data", it will do exactly that. It doesn't know your tribal knowledge. It won't ask about privacy. It won't ask about race conditions. It won't sanitize inputs unless you explicitly tell it to.

The machine has no intent. It only has probability.

Why humans are stuck in the loop

This is why the job isn't going away. It is just getting more stressful.

An AI can generate a week’s worth of code in a minute. But that code is technical debt from the moment it appears until a human verifies it.

The bottleneck is no longer the keyboard. The bottleneck is your ability to hold a complex system in your head and ask a hard question: "Does this generated patch actually work, or did it just solve the puzzle of making the test pass?"

We aren't paid to write code anymore. We are paid to assume the code is wrong. We are the only ones in the loop who actually care about the outcome.

The takeaway

When the cost of syntax drops to zero, the value of context goes to infinity. We are no longer paid to construct software; we are paid to define the constraints and audit the results. The machine provides the velocity, but we must provide the direction. The job is no longer about building features; it is about understanding the system deeply enough to know when the code is lying.