How to use Super Intelligence to break down complicated problems is not simply about turning one big task into a long to-do list. Good decomposition reveals structure: what depends on what, where uncertainty lives, which part is the bottleneck, which parts can be solved independently and how the pieces must be recombined.
Bad decomposition creates fragments. Good decomposition creates a map.
In the eduKateSG life series, Super Intelligence, or SI, is our editorial name for practical AI assistance. This article continues the thinking cluster after How to Think More Clearly with Super Intelligence. The first article clarifies the problem; this one shows how to divide a complicated problem without losing the whole.
The larger architecture remains How to Leverage Your Life with Super Intelligence. The objective is always the same: use additional intelligence where it creates leverage while keeping the human oriented to the real outcome.
Why Complicated Problems Feel Hard
A complicated problem often contains several different difficulties at once.
- too many variables to hold in working memory;
- dependencies that are not visible;
- uncertainty about which information matters;
- several stakeholders with different goals;
- a mixture of reversible and irreversible decisions;
- tasks occurring on different timelines;
- parts that require different expertise;
- feedback that arrives only after action; and
- one hidden bottleneck that constrains everything else.
The person experiences the whole mixture as “this is complicated”. SI can help by making the internal structure visible. The first goal is not to solve every piece. It is to discover the shape of the problem.
The Decomposition Spine
Use a six-stage spine: Outcome → Components → Dependencies → Bottleneck → Interfaces → Recomposition.
Outcome
What result would count as solved?
Components
What major parts contribute to the outcome?
Dependencies
Which parts must happen before others? Which share information or resources?
Bottleneck
Which component currently limits progress the most?
Interfaces
What information or output must pass between components?
Recomposition
How will solved pieces be tested together so local success does not create whole-system failure?
This spine prevents the common mistake of decomposing only by visible tasks.
Start with the Outcome, Not the Parts
If you begin listing parts before defining the outcome, the decomposition can expand indefinitely.
“Improve Mathematics” can generate hundreds of tasks. “Raise independent performance on Secondary 1 algebra and word problems over the next eight weeks” creates a boundary.
“Move house” is broad. “Complete the move by 30 November with essential services active, important documents protected and no missed tenancy obligations” is more operational.
Ask SI: “Before breaking this down, restate the outcome and tell me what would count as complete. Identify anything in my request that is an activity rather than an outcome.”
The outcome acts as the recomposition target later.
Seven Ways to Decompose a Problem
1. By stage
Useful when the problem naturally unfolds over time: prepare, execute, verify, review.
2. By system component
Useful when different functions interact: people, information, money, tools, logistics, governance.
3. By stakeholder
Useful when several people have different responsibilities or constraints.
4. By evidence
Separate what is known, what needs research, what needs measurement and what needs direct confirmation.
5. By risk
Separate low-risk reversible work from high-consequence decisions requiring stronger review.
6. By capability
Separate tasks requiring calculation, writing, domain expertise, coordination, judgement or physical action.
7. By dependency
Separate tasks that can run in parallel from tasks blocked by earlier decisions.
Most real problems benefit from more than one lens. SI can generate several decompositions and compare which exposes the bottleneck most clearly.
The Granularity Problem
Parts can be too large or too small.
“Handle finances” is too large. “Open spreadsheet, click cell B7, type number” is too small for strategic thinking.
A useful component should usually have a clear purpose, identifiable input, output or completion condition, responsible person or system, known dependencies and a reason it deserves to be separate.
Ask SI: “Which components are still too broad to act on, and which are so small that splitting them further creates administration rather than clarity?”
Dependency Mapping
A to-do list says what exists. A dependency map says what must happen first.
Suppose a family is moving house. You cannot confirm final moving-day logistics until the handover date is known. You cannot route utilities until the service address and activation date are confirmed. You can begin sorting possessions in parallel. You can collect quotations before selecting a mover.
SI can turn the components into a dependency graph:
Confirm handover date → confirm mover → finalise moving-day schedule.
Confirm address + activation date → transfer utilities.
Sort possessions → pack non-essential items → pack essentials last.
The map reveals which task blocks several others. That task deserves priority even if it is not the largest.
The Critical Path
The critical path is the chain of dependent tasks that determines the earliest possible completion. You do not need formal project-management software to use the idea.
Ask: “Which tasks, if delayed, delay the whole outcome?”
This prevents effort being spent on easy parallel tasks while the real blocker remains untouched.
For examination preparation, the critical path may be prerequisite understanding → guided practice → independent mixed practice → timed paper. Doing more timed papers before repairing the prerequisite does not accelerate the real path.
The Bottleneck Test
A bottleneck is the constraint that currently limits system performance. It may not be the part with the most work.
A student may have many Mathematics topics but one weak algebra prerequisite that affects several chapters. A business project may have many tasks but one unanswered approval blocking all execution. A household may have several forms but one missing official document.
Ask SI: “If I could improve only one component this week, which one would release the most downstream progress, and what evidence supports that?”
Then verify the assumption. Bottleneck claims should be testable.
Interfaces: Where Good Parts Fail to Join
Many systems fail at the handoff between components.
Research produces a report, but nobody converts it into a decision. A tutor identifies an error, but the next practice set does not target it. A family member books an appointment, but the shared calendar is not updated. A plan is approved, but the person executing it does not receive the current version.
An interface needs an explicit handoff.
- What output leaves Component A?
- What does Component B need to receive?
- How do we know the handoff occurred correctly?
SI is often highly useful at interfaces because it can transform information from one format into another. The transformation still needs verification.
Recomposition: Put the Problem Back Together
Decomposition is incomplete until the pieces are recombined.
A locally correct component can damage the whole. A highly efficient study plan can be impossible alongside school and sleep. A cheaper travel itinerary can create exhausting transfers. A technically excellent work solution can violate the budget. A household process can save one person’s time while creating more work for everyone else.
After solving components, ask SI: “Recombine these parts and identify conflicts, duplicated assumptions, missing handoffs and whole-system constraints.”
The outcome defined at the beginning becomes the final test.
Root Cause Analysis Is Not the Same as Task Breakdown
Task breakdown asks what work must be done. Root cause analysis asks why the problem exists. Do not confuse them.
If a student repeatedly makes sign errors, the task breakdown might be “complete correction, practise ten questions, retest”. The root cause may be weak negative-number control or careless copying.
If the root cause is not identified, the task list can produce more of the same error.
Use SI first to generate plausible causes, then design evidence that distinguishes them. Avoid letting the assistant select a cause solely because it sounds psychologically plausible.
The Five Whys — with a Stop Rule
Repeatedly asking “why?” can uncover a deeper cause, but it can also produce speculative stories.
Example: Project update is late. Why? Data arrived late. Why? Two teams submitted different formats. Why? No shared template was agreed.
At this point, the next useful action is probably to standardise the interface. Continuing to ask “why?” may produce organisational speculation with little evidence.
Stop when you reach a cause you can test or change at the level of responsibility available to you.
Worked Example 1: Improving Secondary Mathematics
Outcome: improve independent performance on current Secondary Mathematics over eight weeks.
Possible components: number fluency, algebra, geometry, reading, method selection, working presentation, time control and error review.
The first decomposition is still too broad. Use evidence from recent work. The student’s largest losses come from algebraic manipulation and multi-step word problems.
Dependency map: negative-number control → algebraic simplification → equations → multi-step applications.
Separate word-problem issue: reading → relationship identification → method selection → execution.
Diagnostic testing shows negative numbers are stable, but bracket expansion is not. Method selection also becomes slow when two topics are mixed.
Bottlenecks: bracket expansion and mixed-topic recognition.
Intervention: repair bracket expansion, then mix with equations; separately practise short method-selection prompts before full word problems.
Recomposition test: one mixed timed set containing both algebra and word problems.
The decomposition prevents the vague solution “do more Mathematics”.
Worked Example 2: Moving House
Outcome: move by the agreed date with essential services active, important records protected and no missed contractual obligations.
Components: tenancy/handover, mover, utilities, address changes, packing, valuables/documents, school/work coordination, cleaning, final inspection.
Dependencies: handover date affects mover and utilities; mover date affects packing sequence; final inspection affects return of the old property.
Parallel work: address-change list, sorting, quotations, document inventory.
High-risk component: identity documents and valuables. Keep human control over handling and location.
Interface: the confirmed move date must update the mover, family calendar, utility activation and leave arrangements.
Recomposition: run a moving-day walkthrough. What happens from waking until essential items are accessible in the new home?
The decomposition creates a coordinated system rather than a pile of packing tasks.
Worked Example 3: Career Transition
Outcome: decide whether to pursue a specialist or management path and gather evidence over six months.
Components: current strengths, target-role requirements, skill gaps, opportunities to test each route, internal constraints, external market information and personal preferences.
Unknowns: how much the person enjoys management work; whether relevant internal opportunities exist; which specialist capability creates the greatest value.
Instead of making one large career decision, decompose into experiments.
Management experiment: lead a bounded cross-team project and request feedback.
Specialist experiment: own a deeper technical problem and present the result.
Interface: evidence from both experiments feeds the decision journal.
Recomposition after three months: compare energy, performance, feedback and opportunity rather than relying on imagined futures.
The big problem becomes a sequence of reversible evidence-building steps.
Worked Example 4: Household Budget Pressure
Outcome: reduce monthly financial strain without hiding essential costs.
Components: fixed obligations, variable essentials, discretionary spending, irregular annual costs, debt payments, savings goals and uncertain upcoming expenses.
Do not ask SI to “cut the budget” immediately. First identify which costs are fixed, which can change, which occur irregularly and which data are incomplete.
Dependency: you cannot evaluate discretionary capacity until annual or quarterly obligations are normalised into the monthly picture.
Bottleneck may be missing visibility rather than excessive spending.
Recomposition: test the proposed budget against a month containing an irregular expense.
Use SI for categorisation and scenarios, while keeping consequential financial decisions and source figures under human control.
Worked Example 5: A Complex Work Project
Outcome: deliver a product launch by a fixed external date.
Components: requirements, design, build, testing, legal/compliance review, marketing, support preparation and release.
A task list can make each team look busy while hiding the dependency structure.
Requirements changes affect design and build. Compliance review may need a stable feature set. Marketing claims depend on the final product. Support documentation depends on tested behaviour.
SI can map dependencies and identify interface contracts: what each team needs from the previous stage.
The critical path may run through compliance rather than engineering.
Recomposition means running launch-readiness checks across the whole system rather than declaring success when each team has completed its local checklist.
Worked Example 6: Health Administration Without Turning SI into a Doctor
Outcome: prepare a clear record and questions for a healthcare appointment.
Components: symptom timeline, medications, relevant records, questions, appointment logistics and source documents.
SI can help organise the timeline and flag missing dates. It should not convert the decomposition into diagnosis.
The interface is the appointment brief handed to the healthcare professional.
Recomposition occurs after the appointment when confirmed medical instructions update the personal record.
The problem is administrative clarity, not delegated clinical judgement.
Problem Trees: Cause, Problem and Effect
A problem tree separates causes below the central problem from effects above it.
Central problem: “weekly reports are consistently late”.
Possible causes: data arrives late, source formats differ, approval is unclear, report template is oversized.
Effects: meetings start without current numbers, decisions are delayed, staff rush at the end.
Ask SI to distinguish causes from effects. Fixing an effect may reduce pain without removing the cause.
Then test each cause with evidence. A problem tree is especially useful when people argue about solutions before agreeing on the problem.
Constraint Maps
Some complicated problems are not caused by missing tasks. They are caused by conflicting constraints.
A parent wants more study time, sufficient sleep, sports participation and protected family time. The total available hours may make all desired levels impossible simultaneously.
SI can map hard constraints, soft preferences and negotiable targets.
Hard: school hours, sleep minimum, fixed training sessions.
Soft: preferred study window.
Negotiable: number of optional activities or practice volume.
Once the constraint map is visible, planning becomes a trade-off problem rather than a motivation problem.
Interface Contracts
When multiple people or systems contribute, define what each handoff must contain.
Example: research → decision. The research output should include source, date, key finding, uncertainty and the decision it informs.
Example: tutor → student practice. The handoff should include target skill, error type, example boundary and retest condition.
Example: parent → family calendar. The handoff should include confirmed event, date, time, location, owner and source.
Interface contracts prevent information from becoming less precise as it moves.
Parallelise What Can Be Parallelised
Good decomposition reveals independent work.
During a move, one person can compare movers while another builds the address-change list. During a research project, source gathering and definition work may run in parallel. During study, different prerequisite skills may be tested separately before the results are recombined.
Ask SI: “Which components are independent enough to proceed in parallel, and which need a shared decision first?”
Parallelisation reduces elapsed time without pretending dependencies do not exist.
Do Not Parallelise Coupled Decisions
Some components look separate but share a constraint.
Choosing a hotel and planning daily transport are coupled by location. Choosing course load and weekly schedule are coupled by available time. Changing a project scope and writing marketing claims are coupled by what the product will actually do.
SI can flag shared variables. If two components both depend on the same unresolved fact, resolve that fact before optimising them separately.
The Anti-Fragmentation Check
After decomposition, ask:
- What important relationship disappeared when we split the problem?
- Which component is being optimised at the expense of another?
- Which assumption appears in several parts?
- Which decision belongs at the whole-system level?
- Which handoff could lose information?
- What final test proves the whole works?
This check protects against local optimisation. A family schedule can optimise every individual’s tasks and still leave no shared time. A business can optimise every department and still fail the customer journey. A learner can master isolated chapters and still fail mixed questions. Recomposition must test integration.
When to Stop Decomposing
Stop when the next part is actionable, testable and small enough to reason about without losing its meaning.
Do not decompose because smaller always feels more manageable. Excess decomposition creates coordination overhead.
A useful stop test is: “Can one person or workflow take this component from a known input to a clear output, and can we verify completion?”
If yes, further splitting may not add value. If no, split again or clarify the boundary.
A Copyable Complicated-Problem Prompt
“Help me decompose the problem below without turning it into a flat to-do list. First restate the outcome. Then identify major components, dependencies, shared constraints, unknowns, bottlenecks and interfaces. Mark which parts can run in parallel and which are blocked. For each component, state its input, output and completion test. Finally, recompose the system and identify risks created by solving parts separately. Do not assume missing facts.”
Use the prompt as a starting structure. Adapt it to the domain and consequence.
A 12-Step Decomposition Worksheet
1. Outcome: What counts as solved?
2. Boundary: What is inside and outside this problem?
3. Components: What major functions contribute?
4. Evidence: What do we know about each?
5. Unknowns: What needs confirmation?
6. Dependencies: What must happen first?
7. Parallel work: What can happen independently?
8. Bottleneck: What currently constrains progress?
9. Interfaces: What must pass between components?
10. Risks: Where can local success damage the whole?
11. Recomposition: How do the parts come back together?
12. Test: What proves the complete outcome works?
The 30-Minute Problem Map
First 5 minutes: define outcome and boundary.
Next 5: list major components without solving them.
Next 5: draw dependencies and shared constraints.
Next 5: identify the bottleneck and unknowns.
Next 5: define interfaces and completion tests.
Final 5: recompose and ask what was lost by splitting.
If the map is still confusing, choose one component and run a diagnostic rather than generating more tasks.
Common Decomposition Failure Modes
Flat task dumping
A long list appears, but dependencies remain invisible. Repair by mapping what blocks what.
Splitting by organisation chart
Tasks are divided by who owns them rather than by the actual flow of the problem. Repair by tracing the outcome across departments or people.
Wrong granularity
Components are too broad to act on or too small to manage efficiently. Repair using input-output-completion boundaries.
Ignoring shared constraints
Each part is planned independently even though all compete for the same time, money or resource.
Assuming the bottleneck
The most visible or frustrating component is labelled the bottleneck without evidence. Test which constraint actually limits downstream progress.
No recomposition
Every component finishes, but the whole fails. Add integration and end-to-end tests.
Infinite root-cause stories
The conversation keeps asking why until it becomes speculation. Stop at a cause that can be tested or acted upon.
Automating the broken structure
SI accelerates tasks before the underlying process is understood. First simplify and stabilise the workflow.
What Progress Looks Like
- you can state the outcome without listing every activity;
- you can identify the few components that actually drive the result;
- dependencies are visible;
- you know which task is blocking several others;
- unknowns are separated from tasks;
- people know what information must cross handoffs;
- parallel work happens without duplicating effort;
- local solutions are tested against whole-system constraints;
- the final system can be recomposed and verified; and
- the next action becomes smaller without becoming disconnected from the goal.
A Problem Model Is Different from a Task Plan
Before you build a plan, build a model.
A task plan says what to do. A problem model says how the parts relate. If the model is wrong, a detailed plan can execute the wrong structure very efficiently.
Suppose a student is falling behind in Mathematics. A task plan might say: revise two chapters, complete three worksheets, attend tuition and do a practice paper. A problem model asks: which skill is unstable, where does it appear downstream, which school topics depend on it, how does time pressure change performance and what evidence would show the repair is working?
The second view may lead to a much smaller plan because one prerequisite explains several visible failures.
Use SI first to produce a structural map. Only after the relationships are plausible should the system convert them into tasks.
The Issue Tree
An issue tree divides a question into branches that together explain the problem space.
Example: “Why is this weekly workflow slow?”
Possible top-level branches: input preparation, reasoning/processing, verification, handoff and execution.
Input preparation may divide into source retrieval, cleanup and missing information. Verification may divide into factual checks, calculations and approval. Execution may divide into human action and external-system delay.
The tree helps prevent random optimisation. If most time is spent retrieving sources, improving the prompt will not solve the main bottleneck.
Mutually exclusive, collectively useful—not perfectly MECE
Consulting frameworks often use the phrase “mutually exclusive, collectively exhaustive”. In everyday life, perfect separation is not always possible because causes interact. Use the principle lightly: try to avoid obvious duplication and cover the important territory, but do not force reality into artificial boxes merely to satisfy a diagram.
Ask SI: “Create three alternative issue trees for this problem using different lenses. Tell me where branches overlap and which tree best exposes the decision I need to make.”
Comparing decompositions is often more valuable than accepting the first tree.
Decompose the Unknowns, Not Only the Work
Complicated problems contain tasks and unknowns. Treating unknowns as tasks too early can produce false certainty.
Suppose you are planning a family trip. “Book transport from the airport” is a task only after the arrival airport, arrival time, hotel location and traveller needs are known. Before those facts are confirmed, the correct component is an unknown dependency.
Create a separate uncertainty map:
- unknown but easy to verify now;
- unknown requiring another person’s answer;
- unknown requiring research;
- unknown requiring a test;
- unknown that cannot be known until later;
- unknown that does not matter to the next action.
Then decide which unknowns block progress. The rest can remain unresolved without holding up the entire project.
The question queue
For complex projects, maintain a short question queue alongside the task list. Each question has an owner, source or test and a deadline only when the answer blocks downstream work.
This prevents unresolved uncertainty from being hidden inside a task that appears ready to execute.
State Decomposition: What Condition Is Each Part In?
Another useful decomposition is by state rather than subject.
A component may be: unstarted, waiting for information, ready, in progress, waiting for approval, blocked, completed or needs rework.
This state view is especially useful when the problem feels large because many components are active at once.
Imagine a house move with fifteen visible tasks. Only four may actually be ready. Three are blocked by the handover date. Two are waiting for quotations. Four can happen now. Two are already complete. The state map immediately reduces the apparent chaos.
Ask SI to separate content from state: “Do not give me more tasks. Tell me which existing components are ready, blocked, waiting, active or complete, and what condition moves each blocked item forward.”
State decomposition converts overwhelm into flow control.
Time-Horizon Decomposition
Some problems become clearer when split across time.
Immediate
What must happen now to stop deterioration or unlock progress?
Near term
What should be stabilised over days or weeks?
Medium term
What capability, system or buffer should be built after the urgent pressure falls?
Long term
What structural change prevents the same problem from recurring?
A student failing an upcoming test may need immediate triage on the highest-yield prerequisite. After the test, the medium-term problem may be a broader algebra foundation. The long-term problem may be study systems and cumulative retrieval.
Mixing all horizons into one plan creates an impossible workload. SI can separate recovery from development.
Resource Decomposition: Time, Money, Attention and People
A plan can be logically correct and still impossible because several components compete for the same resource.
Map scarce resources explicitly.
Time
Which tasks need the same limited windows? Which can move?
Money
Which components compete for the same budget? Which costs are fixed or uncertain?
Attention
Which tasks require deep concentration and which can fit low-energy periods?
People
Which components depend on one person, creating a human bottleneck?
Tools and access
Which components require a specific device, account, permission or physical location?
Ask SI to identify resource collisions after task decomposition. A schedule that ignores resource coupling is only a conceptual plan.
Ownership Decomposition
When several people are involved, every component needs a clear relationship to ownership.
Use four labels: owns, contributes, approves, informed.
The owner is responsible for bringing the component to completion. Contributors supply work or information. Approvers have authority over a decision. Informed parties need visibility but not action.
This prevents two common problems: everybody assumes somebody else owns the task, or several people work on the same component independently.
SI can generate an ownership map, but the people involved must agree. Generated ownership is not consent.
Feedback Loops: Some Problems Are Dynamic
Not every problem is a one-way chain. Some contain feedback loops where one action changes the conditions of the next action.
A student practises, which changes skill level, which changes which questions are appropriate next.
A household budget changes spending behaviour, which changes next month’s available information.
A product launch changes customer demand, which changes support load, which may influence the next release.
A planning system changes the number of tasks accepted, which changes future planning pressure.
When feedback exists, decomposition should include the measurement that updates the next cycle.
Ask SI: “Which components in this system change the inputs of later components? What signal should trigger an update?”
A static task list cannot represent a learning system or adaptive workflow adequately.
Delay Loops
Feedback may arrive late.
A change in study method may not show in marks immediately. A hiring decision may take months to reveal fit. A maintenance change may reduce failures gradually.
Delayed feedback can cause users to abandon a good intervention too early or continue a bad one too long.
Mark the expected feedback delay in the problem map. Decide which early signals are informative and which outcomes need more time.
Failure-Tree Decomposition
Instead of asking how to make the plan succeed, ask how it could fail.
Outcome: “Arrive at the airport with all required travel documents on time.”
Failure branches may include wrong departure time, transport delay, missing document, expired document, wrong terminal, luggage issue or traveller not ready.
Each branch can be tested for likelihood, consequence and preventability.
The value is not pessimism. The failure tree reveals protection points.
For high-consequence tasks, SI can help create the failure tree before automation or delegation.
Do not treat every imagined failure as equal
Rank branches by consequence and plausibility. Otherwise the plan becomes overloaded with safeguards against remote possibilities while ordinary risks remain under-managed.
Pre-Mortem Decomposition
Assume the project failed and ask what visible cause today could plausibly explain the failure.
For a study plan: too many subjects scheduled, no transfer practice, sleep sacrificed, prerequisite ignored.
For a work launch: approval late, source data inconsistent, one person overloaded, customer-support materials unfinished.
For a family trip: booking dates inconsistent, passport validity overlooked, transport assumptions wrong.
Convert the strongest failure modes into checks or milestones rather than merely adding worry.
Decision Nodes: Where the Path Can Branch
Complicated problems often contain points where the route changes depending on new information.
A decision node should state:
- what information arrives;
- which options become available;
- what criterion selects the branch; and
- what downstream work changes.
Example: after a diagnostic test, if the student cannot expand brackets accurately, return to the prerequisite corridor. If expansion is accurate but equation setup fails, move to translation practice. The diagnostic result selects the branch.
SI can help write branching logic, which is often more useful than a single fixed plan.
Thresholds
A threshold is the condition that changes the state of the problem.
Examples: a budget exceeds the cap; a test score falls below the required level; a deadline moves inside the available repair window; a price crosses the purchase limit; a workflow error rate becomes unacceptable.
Write thresholds explicitly so the plan knows when to escalate, stop or change branch.
Without thresholds, a workflow can continue long after the situation has changed.
A Full Case Study: Rebuilding a Student’s Semester
Outcome: stabilise a Secondary 2 student’s school performance across Mathematics, Science and English without increasing weekly study time beyond what the family considers sustainable.
The first temptation is to create a bigger timetable.
Instead, decompose the problem.
Component map
Mathematics: repeated algebra errors and slow mixed questions. Science: content recall is acceptable but explanations lack precision. English: comprehension is stable; writing drafts are slow and vocabulary transfer is weak. System layer: homework occupies most evenings, leaving little retrieval or correction time.
Dependency map
Mathematics algebra affects several upcoming chapters. Science precision depends partly on vocabulary and explanation structure. English writing speed depends on planning and active vocabulary. The system layer shows that simply adding practice increases overload.
Bottleneck
The broad bottleneck is not total study time. It is inefficient use of study time: homework completion consumes capacity while errors are not classified and repaired.
Interface
Schoolwork must feed a weekly error-and-gap record. The record must feed the next targeted practice block. Without that handoff, mistakes disappear after correction and recur in the next test.
Intervention
Mathematics receives two short repair sessions focused on algebra and mixed recognition. Science receives one explanation drill using key terms from current chapters. English receives one timed planning-and-write cycle with vocabulary reuse. No additional total hours are added; lower-value rereading is removed.
Feedback loop
Each week, new errors update the repair queue. When a gap stabilises, time shifts to the next bottleneck.
Recomposition test
At the end of four weeks, use mixed school-like tasks rather than isolated drills. The goal is not three locally improved skills but a student who can perform across the actual school workload without the system collapsing.
This case shows why decomposition should include the learning system, not only the subjects.
A Full Case Study: Planning a Family Trip with Dependencies and Decisions
Outcome: complete a five-day family trip with confirmed travel, accommodation, essential documents, realistic daily plans and manageable total cost.
Top-level components
Travel documents, flights, accommodation, local transport, daily activities, food preferences, insurance, budget and family availability.
Hard dependencies
Travel dates depend on shared availability. Flights and accommodation depend on dates. Local transport planning depends on airport and hotel. Activity bookings depend on the daily geography.
Parallel work
Document validity can be checked while destinations are compared. Budget ranges can be established while availability is confirmed. Food and activity preferences can be gathered in parallel.
Decision nodes
If preferred flight cost exceeds the cap, choose between alternate timing, a different carrier or a revised destination. If a major activity is unavailable, decide whether it is essential enough to change the travel dates.
Interfaces
Confirmed booking details must feed the master itinerary. The itinerary must feed transport estimates. The transport estimates must test whether activity sequencing is realistic.
Failure tree
Wrong date, missing passport validity, airport transfer mismatch, overpacked daily itinerary, hidden fees and another family member assuming a booking was confirmed when it was still only proposed.
Recomposition
Run the itinerary end to end. Check wake time, travel time, meal windows, buffer and the actual distance between stops. A set of individually attractive activities can still create an exhausting trip.
SI can accelerate comparison and itinerary construction, but current booking information and official travel requirements still need direct verification.
A Full Case Study: Fixing a Failing Personal SI Workflow
Outcome: repair a weekly planning workflow that now takes too long and produces inconsistent schedules.
Symptoms
Context preparation takes fifteen minutes. The assistant generates a detailed schedule. Verification takes another fifteen minutes. The user frequently changes the plan the next day.
Task decomposition
Source retrieval, context preparation, priority selection, schedule generation, verification, calendar transfer and next-day adjustment.
Root-cause hypotheses
Too many active projects; duplicated source records; task durations are unrealistic; the assistant receives no priority rule; the generated schedule is too granular.
Evidence
Only four of eleven active projects have near-term work. Two separate task lists contain overlapping items. The schedule allocates nearly every free hour. The user changes low-priority tasks most often.
Bottleneck
The bottleneck is not generation quality. It is poor input state and overcommitment.
Repair
Reduce active projects, choose one source-of-truth list, generate a minimum viable plan rather than an hour-by-hour schedule and preserve buffer.
Recomposition
Planning time falls not because SI became more sophisticated but because the surrounding system became simpler. The problem was organisational before it was generative.
This is an important decomposition lesson: the AI step is often only one component of the actual workflow.
The Whole-System Test
After solving the parts, run five recomposition tests.
Constraint test
Do the combined parts still fit time, money, privacy and capacity limits?
Consistency test
Do two components rely on contradictory assumptions or different versions of the same fact?
Interface test
Does every handoff contain what the next component actually needs?
Failure test
What happens if one critical component is late, missing or wrong?
Outcome test
If every component completes, is the original outcome genuinely achieved?
The final question catches a subtle failure: completing all planned tasks without solving the original problem.
The Decomposition Review
After a complicated project, review the map itself.
Which component turned out not to matter?
Which dependency was discovered too late?
Which interface lost information?
Which bottleneck was misidentified?
Which part should have stayed together instead of being split?
Which unknown should have been resolved earlier?
Which threshold should be added next time?
The review converts one problem map into a better reusable decomposition method.
A Reusable Decomposition Spec
Outcome: [what counts as solved]
Boundary: [inside/outside]
Components: [major parts]
States: [ready/waiting/blocked/in progress/complete]
Unknowns: [questions requiring evidence]
Dependencies: [what must precede what]
Parallel work: [independent components]
Shared constraints: [time/money/people/tools]
Bottleneck: [current limiting component]
Decision nodes: [conditions that change route]
Thresholds: [conditions that trigger stop/escalate/change]
Interfaces: [handoff requirements]
Failure modes: [main ways the system can break]
Recomposition test: [how the whole is verified]
Review: [what the next version should learn]
This specification is intentionally more structured than a normal prompt because complicated problems fail at relationships, not only at individual tasks.
How SI Should Behave During Decomposition
- Ask for the outcome before expanding tasks.
- Label assumptions rather than silently using them.
- Keep unknowns visible.
- Offer alternative decompositions when the first structure is weak.
- Distinguish tasks from causes.
- Identify dependencies and shared resources.
- Avoid assigning ownership without consent.
- State which components require qualified expertise.
- Recompose before claiming the problem is solved.
- Preserve a manual or human route for high-consequence decisions.
These behaviours turn SI from a list generator into a structural reasoning tool.
The Final Decomposition Principle
The purpose of decomposition is not to make the problem look smaller.
It is to reveal where progress actually comes from.
Sometimes that means splitting a problem into ten components.
Sometimes it means discovering that ten visible symptoms share one bottleneck.
Sometimes it means keeping two components together because their interface is the real problem.
Sometimes it means refusing to plan until one unknown is resolved.
Good decomposition reduces confusion without destroying connection. The parts must remain attached to the outcome that gave them meaning.
Decomposition Begins with Boundaries
Before splitting a complicated problem, decide what belongs inside it. Without a boundary, decomposition expands forever because every component connects to something else.
Suppose the problem is “improve the student’s Mathematics this term”. The boundary might include current school topics, prerequisite skills, homework execution, timed performance and revision. It might exclude long-term career planning, unrelated subjects and school-wide curriculum policy. Those topics may matter elsewhere, but they do not belong in this immediate problem map.
Ask SI: “What is inside the boundary, what is outside, and which external factors still constrain the problem?” This creates a useful distinction between components you can act on and environmental conditions you must account for.
Internal components
These are parts of the problem you can directly change, test or assign: practice design, document flow, schedule, method, workflow, communication and resources.
External constraints
These shape the solution but may not be under your control: school timetable, regulation, market price, another person’s availability, fixed deadline or physical distance.
External dependencies
These are outside the core problem but must provide something: approval, source information, payment confirmation, expert judgement or access.
A clean boundary makes the decomposition smaller without pretending the outside world does not exist.
The Problem Graph: Move Beyond Lists
A complicated problem is often better represented as a graph than a hierarchy. In a hierarchy, every subproblem belongs neatly under one parent. In real life, one component can affect several others at once.
Example: sleep affects study concentration, emotional regulation and school attendance. Travel time affects available study windows and family scheduling. A changed work deadline affects budget, time and stress. These are cross-links, not tidy branches.
Ask SI to create a problem graph with nodes and links. Nodes are components, constraints, sources or decisions. Links explain the relationship: depends on, supplies, blocks, consumes, changes or verifies.
The graph does not need technical software. A plain-text representation is enough:
School schedule → limits available study windows.
Algebra prerequisite → affects equations + word problems.
Sleep → affects concentration + timed accuracy.
Parent availability → affects supervised practice.
Upcoming assessment → sets time envelope for repair.
The graph helps identify leverage points because one node may influence several downstream components.
Leverage Points: Where One Repair Changes Several Parts
A leverage point is not merely a bottleneck. It is a component whose improvement creates benefits across multiple parts of the system.
For a student, stable algebraic notation may improve equations, graph interpretation, formula substitution and later Additional Mathematics. For a household, one authoritative calendar may improve appointments, school activities, travel and renewals. For a work project, one agreed data schema may reduce delays across several teams.
Ask SI: “Which component appears in the largest number of important dependencies? Which repair would reduce several downstream errors at once?”
Then verify the claim. A node with many connections can also be a distraction if its influence is weak. Leverage is about downstream effect, not simply the number of arrows.
Four Different Types of Dependency
Sequence dependency
Task B literally cannot begin until Task A completes. Example: final filing cannot occur until the form is signed.
Information dependency
Task B can begin only when information from A is available. Example: travel planning needs the confirmed arrival time.
Resource dependency
Two tasks compete for the same person, budget, device, room or time window. They may be logically independent but operationally coupled.
Decision dependency
Several tasks remain provisional until a choice is made. Example: marketing, support materials and training all depend on the final product scope.
Distinguishing dependency types matters because the repair differs. Sequence dependencies need ordering. Information dependencies need source flow. Resource dependencies need allocation. Decision dependencies need an explicit choice or temporary assumption.
Hidden Dependencies
Some dependencies are not written anywhere because people carry them in their heads.
A weekly report depends on one analyst who knows how to clean the source data. A family outing depends on a parent remembering to check transport. A school project depends on access to software installed only on one device.
Ask SI to identify likely hidden dependencies by examining the workflow, then confirm them with the people involved. Do not accept model speculation as proof; use it as a checklist for discovery.
Hidden dependencies are especially dangerous because they appear only when the person, tool or condition is unavailable.
Decompose Uncertainty Separately from Work
A common mistake is turning unknowns into tasks without distinguishing their type.
“Find out whether the deadline changed” is not the same kind of item as “write the report”. The first resolves uncertainty; the second produces work.
Create an uncertainty register with four categories:
- fact to verify — a source can resolve it;
- decision to obtain — a person or authority must choose;
- forecast to monitor — cannot be known yet;
- assumption to test — evidence can raise or lower confidence.
Then ask which unknowns block progress. Some can remain unresolved while parallel work continues. Others sit on the critical path and deserve immediate attention.
This prevents teams and individuals from working around an uncertainty until the assumption silently becomes part of the final product.
The Decision Queue
Complicated projects often have too many unresolved decisions. Put them in a queue ordered by downstream impact.
A high-impact decision is one that unlocks or invalidates several pieces of work. A low-impact decision can wait without causing rework.
Example in a move: confirm handover date before choosing detailed mover timing. Example in a learning plan: determine whether the prerequisite is actually weak before buying extra resources. Example in a product project: confirm target user and scope before writing detailed marketing copy.
SI can rank decisions by dependency impact, but the user should verify whether the claimed downstream relationships are real.
The Problem Portfolio: Not Every Subproblem Deserves Equal Attention
After decomposition, classify components into four groups.
Solve now
High impact, actionable and currently blocking progress.
Investigate
Important but uncertain. Needs evidence before solution design.
Monitor
Could matter later, but not currently blocking. Set a trigger rather than spending attention now.
Ignore or remove
Low impact, outside boundary or unnecessary. Explicit removal prevents the component from returning repeatedly.
This portfolio view helps SI avoid a common failure: giving equal space to every branch simply because each branch can be discussed.
Decomposition by Failure Mode
Another useful lens is to split the problem according to how it can fail.
For a travel plan, failure modes include missed connection, wrong document, over-budget booking, unsuitable hotel location and inaccessible transport.
For a study system, failure modes include missing prerequisite, weak retrieval, incorrect method selection, careless execution and insufficient time.
For household administration, failure modes include missed date, wrong owner, lost source document, ambiguous requirement and unverified completion.
Ask SI: “For each failure mode, what component controls it, how would we detect it early and what recovery is available?”
Failure-mode decomposition is powerful when a problem already looks organised but still produces recurring bad outcomes.
Decomposition by Threshold
Some problems change character when a threshold is crossed.
A budget may be manageable until an irregular annual expense arrives. A project may be on schedule until review latency exceeds the remaining time. A student’s learning gap may be small until several new topics depend on the missing prerequisite.
Ask SI to identify thresholds where “more of the same” stops working. These thresholds may determine when a component needs escalation rather than incremental repair.
This lens helps explain why a system can look stable for weeks and then fail suddenly: the structure was approaching a boundary that ordinary progress reports did not show.
Whole-System Example: Planning a Secondary Student’s Term
Outcome: the student completes the term with stable school participation, sustainable study, protected sleep, manageable activities and targeted improvement in two weak subjects.
A flat approach might list homework, tuition, revision, tests, CCA and rest. A systems decomposition asks how these interact.
Component 1 — School obligations
Fixed timetable, homework deadlines, assessments, project dates and CCA.
Component 2 — Learning gaps
Subject-specific weaknesses identified from actual work. Each gap needs a diagnostic rather than generic study time.
Component 3 — Recovery capacity
Sleep, meals, travel and unallocated time. These are not leftovers; they constrain whether the study system remains usable.
Component 4 — Support
Parents, teachers, tutors and school resources. Support needs clear roles so the student does not receive contradictory instructions.
Component 5 — Weekly planning
Converts fixed obligations and active learning targets into realistic blocks.
Dependencies
Assessment dates determine revision timing. Learning gaps determine which practice is useful. Sleep and travel constrain usable evening capacity. Tutor feedback should update the next practice block. CCA and family commitments reduce flexible time.
Bottleneck example
If the student understands concepts but cannot complete timed work, adding more explanation is not the bottleneck repair. Execution speed and mixed practice may be the limiting components.
Recomposition test
Look at the actual week. Does the plan preserve sleep? Does it fit school work? Are the weakest skills receiving targeted practice? Can the student complete the schedule without continuous parent enforcement?
The result is a term system, not a pile of educational tasks.
Whole-System Example: Starting a Small Personal Business
Outcome: test whether a small service can attract paying customers without creating unacceptable financial or time risk.
Components include problem definition, target customer, service design, pricing, delivery process, legal and administrative requirements, marketing, payment, customer support and review.
Dependencies matter. Pricing depends on delivery cost and customer value. Marketing claims depend on the real service. Payment setup depends on the legal and operational model. Scaling depends on the delivery process being repeatable.
SI can help produce a first decomposition, research public information, draft material and model scenarios. Human judgement must still verify legal or financial requirements and decide the acceptable level of risk.
Bottleneck before launch
The most important unknown may be whether customers care enough to pay. Building elaborate branding before testing demand is local optimisation.
First experiment
Define a narrow offer, speak to a small number of target customers, attempt delivery manually and observe objections. The evidence then updates pricing, scope and workflow.
Recomposition
Before scaling, test whether marketing, sales, delivery, payment and support work as one end-to-end customer journey. A strong service with a broken handoff still produces a poor business.
Whole-System Example: Researching a Complex Question
Outcome: produce a reliable answer to a multi-source question with clear evidence and uncertainty.
Decompose into definition, scope, source discovery, evidence extraction, contradiction handling, synthesis and verification.
The dependency is important: synthesis should not begin before the key terms and population are defined. Evidence from one time period should not silently answer a question about another. Secondary commentary should not replace the primary source when the primary source is available.
SI can help map subquestions and identify source types. Each subquestion should have an evidence requirement.
Research interface
Every extracted claim should carry source, date, scope and confidence. This information passes into synthesis.
Contradiction branch
When sources disagree, create a separate component: determine whether they use different definitions, populations, time periods or methods. Do not average disagreement away.
Recomposition
The final answer should show how the subquestions connect and where uncertainty remains. A coherent narrative must not erase the structure that made it reliable.
Dependency Failure Patterns
The missing predecessor
A later task begins before its required input is stable. Example: writing final content before scope approval.
The stale predecessor
The dependency exists, but the downstream task uses an old version. Example: schedule built from last week’s deadline.
The overloaded shared resource
Several tasks all depend on one person or tool. The dependency map looks parallel, but the resource makes them sequential in practice.
The circular dependency
A waits for B while B waits for A. Example: marketing wants final features before testing demand, while product wants demand evidence before finalising features. Break the loop with a provisional version or experiment.
The invisible approval
Work appears ready, but one authority must approve before execution. Surface the approval as a formal component.
The dependency nobody owns
Everyone assumes another person will provide the input. Assign ownership or create an explicit escalation rule.
The Bottleneck Diagnostic
When progress is slow, do not automatically attack the largest backlog. Use a bottleneck diagnostic.
Question 1: Which component is preventing several other components from progressing?
Question 2: If this component improved by 50%, would whole-system output improve materially?
Question 3: Is the problem capacity, quality, information, permission or sequencing?
Question 4: Can work be rerouted around the bottleneck?
Question 5: Will improving it simply move the bottleneck somewhere else?
The last question matters. After one constraint is relieved, another may become limiting. Problem solving is often iterative constraint removal rather than one final fix.
The Bottleneck Migration Problem
Suppose a student improves algebraic accuracy. Timed performance then becomes the new limiting factor. Suppose a business automates drafting. Review capacity becomes the new bottleneck. Suppose a family centralises the calendar. Agreement on task ownership becomes the next constraint.
This is not failure. It is evidence that the system moved.
Ask SI after each repair: “What is now most likely to constrain the outcome?” This keeps improvement aligned with the current state rather than the original diagnosis.
The Recomposition Checklist
- Does the whole still meet the original outcome?
- Did any component optimise itself by consuming another component’s resource?
- Do all interfaces use the current version of information?
- Are assumptions consistent across components?
- Are shared constraints still respected?
- Can a person trace important decisions back to evidence?
- Are risks concentrated at one handoff?
- Does the final workflow have a clear completion state?
- Can the system recover when one component fails?
- What changed in the problem after the parts were improved?
Run this checklist before declaring a complicated problem solved.
The Decomposition Review After Action
After a project, compare the map with what actually happened.
Which dependency was missed? Which component was unnecessary? Which bottleneck was misidentified? Which interface created rework? Which task could have run in parallel? Which whole-system constraint appeared too late?
Update the reusable decomposition method, not only the project history.
For example, if every family event repeatedly fails at transport confirmation, add transport-owner confirmation as a standard interface field in future event workflows. If every study plan fails because revision starts too late, make assessment-date capture a standard first step.
This is how problem-solving capability compounds.
The Problem Map Card
Outcome: [what counts as solved]
Boundary: [inside / outside]
Components: [major parts]
Unknowns: [facts / decisions / forecasts / assumptions]
Dependencies: [what blocks what]
Shared constraints: [time / money / people / tools]
Bottleneck: [current limiting factor]
Interfaces: [handoffs and required information]
Parallel work: [independent branches]
High-risk parts: [stronger review needed]
Recomposition test: [how the whole will be verified]
Next action: [smallest high-leverage step]
Save the card only for problems important enough to deserve it. The map should reduce cognitive load, not become another administrative project.
The Decomposition Transfer Test
Use the same problem-map method on three different domains: one learning problem, one household or personal administration problem and one work or project problem.
Notice what stays constant: outcome, boundary, components, dependencies, bottleneck, interfaces and recomposition.
Notice what changes: source quality, acceptable risk, stakeholder rights, professional expertise and verification.
That difference is important. The reasoning architecture transfers. The domain standards do not automatically transfer with it.
A reusable problem-solving skill is not one answer that works everywhere. It is a method that tells you what must be re-checked when the domain changes.
Zoom Levels: Decompose at the Right Scale
Complicated problems exist at several zoom levels. If you stay too high, the components remain vague. If you zoom too far in, the map becomes a maze of micro-tasks.
Zoom 1 — Outcome system
What whole result must exist? Example: “Student can complete current Mathematics assessments independently and sustainably.”
Zoom 2 — Major domains
What large functions support the outcome? Knowledge, method selection, execution, time control, feedback and revision.
Zoom 3 — Working components
Which components can be owned and tested? Bracket expansion, equation solving, mixed-question recognition, timed execution.
Zoom 4 — Immediate actions
What can happen next? Complete three diagnostic questions, classify errors, repair one misconception.
Move between zoom levels deliberately. When a micro-task feels pointless, zoom out and reconnect it to the component. When a component still feels vague, zoom in until the input, output and completion test are visible.
Ask SI to label the zoom level of each item. This prevents strategic goals, projects and next actions from being mixed in one list.
The Decision Corridor
A complicated problem often contains a corridor of decisions rather than one giant decision.
Example: career change. The corridor might be: define target capability → test interest through a project → verify role requirements → identify skill gap → decide whether training is needed → test through application or internal opportunity.
Each decision unlocks the next. Trying to decide the entire career in one conversation produces speculation because later choices depend on evidence that does not yet exist.
Use SI to identify the earliest decision that can be made responsibly with current evidence. Then design the next evidence-producing step.
Good decomposition shortens the decision horizon. You do not need the final answer when the next corridor gate is still closed.
Integration Tests: Prove the Pieces Work Together
Once components are repaired, test the interfaces and whole system. Integration tests are the decomposition equivalent of mixed Mathematics questions: they remove the labels that told you which component was being tested.
Education integration test
After isolated algebra repair, give a mixed set where algebra appears beside ratio, geometry and word problems. The learner must recognise when the repaired skill applies.
Workflow integration test
After repairing source retrieval and scheduling separately, run a real weekly plan from current records through final calendar transfer. Observe whether the handoff still loses information.
Travel integration test
Run a complete day from hotel departure through transport, activities, meals and return. Individual bookings may all be valid while the day remains infeasible.
Work integration test
Take one project item from requirement through build, review, approval and communication. Confirm that every team receives the current version and that the final output satisfies the original requirement.
Integration tests expose relationships that component tests cannot see.
The Interface Failure Audit
When a complicated problem keeps returning despite local fixes, inspect the interfaces.
What is handed off? Is it complete?
Who receives it? Is ownership clear?
When is it handed off? Is the timing usable?
Which version? Is it current?
What acknowledgement exists? Do we know the receiver actually received or accepted it?
What happens when it is incomplete? Is there an escalation route?
A surprising number of “people problems” and “AI problems” are interface problems: the right information exists but does not reach the next step in a reliable form.
A Full Problem Map: Choosing and Completing a Major Research Project
Outcome: produce a reliable long-form research report that answers a defined question, distinguishes evidence from interpretation and can be updated when new information appears.
Boundary
The report covers a defined geography, population and time period. Questions outside that scope go into a future-work list rather than expanding the project indefinitely.
Components
Question definition, terminology, source discovery, source evaluation, evidence extraction, competing interpretations, synthesis, writing, fact-checking and publication.
Dependencies
Source discovery depends on a clear question and vocabulary. Synthesis depends on evaluated evidence. Writing can begin before research is complete, but strong claims cannot be finalised until evidence is checked. Publication depends on fact-checking and source traceability.
Unknowns
Which datasets exist? Which current figures are available? Which claims are contested? Which time window best represents the question?
Bottleneck
Suppose source discovery is abundant but claim traceability is poor. The bottleneck is not more research. It is an evidence ledger linking each important claim to the source and limitations.
Interface contract
Every extracted evidence item carries source, date, population, time period, claim supported and limitation. This structure hands usable evidence into synthesis.
Recomposition
After drafting, test the report question by question. Does every section contribute to the original research question? Are historical facts being presented as current? Are opposing interpretations represented according to evidence rather than rhetorical symmetry?
Review
After publication, record which source categories produced the most corrections and which claims were hardest to verify. The next research workflow improves before the next article begins.
SI can accelerate discovery, extraction and synthesis, but the decomposition keeps source discipline attached to the final report.
A Full Problem Map: Recovering a Project That Is Already Late
Outcome: recover the project without creating a second failure through rushed, uncoordinated work.
Current state
The external deadline is two weeks away. Design is mostly complete. One required approval is unresolved. Testing has started on only part of the product. Marketing material assumes a feature that may change.
First decomposition
Approval, build completion, testing, defect repair, documentation, marketing, launch coordination.
Dependency reality
Marketing cannot finalise the disputed feature claim until approval and build state stabilise. Testing can continue on unaffected components. Documentation can draft stable sections in parallel.
Critical bottleneck
The unresolved approval blocks both final build and external claims. It deserves immediate escalation even though testing has more visible work.
Triage decision
Freeze non-essential scope. Separate must-launch features from desirable features. Do not accelerate everything equally.
Recovery corridor
Resolve approval → freeze launch scope → complete critical build → run targeted integration tests → finalise claims and documentation → launch-readiness check.
Failure protection
Define stop conditions: if critical defects exceed the threshold or approval remains unresolved by the decision date, change the launch plan rather than compressing verification indefinitely.
Decomposition converts “work faster” into a recovery route that protects the parts that determine whether the project can safely finish.
The Decomposition Library: Patterns Worth Recognising
Pipeline pattern
Work moves through stages. Optimise flow and interfaces. Examples: publishing, application processing, lesson preparation.
Hub-and-spoke pattern
Several components depend on one central source or person. Protect the hub from overload and create clear spokes. Examples: family organiser, project manager, shared data source.
Prerequisite ladder
Later capability depends on earlier skills. Repair the earliest unstable rung. Common in education, software setup and certification paths.
Shared-resource pattern
Independent tasks compete for one scarce resource: time, budget, specialist, room or device. The solution requires allocation, not more task decomposition.
Feedback-control pattern
Action changes the state, measurement updates the next action. Common in learning, fitness, budgeting and iterative product work.
Coordination-network pattern
Several people exchange information and commitments. Interfaces and ownership matter more than the complexity of any individual task.
Threshold pattern
The route changes when a variable crosses a boundary. Common in budgets, deadlines, risk controls and intervention decisions.
Recognising the pattern helps SI propose a structure that fits the problem instead of generating a generic checklist.
The Anti-Overengineering Rule
Not every complicated problem deserves a complicated management system.
If one source-of-truth note and one dependency list solve the problem, do not build a database, dashboard and automation layer. Complexity should be proportional to recurrence, consequence and coordination load.
Ask SI to propose a minimum viable decomposition before producing the full architecture.
The minimum version should reveal outcome, major components, blockers, dependencies and next action. Add states, thresholds, failure trees and automation only when the problem requires them.
This keeps the map useful to a human rather than turning the map itself into another complicated problem.
The Decomposition Exit Test
Before leaving analysis and moving to execution, confirm:
Outcome: everyone knows what solved means.
Components: the major parts are visible.
Dependencies: blockers and sequence are understood.
Unknowns: decision-relevant questions have owners or tests.
Bottleneck: the current constraint is identified with evidence.
Interfaces: handoffs are defined.
Resources: shared constraints are acknowledged.
Decision nodes: branch conditions are explicit.
Recomposition: there is an end-to-end test.
Next action: one component can move now.
If those elements exist, additional decomposition may produce diminishing returns. Start moving the system and learn from feedback.
Frequently Asked Questions
Why use SI to break down problems?
SI can quickly generate alternative decompositions, expose dependencies, organise constraints and help compare structures. Human judgement is still needed to verify the map and decide what matters.
Is decomposition just making a to-do list?
No. A useful decomposition includes dependencies, bottlenecks, interfaces, unknowns and a recomposition test, not only tasks.
How small should a component be?
Small enough to have a clear input, output, owner and completion test, but not so small that coordination overhead exceeds the benefit.
What is the difference between a component and a task?
A component is a meaningful part of the system or problem. It may contain several tasks. Tasks are actions taken within or between components.
How do I find the bottleneck?
Look for the constraint whose improvement would release the most downstream progress. Test the claim rather than assuming the most visible problem is the bottleneck.
What is an interface?
The handoff between components: information, approval, material or output that one part must provide to another.
Why is recomposition important?
Because parts can work independently while the whole fails. Recomposition checks conflicts, missing handoffs and whole-system constraints.
Should I always find a root cause?
No. Some decisions can proceed with a reversible diagnostic step even when the full cause is unknown. Avoid speculative root-cause stories.
Can several components run in parallel?
Yes, when they do not depend on the same unresolved fact or scarce resource. Map shared constraints before parallelising.
How does this help students?
It helps turn broad labels such as “weak at Maths” into specific prerequisites, error types, dependencies and retestable skills.
How do I know when to stop decomposing?
Stop when the component has a clear input, output, owner, dependency position and completion test, and further splitting would mainly create coordination overhead.
What comes next in the series?
The next thinking guides move into challenging assumptions, comparing options and seeing problems from multiple perspectives.
Helpful Reading
- How to Leverage Your Life with Super Intelligence
- How to Think More Clearly with Super Intelligence
- How to Turn Super Intelligence from a Chatbot into a Thinking Partner
- How to Identify Where Super Intelligence Can Create the Most Leverage in Your Life
- How to Build Super Intelligence Workflows Instead of Asking Random Questions
Break It Down, Then Put It Back Together
Super Intelligence is very good at producing parts.
The human advantage comes from knowing which parts matter and how they reconnect.
Define the outcome.
Find the components.
Map dependencies.
Locate the bottleneck.
Protect the interfaces.
Solve at the right granularity.
Then recombine everything against the original outcome.
A complicated problem becomes manageable when the map becomes clearer than the confusion—but the map is only useful if it still leads back to the whole.
