Delegation — Scoping a Task an Agent Can Finish
The difference between an agent that delivers and one that flails is usually the size and shape of what you handed it. Scoping is a skill — and it's mostly on you, not the model.
🎯 By the end you'll understand
How to right-size a task so it's neither too big (it drifts) nor too tiny (you'd be faster yourself), how to shape a request so an agent can actually finish it, how to decompose a big goal into delegatable chunks, why a clear definition of done prevents runaway loops, and when chunks can run in parallel.
KEY INSIGHTThe one idea to take away
Agents don't fail because they're dumb. They fail because you handed them something with no edges and no finish line.
In Lesson 3.4 you learned how much to trust an agent. This lesson is about what you hand it. A capable agent given a vague, sprawling goal will wander, burn through its context window, and stop somewhere unsatisfying. The same agent, given a crisp, bounded, verifiable chunk, will nail it. The variable that changed wasn't the model — it was your scoping.
Good delegation = a self-contained chunk with a clear finish line. If you can't say in one sentence what "done" looks like, the agent can't either — and it will either quit early or never stop.
CORE CONCEPTRight-sizing: the Goldilocks problem
Every task you might delegate sits somewhere on a size spectrum, and both ends are traps.
Too big / too open-ended. "Make my app better." There's no boundary, so the agent has to invent one — and it invents a different one every few steps. It refactors, then adds a feature, then second-guesses the refactor. Each detour fills the context window (2.3) with more state than it can track, and once that fills up the agent starts forgetting its own earlier decisions. The result is drift: lots of motion, no landing.
Too tiny. "Change this button's color to blue." Spinning up an agent — having it read files, reason, call tools, report back — costs more of your time and attention than just doing it yourself. Delegation has overhead. Below a certain size, that overhead dominates and you've made the job slower.
The sweet spot. A chunk big enough to be worth handing off, small enough to fit comfortably in the agent's working memory, with a finish line it can recognize. Think: "add a contact form to the About page that emails me when submitted." One coherent unit of work, clearly done or not done.
| Size | What happens | The tell |
|---|---|---|
| Too big | drifts, runs out of context, never lands | you can't picture the finished result |
| Just right | focused work, recognizable finish | one sentence describes "done" |
| Too small | handoff overhead > the work itself | you'd finish it before explaining it |
If you can describe both the task and what "finished" looks like in a single clear sentence, it's probably well-sized. If it takes a paragraph and still feels fuzzy, it's too big — split it. If describing it takes longer than doing it, it's too small — just do it.
FRAMEWORKShaping a task to be agent-friendly
Size is only half of it. A task can be the right size and still be a bad delegation if it's the wrong shape. A well-shaped task has four properties — and notice how they echo the fit test from Lesson 1.6:
A clear done-condition
An explicit statement of what "finished" means. Without it the agent guesses — and its guess of "good enough" rarely matches yours.
A verifiable result
Something you (or the agent) can check. "The form submits and an email arrives" is verifiable. "Make it feel premium" is not — there's nothing to test against.
The needed tools available
If the task requires sending email, the agent needs an email tool. A perfectly scoped task it can't physically do is still a failed delegation. (Tools — Lesson 2.2.)
Bounded scope
Explicit edges: which page, which files, what's off-limits. Boundaries are what keep an agent from "helpfully" rewriting things you never asked it to touch.
"Improve the checkout" is the wrong size and shape. "On checkout.js, add inline validation to the email field so an invalid address shows an error before submit — don't touch the payment logic" is right-sized and well-shaped: done-condition, verifiable, bounded, and the tools (file edits) are available.
SEE ITThe Scope-o-Meter
Same underlying wish — "I want my website to be better" — framed four different ways. Pick a framing and the meter reads out a verdict, why it lands there, and how to fix it. Watch how only one framing is actually delegatable.
CORE CONCEPTBreaking a big goal into delegatable chunks
So your real goal is big — "rebuild the site." That's fine. Big goals are normal; the skill is turning one into a sequence of well-scoped chunks. There are two ways to get that decomposition:
You decompose it. You split the goal into chunks yourself, then hand the agent one chunk at a time. You stay the architect; the agent is the builder.
You let the agent plan it. You hand over the whole goal and let the agent break it down — the planning behaviour from Lesson 2.5. Modern agents can do this surprisingly well.
When to do which? It comes straight from the trust gradient (3.4):
| Decompose yourself when… | Let the agent plan when… |
|---|---|
| stakes are high / changes are hard to undo | stakes are low and the goal is exploratory |
| you have strong opinions about the how | you mostly care about the what |
| the goal touches many systems with hidden coupling | the task is self-contained and well-understood |
| you want to review each chunk before the next | you're happy to review one final result |
Decomposition is splitting a goal too big to delegate as one piece into smaller, self-contained chunks that each are delegatable. You can do it manually or delegate the decomposition itself — but someone has to do it before real work starts.
PRACTICALThe "definition of done" — your stop signal
Here's a failure mode you've already met in Lesson 2.9: the runaway loop. An agent that doesn't know when it's finished will keep going — polishing, second-guessing, re-checking — burning tokens and sometimes undoing good work. The cure is cheap and almost magical: tell it, up front, exactly what "done" looks like.
A definition of done is the agent's stop signal. It turns an open-ended "work on this" into a closed task with a clear exit. Compare:
The second version gives the agent something to check itself against. It can look at its own output, compare it to the done-condition, and decide — correctly — that it can stop. No definition of done, no reliable stopping. This single habit prevents more wasted agent runs than almost anything else.
The best done-conditions read like a checklist a stranger could verify without asking you questions. If your definition of done contains the word "good" or "nice," it isn't done yet — replace it with something observable.
FRAMEWORKSequential vs parallel delegation
Once you've decomposed a goal into chunks, the chunks have a structure. Some depend on each other; some don't.
Sequential. Chunk B needs the output of chunk A. You build the database schema before the API that reads from it. These must run in order, each agent run starting where the last left off.
Parallel. Chunks that share no state and don't touch the same files can run independently — even simultaneously, in separate agents. "Write the About page" and "Write the Pricing page" don't need to know about each other, so two agents can do them at once. (This is exactly the seed of multi-agent systems you'll explore in Stage 4.)
Two chunks can run in parallel if neither reads the other's output and they don't write to the same files. If you're unsure whether they collide, treat them as sequential — a wrong guess about independence causes merge conflicts and silent overwrites.
PRACTICALFrom "make my app better" to a real assignment
Here's the manager analogy that makes all of this click. You'd never tell a new hire on day one: "improve the company." They'd freeze, then flail. You give them a scoped, finishable assignment — "audit our three slowest support tickets this week and write up what's causing the delay." An agent is exactly that new hire: capable, eager, and completely dependent on you to define the edges.
So let's run the transformation on a real wish. You start with:
No size, no shape, no finish line. The agent has to invent the entire problem statement.
Step 1 — decompose the wish into concrete chunks. "Better" how? You realize you mean: faster load, fewer signup drop-offs, and a less confusing settings page. That's three goals.
Step 2 — right-size and shape the one you'll start with. Take "fewer signup drop-offs":
Task: On the signup form (signup.jsx), add inline validation so users see field errors before submitting.
Bounds: Only that file. Don't change the backend or the visual design.
Tools: File edits + the existing test runner.
Definition of done: Empty/invalid email and password fields show an error on blur; the existing tests still pass; you've added one test for the new validation.
Step 3 — sequence it. This chunk is independent of "faster load," so those two could run in parallel agents. The settings-page rework, though, touches signup's shared components, so you'll run it after and review in between.
That's the whole craft. You didn't make the agent smarter. You turned a wish into an assignment a capable worker could actually finish — and you'll review the result in Lesson 3.6.
WEAKNESSCommon mistakes to avoid
"Build me the app" feels efficient but guarantees drift — the agent runs out of context (2.3) tracking a goal too big to hold. Decompose first, then delegate one chunk.
Without a stop signal the agent either quits early at its own private "good enough" or loops forever polishing (the runaway from 2.9). Always say what finished looks like.
Farming out every two-minute edit to an agent adds more overhead than it saves. Delegation has a cost; below a certain task size, just do it yourself. The sweet spot is a chunk, not a keystroke.
KEY INSIGHTHow this connects in your course
- The fit test (1.6) — the four shape properties (done-condition, verifiable, tools, bounded) are the fit test applied to a single delegated chunk.
- Context window (2.3) — why "too big" tasks drift: the agent literally runs out of room to track them.
- Agent planning (2.5) — the "let the agent decompose it" option, and when to trust it versus doing the split yourself.
- Runaway loops (2.9) — the failure a definition of done is built to prevent.
- Writing the brief (3.2) — scoping decides what to delegate; the brief is how you communicate that scope clearly.
- Reviewing output (3.6) — a verifiable done-condition is exactly what makes review fast and trustworthy next lesson.
Scoping is the upstream skill. Get it right and briefing, supervising, and reviewing all get easier. Get it wrong and no amount of clever prompting downstream will save the run.
GLOSSARYKey terms introduced
- Delegation
- Handing a task to an agent to complete on your behalf, then supervising the outcome rather than doing the work yourself.
- Scope
- The size and boundaries of a task — what's included, what's excluded, and where it ends.
- Right-sizing
- Choosing a task that's big enough to be worth delegating but small enough to fit the agent's working memory and have a recognizable finish.
- Definition of done
- An explicit, verifiable statement of what "finished" looks like — the agent's stop signal.
- Decomposition
- Splitting a goal too large to delegate as one piece into smaller, self-contained, delegatable chunks.
- Parallel delegation
- Running independent chunks — ones that share no state and don't touch the same files — separately or simultaneously.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1Why does a task that's "too big" cause an agent to fail?›
With no boundary, the agent invents its own — and a shifting one. It takes detours that fill the context window (2.3) with more state than it can track, so it forgets earlier decisions and drifts: lots of motion, never landing.
2Name the four properties that make a task well-shaped for an agent.›
A clear done-condition, a verifiable result, the needed tools available, and bounded scope. They're the fit test (1.6) applied to one chunk.
3What is a "definition of done" and what failure does it prevent?›
An explicit, verifiable statement of what finished looks like — the agent's stop signal. It prevents the runaway loop (2.9), where an agent that doesn't know it's done keeps polishing, re-checking, and sometimes undoing good work.
4When can two delegated chunks run in parallel rather than in sequence?›
When they're independent: neither reads the other's output and they don't write to the same files. If you can't be sure they're independent, run them sequentially — a wrong guess causes overwrites and conflicts.