The Stigma

Engineers, doctors, lawyers, writers, students. Nobody has remained untouched. Software engineers in particular are using AI at massive scale, and when asked about it, most respond as if they've been caught.

The pleadings sound like confessions. Ask why something shipped fast and the defenses come out. "Are we in court?" "I used it for boilerplate." "Test cases only, I wrote the logic myself." "I knew what to do, I just saved some time." Nobody asked. The colleague didn't accuse them. The manager wasn't there. The over-explanation arrives anyway. That last one is my personal favorite, as if saving time were a character flaw.

There's a logic underneath. Effort used to be evidence. The all-nighter earned credit. The shortcut earned suspicion. AI dissolved the evidence. Now fast work looks like cheating.

I do this too. Total disclosure: I wrote this book using AI. I wrote the prose, the arguments, the structure. The AI corrected my grammar and helped me wordsmith. I did it, didn't I?

That last line is what this chapter is about: the small involuntary justification. The reflex to apologize for using a tool. The reflex to prove you're still real. It has a name.

It's shame.

And shame has a cost. This isn't a technology problem or an AI problem. Shame is the most expensive bug in your codebase. And you can't fix a bug you're ashamed of and not allowed to talk about.

***

India, 2005. I was coding in Java in vi. A black terminal, a blinking cursor, and immense overconfidence. Not because I had to. Because that's what real software engineers did.

Then I discovered Eclipse. A light bulb came on. I started using it. My professor noticed and pulled me aside. "You won't learn anything if you use an IDE and autocomplete."

I nodded. I listened. And then I spent the rest of the semester using the IDE, while telling my classmates, and myself, that I could code without it. Which was true. I just chose not to.

In my final semester, the same professor was teaching Eclipse in his introductory Java course.

We never spoke about the earlier conversation. But it left a residue. A small flinch that came out every time I set up a new dev environment, every time I bought a laptop and installed an IDE. Twenty years of low-grade shame, for the crime of using a tool the entire industry had agreed was the right tool. is half-true.

That's the cost of shame. It doesn't stop you from using the tool. It just makes you slower, quieter, and less honest about it. Multiply that by a generation of engineers currently apologizing for using AI, and you can see why this chapter has to come first.

***

The shame doesn't appear from nowhere. It rides on top of four fears, each of which is real, and none of which is the actual problem.

AI will make me look incompetent. Maybe. In some contexts, in some careers, with some colleagues. Be honest about that. But imagine a doctor in 2026 refusing to use MRI because he worried it made him look obsolete. Patients wouldn't admire his integrity; they'd switch doctors. Tools the field has agreed are useful don't make the user incompetent. Refusing them does.

AI hallucinates. Yes. And this fear is the most legitimate of the four, because hallucination is uniquely insidious: confident, plausible, and invisible at the point of failure. You don't know you've been fooled. That's exactly why review isn't optional. It's the work. What AI produces is never the finished product. A reviewed output is.

AI will replace me. Honestly? Some roles will compress. Some will vanish. Some will elevate. Pretending otherwise insults the reader. But this fear is genuine mostly if your job title is fastest typist in the west. If your moat is typing speed, yes, you're in trouble.

If you're the brain behind what gets typed, AI augments you. The phrase you've heard a hundred times, "someone using AI will replace you," is half-true. The honest version is shorter. AI replaces typing. It doesn't replace thinking.

AI will make me lose my skills. Every tool has been accused of this. High-level languages in the 1950s were going to ruin programmers who had used assembly. IDEs with autocomplete in the 1990s were going to ruin programmers who had used plain text editors. Stack Overflow in 2008 was going to ruin programmers who had used documentation. None of these predictions was entirely wrong. Some skills did atrophy. But the craft evolved, and the engineers who adapted weren't worse engineers. They were different ones. This time will mostly be the same, with one wrinkle worth dimensioning later: AI eats certain kinds of learning friction that used to produce understanding. That's a real cost. We'll come back to it.

***

The fears are real. The shame is the multiplier. The costs this book is going to dimension in the chapters ahead are harder to see and harder to discuss because of the shame layered over them: the always-on expectations, the authorship erosion, the cognitive load that shifted instead of dropping, the illusion of speed.

You can't fix a bug you're not allowed to talk about.

This book is the conversation we haven't been having.

***