Jorge Manrubia

December 30, 2025

Back to the starting line

I loved this reflection by Andrej Karpathy about how he has never felt so far behind as a programmer. In particular, this line resonated strongly with me:

I have a sense that I could be 10X more powerful if I just properly string together what has become available over the last ~year and a failure to claim the boost feels decidedly like skill issue.
Behind whom? We all got put back to the starting line. Everyone.

Andrej is one of the most influential figures in modern AI, just as Kent Beck is in modern software engineering. Food for thought, huh?

A personal blog lets you revisit your past thoughts. I know that in 2022 ChatGPT was making my jaw drop; that in 2023 I was blown away by the productivity boost and the learning possibilities. This year, I tried agentic coding for the first time via Claude Code, and it instantly became essential to the work I did in 2025, which includes Fizzy and Lexxy.

Programming with AI is still in its infancy, and yet it has already redefined what programming will be about in the immediate future. As a programmer, you are going to interact with a frigging robot that writes code on your behalf. What was science fiction yesterday is now a new reality, and it raises many questions. I won’t pretend to have any answers here, just assorted thoughts.

First, manipulating code through natural language is far more efficient. It’s a faster and less brittle process. You may still enjoy your editing shortcuts or how quickly you can refactor with your regex skills, but, for the most part, all that has become obsolete overnight. The first piece of advice in The Pragmatic Programmer was to know your editor. There’s no question this is still a valuable (and enjoyable!) skill, but its value in the overall picture has suddenly dropped to a fraction of what it was.

Second, there are many programming tasks that are methodical in nature, where an AI can do a better job than a human. The list is endless: from troubleshooting bugs to determining which APIs to invoke; from figuring out where a regression was introduced to writing tests that cover specific functionality.

As with low-level code manipulation, AI can turn these tasks into toil: manual, repetitive, and automatable work. Orchestrating agents to take care of them makes programming more fun: you can get more done and focus on the more interesting and creative parts of the job.

Third, AI doesn’t change the motivation for technical excellence. Current AI doesn’t turn software systems into black boxes where you can ignore what happens inside. You still want your systems to be intelligible to you and to other humans. Both humans and LLMs benefit from good design, clear boundaries, proper distribution of responsibilities, tight and concise code, clear interfaces, consistency, and so on.

The undeniable power of LLMs to get things working at the expense of AI slop can be a double-edged sword. After all, “AI slop” is just another term for technical debt. You can incur it to move faster, or simply because you don’t know any better, but it is well known in software engineering that you will pay increasing interest if you don’t repay it. A faster way of generating technical debt should make you extra vigilant.

I haven’t seen any evidence that AI will make expert programmers running the show redundant anytime soon (hopefully, those won’t be my famous last words). Instead, the new challenge for programmers is knowing how to leverage AI to unlock this new potential. Using AI won’t be a skill that replaces other skills you have, but a basic foundation to express those at the new expected level.

My current usage of AI could be described as using it all the time, but with tight direction and supervision. My regular flow now is to get an initial spike via an agent and then start instructing it until the code looks the way I want it to. This affects the big picture, of course, but also the small details:how things are named, how methods are composed or structured, and so on. Sometimes, manual editing is just faster, but I’ve found manipulating code via AI surprisingly fulfilling. You can make changes faster and more predictably, with less back and forth.

And it’s here where the opening tweet resonated with me. This year, I’ve been using my best common sense to work with agents. I quickly learned things like how important prompts, memory, and feedback loops are. But even if things didn’t evolve—and they do every few months—I feel like I’m only using a fraction of this new superpower at my disposal. Tweets like this make me realize I have a lot to learn, and also that I need to be far more intentional and creative in how I use AI than I have been.

Learning and improving should be lifelong goals for anyone. Seeing a green field ahead in your discipline is energizing.

About Jorge Manrubia

A programmer who writes about software development and many other topics. I work at 37signals.

jorgemanrubia.com