For years I upgraded my open source libraries by hand. A breaking change would land upstream and I’d sit with the changelog, the diff, and the source together, working out what each deprecation actually meant for the code I’d written. Slow, occasionally frustrating, and by the end I understood the library better than I had that morning. That understanding went into the next thing I built with it.

Last month the same kind of upgrade came up. I dropped the changelog into a prompt, described the codebase, read the diff, merged it. Done in under an hour. Tests green.

The library is correctly upgraded. I know nothing more about it than I did before.

The code is identical in quality. The engineer is not.

The easy explanations are wrong.

The friction was the craft

For most of my life as an engineer, the hard part was the point. Not in a masochistic way. I never enjoyed being stuck for the sake of being stuck. But the satisfaction at the end was made of the struggle that came before it. The bug you chase for two days teaches you the system in a way no documentation ever will. The function you rewrite four times until it finally reads clean leaves a mark on you. You come out the other side knowing something in your hands that you didn’t know going in.

I’ve written before about slowing down to speed up: how, on the cube and in the pool and in the codebase, the deliberate slow work is the only thing that actually teaches the body and the mind. Here is the part I didn’t say then, because I hadn’t felt it sharply enough yet:

The friction was never the obstacle to satisfaction. The friction was where the satisfaction lived.

This is the thing AI is best at removing. Not just the boring parts. It removes those too, and good riddance. The thing it removes that matters is the productive friction: the slow deliberate wrestling that used to do the teaching. It hands you the other side of the struggle without the struggle. And so you arrive at the destination having never made the journey, which is why it feels like arriving nowhere.

To finish the moment, to find the journey’s end in every step of the road, to live the greatest number of good hours, is wisdom.

Ease and satisfaction were never the same thing. We let ourselves believe they were, because for a while removing friction did make us happier: no more fighting build tooling, no more boilerplate, no more reading the same Stack Overflow thread for the third time. But past a certain point the tool stops removing the friction that was in your way and starts removing the friction that was your way.

Focus, and the new shape of attention

There’s a second thing, quieter than the first, and I think it’s the one people feel as “I can’t focus anymore.”

Creativity needs a particular kind of attention: the long, unbroken immersion where you hold the whole problem in your head at once and turn it over until something clicks. Flow, if you like the word. It’s the same state I find in open water when my breath and my body stop arguing, the same state a good solve has when my eyes are finally ahead of my hands. It is not a state you can enter in ten-second increments.

The AI loop trains the opposite posture. Prompt. Wait. Skim. Accept or reject. Prompt again. The attention of a manager half-watching six things, not the attention of a maker lost in one. Each round is individually faster than doing it yourself. But the loop keeps lifting you out of the deep state and setting you back down in the shallow one, over and over, and after a few hours of it you notice you haven’t actually thought about anything. You’ve been evaluating someone else’s thinking at high speed.

I described the simulation, in another piece, as a thing that extracts your attention by fragmenting it. The uncomfortable part is that this newest fragmenter doesn’t feel like the others. Doomscrolling at least announces itself as waste. This feels like work. It produces commits. The dashboards stay green. You can fragment your attention all day and have shipping software to show for it, which is exactly why it’s harder to notice. The thing you used to do has quietly stopped happening. The deep, whole-problem immersion where the good ideas actually came from. Gone while the dashboards stayed green.

There is no exit

So the obvious move is to refuse. Turn it off. Write everything by hand, the way it was meant to be done. Become the last honest craftsman in a field of people who stopped asking questions. It’s a satisfying story. I’ve tried believing it. I don’t.

The purist who refuses the tools isn’t preserving craft; they’re performing it, usually loudly, usually on the very platforms the tools were built to feed. And it doesn’t scale past the performance. I use these tools every day. This website, that swimmer tool, most of what pays my bills passes through them now, and pretending otherwise would be reaching for the blue pill. It isn’t there anymore. There’s no clean place to stand. To do this work at all, now, is to do it alongside the machine.

It’s to decide, with your eyes open, where the friction stays. Abstinence and surrender are the same mistake wearing different clothes. Both hand the decision to someone else: to the purist’s performance, or to the tool’s default. The craft is in the third thing, the one that asks more of you than either.

Choosing where to keep the friction

Craftsmanship in this era is not doing everything by hand. It’s deciding, deliberately, which parts you do by hand because doing them is the point, and letting the machine take the rest without guilt.

The swimmer who slows a stroke down on purpose isn’t being inefficient. He’s choosing, in that drill, to feel every flaw the fast pace papers over. He keeps the friction exactly where it teaches him, and nowhere else. That’s the whole discipline, ported into software: keep the friction where it makes you better or where the doing is its own reward, and shed it everywhere else.

The code I already know how to write, I let it write. The CRUD, the glue, the migration I’ve written a hundred times. There’s no craft left in those for me; the friction there is pure tax. But I read every line before I accept it, not to catch the machine’s mistakes, but to keep the system in my own head. The moment I’m accepting diffs I don’t understand, I’ve stopped being the engineer and started being the bottleneck who rubber-stamps.

The design I do not hand over. The architecture, the shape of the data, the decision about what we’re even building. I work those out by hand, on paper, slowly, because that’s where the thinking that matters happens. Outsourcing it means never having the thought. For hard problems I use it differently: to analyze, break things down, test a hypothesis, poke holes in my own reasoning. But I stay the thinker. The machine is a partner in that work, not the driver of it. The difference is whether I come out the other side having understood something, or just having shipped something.

None of this is efficient, and that’s the point. The efficient path is to accept everything and feel nothing. The craft is in choosing, case by case, to be slower than you have to be, in the specific places where the doing is worth more than the done.

What the machine can’t want

The machine can make almost anything now. What it cannot do is want something. It has no taste of its own, no sense of what is worth building, no itch that says this is wrong, I don’t know why yet, but it’s wrong. It cannot stand in a kitchen waiting for the water to boil and have an idea ambush it. It generates; it does not intend.

As the making gets faster and more efficient, the scarce thing isn’t the making anymore. It’s the wanting: the taste, the judgment, the direction, the stubborn particular vision of how a thing should feel. That was always the most human part of the work. It’s about to be the only part that’s still ours by default.

But taste is not free. It is built the same slow way everything is built: by doing the work, by being immersed enough to develop a feel, by caring about the hundred small decisions until you can sense the right one before you can explain it. You cannot supervise your way to taste. If you let the machine do all the making, you stop developing the judgment that was supposed to be your contribution, and you end up with neither the craft nor the discretion. Just a fast pipe for output you can no longer tell is good.

The craft is still there. But it belongs to the people who stayed engaged enough to still have a decision to make.

Where the work is still yours

I don’t always get this right. There are nights I accept the whole diff, ship the thing, and notice an hour later that I couldn’t redraw the design from memory if you asked me to. The tool punishes this slowly, the way the codebase always has. Not tonight, not this sprint, but in the second year, when I go to change something and realize I never actually understood it, because I was never really there when it was made.

So I keep going back to the friction. I keep one problem a week for my own hands. For the code I didn’t write, I use AI to understand rather than trust: ask it to explain, to document, to interrogate the assumptions. The judgment is still mine. I do the design slowly, on paper, in the deep unbroken state the loop keeps trying to pull me out of. Not because it’s faster. It isn’t. Because that’s the place where the work is still mine, and the satisfaction is still made of something.

The machine will do the hard part for you now. That’s the gift, and it’s the whole danger in a single sentence.

Decide which hard parts you want to keep.

---