Ian K. Duncan
Software engineer
Nova Reperta: The Invention of Book Printing, Jan Collaert I after Jan van der Straet, c. 1600
Engineering essays
Essay stable 8 min read

Smart People Who Give a Shit Use Tools

LLMs mostly amplify whoever is sitting at the keyboard. Deeply curious, caring engineers multiply what they can build and verify; lazy ones can, for now, coast as meat proxies.

Anyone who has worked on payment rails or old distributed systems knows the exact feeling Justin Michael describes in his post this week. You peel back the curtain on some piece of infrastructure the economy quietly runs on, expecting Swiss watchmaking, and find duct tape, twenty-year-old batch files, and three people in the whole company who know why you never reboot box four on a Tuesday. He calls them “smart people who give a shit,” and he’s dead right that they are the main reason the lights stay on.

Halfway down the page, though, the essay takes a turn I’ve been seeing a lot lately, and it bugs me. Michael points to the recent run of big outages (Microsoft 365, United, major banks, Apple) and blames leadership for trying to swap those people out for generative AI. Fair enough; there’s probably plenty of truth in that. But he doesn’t stop at bad management. By the end, the tools themselves have become the acid dissolving whoever picks them up. “Every prompt moves them one step further away from the system they used to know inside and out,” he writes. Every generated line robs engineers of the struggle that makes them smart and the ownership that makes them care.

The implication is pretty hard to miss: if you’re using AI, you’re giving up on giving a shit.

I use these tools every day on systems where bugs cost significant sums of money or wedge production queues, and my experience has been almost the exact opposite. More than anything else, LLMs amplify who you already are. Deeply curious, caring people can dramatically amplify what they produce and how thoroughly they understand it. Lazy bums can, for now, coast as meat proxies for a chat window, ferrying tickets into a prompt box and clicking merge on whatever falls out.

Think about what “giving a shit” actually meant on a normal engineering team before 2024. Mostly, it meant fighting a losing war against the clock. You’d spot a nasty race condition in a state machine and know you should model it in TLA+, or write a property test that hammers every interleaving, or go read the forty-thousand-line service downstream to be certain your assumption held. Half the time you didn’t, because doing it properly took two days you didn’t have and three other fires were waiting. So you eyeballed the diff, wrote a unit test for the happy path, left a slightly nervous comment, and hoped nobody touched that file for a while. Caring was rarely limited by how much people wanted to do the right thing. It was rationed by how fast one human could read and type.

When you hand a capable model to that engineer, they don’t suddenly shrug and rubber-stamp the first draft. They finally write the TLA+ spec. They pull on the threads they were always curious about, digging into why a gnarly legacy subsystem behaves the way it does instead of treating it as a black box. They build a real simulator for the flaky third-party API nobody ever had time to mock properly. They have the model trace every caller of a legacy function across a sprawling monorepo before changing its contract, instead of grepping for five minutes and praying. They write the exhaustive edge-case tests and run mutation testing against the parts that keep them awake at night.

The kind of rigor that used to be reserved for people writing avionics software or working at Bell Labs is suddenly cheap enough to pull off on an ordinary Thursday. Calling that “caring less” has the whole thing backwards.

Then there is the other side of the amplifier. Anyone who has reviewed a 1,500-line pull request written by a meat proxy who clearly hit “accept all,” got a green linter, and blanked out when asked to explain line 400 knows exactly what Michael is furious about. (I’m certainly guilty of opening massive AI-assisted PRs myself, though in the service of giving a shit, so the line count by itself isn’t the crime.) Prompt, paste, and pray is very real, and it produces miserable software. I’ve written before about the specific sinking feeling of staring at 800 lines of generated code you have no mental model of and deploying it with crossed fingers.

There’s a subtler hazard too, especially for people early in their careers: if you never wrestle with a weird bug or read a stack trace yourself, you never build the scar tissue that tells you when something smells wrong. And LLMs make laziness unusually tempting because of how they fail. A compiler yells at you loudly when you screw up; a model fails in smooth, confident prose that looks totally reasonable until production catches fire. That’s a genuine risk, and pretending it isn’t would be silly.

Still, look closely at what’s actually broken in that scenario. The trouble comes from shipping code nobody verified, without building a mental model, in an organization where nobody feels on the hook when it breaks. We had that exact engineer long before ChatGPT showed up. Ten years ago they pasted the top Stack Overflow answer without reading the comments, pulled in a bloated dependency to avoid thinking for twenty minutes, and stamped “LGTM” on every review after thirty seconds. Now they can coast as a human clipboard for a model, at least for a while, until the production bugs pile up or someone realizes a cron job could do the clipboard part cheaper. Take away their LLM tomorrow and they won’t suddenly start caring about ACH edge cases. They’ll just go back to shipping carelessness at a slower clip.

Look at Michael’s own example of ACH. The people keeping banking rails alive aren’t chiseling NACHA files into stone tablets to stay spiritually close to the metal. Their care shows up in reconciliation scripts, monitors, static checks, runbooks, and custom tooling they built because unaided human attention breaks down on systems this messy. Every jump up the abstraction ladder (compilers, garbage collectors, search engines, high-level frameworks) brought the exact same warning that we were moving another step away from the machine and losing the people who really understood it. Sure, far fewer programmers today can hand-assemble x86 than in 1985. Meanwhile, the systems we have to keep upright grew by several orders of magnitude. Without stronger leverage, you don’t get a golden age of artisanal engineering where everyone holds the whole codebase in their head. You just get more critical systems that nobody understands at all, because they long ago outgrew what one unaided brain can hold.

There is a bigger elephant in the room about all those outages, too, and it predates LLMs by a long shot. A huge share of the instability we are watching right now is the bill coming due for forty years of insufficient engineering rigor. Giving a shit does not make people infallible. Some of the smartest, most conscientious engineers in the industry spent decades building critical infrastructure in memory-unsafe languages, gluing together under-specified protocols, skipping formal verification, and shipping state machines whose edge cases lived only inside one person’s head. Heroics and tribal knowledge kept the wheels on, right up until they didn’t.

Plenty of the vulnerabilities and failure modes knocking systems over today have been sitting quietly in the wild for years, or even decades. We got away with them because nobody had the time or budget to poke every dark corner of a sprawling legacy stack, and because change moved slowly enough for manual patching to keep up. Only now is the issue being forced, by automated bug-hunting that never sleeps, by decades of accumulated coupling, and by systems that have finally grown too tangled for human heroics to paper over. Blaming all of that on AI slop is a comforting story, because it implies we can just go back to the old way of working and everything will steady out. The old way of working is how we ended up with a world where bad updates and long-dormant bugs can wobble major banks, airlines, and cloud providers in the same week.

None of that lets leadership off the hook. Where Michael is completely on target is what’s happening in the executive suite. Leadership looking at an LLM and thinking, fantastic, now we can lay off the prickly senior engineers who push back on bad ideas and replace them with a $200-a-month subscription, really is a slow-motion train wreck, and it makes a fragile landscape much worse. To someone who has never been paged at three in the morning, a fragile system held aloft by quiet competence and a pile of plausible-looking slop look identical on a quarterly slide deck.

That disease, though, is decades older than generative AI. It’s the exact same management fantasy that gave us “let’s fire the expensive in-house team and outsource the core platform to the lowest bidder,” “let’s cut QA because developers can test their own stuff,” and “let’s lay off twenty percent of engineering while keeping the roadmap unchanged.” AI didn’t invent the belief that engineers are interchangeable output factories. It just handed executives a shinier, cheaper-sounding excuse to run the same playbook again.

That’s why lumping AI-using engineers in with the executives hollowing out their companies does real harm. Telling the story as “AI makes engineers dumb and indifferent” accidentally writes bad leadership an alibi: shucks, the new technology didn’t live up to the hype, who could have known? And on the way there, it sneers at the people in the trenches who are grabbing every piece of leverage they can find to keep increasingly absurd systems from falling over.

If you want to know whether someone gives a shit about a system, asking whether they used an LLM is the wrong question. Ask what happens when the code they merged breaks at two in the morning. Ask whether “the model wrote it” flies as an excuse in code review. Ask whether they have the time, standing, and backing to tell a VP that a deadline is reckless.

Companies lose smart people who give a shit when they strip away ownership, punish dissent, and reward shipping volume over reliability. Give those same people real stakes and a good model, and they don’t check out. They finally get to build the guardrails, proofs, and fixes they never had the hours to build before.

Michael is right that capitalism has its hand squarely on a hot stove right now, and that the rest of us are getting burned while executives relearn that you can’t automate away accountability. I just wish we’d aim the anger at the people making that bet, instead of pretending that giving a shit requires typing every character by hand.

Cover: Jan Collaert I after Jan van der Straet (Stradanus), Nova Reperta: The Invention of Book Printing, c. 1600. CC0, source.