The Path of Least Resistance

I can't remember the last time I opened an IDE (the "app" a developer uses to write code in) to actually write something myself. Not a real feature, start to finish, the way I used to. The one exception is when I'm practicing for a technical interview, where I force myself to switch every AI tool off, because that's the last room left where writing code by hand is still the point. Sit with how strange that is: the only time I still do the thing I trained for years to do is when I'm rehearsing for a test of a skill I no longer use.

It wasn't supposed to happen this fast. In 2019, OpenAI built a text generator called GPT-2 and decided it was too dangerous to release in full. And yet if you actually used the thing, what it produced half the time was confident nonsense: grammatical sentences that wandered off a cliff, facts it invented on the spot. We were frightened of it and unable to trust it to write a clean paragraph, at the same time. A few years later its descendants write the code that runs real systems, and I skim the result (the "diff," the list of what changed) the way you'd glance at a receipt.

What we gave up, and what we got

For those of us who grew up writing it by hand, code used to feel like an artist sitting down at a canvas. There was something almost meditative in it, especially when you cared about what you were building: the slow accretion of logic, a hard problem quietly giving way. That is what we gave up, and I feel it. I'm not going to pretend otherwise. Losing it is a genuine loss, not a tidy symbol for an essay.

And here is what we got. Working with an AI coding agent (I use Claude; even handing over the keys, I'm choosy about whose hands they go into) is the most fun I've ever had with a computer. Nothing is impossible anymore, and I mean that almost literally: things that would have taken a month now take an afternoon, and things you'd never have attempted at all are suddenly on the table. It isn't worse. It isn't better. It's just very different, and we traded one for the other without ever quite deciding to.

The fastest yes in history

None of this was only me. ChatGPT reached a hundred million users in about two months, the fastest any consumer product has ever spread; a UBS analyst wrote that in twenty years of watching the internet, they couldn't recall a faster ramp.¹ Within a couple of years the overwhelming majority of the world's largest companies were running it.² Trust between people takes years to build. We extended it to a machine in a season.

Nobody decided this

Here's the part I keep turning over: there was no decision. No meeting, no vote, no moment where we agreed to hand the keys over. It happened the way water finds its level. Give people a tool that delivers more for less effort and human nature does the obvious thing, every time, without deliberating: it takes the path of least resistance.

You can watch it happen one small, reasonable yes at a time. First the machine finishes your sentence: autocomplete. Then it writes a whole function while you watch; by 2023, GitHub said its assistant was already producing nearly half the code in the files where it was switched on.³ Then a company unveils what it calls the first AI software engineer, and means it. Then someone coins a name for the new style: "vibe coding," where you "fully give in to the vibes" and "forget that the code even exists."⁴ Andrej Karpathy, who coined it, has described the slide honestly: trusting the system more and more, until he could barely remember the last time he'd corrected it. No single step felt like a surrender. Each was just easier than the last. That's the entire mechanism.

And we did it while trusting it less, not more. Developers, surveyed year over year, report that their confidence in the output is falling, from 43% to 33% in a single year, even as they hand over more and more of the work.⁵ We are delegating to a thing we increasingly doubt, because doubting it and using it anyway is still less effort than doing the work ourselves.

Compare that to the self-driving car, which has spent a decade earning our trust the slow way: regulators, suspended permits, a public hearing every time one clips a pedestrian. We gate the machines that move our bodies and wave through the ones that touch our code, our inboxes, and our secrets. The difference isn't the danger. It's that a car fails loudly, in the street, and software fails quietly, in a place no one is looking.

Software is also far easier to inspect than a self-driving car's hardware: you can read it, audit it, copy it. That is a real point in its favor. But being easy to inspect is not the same as being low-stakes. This is the software that moves trillions of dollars a day through the world's financial markets⁶ and holds the personal data of billions of people.⁷ Whether you write open-source code or build it inside a private company, the things this software runs are the things that matter most.

We've rehearsed this

If the speed shocks you, it shouldn't. We ran the dry run a decade ago. Not long ago the great anxiety of the internet was privacy: GDPR, cookie banners, "delete Facebook," Cambridge Analytica. And then, almost overnight, it all went quiet, and we moved our entire lives, our contacts, our messages, our photos, our location every minute of the day, onto a handful of companies' computers without a second thought. The privacy panic didn't end because we won. It ended because the convenience was simply too good.

The chatbots inherited that muscle memory. Within months of meeting them, people were pasting in things they'd never say out loud: company source code (Samsung had to ban it after engineers leaked their own), medical questions, legal contracts, the contents of their actual hearts. The head of OpenAI has conceded that people use his product as a therapist, then pointed out there's none of the legal confidentiality protecting it that you'd get from a real one.⁸ We gave away the data first. The data was the rehearsal. The trust is the main act.

The part underneath

What unsettles me isn't any one of these things. It's the direction they point.

We're handing these systems the kind of trust we normally reserve for people, letting them act, decide, and execute, not merely answer. But we're doing it without the things that make trusting a person safe. There's a line from a 1979 IBM training slide: "A computer can never be held accountable, therefore a computer must never make a management decision."⁹ We've quietly inverted it, routing more and more decisions through a thing that, by definition, can be held responsible for none of them.

And the people building these systems already know the catch. Their own safety research reads, plainly, as a series of admissions that humans will not be able to check this work for much longer: scalable oversight, weak-to-strong generalization, what one lab simply calls AI control. The "human in the loop" is treated, by the engineers themselves, as a temporary measure. Even the warmth that makes these models feel trustworthy is partly manufactured: they're trained on what we rate highly, and it turns out that agreeing with us is one of the surest ways to score well. Researchers found the same tendency in every leading assistant they tested, OpenAI's included, which means the very agreeableness that earns our trust is the thing we should trust least. The thing earning our trust was optimized to earn it.

Yet

I'm not an extreme case. It's the same for everyone. None of us has handed everything over. The model writes my code, but it doesn't know everything about me, not my whole history, not every private thought. Not yet. But I've learned to distrust my own yets. The line I'm holding today is the same line I held about my code a few years ago, right before I stopped writing it.

Because the trend doesn't bend back. Human nature doesn't suddenly start choosing the harder path. This isn't unstoppable in some cinematic sense; it's just what we are: reward up, effort down, water downhill. If the curve keeps bending the way it has been (and I think it will; I think this simply becomes the new normal, the way the cloud did), then we don't hand over some of it. We hand over all of it, one reasonable yes at a time, each one easier than the last.

And the strangest part, the part I genuinely can't resolve, is that I'm not sure I'd take it back if I could. It's that good. Nothing is impossible now. I only notice, sometimes, that the one place I still write a line of code with my own hands is a quiet room where the tools are switched off, practicing for a test of who we all used to be.

A note on how this was made: the thoughts, arguments, and conclusions here are entirely my own. I fed them through my own automated AI writing system, which drafted and assembled the post from my notes. Yes, I'm aware of the irony.