If a Task Title Contains "And", Split It
The word and in a task title is a smell. "Add search and filtering and pagination." "Refactor the auth module and update the tests." Each conjunction is usually a seam where one task was quietly stitched to another — and an AI agent that grabs the whole thing has to hold two problems in its head at once. Split on the "and" and you hand the agent something it can finish cleanly.
Why small tasks win with agents
An agent performs best when the work is contained. Every extra subsystem a task touches widens the blast radius: more files in context, more places to go wrong, more chances the agent "fixes" one thing and quietly breaks another. Anthropic's own coding agents lean on the orchestrator-workers pattern precisely for this reason — a central step decomposes a job into narrow subtasks, and each worker handles one of them without predefined coupling.
The failure mode is predictable. Give an agent "add search and filtering and pagination" and it will start the search UI, half-wire the filter state, touch the pagination query, and leave you with three things that are each 70% done and none that pass review. Three separate tasks each get finished, tested, and merged.
The split test
Keep cutting a task until every piece clears three lines:
| Signal | Threshold | Why it matters |
|---|---|---|
| Files touched | ~5 or fewer | The whole change fits in one review and one context window |
| Acceptance bullets | 3 or fewer | More than three "done when…" clauses means more than one task |
| Session length | One focused session | If you can't finish it in a single sitting, the agent can't either |
If a task fails any row, look for the "and" — spoken or implied — and cut there.
Worked example
Before: "Add search with filtering and pagination." That's one title, three subsystems, and easily a dozen files. Split it:
- Basic search — one input, one query, results on screen.
- Filters — add filter controls on top of the working search.
- Pagination — page the already-filtered results.
Three clean, grabbable slices. Each has its own acceptance criteria, its own tests, and its own merge. Search ships and is usable before filters even start. If pagination turns out to be gnarly, it doesn't hold search hostage.
Power moves
- Split by subsystem, not by layer. "Do the frontend and the backend" is still one feature cut badly — the agent needs both halves to prove either works. Cut by capability (search, then filters) so every slice is independently shippable end-to-end.
- Write the acceptance bullets first. If you can't state "done when…" in three bullets, you don't understand the task well enough to hand it off — to an agent or a human. The bullet count is a design smell detector.
- Order the slices so each one merges green. Sequence dependent tasks (search → filters → pagination) so the branch is always in a shippable state. Independent slices can run in parallel agents.
- A short spec beats a big prompt. A five-line task spec — goal, the ~5 files, the ≤3 acceptance bullets — steers an agent better than a paragraph of prose. Fewer ways to wander, less to hold in context.
Resources
- Building Effective AI Agents — Anthropic — the orchestrator-workers pattern and why decomposition beats one big prompt.
- Task Engineering in AI Coding — EclipseSource — how to break a problem into AI-ready pieces.
- How to Write a Good Spec for AI Agents — O'Reilly — the short-spec habit that keeps an agent on rails.
- My LLM Coding Workflow — Addy Osmani — implement one step at a time, test, then move on.
Working with AI coding agents? Yeda AI designs, audits, and ships production LLM systems.