Twenty years ago, writing code meant memorising function names. Then IDEs remembered them for us. Now coding agents write the code itself. It feels like a revolution, but it may just be the next step in something developers have always done: moving away from syntax and closer to what we’re trying to build.
Emacs and the PHP manual
When I started coding in PHP, I wrote it in Emacs. There were no suggestions and no hints. If I wanted to sort an array or check whether a value was in one, I had to already know that sort() and in_array() existed. Then I had to open php.net to check the order of the arguments. Needle first or haystack first? Every developer from that time has a version of this story.
Knowing the language meant memorising it.
Then the IDE started finishing my sentences
IDEs changed that. Type array_ and a list appeared: array_map, array_filter, array_key_exists, each with its parameters spelled out. I no longer had to remember the exact function. I only had to know what I wanted to do.
It was a quiet shift. The skill moved from remembering things to knowing what you wanted. I spent less time on syntax and more on logic, and nobody called it cheating. It was just a better tool.
Agents take the same step, one level up
Coding agents make the same move on a bigger scale. Autocomplete filled in a function name. An agent fills in the whole function, and sometimes the whole feature.
What I bring to the work has changed. I describe what I want to achieve and how I want it built: which technologies, which patterns, where the boundaries are. The agent writes the code. If I understand the system design and the trade-offs, I can guide it, the same way I once guided autocomplete by typing the first few letters of a function name.
The unit of work keeps growing: from characters, to function names, to functions, to whole systems.
What has not changed
There is one important difference. Autocomplete only offered functions that existed. It couldn’t invent a bad one. An agent can write a lot of convincing code that is wrong, insecure, or simply not what you meant.
So the fundamentals matter more, not less. With autocomplete, you still had to know why you wanted in_array. With an agent, you have to know whether what it wrote is right. Reading code, reviewing it and understanding the system it fits into is now the job.
The developers who struggle won’t be the ones who forgot syntax. They’ll be the ones who never learnt to think in systems.
A natural progression
Each new generation of tools has moved us one step further from the machine and closer to the problem. Assembly gave way to high-level languages. Manuals gave way to autocomplete. Autocomplete is giving way to agents.
I don’t think agentic coding is the end of programming. It’s the next layer of abstraction. We stopped memorising syntax a long time ago. Now we are learning to stop typing it too.
What’s left is the part that always mattered: knowing what to build, and why.
