I’m Not Sure I’m a Programmer Anymore

A developer’s honest reflection on the most disorienting — and exhilarating — shift in software history.

A few days ago, Andrej Karpathy posted something that stopped me mid-scroll:

“It is hard to communicate how much programming has changed due to AI in the last 2 months… Coding agents basically didn’t work before December and basically work since.”

He described giving an AI agent a plain English task: set up SSH keys, install vLLM, download a model, build a web dashboard, configure systemd, write a report. He pointed it at his home server and walked away. Thirty minutes later, it was done. Not mostly done. Not a rough draft. Done.

He wasn’t demoing a prototype. He was reporting a field observation. The thing we’ve been waiting for quietly arrived.

And the truth is, I’d felt it too. I just hadn’t put words to it.

The Shift I Watched Happen

I’ve been using AI coding tools for over a year. Early on, they felt like smarter autocomplete. Useful, sometimes impressive, but limited. A strong pair programmer for boilerplate. Weak on context. Brittle when things got complex.

Late 2025 into 2026 felt different.

The leap wasn’t just better code generation. It was coherence. Older agents drifted. They contradicted themselves, forgot earlier constraints, or looped on simple errors. You’d spend half your time correcting them.

That brittleness is mostly gone.

The agents I use now show persistence. They hit a wall, search for answers, try alternatives, fix their own mistakes. They don’t just produce code. They execute tasks.

To be honest, I haven’t written much code myself in the past two months. I delegate most tasks to agents and review what comes back.

That sentence would have sounded absurd a year ago.

Two Feelings, Pulling in Opposite Directions

Here’s the contradiction.

As a builder, I’ve never felt more capable. The gap between idea and working software has collapsed. Projects that once took weeks now take days. Side experiments I would have skipped are suddenly worth trying. I can move at the speed of my curiosity.

It’s exhilarating. And frankly, a little addictive. The feedback loop is tight. One idea leads to another. You look up and it’s 2am, not because you have to keep working, but because you want to.

The creative ceiling just moved higher.

But as a coder, I feel something else. A low hum of unease.

It’s not fear of losing my job. It’s subtler than that. It’s the feeling of a skill you worked hard to develop slowly becoming optional.

I love writing clean, thoughtful code. I love solving hard problems. I love understanding a system deeply enough to make it elegant.

Now I’m aware that loving a skill and needing it are not the same thing.

Karpathy put it bluntly: you’re not typing code into an editor the way we have since computers were invented. That era is ending.

I think he’s right. I’m still deciding how I feel about that.

What This Means for Developers

Panic is the wrong response. Pretending nothing has changed is just as wrong.

What Karpathy calls “agentic engineering” is real. The job is shifting from writing every line to orchestrating systems that can write and execute for you.

That’s not just prompting. It requires judgment.

The developers who thrive won’t be the ones who type clever instructions. They’ll be the ones who understand what’s happening under the hood. The ones who can spot subtle bugs. Who know when an approach is wrong. Who can steer an agent because they understand the system it’s operating in.

The craft isn’t disappearing. It’s moving up a layer.

We’ve seen this before. Assembly to high-level languages. On-prem servers to cloud. Each abstraction shift rewarded people who understood both levels: the new tool and the foundations beneath it.

That still applies.

There’s also something worth protecting on purpose: the joy of writing code yourself.

Not every line needs to be delegated. Wrestling with a tough problem. Building something small and clean from scratch. Knowing a codebase inside out. These experiences sharpen your judgment. They make you better at directing agents. And they’re valuable on their own.

Efficiency isn’t the only metric that matters.

The unease many of us feel isn’t a warning to quit. It’s the discomfort of transition.

The Honest Takeaway

I love coding, and I’m not going to give that up.

But I need to expand my identity.

The future probably doesn’t belong to developers who type the fastest. It belongs to developers who can define problems clearly, evaluate outputs critically, and guide systems that operate at superhuman speed.

That’s not redundancy. That’s leverage.

The best version of this shift is one where deep technical skill becomes more powerful, not less, because it’s paired with tools that amplify it.

Karpathy framed his post as an observation. When I read it, it felt like an invitation.

The era of typing every line by hand is fading.

The era of building faster and more ambitiously than ever might just be beginning.