The first six months I used AI to code, I used it wrong. I had Copilot inline. It finished my sentences. The autocomplete was good. I shipped a little faster than I used to. I told myself this was the future.
It wasn’t. The future was something else, and I missed it for a while.
Two ways to use AI, two completely different jobs
There are two ways an engineer uses AI right now, and they look similar from the outside but they are not the same job at all.
The first way is autocomplete. You write a function name, the model suggests the body, you tab to accept. You write a comment, the model writes the code below it. It is the same job you were doing before — sitting at the editor, holding the whole problem in your head, typing things out — except your hands move a little less. You ship maybe 1.3x faster. You are not transformed.
The second way is leverage. You don’t write a function name. You write a brief. You describe the outcome — what should be true after the change — and you hand the whole thing to an agent. While the agent works, you go review the previous one’s pull request. You ship 5x faster, sometimes 10x, and the job has changed.
The job has changed because the bottleneck has moved. When you’re using autocomplete, your bottleneck is the same as it ever was: how fast you can think and type. When you’re using leverage, your bottleneck is how clearly you can specify what you want, and how well you can verify what came back.
The thing nobody tells you about agents
I run two or three agents in parallel most days. One refactoring something, one writing tests, one investigating a bug. Sometimes I’m the bottleneck — I can’t read the diffs fast enough — and that is a new feeling. Twelve months ago the bottleneck was always typing. Now the bottleneck is whatever isn’t the agent.
What this does to your day is strange. The actual hands-on-keyboard time drops. The reading time goes up. The thinking time stays roughly the same. The decisions per hour goes way up. By 4pm you are mentally exhausted in a way you weren’t before, because you spent the day making twenty decisions about other code instead of writing your own.
This is also why "AI replaces programmers" is the wrong frame. The agent is not the programmer. The agent is the typist. You are still the programmer — but the verb you do most is no longer "write," it’s "review."
The two skills that actually matter now
If the bottleneck has moved from typing to specification + verification, then the skills that pay are the ones that produce a tight specification and a fast verification loop. Specifically:
Skill one: writing briefs that survive interpretation. An agent will do exactly what you said, which is not the same as what you wanted. You learn to write tasks that have no ambiguity — the way you used to write Jira tickets for a contractor in a different timezone you’d never met. "Refactor the auth flow" is not a brief. "Replace the JWT verification in src/lib/auth.ts with the helper in src/lib/jose.ts, keep the public function signature unchanged, update the three callers, run the test suite" is a brief.
Skill two: building a verification surface the agent can hit. If the only way to know whether the agent did the right thing is to read the diff and run the app, you will be a bottleneck. If there’s a test suite, a typecheck, a build, a smoke test — the agent runs through them itself and only surfaces work that’s passing. The verification surface IS your leverage. People who think "tests are slow" are about to find out that tests are the only thing that lets them go fast.
The honest part
Autocomplete still works. I still use it. It’s genuinely helpful when I’m in the middle of something and just need the next 4 lines. But it is a small win. The leverage win is the big one. And the leverage win is invisible to people who haven’t made the switch — because from the outside it just looks like the same job, slightly faster.
It’s not the same job. It’s a different one. Worth knowing.
