How big should a task for a coding agent be
Learn how to size tasks so an agent’s output can still be reviewed in one sitting, how to cut a task into smaller reviewable pieces, and why many small changes beat one large one.
the short answer
A task should be the largest change one person can read and judge in a single sitting, not the largest change an agent can finish.

You will end up with a set of small, independent tasks that one person can read and judge in a single sitting, each of which can be reviewed in minutes rather than hours.
Pick the largest change a reviewer can absorb in one sitting
The right task size is not how much the agent can finish, but how much one person can review without losing context. When a change grows past one screen of diff and a few minutes of reading, reviewers start to skip details, ask clarifying questions later, or defer the review entirely. That delay introduces risk: the longer a change sits unreviewed, the more it diverges from the current codebase and the harder it becomes to fix.
Start by imagining the diff a reviewer will see when the agent finishes. If it will scroll past your screen or require opening more than a handful of files to understand, split the task. The goal is to keep the diff small enough that a reviewer can answer three questions in one sitting: what changed, why it changed, and whether it introduces risks.
Look for these signs a task is too big
- Changes that span more than one feature or user story in a single commit or PR
- Diff hunks that touch more than five files or require opening a module you have never edited
- Tasks where the agent’s first pass already produces a change longer than a few hundred lines
If any of these apply, treat the task as a candidate for splitting before the agent starts. Reviewers will thank you later, and the agent will still finish faster than waiting for a deferred review.
Split along boundaries that do not touch the same files
The cleanest way to split a task is to find seams in the codebase that already exist: REST endpoints, CLI commands, internal libraries, or feature flags. Each seam becomes a separate task. Reviewers can judge one seam in isolation without needing to understand the others, which speeds up both reviews and rework.
Avoid splitting by line count or by internal code complexity. Instead, split by the shape of the change the agent will make. If two parts of the task touch the same file, the reviewer must hold both changes in mind at once, which defeats the purpose of splitting. Look for places where the code already separates concerns, even if the separation is not perfect.
Example: splitting a user profile update
Imagine an agent tasked with updating a user profile endpoint to support email changes, password resets, and address updates. The agent could finish all three in one pass, but the resulting diff touches the same handler and service layer files. Splitting along responsibility boundaries yields three smaller tasks:
- Update the email change endpoint and schema (handler, DTOs, database migration).
- Add password reset flow (new endpoint, password hashing utility, rate limiting).
- Update address update endpoint (new fields, validation, and a separate database table if needed).
Each task produces a diff that fits on one screen and touches a distinct set of files. Reviewers can judge one change at a time, and merge conflicts are less likely because the changes do not overlap.
Prefer many small reviewed changes to one large unreviewed change
Even when an agent could finish a large task in minutes, the time saved is lost if the change sits unreviewed for days. A stack of small, reviewed changes integrates quickly, reduces merge conflicts, and surfaces issues while the context is still fresh. The total wall-clock time from task start to merge may increase, but the cycle time from agent finish to production decreases.
Small changes also make it easier to pair a reviewer with the agent during generation. When a change is small, you can open the diff in a side-by-side view and ask the agent to explain each hunk as it writes it. This live review prevents surprises and keeps the agent focused on the right boundaries.
When the agent pushes back on small tasks
Agents prefer large tasks because they can finish faster, but they do not experience the review burden. If the agent argues that a task is too small, explain that reviewability is the constraint, not the agent’s completion time. Offer to let the agent work on the next small task in parallel once the first is reviewed, which keeps it busy while the review happens.
If the agent still insists, split the task along a different seam or let it finish a larger piece and then immediately split the result into smaller reviewable chunks. The goal is to keep the diff small enough that a reviewer can answer the three questions without opening a second terminal window.
Keep the agent aligned while you split the work
After you split a task, you need to tell the agent which piece to start with and what the boundaries are. Give the agent a concise prompt that names the first subtask, the files it can touch, and the files it must not touch. If the agent strays into another subtask, pause it and redirect it to the correct boundary.
You can also use a shared workspace to keep the agent honest. When the agent claims a task with start_work, the workspace records its scope and boundaries. If the agent later tries to expand beyond that scope, the workspace can surface an overlap warning so you can intervene before the diff grows.
Once the agent finishes a subtask, review it immediately. If it passes, let the agent start the next subtask in the stack. This keeps the agent busy while the first change is reviewed and prevents the backlog of unreviewed work from growing.
A reviewer who cannot hold the entire change in mind will skip details or defer the review, which introduces risk faster than the agent can finish.
If you coordinate multiple agents on the same codebase, the same rule applies to each agent’s output. Each agent should produce a task small enough for one reviewer to judge in one sitting, and the shared workspace should surface overlaps before edits begin. Otherwise, you trade one kind of chaos for another.
What to do when you cannot split the task further
Some tasks are genuinely indivisible: a refactor that touches every file in a module, or a security audit that must inspect every entry point. In those cases, split the review instead of the task. Assign one reviewer per logical layer or file group, and have them review sequentially or in parallel with clear hand-off points.
You can also stage the change in layers: first the schema, then the API, then the UI. Each layer is small enough to review, and the layers compose into the final change. Reviewers can still judge one layer at a time, even if the overall task is large.
If neither splitting nor staging works, schedule the change for a time when the codebase is stable and reviewers are available. A large unreviewed change is still a risk, but it is a known risk you can plan for, unlike a surprise that arrives during a release week.
The key is to keep the reviewer’s cognitive load low. If you cannot make the diff smaller, make it easier to digest by breaking the review into smaller chunks or spreading the review across multiple people. The agent’s output does not have to be a single PR to be useful.