Some of the best software engineers are leaving the discipline
For some, coding in the age of agents just isn't worth it
A friend of mine runs an engineering team. His best engineer, or the person who was unambiguously his best engineer a year ago, now mostly wants to refactor code. Careful, beautiful refactors, for good reasons. It’s also a terrible idea, because an agent will overwrite every line of it within the month.
I’ve had a version of this conversation three times in the last month with different friends. The specifics vary (one refuses to ship anything but code written by himself in vim, another doesn’t like reviewing or testing agent written code), but the broad theme remains: rather than being transformed in a way that accentuates skill, the software engineering job has changed in a way that makes different skills altogether valuable. All three friends expect to lose the employee in question, because their once-star employee just doesn’t seem to have task relevant skills anymore.
Keeping up with Codex
The default assumption about engineers struggling in the agent era is that they just can’t keep up. That they’re unable to adapt. They’re not fast enough. Sometimes, very uncharitably, that they hate progress.
Or, sometimes I hear the claim that AI has entirely displaced junior engineers, and there isn’t any value that they can add anyway - it’s only the seniors who still have value to add.
In my experience, none of the above are true. There is no uniformity: the ones who are having trouble adapting are not all junior engineers, nor are they ones who can’t keep up, nor ones who have a problem with progress. In fact, I’m often finding that they are the strongest engineers - or at least they were unequivocally strong prior to coding agents.
I now know four engineers who have left their jobs because they prefer writing code by hand. Two of them might leave the profession. All four are very smart, incredibly capable engineers.
Every productivity tool before this one killed work that everybody hated
People struggling to figure out what advancing technology is going to do to their craft isn’t a new story at all. Even within software engineering, some significant improvements in tools include:
Compilers, 1957: killed hand-writing machine instructions
Terminals: killed submitting punch cards and waiting overnight
Packages: killed rebuilding what someone already built
Stack Overflow: killed memorizing
In each of the above, there was plenty of grumbling. Assembly programmers called compiled code “not real programming”. When tons of javascript packages started getting released, there was a ton of framework churn and a common complaint was “programming is just plumbing now”. But, the grumbling faded every time.
There are two differences between the previous revolutions and the agentic one: 1) they mostly killed the work that no one liked doing anyway, and the point of the job survived each one, and 2) each one took a decade to happen, so you could steer your career around it in whatever way suited you best. Not so with agentic coding.
This time, I would start the clock at May 2025, when Claude Code got really good as an agent harness. Within a year, for many engineers, life had completely changed - they never look up documentation, many choices are made for them, they barely write code, and they never write tests themselves. And there doesn’t seem to be any sort of settling point either, the engineering job spec seems to continue to change every quarter.
But this time the change looks different depending on who you ask. For some people it looks like the previous ones: it got rid of a chore (writing out code). But for a different kind of person, crafting the code was the whole point of the job. It’s the first tool in seventy years of the profession to split practitioners on whether it took the joy away.
The two passions
It turns out, in software engineering, there were two passions that animated people.
Making things exist
The making itself
And the filter for hiring software engineers was “can you write code” and people with either passion could pass that. Resumes, interviews, and CS degrees didn’t differentiate those two passions either. Leetcode certainly didn’t.
So, this split never became obvious, until agentic coding. Call the first group the makers, and the second the artisans.
The makers are really thriving - for them, writing code was a hindrance to making things exist, and that hindrance is getting more and more solved.
And the artisans are really struggling - what’s the point of writing beautifully engineered code if some agent is going to overwrite it with slop in the next commit anyway.
Coaching
I should say that I build AI agents for a living at woodrow.ai, the kind that will do this to other professions, so I’m not writing this from the sidelines.
The engineering managers I’ve talked to are trying their best to resolve this by coaching the artisans into operating better in the new world. Either by doing different kinds of work, or by adapting and using agents more. The obvious fix is to make them the reviewers and architects; nobody is better qualified to catch agent slop. But ability was never the problem. You can’t coach someone into loving different work.
I don’t think it’ll work, and I get the sense that the eng managers don’t think it’ll work either. What’s most likely to happen is that they’ll leave that particular job, and try to find a job under a CTO who themselves is an artisan, and is committed to remaining one, and has the support of the rest of their leadership to stay that way. I think many of those jobs will continue to exist (but that they’ll be a minority), and there will be a role for the artisans.
However, some won’t be able to abide by this revolution, and will leave the profession. But, they’ll be fine. They are talented systems thinkers and puzzle solvers, and there are many places a puzzle solver can apply themselves without AI taking away work (so far). But fine is doing a lot of work in that sentence; a professional athlete who retires at thirty is also fine.
The makers aren’t philistines, and the artisans aren’t luddites - they just wanted different things.
Somewhere right now, the best engineer on the team is refactoring a feature for the third time, even though it will just get washed away by more AI commits. Beautifully engineered code, for readers who are never coming. The want migrated from the outcome to the activity, and only one of those was ever for sale.