What seniors should stop deciding

Dave Thomas wrote a short piece that hit me hard: Your Coding Agent is a Honey Badger — and it don’t care.

He starts with that old viral clip. The honey badger climbs into a nest of bees, fights a snake, and keeps going. Its trick is simple: it does not give a damn what it costs.

Then Dave points at the coding agents many of us use every day. Claude will dive into a mess of tangled code and keep fighting until a feature lands. Codex will plow through a thick technical document and pull answers out of opaque prose. That fearlessness helps. It is also not enough.

The problem, Dave says, is that these agents are fearless because they don’t care. They have nothing at risk. They push forward without worrying about the damage they cause along the way. He catches a familiar flip:

AI: Dave, we should definitely use a list to hold these.
Me: But we need keyed access: wouldn’t a hash be better?
AI: Of course, we need to use a hash.

Total confidence either way. No hesitation. It just don’t care which answer was right a moment ago.

Then comes the line that matters if you lead engineers: Caring is what people do. We bring judgment. We have something at stake. We watch those little honey badgers tear through the code with our fingers on Ctrl-C — not that way; try this instead. We matter because we want to get it right. We matter because we care.

I have managed teams long enough to know care is not a feeling you hope people have. It is how you design the work. And most engineering groups accidentally spend their most careful people on questions that should never have needed a senior in the room.

Where the people who care get worn down

Every healthy place I have liked working had the same leak.

It was not the midnight outages. It was not the brittle tests that fail for no good reason. Those are loud problems. You see them. You fix them.

The quiet problem is different. Your most experienced engineers — the ones who notice when a plan is wrong, who feel what will break overnight, who still want to teach — spend morning after morning as a traffic cop:

• Which code review needs a careful look?
• Which alert is noise?
• Is this junior ready for a harder assignment?
• Does this meeting really need three senior engineers?

None of those questions is hard alone. Stacked every day, they burn out the people Dave is talking about.

Tools that don’t care can still ship a demo. A culture that doesn’t care — speed with no stake in the outcome — gives you green charts and quiet careers. The work looks fine. Teaching dies at the door.

3MINDS starts from the same refusal Dave names. Machines can keep the speed. We will not keep the indifference. You hire people who own the result. Tools help those people care at scale. Tools do not replace caring.

What healthy management looks like from where I sit

Good teams run on apprenticeship, whether they say so or not. Juniors get better by taking real work with a safety net. Seniors get better by building that net — not by answering the same three routing questions until Friday.

When every small decision needs a conversation, the senior becomes the door. The junior learns to wait. The senior learns to resent the knock. Everyone is busy. Almost nobody is getting better — which means almost nobody is practicing the judgment Dave says is the human job.

Care, as management, is structure:

• Clear rules for ordinary work
• A clear bar for harder assignments
• Real exceptions escalate with a reason
• Time protected for teaching and design
• No confusing “who stayed up latest” with “who is doing excellent work”

Where Jev helps — without replacing care

Jev (from TypeSafe.ai) will not make your team kinder by itself. Used well, it stops your best people from spending their care on decisions that should already be settled.

Think of it as a fast decision helper for the routine calls. It asks structured questions, scores risk, and picks among clear options — with a confidence number so you know when a human still needs to step in. The point is not to push people out of judgment. The point is to clear the small interrupts so humans keep their fingers on Ctrl-C for the moments that need a real stake in the outcome.

Code review that teaches

Ask simple facts: how long has this person worked in this area, how big is the change, has this code been in recent incidents, how well is it tested. Then decide: merge as-is, peer review, senior review, or pair. Seniors stop being the default destination. Juniors see why a change needed more eyes. Teaching is built into the gate.

On-call that does not worship heroes

Look at how heavy each person’s week already is. Decide who takes the next primary turn, or when to split a noisy service. Optimize for people who still have a head for real work on Thursday — not for who can absorb the most pain.

Harder assignments with a clear bar

“Are they ready?” as a gut feel wastes goodwill. Ask what they have already shipped in related code, how hard the next step is, and whether they should go alone with a shadow, pair, or have a senior own it. Low confidence earns a human conversation. High confidence stops holding ownership hostage to calendar luck. People get happier when the path to bigger work is visible.

Meetings that earn their cost

Score the agenda before you fill the room. Only the thin, high-risk, or tangled items earn three senior engineers. Everyone else gets their morning back — where design and mentorship actually happen.

Rules the team can own

Keep a written set of what “good” looks like for review, release, and severity (that is the LEAP side of our house). Argue about the rules when the world changes. Let the fast helper run the stable questions. Care compounds when judgment lives in something the team owns — not only in whoever happened to be awake.

Fingers on Ctrl-C

Dave’s picture sticks with me: watching the honey badgers romp, fingers ready, steering because we care. That is not only how you code with an agent. It is how you manage a team.

Seniors should stop deciding the easy things so they can keep deciding — and teaching — the ones that require a human stake. Jev is one way to make that possible. The rest is still on us: notice who is waiting at the door, protect apprenticeship, and refuse to run an engineering group that doesn’t care.

— Alan Kucheck