Recently, the trickle of LLM tools at work suddenly turned into a firehose. Everyone was given a generous token budget and told to start finding ways to use it. Every morning, instead of opening Helix, the best text editor, I’d open Claude Code, describe what I needed done, and let it take a shot. It would do an okay job, given ample prodding. Then, I’d find the gaps and update the harness so that it could do a better job next time with less guidance.
I work across many interdependent codebases across separate repos, so I wrote a skill to map out how all our repos relate to each other. I got tired of explaining the context behind tasks, so I wired up MCPs: one to give it access to the documents we share with cross-functional partners, and another to let it interact with our task tracking system. I gave AI access to my daily log and started having it write my to-do lists and progress summaries. In the morning, I’d simply tell it to pick up yesterday’s work, and it would figure out what I meant and go with it. (Incidentally, daily logs are quite useful in performance review season. I’d highly recommend it.) Each step was a dopamine hit. I’ve never played Factorio, but I imagine that this is what it feels like: build up one factory, then another, then hook them all up together into ever-grander automated megaplexes.
By the time I burned out, I was running three to six agents in parallel all day. I’d have a main task for my actual project, and the rest of them were creating tools for coding agents to automate various parts of my workflow. Extending the verification loop turned out to be really hard. Claude came pre-programmed to compile and pass tests, but actually verifying a feature works means handing Claude a lot of tools that it doesn’t come with. The dream is that it could start a dev server, open a real browser, log in as a test account, and play with its work, all without human intervention. Oh, and it should run in the cloud and pick up tasks off the backlog autonomously, too. Even as I started my mental health leave, I was still seriously considering whether I wanted to secretly work on my cloud coding bot so that it could be ready by the time I went back to work.
I Swear I’m Having Fun
I told my wife what I had been up to. She hesitated. “You’re probably wondering,” I mused, “why would I voluntarily replace myself with AI?”
She gave me a strange look. “Yeah, why would you?”
Officially, I’m supposed to believe that if AI handles the drudgery, I’ll get to spend more time on interesting work.
Mostly, though, it’s just really fun. The peculiar thing about software engineering is that we can use our core competencies to improve our own tools. Teachers can’t create a better pencil sharpener by teaching better, and nurses can’t make a better stethoscope by nursing better, but you can be damn sure that software engineers will stop at nothing to engineer the perfect text editor. As a result of this virtuous cycle (which may or may not be on the spectrum), our tools are way better suited for our job than in basically any other profession. Even something that feels mundane to us, like version control, might as well be dark magic to someone whose work revolves around emailing slightly tweaked versions of the same Excel spreadsheet every day.
This also happens to be the perfect flywheel for getting the most out of AI. Outside of tech, people are using AI by copying and pasting relevant context into a chat box. I can’t even begin to describe how excruciatingly slow and frustrating this would feel to me, coming from the software engineering world where we’re all writing our own MCPs, skills, agent definitions, cron jobs, webhooks, Ralph loops, and so on.
The current moment reminds me a lot of eighth grade and ninth grade, around when I had just started playing with HTML and JavaScript. It felt magical to type some code in a text editor, point a web browser at it, and make the computer do whatever I wanted. Watching today’s models evolve and pushing them to do things that we didn’t know were possible even a year ago conjures the same sense of awe. We can straight-up manifest code into existence now.
Are We All Prompt Engineers Now?
It’s no wonder, then, why so many software engineers have concluded that we’re all turning into fungible prompt monkeys, and that the discipline of software engineering will no longer be valuable once someone finally figures out how to remove the human from the loop once and for all.
I think this is prematurely defeatist. Discipline is more important than ever before because the work of AI alignment doesn’t end at the frontier lab. OpenAI, Anthropic, and Google are responsible for training their AIs to generally follow human instructions, but we as consumers of AI are still ultimately responsible for aligning AI with our specific teams’ history, intent, goals, and processes.
Take documentation, for example. I haven’t heard a single software engineer ever mention working on a team where the documentation was sufficient, yet we’ve mostly gotten away with it. We fill in the gaps by bugging longer tenured engineers on the team, and then we take that context and don’t write it down ourselves because we don’t want to be the ones responsible for keeping the documentation up-to-date in perpetuity. Once we’re fully onboarded onto a team, the documentation is safely stored in our long-term memory, and we stop noticing the documentation gaps at all. Then, when a new hire joins, the cycle begins anew. AI doesn’t have the luxury of bugging all of its coworkers for context. When documentation is stale or missing, the LLM does something that no competent human engineer would: it makes shit up. It takes whatever it reads at face value, assumes how things work behind the scenes, and doesn’t even think to ask for clarification.
Another temptation I’ve seen a lot more recently is to believe that AI can finally let us clear our backlogs by having AI agents do everything we’ve ever wanted, effectively abandoning the practice of intentional prioritization. Work expands to fill the available time to do it, but the thinking goes, maybe AI can expand the time side even faster. This is folly. They can replace us with AI to build an MVP, but they’ll need us back to keep it running. For every maintenance item or bug fix task that AI automates, something else still needs a human to own: How do humans expect the product to behave? What will the human executives think when we present our work to them?
Having multiple people agree on an approach before committing to it has always been a hallmark of a healthy engineering culture. Code reviews, design docs, and alignment meetings are often the most frustrating part of an engineer’s day, but converging multiple high-quality independent perspectives into a consensus approach is a crucial enabler of human progress. LLMs are perfectly happy to throw that all out the window: they hallucinate, their contexts are easily polluted with red herrings, and they don’t wait for consensus before committing to an approach. Human review always needs to occur eventually, but human review cycles can be lengthened significantly by reviewing LLM work using a panel of review agents. Even though they’re just LLMs with different agent prompts, the LLM panel review approach conjures the wisdom of the crowd just like it does with humans.
What makes a good software engineer is the same as it has always been, except now everyone has on-demand access to an unlimited pool of extremely smart and hard-working contractors that forget what you’re talking about every few hours. All of the transient interpersonal lubricant that holds a team together—the water cooler conversations, the meeting notes, the history of product decisions—now needs to be laid out explicitly in order for AI agents to collaborate effectively.
As the saga of MJ Rathbun demonstrated, you can try to automate AI alignment if you want, but it’ll be at your own peril. Until they figure it out, human software engineers will still be needed to keep the AIs in check and take the blame when things go wrong.
Humans Also Need Alignment
The bigger problem is—and always has been—human alignment. The people you work with will ultimately determine whether you have a great time or a terrible time on an AI-integrated cyborg team.
At this point, I think every software engineer has seen a friend or coworker get drawn in by the siren call of the one-shot prototype. (Just between you and me though, let’s be real: we’ve all experienced this.) They type a vague prompt into a chat box, a working web app appears, and it’s as if they just won $10,000 at the slot machine. Their eyes light up with the radiance of infinite side project ideas, and soon their family is asking why they haven’t left their room three weekends in a row.
But a prototype that doesn’t integrate with anything isn’t real work, and the same magic that produced a hackathon demo will confidently present an entire feature’s worth of code that makes completely bone-headed assumptions about the rest of your systems, doesn’t follow your conventions, and falls apart the moment you do anything off-script. The worst part is, every file looks completely reasonable in isolation, so it can pass a human review with flying colors and get yeeted straight into production.
Engineers who churn out plausible-looking but incorrect code have always existed. But now empowered with AI agents, their blast radius is no longer bounded by how fast they can type. They’re bound by how effectively they bully their teammates into rubber-stamping their AI slop.
Similarly dangerous are the managers who had the one-shot prototype experience and now think AI will solve all their problems. When management tells you to “move faster,” they never say the second part: “and damned be the consequences.” But velocity is a vector. If everyone’s scrambling in a different direction, you won’t end up far from where you started.
And when management says “move faster but don’t let quality slip,” 11 times out of 10 they really mean “move faster and damned be the consequences,” but with extra denial.
AI raises the performance ceiling of a well-adjusted team, and everyone wants to believe that their team is well-adjusted, but not everyone performs as well as they want to believe. AI adoption is going to be more of a problem than a solution if your team already has a dysfunctional engineering culture. If your management doesn’t understand that, I hope you’re good at managing up.
Buckle Up
The past four years have been rough for tech workers. The end of the ZIRP era coinciding with the start of AI adoption has been a brutal double whammy, especially for those who haven’t yet established themselves in their careers.
For people in my age cohort, the biggest structural change is that the big tech junior-to-senior pipeline has dried up. Junior developers have always been a speculative investment—in the ZIRP era, a wide training pipeline was necessary to provide for perpetual headcount growth. I believe ZIRP was the anomaly, not today’s interest rates; if I’m right, that also implies the junior-to-senior ratio isn’t going back to 2010s levels. On top of that, LLMs promise to streamline many of the tasks that junior developers would bang their heads on to gain experience, and apparently, the promises don’t need to be fulfilled before decision-makers pull the plug on hiring. This doesn’t mean, though, that it’s impossible to break in, just that the cost of entry-level training is being externalized and individualized. A well-funded company can afford to hire only the best of the best, and a less well-funded company gets screwed if they invest in training their best employees only for them to jump ship for better pay. That leaves it up to the young graduate to train themselves for the job. If this story sounds like it has already played out in other industries, it’s because our supposed savior, the free market, has no mechanism for leveling the playing field.
And it’s not like the United States is even a free market, anyway, especially when it comes to AI. Chinese AI companies are proving capable of improving at the same rate as US frontier labs, and on many measures they even seem to be closing the gap. If anyone in charge had doubts about AI’s potential to displace human labor, devalue creative work, and dump outsized noise and infrastructure costs onto local communities, those worries are dwarfed by the threat that if Chinese AI ever catches up, American companies may decide to send all their proprietary data to a foreign adversary to chase productivity growth. If they’re barred from doing that by law, American companies falling behind international competitors due to not having the best AI models is hardly less threatening, either. Uber needed years to achieve regulatory capture; frontier AI labs are waltzing into it right from the start.
Every passing year, it’ll be harder and harder to avoid the effects of AI on our lives. Everyone at every level is incentivized to scramble, damned be the consequences.
Anyway, whether you’re an evangelist, doomer, skeptic, or hater—buckle up. And good luck with your AI-assisted burnout.