Writing Code in the LLM Era — are we still programmers?
I started writing code in an old era — before Stack Overflow existed, when coding was seen as a dark art and you learned from books. If you got stuck, you posted on a forum and waited hours or days for an answer. Often the answer wasn’t even helpful.
Coding was slow. Write, compile, run, debug, repeat. Grueling — but also deeply rewarding. When something finally worked after hours of fighting, the sense of accomplishment was real.
Enter Copilot
Thanks to my university student status I got early access to GitHub Copilot, and it was a game changer.
Not just autocomplete — it completed entire lines, entire functions, pulling context from the surrounding code. It felt like having a blazingly fast pair programmer. Sometimes dumb, often good enough, always fast.
At first I was skeptical. I thought it would make me lazy, erode my skills. It didn’t. It actually made me write better code — surfacing approaches I wouldn’t have thought of, generating patterns I hadn’t seen before. Reading, reviewing, and accepting a suggestion is much faster than typing from scratch, and you still understand every line.
The agent shift
Then came the chat inside the IDE, and I hated it immediately.
I am the human. I do the thinking. I do the coding. A chat felt like a gimmick.
I was wrong.
Once the chat stopped being a chat and started becoming an agent, everything changed. It wasn’t about asking questions — it was about delegating tasks.
That boring CRUD you’ve written a hundred times?
“Write me a CRUD based on how it’s done in this other class.”
Done.
Tests? Great idea, terrible chore. I like creating things. Writing code that checks if the code works is not creating, it’s bookkeeping. And now?
“Write me tests for this class.”
Done.
Then came Claude
Copilot was impressive. Claude is a different category.
Not just smarter suggestions — a full agent that reads your entire codebase, plans changes across multiple files, writes code, runs commands, reads the output, fixes its own mistakes, and iterates. You describe a goal. It executes.
I rewrote this entire website from Hugo to Astro — new framework, new theme, custom terminal design, animated typewriter effect, MDX support — and I barely typed a line of code myself. Directed it? Yes. Reviewed it? Yes. Wrote it? Not really.
And here’s the uncomfortable part: it did it faster and with fewer mistakes than I would have alone.
The gap between what a senior developer can produce in a day and what Claude can produce in an hour is no longer a gap — it’s a canyon. The average programmer, grinding through boilerplate, looking up docs, copy-pasting from Stack Overflow — that workflow is effectively obsolete.
This doesn’t mean programmers are obsolete. But it does mean that being average is no longer enough. If you bring the same value to a task that an LLM does, you are being outcompeted. Silently, cheaply, and at scale.
Are we still programmers?
The LLM era is making coding faster, more efficient — but it raises an uncomfortable question:
If a machine can write the code, do we still need to know how to code?
I think the answer is yes, but differently.
You still need to understand what the LLM is doing. You need to read and evaluate the code it generates — spot security issues, performance problems, design mistakes. For that, you need a solid grasp of frameworks, patterns, best practices, and trade-offs. The LLM is only as useful as the person directing it.
What about the joy of it?
Here’s the harder question.
What about opening the IDE with a half-formed idea, watching the code take shape as you write it — the repository growing organically, the architecture emerging? What about the pure satisfaction of solving a problem with your own two hands?
When an LLM can replicate that process in minutes, what’s left?
I don’t have a clean answer. But I don’t think the soul of code lives in the keystrokes. It lives in the idea, in the problem being solved, in the impact it has. The creativity, the vision, the obsession with getting it right — those are still ours.
Where this leaves us
Two years ago I would have said code written by a machine will never have the soul of code written by a human. I’m not so sure anymore.
The role is shifting. The programmer of the future is less about being the fastest typist or knowing every language quirk, and more about being:
- a good architect
- a sharp problem solver
- a rigorous reviewer
- a clear communicator
Was that what I imagined when I started coding? No. Will it be fun? I genuinely don’t know — but I’m curious.
Closing thought
I sometimes miss the old days. Then I remember that I rewrote my entire website in a new framework in under 30 minutes.
Would I have done that without an LLM? Probably not. The old version would have stayed forever, rotting quietly.
Why not rewrite that old codebase you’ve been avoiding? Why not finally start that side project you’ve been putting off for years? Why not learn that technology you never had time for?
Writing code has changed — faster, less personal. But it doesn’t have to be less creative or less rewarding. It just means thinking of ourselves differently: not as code monkeys, but as orchestrators.
The love of building things, solving problems, and exploring what’s possible? That part doesn’t go away. It just gets faster.