VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How to Solve Problems With Super Intelligence | AI Problem Solving, Evidence and Decision Support

Three secondary students review open books and notes together in a classroom.
Secondary students solving problems together

How do you solve problems with Super Intelligence? Start by defining the problem before asking for solutions. Separate facts, assumptions, goals, constraints, unknowns and evidence. Then use SI to generate options, test reasoning, simulate consequences, check calculations and expose blind spots while keeping the human responsible for the final decision.

Good AI problem solving is not “ask SI what to do”. It is a controlled reasoning process. The problem is framed, decomposed, investigated, tested and repaired. The system becomes useful because it helps organise the work, not because its first answer is automatically correct.

This eduKateSG guide explains a practical SI problem-solving system for study, work, research, business, coding and everyday decisions. It begins Stage 4 of the How to Learn Super Intelligence Quickly curriculum after Stage 3 research and knowledge work.

Terminology: SI is our editorial term for practical contemporary AI learning. Problem solving with SI means using AI to support analysis, evidence and option generation while preserving verification and human agency.


The First Principle: Define the Problem Before Solving It

Many failed solutions solve the wrong problem well. A learner asks how to “study harder” when the real issue is one missing prerequisite. A business asks how to “increase productivity” when the bottleneck is approval delay. A programmer asks for a code rewrite when the defect is a misunderstood requirement.

Before generating options, write the problem in one sentence. Then write the observable desired state. The difference between current state and desired state is the first problem definition.

If the problem cannot be stated without vague words such as better, faster or improve, define what those words mean in this context.

Step 1 — Describe the Current State

List what is true now. Use sources, measurements or direct observation where possible.

Current state should not contain desired outcomes disguised as facts. “The team is inefficient” is an evaluation. “Average approval time is four days and two days occur before manager review” is more operational.

SI can help organise the state, but the facts should remain traceable.

Step 2 — Describe the Desired State

Define what success looks like. A solution cannot be evaluated without an outcome standard.

Examples: reduce approval time without increasing error; solve linear equations independently; publish a factual article with traceable sources; restore a software feature without breaking existing tests.

The desired state should include quality, not only speed.

Step 3 — Identify Constraints

Constraints define the solution space: budget, time, policy, tools, skill level, privacy, safety and commitments.

A solution that ignores constraints is not a solution to the real problem.

Use explicit SI constraints so the system does not optimise an imaginary version of the task.

Step 4 — Separate Facts, Assumptions and Unknowns

Create three lists. Facts are supported by evidence. Assumptions are working beliefs. Unknowns are unresolved information that may affect the solution.

SI can help expose hidden assumptions by asking what must be true for a proposed explanation to hold.

Do not turn unknowns into assumptions automatically. Some unknowns should trigger research before solution design.

Step 5 — Identify the Decision Owner

Who is responsible for choosing or approving the solution? Some problems are analytical; others include values, authority or professional responsibility.

SI can compare options without becoming the decision owner. Keep the human or institution visible where accountability matters.

Step 6 — Find the Bottleneck

A bottleneck is the constraint or failure point that currently limits progress most. Fixing non-bottlenecks can create activity without meaningful improvement.

Ask where work waits, where errors begin or which prerequisite fails first. Use data when possible.

The bottleneck may change after repair, so problem solving is iterative.

Step 7 — Build a Causal Hypothesis

Why is the problem happening? Generate several plausible causes instead of accepting the first explanation.

For each cause, ask what evidence would support or weaken it. This converts speculation into a testable hypothesis.

Do not ask SI to choose one cause merely because it sounds coherent.

Step 8 — Generate Multiple Solution Families

Generate alternatives that differ in mechanism, not wording. For a delay problem: remove work, simplify approval, add capacity, change sequencing or automate a stable step.

For a learning problem: repair prerequisite, change explanation, add retrieval, change practice difficulty or improve feedback.

Diverse solution families reduce anchoring on the first idea.

Step 9 — Define Evaluation Criteria

Compare options on criteria that matter: effectiveness, cost, speed, risk, reversibility, maintainability, learning impact or fairness.

Separate factual measurements from preference weights. SI can populate evidence; the human decides which trade-offs matter.

Step 10 — Test the Weakest Assumption

A solution often depends on one assumption more than others. Find it and test it first.

If automation only works when data is clean, test data quality. If a study plan assumes thirty minutes every day, test whether that time is realistic.

Testing the weakest assumption prevents large investments in fragile plans.

Step 11 — Prefer Reversible Tests

When uncertainty is high, start with actions that are easy to reverse. Pilot, prototype, simulate or run a small experiment.

Reversible tests produce information while limiting downside.

SI can help design tests, but the test should measure the real uncertainty rather than merely generate activity.

Step 12 — Measure Before and After

Without a baseline, improvement claims become vague. Record the current measure before changing the system.

Use the same metric and quality standard afterward. Include repair and review cost, not only first-pass speed.

A change is useful when it improves the actual outcome under comparable conditions.

Step 13 — Check Second-Order Effects

A local fix can create a new problem elsewhere. Faster content generation may increase editing backlog. More study hours may reduce sleep. More automation may increase exception-handling burden.

Ask what downstream system receives the output and what new load the solution creates.

This is where systems thinking becomes part of ordinary problem solving.

Step 14 — Design Failure Detection

Ask how you will know the solution is failing. Define early warning signals, error checks and escalation.

A system that works only when nothing goes wrong is incomplete.

SI can propose failure modes; verify the important ones against real domain experience.

Step 15 — Define Stop Conditions

Some plans should stop when data is missing, cost exceeds a threshold, permission is absent or risk rises.

Stop conditions prevent the workflow from continuing simply because SI can generate another step.

They are especially important for tool-connected and agentic systems.

Step 16 — Choose the Smallest Viable Solution

Complex solutions create more handoffs and failure points. Start with the simplest method capable of meeting the objective.

Add sophistication only when the simpler method fails a real requirement.

This principle keeps SI problem solving from becoming technology theatre.

Step 17 — Implement in Stages

Stage implementation so each part can be validated. Avoid changing every variable at once.

A staged rollout makes cause and effect easier to interpret and recovery easier if something fails.

Document what changed in each stage.

Step 18 — Review Outcomes

After implementation, compare result with desired state. Which metric improved? Which did not? What new problems appeared?

Avoid explaining success or failure only after the fact. Compare with the assumptions and predictions recorded earlier.

Outcome review turns one problem into learning for the next.

Step 19 — Capture the Lesson

Record the problem pattern, bottleneck, solution, evidence and limits. This becomes reusable knowledge.

The lesson should be short enough to retrieve later. Store representative failure cases when they are likely to recur.

Step 20 — Reopen When Conditions Change

A solved problem can return when scale, tools, people or constraints change. Preserve review triggers.

Do not assume yesterday’s solution remains optimal forever.

Problem-solving systems need maintenance just like knowledge systems.

The SI Problem-Solving Canvas

  • Problem statement.
  • Current state.
  • Desired state.
  • Facts.
  • Assumptions.
  • Unknowns.
  • Constraints.
  • Decision owner.
  • Bottleneck.
  • Candidate causes.
  • Solution families.
  • Evaluation criteria.
  • Weakest assumption.
  • Pilot or reversible test.
  • Success metric.
  • Failure signals.
  • Stop conditions.
  • Next review date.

A Worked Example: Student Underperformance

Problem: a student studies many hours but examination results remain unstable.

Current state: strong homework completion, repeated mistakes in timed algebra questions, sleep reduced during revision. Desired state: stable accuracy under timed conditions without increasing weekly study hours.

Hypotheses: algebra prerequisite gap, weak transfer, time-pressure errors or fatigue. Test each with diagnostic tasks rather than prescribing more study immediately.

Solution may combine targeted algebra repair, mixed timed practice and restored sleep. Measurement uses fresh test performance, not number of hours studied.

A Worked Example: Slow Business Approval

Problem: proposals take seven days to approve. Data shows four days occur before first review.

Bottleneck is queue time, not writing speed. Solution families: change review cadence, delegate certain approvals, create triage criteria or automate low-risk preparation.

Pilot one team for two weeks. Measure approval time and error or rework rate.

Do not automate the entire process before proving which delay actually matters.

A Worked Example: Research Question

Problem: sources disagree on whether an intervention improves learning.

Separate population, outcome, study design and time period. The disagreement may disappear once the studies are aligned.

If disagreement remains, preserve it. Compare methodological strength rather than forcing one answer.

The bounded conclusion becomes the solution to the research problem.

A Worked Example: Software Bug

Problem: application intermittently fails when saving.

Current state: failure only under large payloads. Hypotheses: timeout, database constraint, memory or network retry.

Reproduce under controlled conditions, inspect logs and test hypotheses one at a time. Do not rewrite the whole feature.

Repair the smallest confirmed cause and add regression tests.

A Worked Example: Content Workflow

Problem: articles publish quickly but later require large factual repairs.

Bottleneck is verification, not writing speed. Candidate solutions: source map before drafting, protected facts, fact-check stage or structured claim ledger.

Pilot one workflow and measure total time to acceptable publication, including corrections.

Problem-Solving Failure 1 — Jumping to Solutions

The user asks “what should I do?” before defining the problem.

Repair by describing current state, desired state and evidence.

Failure 2 — One-Cause Thinking

The first plausible explanation becomes the only explanation.

Generate alternatives and define tests that distinguish them.

Failure 3 — Solving Symptoms

The visible error is downstream of the real bottleneck.

Trace the process backward to the earliest divergence.

Failure 4 — No Baseline

Improvement is claimed without comparable before/after evidence.

Measure before intervention.

Failure 5 — Optimising One Metric

Speed improves while quality declines.

Use a balanced criterion set.

Failure 6 — Irreversible First Move

A large change is made before uncertainty is reduced.

Prefer pilot, sandbox or reversible test.

Failure 7 — Ignoring Human Authority

SI recommendations become decisions without an accountable owner.

Separate analysis from approval.

Failure 8 — No Recovery Plan

The solution has no path when a tool fails or assumption breaks.

Add failure detection and recovery.

Failure 9 — Endless Analysis

More options are generated after the decisive uncertainty is already known.

Define closure and next action.

Failure 10 — No Learning Capture

The same problem is solved repeatedly from scratch.

Store pattern, decision and result in the knowledge base.

A Problem-Solving Review Checklist

  • Are we solving the right problem?
  • What evidence describes the current state?
  • What would success look like?
  • What constraints are real?
  • Which assumptions are weakest?
  • Where is the bottleneck?
  • What alternative causes exist?
  • What different solution mechanisms exist?
  • Can we run a reversible test?
  • How will we measure outcome?
  • What second-order effect could appear?
  • What would make us stop or escalate?

A Practice Lab: Solve One Problem Without Asking for the Answer

Choose a real low-stakes problem. Give SI the current state and ask it to help generate questions, causes and tests rather than solutions.

You choose the evaluation criteria and next experiment. After the result, compare prediction with outcome.

The exercise teaches SI as reasoning support rather than decision replacement.

Frequently Asked Questions

Should SI decide the solution for me?

It can compare options and evidence. Important trade-offs, values and accountability remain human decisions.

How many options should I generate?

Enough to represent meaningfully different mechanisms. Stop when new options become variants of the same idea.

What if I do not know the cause?

Treat causes as hypotheses. Design tests that reduce uncertainty before choosing a large intervention.

Can SI solve problems it has never seen?

It can help reason by analogy and decomposition, but novel problems increase uncertainty. Verification and domain expertise become more important.

When should I use an expert?

When the problem is high consequence, regulated, physically dangerous or outside your ability to verify independently.

What comes next?

Continue with How to Break Complex Problems Into Smaller Problems, where Stage 4 goes deeper into decomposition and dependency maps.

The Problem-Solving State Machine

Complex problem solving becomes easier to control when the work is treated as a state machine rather than one conversation. A practical sequence is Define → Investigate → Hypothesise → Test → Decide → Implement → Verify → Learn.

Each state has an exit condition. Definition closes when the problem, current state, desired state and constraints are explicit. Investigation closes when enough evidence exists to form plausible causes. Testing closes when the decisive uncertainty has been reduced enough to choose or reject an option.

This structure prevents SI from jumping ahead merely because it can generate a solution. The current state determines what kind of assistance is useful.

Problem Statements That Can Be Tested

A strong problem statement contains an observable gap. “Our process is bad” is weak. “Forty percent of applications require rework after first review, mainly because three required fields are missing” is testable.

A good statement should answer who or what is affected, what currently happens, what should happen, and which evidence establishes the gap.

If the statement already contains the proposed cause—“sales fell because the price is too high”—rewrite it neutrally until causation has been tested.

Problem Framing and Reframing

Some problems remain difficult because the original framing narrows the solution too early. Reframing asks whether the same evidence supports a different problem definition.

Example: “We need a faster writer” may reframe as “We need fewer factual revisions after first draft.” The second frame points toward source architecture and verification, not typing speed.

Ask SI to generate alternative framings, then check them against the evidence. A useful reframe changes the set of plausible solutions while remaining faithful to the observed problem.

Root Cause Analysis

Root cause analysis traces a failure backward until the team reaches a cause that can be acted upon and whose repair would meaningfully reduce recurrence.

Use methods such as repeated why-questions, process mapping or fault trees. Avoid treating the first human error as the root cause when the system repeatedly makes that error likely.

SI can organise the chain, but real logs, measurements and domain knowledge should determine which causes are supported.

The Five-Why Technique With Guardrails

Repeatedly asking why can expose deeper causes, but it can also create a fictional causal story. Use each answer as a hypothesis requiring evidence.

Example: Why was the report late? Because data arrived late. Why did data arrive late? Because source owners sent different formats. Why? Because no shared submission template existed. Each step should be checked rather than assumed.

Stop when further “why” questions become speculative or when the current cause is actionable enough to test.

Fault Trees

A fault tree starts with the failure and branches into possible conditions that could produce it. This is useful when several causes may combine.

For an application outage, branches might include network, database, code path, authentication and external dependency. For student underperformance, branches might include prerequisite knowledge, question reading, execution accuracy and time pressure.

The tree should support evidence collection. Remove branches disproved by data and deepen branches that remain plausible.

Constraint Trees

Some problems are not caused by failure but by incompatible constraints. A constraint tree asks which limits are fixed, negotiable or assumed.

Example: a project is late under fixed quality and staffing. Is deadline truly fixed? Can scope change? Can sequencing change? Can part of the work be removed?

The tree reveals which apparent constraints are actually choices and which are external requirements.

Evidence Before Explanation

People prefer coherent explanations. SI makes coherent explanations cheap. This increases the need to collect evidence before committing to a story.

Build an evidence table: observation, source, date, reliability, implication. Then ask which causal hypotheses fit the evidence and which do not.

A hypothesis that explains one observation but contradicts three others should not survive merely because it is intuitive.

The Hypothesis Register

Keep candidate causes visible instead of allowing the conversation to converge prematurely.

  • Hypothesis.
  • Evidence supporting.
  • Evidence weakening.
  • Test that would distinguish it.
  • Cost of testing.
  • Status: active, weakened, rejected or supported.

The register makes uncertainty explicit and reduces confirmation bias.

Disconfirming Evidence

Strong problem solving asks what would prove the preferred explanation wrong. SI can help generate disconfirming tests.

If the team believes slow performance comes from database latency, ask what result would instead point to application code or network. Run measurements that can distinguish the causes.

This is stronger than collecting only evidence that supports the initial story.

Sensitivity Analysis

When a decision depends on uncertain values, sensitivity analysis asks how much the conclusion changes when those values change.

A project may be worthwhile if demand exceeds one threshold but not below it. A schedule may work if task duration is under three days but fail above four.

Use SI to organise scenarios and calculations, but keep the assumptions and formula inspectable.

Threshold Thinking

Many problems change character after a threshold. Capacity may be adequate until volume crosses a limit. Student performance may remain stable until task complexity exceeds working fluency.

Ask what threshold causes the system to move from normal operation into failure or overload.

A solution can then increase the threshold, reduce load or add early detection before the threshold is crossed.

Buffer Thinking

Robust systems need margin. A schedule using 100% of available time has no recovery capacity. A team operating at maximum workload cannot absorb variation.

Include buffers in solution design: time margin, spare capacity, review time, financial reserve or rollback path.

SI can optimise a plan tightly; the user should decide whether tight optimisation makes the system brittle.

Reversibility Analysis

Classify solution steps by how difficult they are to reverse. Editing a draft is reversible. Publishing widely, deleting data or making contractual commitments is less reversible.

Under uncertainty, sequence reversible actions before irreversible ones where possible.

This preserves optionality while evidence accumulates.

Option Value

Sometimes the best short-term solution is the one that preserves future choices rather than maximises immediate performance.

A pilot creates information and preserves the option to scale or stop. A modular technical design preserves the option to replace one component later.

Ask SI to identify which options become unavailable after each choice.

Decision Matrices

A decision matrix compares options on explicit criteria. Use consistent criteria across options and keep missing data visible.

Do not hide value judgments inside weights. If cost is weighted more than speed, that is a human preference or organisational policy.

Run sensitivity analysis on weights when the decision is close. If tiny changes reverse the result, the conclusion is fragile.

Expected Value With Caution

Expected-value reasoning can help where probabilities and outcomes are meaningful, but inputs may be uncertain or impossible to estimate credibly.

Use ranges or scenarios rather than false precision. Record where probabilities come from.

For many human decisions, non-quantifiable values still matter. Numerical framing should support rather than erase them.

Worst-Case and Regret Analysis

When probabilities are unclear, examine worst plausible outcomes and potential regret. Which option creates an unacceptable downside? Which mistake is reversible?

This is useful for safety, irreversible commitments and decisions with asymmetric consequences.

Avoid imagining fantastical extremes. Use plausible scenarios grounded in the domain.

Pre-Mortems

Imagine the chosen solution failed. Ask why. This can reveal missing dependencies, incentives, data quality problems or operational bottlenecks.

Turn the strongest failure reasons into checks or contingency plans.

Do not let the pre-mortem expand indefinitely; focus on high-impact plausible risks.

Postmortems

After implementation, compare what happened with what was expected. Identify first divergence, detection delay, recovery and prevention.

Keep postmortems evidence-based and system-focused. The objective is to improve future problem solving.

Store important lessons in the knowledge base or failure library.

Systems Mapping

A problem often belongs to a larger system. Map inputs, processes, outputs, feedback loops and downstream receivers.

Ask what happens if one component improves. Does another become the bottleneck? Does the solution shift cost elsewhere?

Systems mapping protects against local optimisation.

Feedback Loops

Positive feedback amplifies change; negative feedback stabilises. In ordinary workflows, feedback loops may be social, operational or technical.

For example, faster content production can increase publishing volume, which increases review load, causing later delays. The initial improvement feeds a new bottleneck.

Identify reinforcing and balancing loops when the problem keeps returning despite local fixes.

Delay Effects

Some solutions appear ineffective because outcomes lag behind intervention. Others appear successful briefly before delayed side effects emerge.

Record expected time-to-effect. Do not evaluate a long-term learning intervention after one day or a capacity change before the system reaches normal load.

SI can help build timelines, but the domain determines realistic delays.

Incentive Analysis

People respond to incentives, measurement and constraints. A process problem may persist because the system rewards behaviour that conflicts with the stated goal.

Ask what each actor is optimising, what they are measured on and what costs they personally bear.

Avoid simplistic motive claims. Use observable incentives and behaviour rather than speculation about intent.

Stakeholder Analysis

List people affected by the solution, their role, information, authority and potential impact.

This prevents a solution from working for the designer while creating unrecognised cost for operators or users.

Stakeholder analysis does not mean every preference has equal weight; it means material effects are visible.

Information Value

Before collecting more data, ask whether the information could change the decision. If not, the research may be unnecessary.

Prioritise evidence with high value of information: facts that distinguish major hypotheses or reverse the preferred option.

This prevents endless research after the decision-relevant uncertainty has already been reduced.

Experiment Design

A good experiment changes one important variable where possible, defines a comparison and measures the outcome.

In operational settings, randomisation may not be possible. Use pilots, before/after comparisons or staged rollouts carefully, acknowledging limitations.

SI can help design and document experiments, but causal interpretation should match the actual design.

Pilot Design

A pilot should be large enough to reveal meaningful problems but small enough to recover from failure.

Define scope, duration, success metrics, stop conditions and what decision the pilot informs.

A pilot without a decision rule can become permanent by inertia.

Prototype Design

A prototype tests feasibility or interaction, not production readiness. Keep its claims narrow.

Use prototypes to answer one or two questions: can the workflow extract fields reliably? Can users understand the interface? Can the calculation be automated?

Do not infer scale, security or reliability from a small demonstration unless those properties were tested.

Sandboxing

When the solution involves tools or external actions, use sandbox or test environments where practical.

Sandboxing makes failure reversible and supports higher variation in testing.

The transition from sandbox to live environment should have a separate readiness check.

Rollback Design

Before implementing a consequential change, define how to return to the previous stable state.

Rollback can be technical, procedural or contractual. Not every action can be reversed, which increases the importance of pilot and approval.

A solution without recovery is harder to justify under uncertainty.

Monitoring Design

After implementation, decide what signals show health, degradation or failure. Monitoring should connect to the original objective.

A speed improvement should not be monitored only for speed if error rate can rise. Include balancing metrics.

Define who responds when a threshold is crossed.

Problem-Solving Governance

Recurring or high-consequence problems need clear ownership. Who can change the system? Who approves? Who reviews evidence? Who receives alerts?

SI can coordinate information, but authority should remain explicit.

Governance reduces the chance that a generated plan turns into action without the appropriate decision process.

A Full Case Study: Reducing Article Rework

Current state: articles publish quickly but require many post-publication corrections. Desired state: maintain publication speed while reducing factual and structural repairs.

Evidence shows most repairs come from missing source checks and duplicate search intent, not writing quality. Hypotheses focus on source architecture and collision detection.

Pilot: one batch uses source ledger, canonical-slug check, protected facts and final WordPress audit. Measure total time including corrections.

If post-publication repair falls without excessive production delay, the workflow can become standard. The lesson is captured as publishing knowledge.

A Full Case Study: Improving a Student’s Test Results

Current state: high homework scores, low timed-test scores. Desired state: stable timed performance. Constraints: no increase in weekly study time.

Hypotheses: overreliance on hints, weak retrieval, slow method selection, fatigue. Diagnostics distinguish them.

If fresh untimed problems are correct but timed performance falls, speed and selection become stronger hypotheses. Practice then targets mixed timed tasks rather than more explanation.

Measure transfer in later tests and preserve sleep and total workload as balancing variables.

A Full Case Study: Choosing Between Two Software Architectures

Define criteria: reliability, latency, cost, team skill, migration risk and reversibility. Gather benchmark and operational evidence.

Identify assumptions: traffic growth, data model stability, team maintenance capacity. Run prototypes only for uncertainties that can change the decision.

Use a decision record rather than letting the matrix produce a disguised automatic winner.

Set review conditions if assumptions later change.

A Full Case Study: Researching Conflicting Claims

Two sources disagree. Align population, outcome, time and method. Build a source matrix.

If one study measures self-reported behaviour and another measures observed performance, the contradiction may be only apparent.

If disagreement remains under comparable definitions, preserve it and evaluate methodology.

The solution to the research problem may be a bounded conclusion with uncertainty rather than one categorical answer.

The Problem-Solving Knowledge Base

Store recurring problem patterns, diagnostic questions, failure cases, successful tests and decision records.

Link problems to mechanisms rather than only topics. “Wrong denominator” can recur in attendance, finance and research.

SI can retrieve analogous cases, but the current problem still needs evidence.

The Problem-Solving Maturity Ladder

Level 1 — Answer seeking

User asks for a solution and evaluates mainly by plausibility.

Level 2 — Problem definition

User defines current state, goal and constraints.

Level 3 — Evidence and hypotheses

User separates facts, assumptions and causes and tests competing explanations.

Level 4 — Experiments and systems

User uses reversible tests, system effects, monitoring and recovery.

Level 5 — Reusable problem-solving system

Lessons, cases and decision records improve future diagnosis while human authority remains explicit.

The ladder is descriptive. Use it to identify the next process capability rather than to score people.

A Final Problem-Solving Examination

Choose a real low- or moderate-stakes problem. Write the current state, desired state, constraints and three competing causal hypotheses.

Identify the single piece of evidence with the highest value for distinguishing the hypotheses. Obtain or simulate that evidence where appropriate.

Design one reversible intervention, define metrics and stop conditions, then predict the outcome before testing.

Afterward, review what changed in your model of the problem. The strongest evidence of problem-solving skill is not that the first solution worked; it is that uncertainty became smaller, the decision became more defensible and the lesson can be reused.

The Problem Decomposition Trigger

A problem should be decomposed when it contains several dependent uncertainties, several stakeholders or several transformations that cannot be checked as one unit.

Do not decompose automatically. A simple arithmetic question does not need a project plan. Decomposition adds coordination cost, so it should exist because the problem is too large or opaque to reason about safely as one block.

Use Article 32 when the main difficulty is finding the right subproblems and dependency order. Article 31 remains the owner of the wider problem-solving cycle.

Problem Representation Before Solution Generation

A useful representation can take many forms: equation, diagram, flowchart, table, timeline, causal map, decision tree or plain-language brief.

Ask which representation makes the hidden structure visible. A timeline exposes delay. A flowchart exposes routing. A causal map exposes hypotheses. A table exposes unequal evidence across options.

Changing representation can solve part of the problem before any new idea is generated because relationships become easier to inspect.

Constraint Satisfaction Problems

Some problems are primarily about finding a configuration that satisfies several rules. Scheduling, resource allocation, layout and planning often fit this pattern.

List variables, domains and constraints. Separate hard constraints from preferences. Identify which constraint creates the tightest bottleneck.

SI can propose candidate configurations, while deterministic solvers or direct checks may be better for exact optimisation when the problem is formally specified.

Optimisation Problems

Optimisation differs from simple constraint satisfaction because several feasible solutions may exist and the task is to choose among them according to an objective.

Define the objective function carefully. Minimising cost may increase risk. Maximising speed may reduce quality. Multi-objective problems require visible trade-offs.

Do not let a numerical objective erase human values that were never encoded in the metric.

Classification Problems

Some problems ask which category a case belongs to. Good classification requires clear category definitions, representative examples and boundary cases.

SI can classify unstructured inputs, but the categories should be validated and the consequences of misclassification considered.

Use Unknown or Human Review states when the input does not support a reliable category.

Forecasting Problems

Forecasts require assumptions about how current patterns relate to future states. SI can organise scenarios and historical evidence but should not convert uncertain forecasts into facts.

Define the time horizon, baseline, variables and uncertainty. Compare several scenarios rather than producing one unjustified precise number when evidence is weak.

Forecasting is strongest when predictions are recorded and later compared with outcomes.

Design Problems

Design problems have many acceptable solutions. The task is to satisfy needs and constraints while producing something useful.

Use SI to generate alternatives, critique trade-offs and simulate receiver perspectives. Keep the design brief and acceptance criteria visible.

Prototype early. Feedback from actual use often reveals constraints that discussion missed.

Diagnostic Problems

Diagnostic problems ask what mechanism explains observed symptoms. Examples include debugging, learning difficulties, process failures and equipment issues.

Keep several hypotheses active and choose tests that discriminate between them. Avoid treatment or repair before the cause is sufficiently understood.

The same symptom can arise from different causes; diagnosis should remain evidence-led.

Planning Problems

Planning problems convert goals into sequences under constraints. They require dependencies, resources, timing, buffers and contingency.

A plan is a hypothesis about execution. Monitor real progress and update when assumptions fail.

SI can draft plans quickly, but the user should verify feasibility against real calendars, resources and permissions.

Negotiation Problems

Negotiation involves multiple agents with different goals, information and alternatives. SI can help prepare interests, options, questions and scenarios.

Do not reduce negotiation to one “winning” script. Understand the other side’s plausible constraints and preserve ethical boundaries.

Afterward, review what assumptions about interests or leverage were wrong.

Problem Solving Under Incomplete Information

Many real problems never become fully known. The correct goal is not perfect certainty but enough evidence to choose a proportionate action.

Ask which unknowns are decision-critical and which can remain unresolved. This prevents endless information gathering.

Use reversible actions when uncertainty remains high.

Problem Solving Under Time Pressure

Time pressure changes the process. Prioritise high-consequence facts, robust options and fast validation. Defer low-value analysis.

Use prebuilt checklists for recurring urgent problems. SI can retrieve and apply them quickly, but the checklist should come from prior verified practice.

After the event, run a slower review to capture lessons that pressure prevented in the moment.

Problem Solving With Conflicting Objectives

Stakeholders may want speed, quality, cost control and flexibility simultaneously. Make the conflict explicit instead of pretending one solution maximises everything.

Construct a trade-off table and identify non-negotiable thresholds. Some objectives may be satisfice targets rather than maximisation targets.

The final choice remains a governance decision when values conflict.

Problem Solving With Unknown Unknowns

No framework can enumerate every surprise. Build resilience rather than assuming complete prediction.

Use buffers, monitoring, modular design, rollback and escalation. Invite diverse review to expose blind spots.

SI can generate candidate risks, but robust systems also assume some risks will not be anticipated.

The Solution Portfolio

For complex problems, maintain a portfolio rather than one plan: preferred solution, fallback, emergency response and investigation path.

The portfolio should not become excessive contingency planning. Keep alternatives only where they protect meaningful uncertainty.

This makes the system more resilient when the primary assumption fails.

The Decision Record

After choosing, record problem, evidence, alternatives, criteria, decision, owner and review condition.

A decision record supports later learning because the outcome can be compared with the assumptions that existed at the time.

Do not rewrite history after the result is known. Preserve the original reasoning state.

The Recovery Record

If implementation fails, record the last known stable state, failure, impact, recovery action and remaining uncertainty.

This becomes useful knowledge for future incidents and improves the quality of contingency planning.

SI can structure recovery documentation while system logs or direct evidence control the facts.

A Problem-Solving Team Protocol

  • One person states the problem neutrally.
  • Evidence is listed before explanations.
  • Several causes remain active until tested.
  • Criteria are agreed before option ranking.
  • Disagreement is recorded rather than averaged away.
  • Decision owner is explicit.
  • Implementation has monitoring and stop conditions.
  • Outcome review captures lessons.

The protocol reduces social and AI-assisted pressure toward premature consensus.

The Receiver Test for Solutions

A solution is incomplete if the person who must execute it cannot tell what to do, why, with which resources and what to do when the plan fails.

Give the solution to the receiver without the full analysis transcript. If they need hidden context, improve the handoff.

Problem solving ends in usable action, not only correct reasoning.

The Portability Test

Repeat the problem-solving process with a different SI tool or no SI on one bounded case. The essential reasoning structure should remain usable.

If the process collapses without one interface, too much of the competence may be externalised.

Portable problem solving is the real objective of SI-assisted training.

A Final Problem-Governance Gate

Before acting on a consequential solution, verify the current problem statement, evidence, decision owner, permissions, rollback or recovery and success metrics.

Confirm that no old assumption from an earlier conversation has silently re-entered the plan.

Then ask one final question: what result would make us stop, reverse or seek expert review? If the answer is undefined, the solution is not operationally complete.

This final gate preserves human control while allowing SI to accelerate analysis, experimentation and documentation.

The Final Solution Handoff and Maintenance Gate

Before closing a solved problem, hand the solution to the person or system that must operate it. They should be able to identify the goal, actions, dependencies, evidence, monitoring signals, stop conditions and recovery path without reading the full reasoning history.

Then define when the solution should be reviewed. A change in volume, policy, technology, cost, learner state or available evidence can make yesterday’s solution obsolete. The review trigger should be tied to the assumptions that matter most.

Finally, preserve the reusable lesson: problem pattern, root cause, tested intervention, outcome and operating boundary. Do not preserve every brainstorm. Keep the knowledge that makes the next similar problem faster to diagnose.

This gate turns one successful intervention into a maintained problem-solving capability rather than a one-off answer.

The Final Problem-Solving Transfer Gate

Apply the same problem-solving method to a different domain: a study problem, workflow delay, research disagreement or technical failure. Keep the structure—state, evidence, hypotheses, reversible test and review—while changing the surface details.

If the method survives the new domain, the learner has acquired a transferable problem-solving process rather than memorised one case. If it fails, identify which step depended on domain knowledge and add the appropriate source or expert input.

Strong Problem Solving Makes the Unknowns Smaller

The goal is not to make SI produce a clever answer. It is to turn a vague problem into a sequence of increasingly testable questions and decisions.

Use SI to widen the search space, expose assumptions and accelerate feedback. Keep evidence, constraints and human authority visible.

Return to the complete SI learning hub for the rest of Stage 4.