
How do you break a difficult task into steps with Super Intelligence? Start by identifying the final outcome, the information required to reach it and the dependencies that determine what must happen first. Good decomposition turns one vague, high-load request into smaller tasks that can be completed, checked and repaired independently.
Breaking complex work into steps is one of the most important SI skills because large tasks often fail for reasons that are hard to see. Research may use the wrong source before writing begins. A calculation error may enter a report and then spread into a presentation. A missing approval may appear only when an automated action is about to execute.
This eduKateSG guide teaches practical AI task decomposition for learning, research, writing, coding, data analysis, projects, workflows and agents. It follows How to Ask Super Intelligence Better Questions and prepares the next article on using examples to teach SI what you want.
Terminology: SI is our editorial term for practical contemporary AI learning. Decomposition does not make every difficult task easy; it makes the structure of the difficulty easier to inspect and manage.
The First Principle: Split by Dependency, Not by Arbitrary Size
A good step exists because something depends on it. “Write 500 words, then another 500 words” is not necessarily decomposition. “Verify the source, extract the evidence, form the outline, draft the explanation and check the final claims” follows real dependencies.
The order matters. If the source is wrong, polishing the prose is wasted work. If the data is incomplete, generating the chart may create false confidence. Decomposition protects later stages by validating earlier prerequisites.
Ask: what must be true before the next step can succeed? That question reveals the dependency graph.
The Four Elements of a Decomposed Task
Outcome
Define what should exist at the end: a verified report, a solved problem, a tested function, a lesson plan or an approved schedule.
Inputs
Identify the information, files, assumptions, tools or permissions each step requires. Missing inputs should stop or redirect the process rather than be silently invented.
Transformation
State what the step does: search, extract, compare, calculate, draft, test, classify or approve.
Check
Define how the step is accepted. A source is accepted because it is authoritative and current enough. A calculation is accepted because it reproduces. A draft is accepted because protected facts remain intact.
Decomposition Pattern 1 — Research
Large research questions often combine discovery, source evaluation, extraction, comparison and synthesis. Separate them.
- Define the research question and scope.
- Identify the source type capable of answering it.
- Search for candidate sources.
- Evaluate authority, date and relevance.
- Extract the passages or data that matter.
- Compare agreement, disagreement and scope.
- Write the bounded conclusion.
- Verify citations and unresolved questions.
This pattern prevents a polished synthesis from appearing before the evidence base has been inspected.
Decomposition Pattern 2 — Writing
Writing can be divided into meaning, structure, drafting and editing. Combining all four in one request can make revision difficult to diagnose.
- Define purpose and receiver.
- Extract protected facts and commitments.
- Choose the structure.
- Draft for meaning.
- Edit for clarity and tone.
- Check factual fidelity.
- Prepare the final format.
If the problem is factual drift, repair the source or preservation step rather than repeatedly changing sentence style.
Decomposition Pattern 3 — Learning
Learning should be split around the learner’s cognition rather than the tool’s ability to answer.
- Attempt the task independently.
- Identify the first uncertain step.
- Request a hint or targeted explanation.
- Complete the original attempt.
- Explain the principle in your own words.
- Try a fresh transfer example.
- Review the new error pattern.
The final step returns evidence to the next learning cycle.
Decomposition Pattern 4 — Data Analysis
Data work can fail at input quality, transformation, calculation or interpretation. Keep these stages visible.
- Define the question.
- Identify rows, columns, units and missing values.
- Clean or validate the data.
- Choose the calculation or analysis.
- Run the computation.
- Check the result independently.
- Interpret within the data’s scope.
- Visualise only after the measure is stable.
A correct chart of the wrong measure remains wrong. The dependency order protects against that.
Decomposition Pattern 5 — Coding
Coding tasks benefit from specification and tests before implementation.
- Define expected behaviour.
- Identify environment and constraints.
- Write representative test cases.
- Implement the smallest solution.
- Run tests.
- Reproduce failures.
- Make targeted repairs.
- Run regression tests.
- Review security, performance and deployment needs.
This structure helps SI assist with coding without turning every bug into a complete rewrite.
Decomposition Pattern 6 — Decision-Making
A decision should not begin with “choose”. Separate evidence from preference.
- Define the decision owner.
- Set criteria.
- Gather relevant evidence.
- List assumptions.
- Generate meaningfully different options.
- Compare consequences and reversibility.
- Verify critical claims.
- Record the human decision.
- Set a review condition.
The system can support the analysis while leaving responsibility visible.
Decomposition Pattern 7 — Tool-Using Workflows
When external tools are involved, each tool call becomes a potential failure point. Define what enters, what should return and what downstream step depends on it.
Search should return sources. A calculator should return a computation. A file reader should return identified content. A calendar connector should return a confirmed event or an explicit error.
Do not let a later step treat a missing or failed tool result as success.
How to Find the Right Granularity
Steps can be too large or too small. A step is too large when failure is difficult to diagnose. It is too small when coordination overhead exceeds the value of the split.
“Research this topic” is too large for a complex project. “Read every sentence and label every noun” may be unnecessarily small. The useful middle layer is a task with one coherent purpose and one acceptance check.
Adjust granularity based on consequence. High-impact steps deserve more explicit checks.
The Earliest-Unstable-Step Rule
When a workflow fails, trace backward until you find the earliest step whose output cannot be trusted. Repair there.
If a report contains a wrong statistic, do not begin by editing the paragraph. Check the calculation. If the calculation uses the wrong denominator, inspect the input definition. If the denominator came from the wrong source, repair source selection.
This rule prevents late-stage cosmetic fixes from hiding early-stage structural errors.
Checkpoints: Where to Pause Before Error Propagates
A checkpoint belongs where a wrong result would contaminate substantial downstream work. Confirm sources before synthesis. Confirm calculations before presentation. Confirm draft meaning before publication. Confirm approval before external action.
Too many checkpoints create friction. Too few make recovery expensive. Place them at high-leverage handoffs.
Parallel vs Sequential Work
Not every step needs to be sequential. Independent source searches can run in parallel. Several alternative designs can be explored at the same time. But tasks sharing a dependency should wait for that dependency.
Use parallel work to reduce time without creating contradictory state. Then define a merge step that compares results and resolves conflicts explicitly.
A Worked Example: Break a School Research Project Into Steps
Task: produce a short report on how urban heat affects a neighbourhood. A one-shot request might ask SI to research, write and cite everything. A decomposed workflow is safer.
Step 1 defines the question and location. Step 2 identifies source categories: meteorological data, urban-planning material and peer-reviewed research. Step 3 gathers sources. Step 4 extracts evidence. Step 5 separates local observations from general findings. Step 6 creates the outline. Step 7 drafts. Step 8 checks every important claim.
The student can now see whether weakness lies in research, interpretation or writing rather than receiving one opaque final report.
A Worked Example: Break Exam Revision Into Steps
Task: improve a weak Secondary Mathematics topic before an assessment. Do not begin with a large worksheet.
Step 1 samples several questions. Step 2 classifies errors. Step 3 identifies the earliest prerequisite gap. Step 4 repairs that gap with guided practice. Step 5 uses fresh questions. Step 6 introduces time pressure only after accuracy stabilises. Step 7 mixes the topic with other chapters.
The decomposition protects the student from practising speed on an unstable method.
A Worked Example: Break a Business Brief Into Steps
Task: prepare a decision brief from meeting notes, metrics and two supplier proposals.
Step 1 labels current source versions. Step 2 extracts confirmed decisions and unresolved questions. Step 3 validates the metrics. Step 4 compares suppliers using agreed criteria. Step 5 drafts the brief. Step 6 checks facts. Step 7 returns it for human decision.
Sending the decision or changing a system is not part of the drafting step unless separately authorised.
A Worked Example: Break a Debugging Task Into Steps
Task: fix an application that intermittently returns empty results.
Step 1 reproduce the failure. Step 2 capture inputs and logs. Step 3 determine whether the empty result comes from retrieval, parsing or display. Step 4 isolate the smallest failing component. Step 5 repair. Step 6 run regression cases. Step 7 monitor the real system after deployment.
SI can help at each step, but the decomposition prevents a speculative rewrite of the whole application.
Decomposition and Context
Each step should receive only the context needed for that step plus the state required from earlier steps. This reduces distraction and makes handoffs clearer.
Anthropic’s context-engineering work describes context as a finite resource that must be curated for agents. The same principle applies to ordinary workflows: give each stage the information it needs instead of carrying the entire project indiscriminately.
Decomposition and Prompting
Prompting becomes easier when a task is decomposed. Each prompt can state one coherent job, input and output contract.
Instead of one giant instruction with twenty conditions, use a sequence of prompts whose intermediate outputs can be checked. The cost is coordination; use decomposition only where the checkpoints create real value.
Decomposition and Agents
Agents are useful when the path cannot be fully predetermined, but agentic work still benefits from decomposition. The agent needs goals, tools, state and feedback.
A good agent may choose among substeps dynamically, but the system designer should still know what evidence marks progress and what conditions require stopping or escalation.
Failure Modes of Decomposition
Splitting by word count instead of logic
This creates pieces with no meaningful dependency or check.
Too many microsteps
Coordination overwhelms the original task. Merge steps that share one purpose and one validation method.
No handoff contract
The next step receives ambiguous or incomplete output. Define what must be passed forward.
Checking only at the end
Early errors become expensive. Move validation to the handoff where the error first becomes visible.
Automating before stabilising
A poorly understood process becomes harder to inspect when automated. Document the manual workflow first.
A Decomposition Checklist
- What is the final outcome?
- What inputs are required?
- Which parts depend on earlier results?
- Which parts can run independently?
- What is the smallest coherent step?
- How is each step accepted?
- Where would an error propagate most widely?
- Where should a checkpoint sit?
- What should stop the process?
- What does the receiver need from the final handoff?
Frequently Asked Questions
Should I always break large tasks into many prompts?
No. Decompose when it improves clarity, checking or recovery. A simple task can remain one step.
How many steps are ideal?
There is no universal number. Use the fewest steps that keep important dependencies and failures visible.
Should I let SI create the plan?
SI can propose a decomposition. Inspect whether the steps reflect real dependencies and whether the checks are meaningful.
What if the steps change during the project?
Update the plan. Decomposition is a working model, not a contract with the original outline.
Can steps run in parallel?
Yes when they do not depend on each other and the merge process is defined.
What should I learn next?
Continue with How to Use Examples to Teach Super Intelligence What You Want.
A Dependency Map: The Backbone of Complex Work
Before writing steps, draw the dependency map. A dependency exists when Step B cannot be completed responsibly until Step A has produced a valid result. This map distinguishes true sequence from mere preference.
For a research report, source validation precedes synthesis. For a spreadsheet, data definitions precede formulas. For a presentation, the analysis precedes the visual story. For an external action, approval precedes execution.
Once dependencies are visible, SI can help order the work. Ask it to identify prerequisites, but verify the map against the real process because informal dependencies may be absent from the supplied documentation.
The Critical Path
Some steps determine the earliest possible completion of the whole project. These form the critical path. Delays or errors there have disproportionate impact.
Use SI to identify which steps are sequential and which have slack. Then focus checks on the critical path. A late formatting adjustment may be inconvenient; a wrong source on the critical path can invalidate the entire report.
This makes decomposition more strategic. Not every step deserves equal attention.
State Transitions: Define What Changes Between Steps
Every step should leave the project in a clearer state. “Research done” is vague. “Three authoritative sources selected and their relevant passages extracted” is observable.
Define state transitions explicitly. Before the step, the source set is uncertain. After the step, the source set is approved. Before calculation, raw values exist. After calculation, a verified metric exists.
State-based design makes it easier for SI and humans to know whether the process should continue.
Handoff Contracts
A handoff contract defines what one step must pass to the next. It can include fields, units, source references, status and unresolved issues.
For example, a research extraction handoff might require Claim, Source, Date, Passage and Confidence. A data-cleaning handoff might require cleaned table, missing-value log and unit definitions.
Handoffs reduce ambiguity and make multi-step work portable between people, tools or agents.
Stop Conditions
A step should know when not to continue. Stop if a required source is missing. Stop if two authoritative dates conflict and no priority rule exists. Stop if a tool lacks permission. Stop if the calculation needs a denominator that is absent.
A stop condition is not failure of the workflow. It is safe failure. It protects downstream work from false completion.
Define escalation: ask the user, consult the source owner, request approval or switch to a different tool.
Recovery Paths
Every important step should have a recovery path. If search finds no authoritative source, broaden the search or ask for a different evidence route. If parsing fails, preserve the file and use another extraction method. If a calculation fails, inspect the inputs before replacing the formula.
Recovery paths prevent users from restarting the entire project after local failures.
The recovery should return the process to a valid state, not merely force it forward.
Decomposition by Risk
Another way to split work is by consequence. Low-risk exploration can be broad. High-risk interpretation, publication or external action deserves separate steps and stronger checks.
For example, brainstorming possible email wording is low risk. Sending the email is higher risk. Separate them. Generating a database migration plan is different from executing it.
Risk-based decomposition is especially useful for agents because tool permissions can be assigned only to the stages that truly need them.
Decomposition by Expertise
A workflow may cross domains. One step requires legal review, another numerical analysis, another writing. Separate steps when different expertise is needed.
SI can prepare materials for an expert, but it should not erase the handoff to qualified judgment. Decomposition makes that boundary explicit.
This also improves collaboration because each reviewer sees the material relevant to their role.
Decomposition by Reversibility
Keep reversible work early and irreversible work late. Draft before publish. Simulate before deploy. Propose before approve. Test on copies before modifying originals.
This sequencing reduces the cost of error and gives the team more evidence before consequential actions occur.
A good decomposed workflow increases commitment gradually as confidence increases.
Map–Do–Check–Merge
A compact decomposition pattern is Map, Do, Check, Merge. Map defines the subproblem. Do performs the work. Check validates it. Merge integrates the accepted result into the larger project.
This pattern can repeat recursively. A large research step can itself contain smaller Map–Do–Check–Merge loops.
The merge step matters because locally correct outputs can still be incompatible. Two sections may use different definitions. Two parallel analyses may assume different time periods. Merge checks consistency.
A Full Worked Case: Build a Long Research Report
Outcome: a verified report on how heat affects urban learning environments. The naive request would ask SI to research and write the report at once.
Step 1 defines scope: age group, geography, time period and outcomes. Step 2 builds a source plan. Step 3 gathers official climate data, education research and building-environment research. Step 4 evaluates each source. Step 5 extracts claims and evidence.
Step 6 groups evidence into mechanisms: thermal comfort, concentration, attendance and infrastructure. Step 7 identifies disagreements and limitations. Step 8 builds the outline. Step 9 drafts section by section. Step 10 verifies every major factual claim.
Step 11 checks coherence across sections. Step 12 formats the final report and references. Each step has a clear acceptance state, making the project recoverable if one section fails.
A Full Worked Case: Build a Presentation
Outcome: a ten-slide presentation for a leadership meeting. Do not begin with slide design.
Step 1 defines the decision the presentation supports. Step 2 validates the underlying data. Step 3 identifies the three most important findings. Step 4 chooses the narrative sequence. Step 5 decides which findings require charts and which require explanation.
Step 6 drafts slide messages. Step 7 creates visuals. Step 8 checks labels and numbers. Step 9 performs a receiver test: can a leader understand the decision without hearing the private reasoning from the creator?
The visual layer appears late because presentation quality cannot compensate for weak evidence.
A Full Worked Case: Build a Study Plan
Outcome: prepare for a Mathematics examination in six weeks. Step 1 gathers recent test evidence. Step 2 classifies errors by topic and mechanism. Step 3 ranks gaps by prerequisite importance and exam exposure.
Step 4 allocates concept repair. Step 5 adds retrieval practice. Step 6 adds mixed practice. Step 7 adds timed execution. Step 8 runs weekly checkpoints. Step 9 changes the plan based on evidence.
The plan is dynamic because decomposition creates feedback loops rather than a fixed calendar.
A Full Worked Case: Build an Automated Meeting Workflow
Outcome: turn meeting notes into approved tasks. Step 1 obtains authorised notes. Step 2 extracts candidate actions. Step 3 quotes the supporting sentence. Step 4 classifies each item as confirmed or proposed. Step 5 assigns an owner only when the source identifies one.
Step 6 presents the task list for human review. Step 7 writes approved tasks to the task system. Step 8 confirms the destination records. Step 9 logs exceptions.
The automation is safe because extraction, interpretation, approval and write access are separate stages.
A Full Worked Case: Build a Web Page
Outcome: publish a factual information page. Step 1 defines search intent and reader job. Step 2 selects authoritative sources. Step 3 builds the information architecture. Step 4 writes a factual outline. Step 5 drafts.
Step 6 verifies claims and links. Step 7 checks mobile readability and headings. Step 8 checks metadata and canonical ownership. Step 9 previews. Step 10 publishes. Step 11 confirms the public page.
Publishing is late because it is harder to reverse than drafting.
A Full Worked Case: Debug a Data Pipeline
Outcome: fix missing rows. Step 1 reproduce the missing-row case. Step 2 locate where row count first changes. Step 3 inspect filter conditions. Step 4 test the smallest suspected condition.
Step 5 repair. Step 6 run regression tests on normal and boundary data. Step 7 compare total row counts and key aggregates. Step 8 deploy to a safe environment. Step 9 monitor.
Decomposition converts a broad “pipeline is broken” problem into traceable state changes.
A Full Worked Case: Compare Two Policies
Outcome: produce a neutral comparison. Step 1 define the exact provisions being compared. Step 2 obtain authoritative texts. Step 3 align definitions. Step 4 build a provision-by-provision table.
Step 5 identify similarities. Step 6 identify differences. Step 7 separate documented effects from attributed predictions. Step 8 write a neutral summary. Step 9 verify citations.
This structure prevents the comparison from becoming a rhetorical contest before the facts are aligned.
Decomposition for Multi-Agent Systems
Multi-agent systems add coordination. Do not split work merely to create more agents. Assign separate agents when the subproblems are meaningfully distinct and their outputs can be merged under clear contracts.
A research agent might gather sources while an analysis agent compares claims. A verification agent can inspect citations. But the system still needs a shared state and a merge policy.
More agents increase communication cost. Use the fewest agents that provide a real capability or independent check.
The Coordination Tax
Every split creates coordination overhead: instructions, handoffs, versioning and merge work. Decomposition is valuable only when the benefits of clarity and recoverability exceed this tax.
Measure coordination. If a five-step workflow takes longer to manage than the original task and catches no meaningful failures, simplify it.
Advanced users know how to merge steps after the underlying risk becomes understood.
Decomposition Under Time Pressure
When time is short, protect the critical path rather than removing all checks. Confirm the source, calculation and consequential action first. Reduce cosmetic refinement.
Use a triage decomposition: must be correct, should be clear, nice to improve. This prevents limited time from being spent on low-impact polish while critical facts remain unchecked.
Decomposition Under Uncertainty
When inputs are uncertain, create discovery steps before execution steps. The first job may be to establish what is known rather than complete the final output.
Use branching workflows: if source found, continue; if conflict, escalate; if missing, stop. Branching is more honest than pretending every path leads to the same final answer.
Decomposition Under Changing Requirements
Projects change. Keep the outcome and dependency map versioned. When a requirement changes, identify which downstream steps are invalidated.
Do not redo unaffected work. Trace dependencies. If only the audience changes, evidence may remain valid while writing and presentation must change.
This is another advantage of modular work: local changes remain local.
A Decomposition Failure Library
- Wrong outcome: the workflow optimises a task nobody actually needs.
- Missing prerequisite: a later step begins without a valid input.
- Hidden assumption: one step silently chooses a value or definition.
- Leaky handoff: important context is lost between steps.
- Invalid merge: correct suboutputs use incompatible definitions.
- Late validation: an early error survives until the final stage.
- No stop condition: the process keeps generating despite missing evidence.
- Permission leak: a preparation step can perform an execution action.
- Over-fragmentation: coordination consumes more effort than the task.
- Under-fragmentation: one step contains several unrelated failure mechanisms.
A Decomposition Design Exercise
Take one task you perform monthly. Draw the current sequence from input to final receiver. Mark every point where a human checks, waits, corrects or requests missing information.
Ask SI to propose a cleaner dependency structure. Compare it with the real process. Add informal steps the model missed. Then identify one checkpoint that could move earlier to catch errors sooner.
Finally, remove one unnecessary split. The exercise should improve both control and simplicity.
A Decomposition Evaluation Rubric
- Each step has one coherent purpose.
- Inputs are explicit.
- Outputs are inspectable.
- Dependencies are real rather than arbitrary.
- High-risk handoffs have checks.
- Missing information has a stop path.
- Parallel tasks have a merge rule.
- External actions have approval boundaries.
- Receiver requirements are represented.
- The total coordination cost is justified.
How to Teach Decomposition
Begin with a familiar task such as making a sandwich, solving an equation or preparing a school presentation. Ask which step must happen first and what evidence shows that step is complete.
Then introduce a failure. What happens if the source is missing? What happens if the calculation is wrong? The learner discovers why some steps need checks.
Finally, ask the learner to simplify the workflow. Teaching both splitting and merging prevents the misconception that more steps are always better.
The Maintenance Rule
Review decomposed workflows after they have been used. Which step catches errors? Which step never changes anything? Which handoff repeatedly loses information?
Strengthen high-value controls. Merge low-value steps. Update dependencies when tools or requirements change.
A mature workflow is not frozen. It becomes simpler as understanding improves and more explicit where risk remains.
A Final Decomposition Examination
Choose a difficult task that previously produced confusion. Write the final outcome. Draw the dependency map. Identify the critical path. Define inputs, outputs and checks for each major step.
Run the workflow on one representative case. Record the first failure. Repair only the responsible step. Then rerun from that point rather than restarting everything.
The examination is complete when you can explain why the steps exist, where the process should stop and how a failure can be recovered without losing the whole project.
Decomposition as a Control System
A decomposed workflow is more than a to-do list. It is a control system: each stage receives an input, produces an output, checks whether that output is inside an acceptable range and either continues, repairs or stops.
This framing is useful because it separates progress from motion. A workflow can execute many steps without getting closer to a trustworthy result. Checkpoints convert activity into evidence of progress.
For recurring SI work, label each step with one of four states: ready, running, blocked or accepted. A blocked step should carry the reason it cannot proceed. An accepted step should carry the evidence that allowed the process to continue.
Receiver-First Decomposition
Work backwards from the receiver. What does the final reader, student, manager or downstream system need in order to act? That requirement determines what the last step must produce, which determines what the preceding step must provide.
For a parent notice, the receiver needs accurate logistics and requirements. The final editing step therefore depends on verified dates and obligations. The verification step depends on the original source. The workflow can be designed backward from those needs.
Receiver-first design prevents substeps from becoming internally elegant but externally useless.
Evidence-Carrying Outputs
Whenever possible, pass evidence with the output. A research claim should carry its source. A calculation should carry inputs and units. A classified action item should carry the source sentence. A tool action should carry the external result identifier.
Evidence-carrying handoffs reduce the need for downstream components to reconstruct how a conclusion was reached. They also make review faster because the supporting material is already attached.
This practice is particularly important when SI coordinates several tools or agents.
Branching Workflows
Not every process is a straight line. Branch when the next step depends on a condition.
Example: if an authoritative source is found, extract and continue. If two authoritative sources conflict, compare scope and date. If no source is found, stop and report the gap. Each branch has a different next action.
Write branch conditions in observable terms. Avoid vague rules such as “if the answer seems uncertain”. Use conditions such as missing required field, contradictory date, failed tool response or unsupported claim.
Loops: When the Workflow Should Repeat
Some tasks need iteration. Draft → review → repair is a loop. Test → debug → retest is a loop. Practice → feedback → transfer is a learning loop.
Every loop should have an exit condition. Without one, an agent or user can refine indefinitely. Define acceptable performance: tests pass, protected facts match, transfer succeeds or the reviewer approves.
Also define a maximum escalation path when the loop does not converge: seek a human expert, change the source, narrow the task or stop.
Queues: Handle Multiple Items Without Losing State
When a workflow processes many similar items, use a queue. Each item should retain its source, status, errors and output. This is safer than combining all items into one unstructured conversation.
For example, a batch of documents can move through pending → extracted → verified → approved. Failed documents remain visible instead of disappearing into a global success message.
Queues are an important bridge from personal prompting to operational SI systems.
Batching vs Individual Processing
Batching can be efficient when items share the same schema and validation rules. Individual processing is safer when items are highly variable or high consequence.
Test batch size. A prompt that handles five short notices well may lose details across fifty. The operating envelope includes scale.
When batching, keep per-item identifiers and checks so one failure does not contaminate the entire batch.
Decomposition for Mobile and Human Attention
Human attention is also a limited resource. Long workflows should expose short checkpoints and current-state summaries so the user does not have to remember the whole process.
On mobile, especially, one clear next action is more usable than a giant wall of intermediate output. Decomposition can improve interface design as well as reasoning.
Ask what the user needs to decide now, and hide or archive the detail that does not affect that decision while keeping it retrievable.
Decomposition and Version Control
Each major step can create a versioned artifact. Source set v1, analysis v2, draft v3. This makes it possible to identify what changed and to roll back when a later edit introduces an error.
Versioning is particularly useful when several people or agents work on the same project. The handoff should name the version being consumed.
Do not treat the latest file as automatically correct. Version and approval state are separate concepts.
Decomposition and Quality Gates
A quality gate is a checkpoint with a defined pass condition. The process cannot continue until the condition is met.
Examples: sources must be current enough and relevant; calculations must reproduce; code tests must pass; a human must approve the final message before sending.
Quality gates should be proportionate. Use strong gates where failure would propagate or create consequence, and lighter checks for low-risk exploratory work.
A Stage-Gate Template
- Stage: the coherent unit of work.
- Entry condition: what must already be true.
- Input: material or state consumed.
- Action: transformation performed.
- Output: artifact or state produced.
- Check: evidence of acceptable quality.
- Failure path: what happens if the check fails.
- Exit condition: what allows the next stage to begin.
- Owner: human or tool responsible.
- Receiver: who or what uses the output next.
This template is useful for complex recurring workflows because every stage becomes inspectable and transferable.
Case Study: Decompose a 60,000-Word Knowledge Hub
A very large article should not be drafted as one uninterrupted generation. Begin with ownership: what search intent and knowledge territory does the hub own? Then build the section architecture. Then identify which sections need current research, internal links, examples and definitions.
Draft in modules. After each module, run a local check for accuracy, duplication and continuity. Maintain a live outline showing completed and unresolved sections. Periodically merge repeated concepts and protect canonical terminology.
Before publication, run a global audit: search intent, opening paragraphs, heading hierarchy, substantive depth, internal links, factual claims, mobile readability, conclusion and metadata. Decomposition makes a large artifact manageable because failures remain local until the final integration test.
Case Study: Decompose a Long-Running Agent Task
A long-running agent cannot rely only on one uninterrupted context. It needs durable state. Anthropic’s work on long-running agent harnesses emphasises leaving clear artifacts that allow later sessions to continue progress.
Decompose the task into milestones with persistent outputs: project plan, current state, completed work, test results and next action. Each session reads the state, performs bounded work and updates the artifacts.
This prevents the new session from reconstructing the entire history from memory and reduces repeated work.
Case Study: Decompose a Family Decision
A family choosing an enrichment programme may mix price, travel time, child interest, schedule and educational value in one conversation. Separate them.
First define non-negotiable constraints such as schedule and travel. Then gather factual programme information. Then identify preferences. Then compare options using the agreed criteria. Finally, record the family’s value judgment.
SI can organise the comparison without deciding what the family should value.
How to Simplify After Decomposition
The first version of a workflow may be intentionally explicit. Once repeated use shows that two steps always travel together and no unique failure appears between them, merge them.
Keep a checkpoint only when it catches meaningful problems or protects a consequential transition. Remove ceremonial steps.
This creates a mature cycle: decompose to understand, instrument to observe, then simplify without losing control.
Final Receiver Test
Give the decomposed workflow to another authorised person without oral explanation. Can they identify the current state, next step, required inputs and stopping conditions?
If not, the decomposition exists only in the original designer’s head. Improve the handoff artifacts.
A strong decomposed process is understandable enough to continue even when the original author is unavailable.
The Core Principle: Decompose by Dependency, Not by Convenience
Breaking a task into steps is not the same as slicing it into equal-sized pieces. A good decomposition follows dependencies: which result must exist before the next step can be done correctly?
For example, a research report should not begin with final prose if the source set is still uncertain. A presentation should not be polished before the underlying calculations are checked. A software deployment should not occur before tests and configuration are verified.
The best sequence therefore protects the task from error propagation. Each early step creates a stable input for the next step.
The Seven-Part Task Decomposition Model
- Goal: What useful final result is required?
- Inputs: What information, files, data or decisions are needed?
- Subtasks: What independent or sequential pieces of work produce the result?
- Dependencies: Which subtasks must happen before others?
- Checks: Where can an error be caught before it spreads?
- Handoffs: What exactly must one step pass to the next?
- Closure: What shows the entire task is complete?
This model works for schoolwork, research, writing, coding and professional workflows because it is based on information flow rather than a particular product.
Step 1 — Define the Final Deliverable
Before asking SI to create steps, define the end state. “Help me with my project” is too vague. “Produce a three-page evidence-based brief for a manager, including decision options, risks and unresolved questions” creates a target.
The final deliverable determines which subtasks matter. If the output is a study plan, you need diagnostic information. If the output is a report, you need sources. If the output is an application, you need requirements and tests.
A strong decomposition starts from the receiver. What does the receiver need to do next? Work backwards from that need.
Step 2 — Identify Required Inputs
List what the task cannot proceed without. These may include documents, data, user choices, current facts, technical access or approval.
Do not let SI guess missing inputs simply to keep the workflow moving. If a deadline is absent, the task may require clarification. If a calculation lacks a denominator, the correct next step is to obtain it.
Input completeness is an early checkpoint. Catching a missing input here is cheaper than discovering it after several downstream steps.
Step 3 — Find Natural Subtasks
A natural subtask produces a meaningful intermediate result. Research may split into question definition, source gathering, source evaluation, extraction, synthesis and writing. Coding may split into specification, tests, implementation, debugging and deployment.
Avoid micro-steps that create administrative noise without improving control. “Open document”, “read first sentence” and “read second sentence” are rarely useful decomposition units. The step should correspond to a meaningful transformation or decision.
Also avoid giant steps such as “analyse everything”. If the step cannot be checked independently, it is probably too large.
Step 4 — Map Dependencies
Draw arrows mentally or explicitly. Which step depends on which output? A literature synthesis depends on selected sources. A budget chart depends on validated calculations. A final email depends on approved content.
Dependencies reveal where parallel work is possible. Two independent source searches can occur in parallel. Drafting the conclusion cannot reliably happen before evidence exists.
SI can help propose a dependency map, but the user should verify it against the real process. Informal human steps are often missing from formal descriptions.
Step 5 — Insert Checkpoints
A checkpoint is a place where the workflow verifies an intermediate result before continuing. Checkpoints reduce error propagation.
Examples: confirm extracted deadlines before drafting a plan; validate formulas before building charts; run unit tests before integrating modules; verify source authority before writing conclusions.
Not every step needs a heavy review. Put the strongest checks where mistakes would be costly or difficult to recover later.
Step 6 — Define Handoffs
A handoff is the information passed from one step to another. Strong handoffs are explicit. Instead of “send research to writer”, define the package: source title, URL, date, relevant passage, claim supported and uncertainty.
In software, a handoff may be an API response with defined fields. In a school project, it may be a completed outline with sources attached. In a team workflow, it may be an approved decision note.
Handoff quality determines system quality. A correct step can still produce downstream failure if its output is ambiguous.
Step 7 — Define Closure
Tasks become endless when completion is undefined. Closure may be a validated file, a reviewed report, a successful test suite or a human approval.
If uncertainty remains, closure can include an unresolved-question list. Completion does not require pretending every issue is solved; it requires making the remaining state explicit.
Serial Decomposition: When Steps Must Be Sequential
Serial decomposition is appropriate when each step depends on the previous one. Example: extract data → clean data → calculate → interpret → write report.
The advantage is control. Each intermediate result can be checked. The disadvantage is speed when some steps could safely run in parallel.
Use serial structure when dependency is strong or when early errors would contaminate later work.
Parallel Decomposition: When Work Can Run Side by Side
Parallel decomposition is appropriate when subtasks are independent. A research team can examine different source categories at the same time. A product analysis can separately evaluate cost, technical feasibility and user impact.
Parallel outputs need a later synthesis step. Define compatible formats so the branches can be compared. Otherwise, each branch may use different assumptions and become difficult to combine.
Do not parallelise steps merely because multiple agents are available. Coordination cost can exceed the benefit.
Recursive Decomposition: Break Down Only the Part That Is Still Too Large
A task does not need to be decomposed to the smallest possible unit at the beginning. Start with major phases. If one phase remains unclear, decompose that phase further.
For example, “verify sources” may be adequate in a simple assignment. In a complex research project, it may split into authority, date, population, methodology and claim support.
Recursive decomposition keeps the plan readable while allowing detail where difficulty requires it.
Task Decomposition for Learning
Students often face large tasks such as “revise algebra”. Break this into diagnostic and practice stages: identify error patterns, select the largest gap, review concept, practise isolated skill, attempt mixed questions and run an independent checkpoint.
The sequence matters. Random mixed practice before repairing a prerequisite can create repeated failure without learning.
SI can help generate practice at each stage, but the student should retain independent attempts and checks.
Task Decomposition for Writing
A writing task can be separated into purpose, source facts, audience, outline, draft, factual review, structural edit and final proofread.
Do not combine factual review with stylistic editing when the facts are still unstable. A beautiful paragraph should not become psychologically difficult to change simply because it was polished too early.
Use checkpoints after outline and after factual review. The receiver’s needs should guide the final structure.
Task Decomposition for Research
Research can be decomposed into question definition, search strategy, source discovery, source evaluation, evidence extraction, comparison, synthesis and writing.
Keep discovery separate from support. A search result identifies a candidate source. Evidence extraction determines whether the source actually supports the claim.
For current topics, add a freshness check. For contested topics, add perspective and methodology comparison.
Task Decomposition for Data Analysis
Data work can be separated into question, data acquisition, schema inspection, cleaning, validation, calculation, visualisation, interpretation and communication.
The most dangerous shortcut is interpreting before validating. A sophisticated chart built from incorrect units is still incorrect.
Define missing-value rules and units early. Use deterministic calculations where appropriate and keep the raw data available for review.
Task Decomposition for Coding
Coding can be decomposed into requirements, interface, tests, implementation, debugging, review, integration and deployment.
Write expected behaviour before generating code. Test the smallest unit before combining it with other components. A failure discovered after deployment is more expensive than the same failure discovered in a unit test.
Use SI to explain or draft components, but keep the codebase, tests and environment as the source of truth.
Task Decomposition for Presentations
A presentation should begin with audience and decision, then evidence, narrative, slide structure, visual design and rehearsal.
Designing slides before deciding the narrative can produce attractive fragments without a coherent argument. Build the story first. Then decide which evidence belongs on each slide.
Check legibility and factual support separately. A visual can be beautiful and misleading.
Task Decomposition for Automation
Automation begins with mapping the manual process. Identify repeated inputs, stable transformations, judgment points, approvals and exceptions.
Automate the stable parts first. Keep exception handling and high-consequence decisions visible. If the workflow cannot describe what happens when a source is missing or a tool fails, it is not ready for unattended execution.
Measure total process time after automation, including review and failure recovery.
A Worked Example: Turn a Vague School Project Into Steps
Task: “Create a presentation about renewable energy.” This is too broad for dependable execution.
Step 1: define audience and learning objective. Step 2: choose three energy types. Step 3: collect reliable sources. Step 4: extract one mechanism, one advantage and one limitation for each. Step 5: compare them. Step 6: build slide outline. Step 7: create visuals. Step 8: verify facts. Step 9: rehearse.
Each step produces something checkable. The final presentation is easier because the evidence and narrative were stabilised before visual polish.
A Worked Example: Meeting Notes to Action Plan
Input: meeting notes containing decisions, proposals and open questions. Final deliverable: action plan with owner, deadline and status.
Step 1: extract candidate actions. Step 2: classify each as confirmed or proposed. Step 3: identify owner and deadline. Step 4: flag missing fields. Step 5: draft action table. Step 6: verify against notes. Step 7: return for approval.
Do not create tasks automatically when owner or approval is missing. The workflow stops at the uncertainty instead of guessing.
A Worked Example: Debug a Failing Application
Final goal: restore a failing feature without breaking existing behaviour.
Step 1: reproduce the failure. Step 2: capture error and inputs. Step 3: isolate smallest failing component. Step 4: identify expected behaviour. Step 5: write or confirm regression test. Step 6: make minimal repair. Step 7: run local tests. Step 8: run broader test suite. Step 9: review deployment plan.
This decomposition protects against the common failure of rewriting large amounts of code before the bug is understood.
A Worked Example: Compare Two Policy Options
Final goal: prepare a neutral decision brief. Step 1: define criteria. Step 2: gather source evidence for each option. Step 3: separate factual effects from predictions. Step 4: identify uncertainties. Step 5: compare on the same criteria. Step 6: identify trade-offs. Step 7: verify key claims.
The final decision belongs to the responsible human or institution. Decomposition makes the analysis visible without hiding the value judgment.
Decomposition Failure Mode 1 — Too Many Steps
Over-decomposition creates management overhead. If a workflow contains dozens of tiny steps that do not produce independent value or checks, merge them.
A good step should either transform information, make a decision, perform a tool action or verify a result.
Decomposition Failure Mode 2 — Steps That Hide the Real Work
A step such as “analyse the problem” can hide several distinct tasks. Ask what analysis means: classify errors, compare sources, calculate metrics or identify assumptions?
Replace vague steps with observable operations.
Decomposition Failure Mode 3 — No Checkpoints
A long chain without checks allows early mistakes to propagate. Add validation at high-leverage boundaries.
The checkpoint should use evidence independent enough to catch the relevant failure. A source check catches factual drift; a unit test catches code behaviour; a human approval catches an unauthorised external action.
Decomposition Failure Mode 4 — Wrong Order
Tasks can be decomposed correctly but sequenced incorrectly. Drafting before source validation creates rework. Automating before documenting the manual workflow scales ambiguity.
Use dependency arrows to find the correct order.
Decomposition Failure Mode 5 — Missing Handoff Contract
If one step outputs “research notes” and the next step expects precise citations and dates, the handoff is underspecified.
Define the fields the next step needs. Handoff contracts make multi-step SI workflows more reliable.
Decomposition Failure Mode 6 — Automating Judgment
Some steps contain human values, professional responsibility or authority. Decomposition should expose those steps rather than quietly assigning them to an automated component.
Label them explicitly: “human chooses trade-off”, “teacher approves answer key”, “manager approves external change”.
A Decomposition Checklist
- Can the final deliverable be stated clearly?
- Are all required inputs identified?
- Does each subtask produce a meaningful intermediate result?
- Are dependencies explicit?
- Can independent steps run in parallel safely?
- Are checkpoints placed before expensive downstream work?
- Does every handoff contain what the next step requires?
- Are unknowns and exceptions visible?
- Are human approval points explicit?
- Is the closure condition observable?
A Practice Lab: Decompose Five Common Tasks
Study for a test
Diagnose topics → rank gaps → repair prerequisite → practise isolated skill → mixed practice → timed checkpoint → review errors.
Write a report
Define question → gather sources → evaluate sources → extract evidence → outline → draft → verify → edit → deliver.
Build a spreadsheet
Define decision → identify inputs → design columns → validate data → write formulas → test edge cases → build charts → review.
Plan an event
Define objective → date constraints → venue requirements → participants → budget → schedule → confirmations → contingency → final communication.
Build an SI workflow
Map manual process → identify stable tasks → define inputs → specify tools → add checks → define permissions → test failures → pilot → evaluate → scale.
The Decomposition Depth Test
A step is too large when you cannot say how to check it. A step is too small when it creates no meaningful transformation or decision. Adjust until each unit is understandable and useful.
Different tasks need different depths. A school summary may need four steps. A production software system may need dozens. The principle is not a fixed number but appropriate granularity.
How SI Can Help Decompose Without Taking Over
Ask SI to propose a task tree, then inspect it. Identify missing dependencies, unnecessary steps and human decision points. Do not accept the proposed decomposition automatically.
A useful prompt is: “Break this task into checkable stages. For each stage, state required input, output, dependency and validation. Flag steps that require human approval.”
Then simplify. The first machine-generated plan may be more detailed than necessary.
How to Know the Decomposition Worked
A good decomposition reduces ambiguity, localises errors and makes progress visible. If a problem occurs, you should know which step owns the repair.
The receiver should also experience less confusion. A later step receives the information it needs instead of reconstructing missing context.
Measure rework. If decomposition creates more handoffs than value, simplify the plan.
Frequently Asked Questions
How many steps should a task have?
Enough to make dependencies and checks visible, but not so many that coordination dominates the work. Use meaningful intermediate results as the unit.
Should I ask SI to create all the steps?
It can propose a structure. You should verify the dependencies and identify hidden real-world steps, permissions and approvals.
When should tasks run in parallel?
When they do not depend on one another and can use compatible assumptions and output formats.
What if a later step changes an earlier assumption?
Return to the affected step and propagate the update deliberately. Do not patch only the final output while leaving the workflow inconsistent.
Does decomposition always improve speed?
Not necessarily. It improves control and can reduce rework. For simple tasks, excessive decomposition can slow the process.
What comes next?
Continue with How to Use Examples to Teach Super Intelligence What You Want. Examples become especially powerful when attached to a well-defined step in a decomposed workflow.
A Difficult Task Becomes Manageable When Its Dependencies Become Visible
The purpose of decomposition is not to make work look organised. It is to make the structure of the work real: inputs, dependencies, checks, handoffs and closure.
SI can help build and operate that structure, but the human still defines the objective, verifies critical intermediate results and protects decision boundaries.
Return to the complete SI learning hub for the rest of Stage 2. The next capability is teaching SI a pattern through examples.
The Decomposition Maintenance Gate
Before a decomposed workflow becomes permanent, run it several times and review where real effort is spent. Some steps that looked necessary on paper may never catch a failure. Other handoffs may repeatedly create confusion. Maintenance should follow observed behaviour rather than the elegance of the original diagram.
Ask whether each step still has a unique purpose, whether its input contract remains accurate and whether the receiver still needs the output in the same form. When tools change, update only the affected stages and rerun the downstream checks that depend on them.
Keep one regression case containing a historical failure. If a workflow once lost an owner during a handoff, rerun that case after simplifying the process. The control can be removed only when the simpler process still prevents the old failure.
Also review permissions. A step that once needed write access may become read-only after redesign. Removing unnecessary permission reduces the blast radius of later mistakes without changing the useful capability.
The Decomposition Floor
A task is sufficiently decomposed when three things are true. First, the major dependencies are visible. Second, important failures can be located without rebuilding the whole project. Third, the receiver can understand the state and next action.
Going beyond that floor is optional. More steps are justified only when they improve checking, parallelism, specialist handoff or recovery. If they do not, merge them.
This floor protects the core purpose of decomposition: make difficult work more controllable, not more bureaucratic.
What the Learner Should Be Able to Do After This Article
You should be able to take a vague complex task, define the final state, draw the dependency map, choose coherent stages, attach checks to the critical handoffs and specify stop conditions. You should also be able to identify steps that can run in parallel and describe how their outputs will be merged.
Most importantly, you should be able to repair a local failure locally. If a source is wrong, fix the source stage. If a calculation is wrong, fix the calculation stage. If approval is missing, stop before execution. That ability is the practical evidence that decomposition has become a working SI skill.
Good Decomposition Makes Failure Smaller
The deepest benefit of breaking work into steps is not that every task becomes shorter. Failure becomes local. You can see which source, calculation, interpretation or action failed without rebuilding the entire project.
Use decomposition to protect the critical path, preserve evidence and make handoffs understandable. Then simplify the workflow as your understanding improves.
Return to the complete SI learning hub for the rest of Stage 2.
