Task 1.6: Design task decomposition strategies for complex workflows

• AA coordinator that spawns research subagents to investigate each service in whatever way it judges best that week

  Incorrect

  Dynamic multi-agent delegation suits open-ended research, not a repeatable checklist, and multiplies token use.

• BOne prompt that contains all 40 services and asks for every step and the summary in a single response

  Incorrect

  Packing every service and step into one call dilutes attention and leaves no point to check intermediate output.

• CA fixed prompt chain that runs the same steps per service, with checks between steps, then a summary

  Correct

  The steps are known in advance, so a fixed sequence of focused calls gives predictable, comparable output at the lowest cost.

• DAn autonomous agent that decides each week which steps to run for each service based on what it finds

  Incorrect

  Open-ended planning adds cost and variation to a task whose steps never change.

Choose prompt chaining when a task breaks into fixed, predictable subtasks, and keep dynamic decomposition for open-ended investigations whose next step depends on what was found.

• AFix the complete test plan before writing anything and do not change it, so the work stays predictable

  Incorrect

  A frozen plan cannot absorb the dependencies the investigation will uncover in undocumented code.

• BMap the structure first: entry points, modules, existing tests and how the pieces depend on each other

  Correct

  An open-ended task starts with discovery, because the right subtasks depend on what the codebase actually contains.

• CRequire full line coverage of each file before the agent moves on to the next one

  Incorrect

  A uniform coverage target per file spends time on trivial code and delays the high-risk areas.

• DRank areas by impact and risk, then work through a prioritized plan that is revised as new dependencies turn up

  Correct

  An adaptive plan focuses effort where tests matter most and changes as the investigation reveals more.

• EWrite tests file by file in alphabetical order so that progress is easy to track

  Incorrect

  An order that ignores impact spends effort on low-value files and does not adapt to what is found.

For open-ended work, decompose adaptively: explore the structure, find the high-impact areas, and plan in priority order, adjusting the plan as each step reveals more.

• AInto one subtask per file, all run in parallel and merged at the end

  Incorrect

  Nothing is verified until the merge, which is exactly when failures are hardest to pin down.

• BInto subtasks that can each be verified before the next begins

  Correct

  Checkable steps localize failures, keep the system working between steps and let the plan adapt.

• CInto phases by layer, such as interfaces, call sites and tests, checked once all phases finish

  Incorrect

  A single check at the end still leaves every failure to be found at once.

• DInto subtasks sized to fit one context window each

  Incorrect

  Size decides what fits in context, not whether each step can be checked.

Decompose large changes into steps that each produce something you can check. Programmatic checks between steps keep the process on track and show where a failure came from.

• AOne call is always more accurate because it sees everything at once

  Incorrect

  Combining steps removes the gate that catches errors.

• BThe chain is cheaper and faster than one call

  Incorrect

  More calls usually mean more latency, not less.

• CThere is no tradeoff; both designs give the same quality

  Incorrect

  Splitting a task into easier steps generally improves quality.

• DThe chain is slower but easier per step, with a check in between

  Correct

  Prompt chaining trades latency for accuracy by making each step simpler and gated.

Prompt chaining makes each call an easier task and allows checks between steps, at the cost of latency. It fits offline jobs where quality comes first.

• AMost-used packages first, so that the biggest impact lands early

  Incorrect

  Usage ignores which packages need others to be done first, so the same failures recur.

• BIn the order the owning teams asked for the upgrade

  Incorrect

  Request order is unrelated to the dependencies that are causing the failures.

• CBy the dependency graph, prerequisites first

  Correct

  Ordering by dependencies means each step builds on finished prerequisites.

• DIn parallel batches of five, retrying failed packages until they pass

  Incorrect

  Retries cannot pass while a package's dependencies are still on the old version.

When subtasks depend on each other, the plan must respect the dependency order. Work out which packages need which, then upgrade prerequisites before the packages that need them.

• ANo interruptions, so that the agent finishes as fast as possible

  Incorrect

  Unchecked long runs let early mistakes spread.

• BA human approval for every single tool call

  Incorrect

  Approving every call removes the benefit of autonomy.

• CA fixed script instead of an agent, written in advance

  Incorrect

  A cleanup whose steps depend on findings cannot be scripted fully.

• DCheckpoints where it pauses for human review

  Correct

  Agents can pause for human feedback at checkpoints or blockers, which limits compounding errors.

For long autonomous runs, build in human checkpoints at milestones or blockers, along with appropriate guardrails.

• AA request to "be consistent with the other chunks"

  Incorrect

  A chunk cannot see the others, so the instruction cannot be followed.

• BNothing extra; fix inconsistencies by hand afterwards

  Incorrect

  Manual cleanup across 300 pages is the cost to avoid.

• CA shared glossary of approved term translations

  Correct

  Common context passed to every section keeps independently processed parts consistent.

• DThe full translations of all other chunks

  Incorrect

  Other chunks are not finished yet, and their text would flood each request.

When work is split into sections processed separately, give every section the shared context it needs, such as a glossary, so the results fit together.