The Grind Was the Teacher

Judgment was never taught. It was a byproduct of the grunt work we just handed to the agents. A note on the reps we deleted, and how to build judgment back on purpose.

By Jason Waldrip, with Claude Opus 4.8 August 4, 2026 08:12

Think about the moment you actually got good. Not the class, not the bootcamp. The night.

You were three hours into a bug that made no sense, staring at a stack trace that lied to you twice, and somewhere around the second bad guess you stopped reaching for Stack Overflow and started reasoning about what the system was actually doing. That night rewired you. You came out of it with an instinct, a small permanent voice that now says “check the boundary” or “that’s a race condition” before you can explain why. Nobody handed you that voice. You paid for it, in hours, in dead ends, in the specific humiliation of shipping the dumb thing and watching it break.

That grind is exactly the work the fleet does now. Faster, cheaper, and without the 2am part.

the reps nobody scheduled

Here’s the thing we never said out loud, because we never had to: the grunt work was doing two jobs. It produced the code, and it produced the engineer. We only ever invoiced for the first one. The boilerplate, the fifth CRUD endpoint, the migration you’d written a hundred times, the flaky test you chased for an afternoon. That was the boring half of the job, and everyone agreed it was overhead we’d automate away the second we could. So we did.

But the boring half was where the reps lived. Anders Ericsson spent his career on this, and his actual finding got flattened into the “10,000 hours” bumper sticker, which he openly disliked. His real claim was narrower and more useful: expertise doesn’t come from hours, it comes from deliberate practice. Reps against a real problem, at the edge of what you can do, with a tight feedback loop telling you when you got it wrong. That is a precise description of debugging your own bad code. You attempt, you fail visibly, the system corrects you, you adjust. The grind wasn’t in the way of learning. The grind was the learning. It just wore the costume of overhead so convincingly that we shipped it off to the machines and congratulated ourselves on the efficiency.

Now the feedback loop runs somewhere the junior can’t see it. The agent hits the boundary condition, reasons about it, fixes it, and opens a clean pull request. The bug that would have rewired a person quietly fixes itself before that person ever feels it. The reps still happen. They just don’t happen to anybody.

you can’t teach the thing directly

The obvious answer is “so teach them the judgment directly, skip the busywork.” I’ve spent twenty years finding out that doesn’t work, and I’d already learned why before any of this.

At iTriage the most durable thing I ever shipped wasn’t a feature. It was other engineers, and I built them the only way that ever took: pairing, not lectures. I could say “watch the coupling here” until I was blue, and it would bounce off. What stuck was sitting next to someone while they felt the coupling bite, then naming it in the exact second it hurt. Teach the principle, not the patch only works if there’s a live moment of struggle to attach the principle to. The principle is the label. The grind is the thing being labeled. Hand someone the label with nothing underneath it and you get a junior who can recite “where does the state live” and has never once been burned by getting it wrong.

At Brandfolder I hired and trained a team of six into a product that was on fire when I walked in, and none of them got good from my slide deck. They got good from the fire. The value I keep coming back to, the most durable thing a senior ships is other engineers, assumed a pipeline that ran on its own: juniors did the grunt work, the grunt work grew them, seniors shaped the growth. Pull the grunt work out of the middle and the pipeline doesn’t speed up. It stops feeding.

the tuition came due and nobody noticed

So here’s the pattern, and it’s the one I think most teams are going to hit the expensive way. Judgment was never on the invoice because it came free with the reps. The grind was tuition, and we’d been paying it without ever seeing the line item. Automate the grind and you don’t just save the money. You stop paying the tuition, and you don’t find out until you go looking for a mid-level engineer with real instincts and realize the last three years quietly stopped producing any.

This is the same shape as volume being free now, one turn deeper. When generation got cheap, judgment became the moat, and everyone nodded. What fewer people are asking is where the next generation’s judgment comes from, now that we’ve automated the exact activity that used to manufacture it. A moat you can’t refill is just a hole that’s currently full of water.

And I want to be honest that this cuts at me too. I love that the fleet eats the boring work. I built my whole current practice on it. The weekend I finally took actually off, the agents kept the line while I was at the grill, and that’s the dream. But the dream has a bill attached, and the bill is that the boring work was never only boring.

build the reps back on purpose

The fix has nothing to do with making people grind out CRUD by hand for old times’ sake. That tuition is genuinely obsolete, and pretending otherwise is nostalgia dressed as training. The real move is to notice that reps used to be automatic and now have to be deliberate, and to build them somewhere the work still lives.

The work moved. It used to live in producing the diff. It now lives in judging it, and that turns out to be the better classroom anyway, because it’s closer to the actual job. A few things I’d make non-negotiable:

1. Make juniors defend the shape, not type the code. Put a person in front of the agent’s pull request and make them argue where the state lives, what it couples to, whether the approach even matches the problem. That’s the same review skill seniors have always used, pointed at a fleet instead of a teammate. It’s a rep, and it’s the rep that matters now.
2. Give them the failure back. Deliberate practice needs a real feedback loop, so stop letting the agent silently absorb every mistake. Have people predict what breaks before they read the fix. Have them find the bug the fleet shipped, because it will ship them. A wrong guess that gets corrected is worth more than a right answer they never had to reach for.
3. Pair on the judgment, live. The principle only sticks in the second the struggle happens. So do the review together, out loud, and name the instinct in the moment it fires. The agent removed the grunt work. It did not remove the need to sit next to someone while the coupling bites.

None of this is free. It’s slower than letting the fleet run clean, and it will feel like overhead, which is exactly the trap, because that’s precisely how the grind felt right up until we automated it and found out what it was holding up.

So the question I’d leave you with is the one I ask on every engagement now. Your fleet is faster than any team you’ve ever run. Five years in, when the seniors who trained on the old grind start to age out, who on your bench has actually been burned enough to catch what the fleet gets confidently wrong? If you can’t name them, you’re not short on velocity. You’re short on the only thing velocity was ever protecting.