Your job is now babysitting Claude Code. Here's how to do it well.

Anthropic just published a report on how AI has changed its own workforce, and TechCrunch covered it on October 17. It has plenty of numbers, but one detail stuck with me.

In an April 2026 internal survey, 20% of Anthropic employees said their job had shifted from doing the work to managing Claude instances. One engineer compared it to babysitting: several Claude sessions running at once, each one needing attention.

That's the company that builds Claude. If one in five people there spend their day watching over Claude, the rest of us aren't far behind.

Babysitting is the job now

We usually say "babysitting" with a sigh, as if it were a distraction from the real work. It isn't anymore. When the agent writes the code, watching over it is the work.

Anthropic's report says as much. It names human attention and judgment as the bottleneck, because the agents produce more output than people can read and sort. The agent isn't the scarce resource. You are.

So the question isn't whether you babysit your Claude Code sessions. You already do. The question is how well.

Same agent, very different results

Anyone who has left their kids with two different sitters knows how much the sitter matters.

A bad sitter either hovers over everything or doesn't look up until something breaks. Rules are made up on the spot. You come home to a mess and no clear account of what happened.

A good sitter knows the house rules before you leave, sets clear limits, checks in at the right moments, steps in early when things drift, and gives you a clear report at the end.

Claude Code is the same. Two developers can give the same agent the same task and end up with very different time, cost and quality. Research from the Stanford Digital Economy Lab found that the same agent on the same task can cost up to 30 times more from one run to the next. The model doesn't change. The babysitting does.

Five habits of a good Claude Code babysitter

Here is what good babysitting looks like in real sessions.

1. Set the house rules before you leave the room

A good CLAUDE.md is the note on the fridge. It tells the agent how your project is built, which commands to run, what to avoid, and what "done" means. Without it, you end up correcting the same mistakes in every session.

Try this: whenever you correct Claude for the same thing twice, turn the correction into a rule in CLAUDE.md.

2. Give clear instructions, not vague wishes

"Fix the login bug" leads to four rounds of back and forth. "Login fails with a 401 after token refresh. Look at auth/refresh.ts, reproduce it with the existing test, then fix it without changing the public API" usually finishes in one.

Try this: before you send a prompt, ask yourself whether a new teammate could act on it without coming back with questions.

3. Pay the right amount of attention

Hovering over every step wastes your judgment, which is the one resource the agent can't replace. Walking away with no guardrails wastes tokens and lets bad code through. Good babysitters match their attention to the risk: they stay close on migrations, auth and anything irreversible, and let routine work run.

Try this: decide at the start of a session which steps need your approval and which don't.

4. Catch drift early

The most expensive moment in a session is when the agent heads the wrong way and nobody notices for twenty minutes. By then it has edited ten files based on a wrong assumption.

Try this: for bigger tasks, ask for a short plan first and approve it before any code is written.

5. Check before you trust

About half of AI-written code samples fail security tests, according to Veracode. A good sitter doesn't take "everything was fine" on faith. Tests, reviews and a quick run of the app are how you know the output is safe to ship.

Try this: end every task by asking the agent to run the tests and show you the result, not just say it passed.

The catch: nobody can see how well you're doing it

Here is the uncomfortable part. Even Anthropic, a company built around AI, measures productivity mostly by volume: more code per person, more deals closed, more contracts processed. The report itself concedes that "more code does not necessarily mean better code."

Volume can't tell good babysitting from bad. An agent left alone produces plenty of code. So does one you spend all afternoon cleaning up after.

Your gut isn't much help either. In METR's study, experienced developers were 19% slower with AI while believing they were 20% faster.

The only honest record of how well you babysit your agents is the sessions themselves: what you asked, what context you gave, where the agent drifted, and how quickly you caught it.

How we measure our own babysitting

We build most of our product with Claude Code and Codex, so we had the same problem. Volume told us the agents were busy. It didn't tell us whether we were directing them well. So we started grading ourselves on the sessions instead of the output.

We score how we work, not how much we ship. We grade our sessions on 10 areas. The five habits above cover most of them:

• House rules: memory and knowledge (is CLAUDE.md doing its job?) and context engineering (does the agent get what it needs up front?)
• Clear instructions: planning and specs
• The right attention: human steering
• Catching drift: orchestration, meaning how tasks get split up and how quickly feedback loops close
• Checking before trusting: testing and evals, plus security

The last two areas are tool integration and efficiency and cost.

Every grade has to point to evidence. "Weak context engineering" means nothing on its own. A useful grade says which sessions, which prompt, and what went wrong, for example the agent spent ten turns searching for a file that one line of context would have named.

Every weakness has to become a change. A finding is only useful if it turns into something concrete: a new rule in CLAUDE.md, a better prompt template, a check we now run before merging.

We re-measure every day. A habit only counts as fixed if the next round of sessions shows it. Measuring daily keeps us honest about which changes actually helped and which just felt like they did.

The sessions stay private. Session logs are full of code, keys and half-formed ideas. We analyze them locally, on the machine they came from, which is also what makes people willing to be measured at all.

None of this needs special tooling to start. Pick last week's five longest sessions, reread them with the five habits in mind, and write down one rule you'd add to CLAUDE.md. You'll be surprised how much the transcript shows that the code never did.

Why this matters more every month

The report has another telling number: since early 2025, junior technical hires at Anthropic fell from 27% to 9%. The old way to learn the craft, writing lots of code next to someone more senior, is getting narrower.

If watching over agents well is the new core skill, people need a new way to learn it and to show they have it. That has to come from honest feedback on real work, not from counting lines of code.

The developers and teams who pull ahead won't be the ones running the most Claude sessions. They'll be the ones who babysit them best, and can prove it.

Download Vibemetric and see how well you babysit your Claude Code sessions.