What to Hand Off
Module 2 · Delegation

What to Hand Off

Choose tasks that suit an agent. Size the task, check that the result can be verified, weigh how bad a mistake would be, and know which work to keep for yourself.

Not “Can It?” but “Should It, Like This?”

Claude Code can attempt almost any coding task. That makes “can it do this?” the wrong question. The useful question is: is this a task where handing it to an agent produces a better result, and where I can tell whether it did?

Three questions settle most delegation decisions.

  1. 1 Verifiable?

    Can I tell if it worked?

  2. 2 Sized?

    Small enough to review

  3. 3 Reversible?

    How bad is a mistake?

1. Can the result be verified?

The best agent tasks come with a built-in judge: a failing test that should pass, a type checker that should go quiet, a page that should render, a script whose output you can compare. When the agent can check its own work, it iterates toward a real answer instead of a plausible one.

When there’s no judge, you are the judge. That’s fine, but it means your review is the only quality check, and the delegation is only as good as that review.

2. Is it sized for review?

A useful rule: delegate in units you’re willing to review. “Migrate the whole app to the new API” produces a diff nobody reads carefully. “Migrate the billing module, then stop and summarize” produces one you can.

Large tasks still work, when you break them up. Ask for a plan first, then have the agent execute one step at a time with a checkpoint after each.

3. How reversible is a mistake?

Editing source code in a git repo is highly reversible. Running a database migration against production, sending an email, deleting cloud resources, or publishing a package isn’t. The less reversible the action, the more human judgment it needs, and the less autonomy the agent should have when it gets there.

Put the first and third questions together and you get a quick map:

Keep it, or advise onlyarchitecture, auth logic,anything on production dataDelegate with gatesschema changes, CI config:you approve each risky stepDelegate, then read closelyuntested refactors, docs drafts:your review is the only checkDelegate freelytests, lint and type fixes,a bug with a failing testCOST OF A MISTAKEhighlowhardeasyHOW EASY IS IT TO VERIFY?

Size (the second question) cuts across all four boxes. Any of them can be split into smaller, reviewable steps.


A Delegation Map

Usually great to delegateDelegate with close reviewKeep for yourself, or do together
Exploring and explaining unfamiliar codeFeatures that touch many filesArchitecture and product decisions
Writing tests for existing behaviorRefactors of core modulesSecurity-sensitive logic (auth, crypto, permissions)
Fixing a bug with a failing test to reproduce itDependency upgradesAnything touching production data or infrastructure
Boilerplate, scaffolding, and repetitive editsPerformance work (needs measurement)Deciding what to build and why
Lint, type, and build error cleanupDatabase schema changesCode you’ll need to defend in an interview, exam, or audit without help
Drafting docs, READMEs, and commit messagesChanges to CI and deploy configLearning a concept you need to own

The right-hand column isn’t “AI can’t help.” It’s “the judgment is the work.” Claude Code can still research options, draft a comparison, or poke holes in your design. The decision stays with you.

⚠️ Common Pitfall: Delegating the Learning

Common mistake: using the agent to skip the part of the task you were supposed to learn from.

If you’re new to a language, a framework, or a codebase, having Claude Code write everything means you can ship code you can’t explain, debug, or extend. Fluent learners switch modes: they ask the agent to explain and review while they write, or have it write a first version and then rebuild it themselves. Decide on purpose whether this task is about the output or about you.


Augmentation or Agency?

From Foundations, you know three modes: automation, augmentation, and agency. With Claude Code, the last two cover most work:

  • Augmentation: you stay in the loop turn by turn. “Show me three ways to structure this.” “Review my function for edge cases.” “Why is this test flaky?” Best when the judgment calls are frequent and yours to make.
  • Agency: you set a goal and boundaries, and let it run. “Make these five failing tests pass without changing the tests.” Best when the goal is clear and the result is verifiable.

A good session often starts in augmentation (explore, discuss, plan), then switches to agency for execution, then returns to augmentation for review.

🧪 Try It: Sort Your Backlog

Take five real tasks from your current backlog or issue tracker.

  1. For each, answer the three questions: verifiable? sized for review? reversible?
  2. Place each in a column of the delegation map.
  3. For any task in the middle column, write how you’d split it into reviewable chunks.
  4. For any task in the right column, write one way Claude Code could still help without making the decision.
🧠 Knowledge Check

1. Which task is the strongest candidate for handing to Claude Code in agency mode?

2. What does 'delegate in units you're willing to review' mean in practice?

3. Why does reversibility matter for delegation?


Up Next

You’ve decided what to hand off. Next: deciding how much autonomy the agent gets while doing it, with permission modes.