jorgemanrubia.com / Posts

Oh my craft!

I am rarely opening my code editor anymore. And when I do, it is only for reading. It’s been months since I wrote a single line of code myself. The thing is that I used to live inside it, and I considered crafting every little code detail an essential part of what I do. The strange thing is that I haven’t felt sorry about the loss for a second. I don’t remember feeling this energized about building software in a long while. What the hell happened here?

My thoughts about AI have been changing as quickly as the models have evolved:

  1. 2023: ChatGPT is amazing for learning and writing code snippets
  2. 2025: Started using Claude seriously at work in April, and by the end of the year I was already blown away by the paradigm shift. Agents were amazing, but needed close supervision and steering.
  3. 2026: Models keep getting better and they are, in many scenarios, just better programmers than me. My attention shifted to how to get the most out of this unthinkable technology, which we still need to steer closely. Well, that was the first half of the year; I don’t believe supervision has to be so close anymore. And 2026 hasn’t ended yet!

My experience with the first agentic models was that the generated code mostly worked, so it was a matter of getting it into shape. That already represented a huge productivity boost, especially since the agent could also help with the latter.

The thing is, the need to intervene on the small stuff is decaying quickly as models improve. Agents are increasingly better at respecting your coding style and idioms, which is essential. And when models are capable enough to handle those details themselves, spending too much time there starts to feel like a poor use of your human attention.

Just an example from this week: I got Claude Opus working on some spam mitigations for HEY. It introduced a “cluster” domain entity that nicely encapsulated the new checks we needed in the existing “reputation” entity.

class Account::Reputation
  # ...
  def cluster
    @cluster ||= Cluster.new(account)
  end
end

class Account::Reputation::Cluster
  def nearby_accounts
    # ...
  end
end

class Account::Reputation::Audit
  # ...

  private
    def nearby_accounts
      reputation.cluster.nearby_accounts
    end
end

That totally feels like code we would write ourselves. I didn’t add indications about how to do it and we don’t have agentic style guidelines for HEY. The LLM just analyzed existing conventions and extended those. These kinds of design decisions are the ones I would find myself making just weeks ago.

I am not saying you can blindly merge code now. I am just identifying the trend. The times of good old software craftsmanship are changing, and they are changing fast, at least for professional software development. I am sure a counter-movement celebrating manually sweating every character in your software is in the cards down the road.

So, what is left for software engineers? I believe that… a lot! Let me explain. I see three areas of technical competence:

  1. Code design and implementation, which you can’t really separate from each other.
  2. High-level design: architecture, domain model and vocabulary, subsystems, dependencies, interfaces, technical stacks, etc.
  3. Use this new AI sorcery, which I am sure consultants will call agentic engineering or something like that. Hear me: sorcery.

I am seeing the bulk of (1) fade away in front of my eyes, even if reviewing code will be present for a while, and that requires all the skills of a pre-AI programmer. I believe (2) will require a decent amount of human steering for the foreseeable future, and it is an area where experience pays off. And (3) is the Wild Wild West for our discipline to discover. The more I work with AI, the more my focus is changing from (1) to (3).

I had this realization recently, when working on a large refactoring in Basecamp. I wanted to unify different systems we were using for both pagination and drag & drop across the app. The Basecamp codebase is 12 years old, the product surface is huge, and we have quite a bit of legacy JavaScript, so this was a large effort.

I had used agents enough to be ambitious here. I had agent Marie (Claude Opus) plan all the work in individual cards across two Basecamp tables. I asked Marie to ask me whatever clarification she needed; she did, and I addressed a bunch of questions. Then I got it to work on all the cards. I got a Fable review to tighten up the code, and a Codex adversarial review to polish things further.

In the back of my mind, I was always expecting to do a lot of code reviewing. I wanted to postpone the moment until the code was in the best possible AI-shape. Before reviewing the code, I wanted to be sure it worked, so I asked Marie to prepare a system where it would seed the data and include clear instructions for me to test the different screens. I manually reviewed dozens of screens this way, detected a bunch of minor visual bugs, and the agent fixed them all. This represented the bulk of the work I did.

When it was code-review time, I only had to offer minimal input, to my surprise. Small aesthetic stuff. I was really NOT expecting that.

Pre-AI, this would have been a multi-month effort. I could finish it in one week (with QA pending, to be fully transparent). It left me with two lessons, though:

First, I should stop assuming that I know much better than the current frontier models, even in systems I know inside out.

Second, the agents could have caught many of the bugs I did automatically, if I had asked it to take GIFs for the interactions and compare them, making it clear I didn’t want any visual regression. I needed to level up how I use AI for the next one!

A recurring thought I have is that we are only scratching the surface. Just with this example, why not automatically prepare ad-hoc mitigations when detecting SPAM waves? Why not have an agent monitor legacy duplicated systems to unify and improve them?

Before AI, the space of things we could imagine building was always effectively infinite; our capacity to actually build them was not. Now, the mechanisms to build abstractions are just limited by our ability to think and to express those thoughts. The paradigm shift is so abrupt that I think it will take the next decades for our discipline to start taming it.

That is where I am putting my attention next.