Punggol Primary Mathematics | Find the First Wrong Line Before Giving More Practice keeps its original 2017 title and URL, but the page is rebuilt around mathematical debugging. When an answer is wrong, the common response is to correct the entire solution and assign more questions. That can waste effort because the learner may have understood most of the problem and made only one early break that contaminated every later line.
For readers searching for Punggol Primary Mathematics, PSLE Maths tuition, Maths error analysis, Primary Mathematics Punggol, the diagnostic sequence is target → representation → operation/model → arithmetic → interpretation → checking, then identify the first point where a valid mathematical state becomes invalid.
This legacy eduKateSG page does not claim a current Punggol branch. For current local-facing information, use eduKatePunggol.com. eduKateSG keeps this page as a deep Primary Mathematics debugging guide aligned to the current syllabus and 2026 PSLE Mathematics.
Preserve Correct Work
Do not mark the whole solution as wrong if the first three lines are valid. Preserve what the learner already controls.
First Wrong Line
Locate the earliest step where information, representation, operation or computation becomes invalid.
Task Interpretation
The first error can occur before mathematics begins if the learner misreads the target or condition.
Representation
A wrong bar model, table, diagram or equation can generate perfect arithmetic for the wrong relationship.
Operation and Model
Students may understand the story but choose addition instead of multiplication, or use the wrong base for percentage.
Arithmetic
Sometimes the model is correct and only calculation fails. Repair exactly that layer.
Interpretation
The computed number may be correct but reported with wrong unit, wrong meaning or wrong subpart.
Checking
Verification should test both the model and the arithmetic. Re-reading the same work is not enough.
Retest
Use new numbers and a changed surface after correction. Same-question redo is weak evidence.
Independence
The end goal is for the learner to debug their own first wrong line before the tutor or answer key does.
One Hundred First-Wrong-Line Clinics
Each clinic below treats a wrong answer as a debugging trace. The objective is to repair the smallest mechanism that caused the downstream failure.
First-Wrong-Line Clinic 1: copied number wrong
Do not erase the whole solution. Observed trace: Student copies 340 as 304.
Debugging move: Mark the copy error as the first wrong line; do not reteach the concept.
Why it matters: Attention error precedes mathematics. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 2: unit omitted
Mark the first line where validity breaks. Observed trace: Student begins calculation before converting cm to m.
Debugging move: Mark unit alignment as the first break.
Why it matters: Later arithmetic may be correct on incompatible quantities. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 3: wrong target
Separate model from arithmetic. Observed trace: Question asks remaining amount; student finds used amount.
Debugging move: Restate target before solving.
Why it matters: Task interpretation can be the first wrong line. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 4: bar model relation wrong
Ask what the learner believed at that line. Observed trace: Student draws additive bars for multiplicative comparison.
Debugging move: Repair representation before operations.
Why it matters: A bad model can generate correct arithmetic for the wrong relation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 5: table labels wrong
Repair only the layer that failed. Observed trace: Rows/columns are swapped.
Debugging move: Fix variable meaning before calculation.
Why it matters: Representation labels carry mathematical state. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 6: diagram not labelled
Do not erase the whole solution. Observed trace: Student assumes a side length from appearance.
Debugging move: Add only stated/given measures.
Why it matters: Visual inference can be the first wrong step. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 7: equation wrong, arithmetic right
Mark the first line where validity breaks. Observed trace: Student writes 45+12 instead of 45−12.
Debugging move: Diagnose operation/model selection, not calculation.
Why it matters: Final answer error began before arithmetic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 8: equation right, arithmetic wrong
Separate model from arithmetic. Observed trace: Student writes 45−12 then gets 37.
Debugging move: Repair subtraction only.
Why it matters: Do not reteach problem interpretation unnecessarily. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 9: fraction whole wrong
Ask what the learner believed at that line. Observed trace: Student identifies denominator part but wrong whole.
Debugging move: Mark referent identification as first break.
Why it matters: Fractions are relationships to a whole. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 10: fraction operation wrong
Repair only the layer that failed. Observed trace: Whole is correct but learner adds instead of multiplies/divides.
Debugging move: Repair fraction-of relation.
Why it matters: Operation selection is distinct from referent. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 11: percentage base wrong
Do not erase the whole solution. Observed trace: Student calculates 20% using final instead of original value.
Debugging move: Mark base/reference amount.
Why it matters: Percentage errors often begin in model state. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 12: ratio units wrong
Mark the first line where validity breaks. Observed trace: Student adds ratio units directly to quantity.
Debugging move: Translate ratio parts to actual value first.
Why it matters: Representation-to-number bridge is the key line. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 13: average total wrong
Separate model from arithmetic. Observed trace: Student uses average as total.
Debugging move: Write total=average×number first.
Why it matters: Definition should precede arithmetic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 14: speed quantities mixed
Ask what the learner believed at that line. Observed trace: Distance from one stage and time from another are used.
Debugging move: Use stage table and align quantities.
Why it matters: State mixing is the first break. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 15: time conversion wrong
Repair only the layer that failed. Observed trace: 1 h 30 min treated as 1.30 h.
Debugging move: Repair representation of time before formula.
Why it matters: Decimal notation can hide unit structure. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 16: money decimal error
Do not erase the whole solution. Observed trace: $3.50 treated as 3.5 cents/other confusion.
Debugging move: Standardise money representation.
Why it matters: Place value and unit interact. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 17: place-value regrouping
Mark the first line where validity breaks. Observed trace: Student subtracts across zeros incorrectly.
Debugging move: Mark regrouping line.
Why it matters: Word-problem method may be intact. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 18: multiplication partial products
Separate model from arithmetic. Observed trace: One partial product shifted incorrectly.
Debugging move: Identify place-value alignment.
Why it matters: Algorithm errors have local origins. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 19: division quotient placement
Ask what the learner believed at that line. Observed trace: Digit placed in wrong column.
Debugging move: Mark place-value step.
Why it matters: Procedure diagnosis should be precise. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 20: remainder meaning
Repair only the layer that failed. Observed trace: Student calculates remainder correctly but reports wrong interpretation.
Debugging move: Mark answer-interpretation line.
Why it matters: Mathematics includes context after computation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 21: rounding too early
Do not erase the whole solution. Observed trace: Intermediate decimal rounded and final answer shifts.
Debugging move: Keep exact/intermediate precision until final step.
Why it matters: The first wrong line may be a premature approximation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 22: rounding wrong place
Mark the first line where validity breaks. Observed trace: Student rounds to wrong decimal place/significant figure.
Debugging move: Mark task interpretation/rounding line.
Why it matters: Answer-format errors are separate from solution logic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 23: graph scale misread
Separate model from arithmetic. Observed trace: Student reads one square as 1 instead of 5.
Debugging move: Mark scale decoding.
Why it matters: Everything downstream inherits the wrong value. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 24: table heading ignored
Ask what the learner believed at that line. Observed trace: Student uses wrong column.
Debugging move: Mark information selection.
Why it matters: Data reading can be first failure. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 25: picture graph key ignored
Repair only the layer that failed. Observed trace: Student counts icons without multiplying by key.
Debugging move: Mark representation decoding.
Why it matters: The visual key is mathematical information. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 26: pie chart proportion
Do not erase the whole solution. Observed trace: Student estimates sector without using given percentage/angle.
Debugging move: Mark representation choice.
Why it matters: Approximation may replace required relation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 27: angle theorem wrong
Mark the first line where validity breaks. Observed trace: Student chooses supplementary rather than vertically opposite.
Debugging move: Mark theorem selection.
Why it matters: Arithmetic subtraction is not the core issue. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 28: perimeter vs area
Separate model from arithmetic. Observed trace: Student chooses area formula.
Debugging move: Mark target concept.
Why it matters: Common topic confusion occurs before calculation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 29: area formula right, length wrong
Ask what the learner believed at that line. Observed trace: Student substitutes perimeter value.
Debugging move: Mark quantity identification.
Why it matters: Variables must correspond to formula. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 30: composite area
Repair only the layer that failed. Observed trace: Student double-counts overlap.
Debugging move: Mark decomposition diagram.
Why it matters: Spatial model is first break. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 31: volume
Do not erase the whole solution. Observed trace: Student uses square units.
Debugging move: Mark dimensional interpretation.
Why it matters: Unit can expose concept error. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 32: pattern next term
Mark the first line where validity breaks. Observed trace: Student notices difference but misses alternating rule.
Debugging move: Mark pattern model.
Why it matters: Pattern questions need evidence across terms. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 33: nth term
Separate model from arithmetic. Observed trace: Student gets next terms but no general rule.
Debugging move: Use position-value table.
Why it matters: Generalisation is a new step. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 34: logic problem
Ask what the learner believed at that line. Observed trace: Student guesses case.
Debugging move: Use systematic table/list.
Why it matters: Organisation is part of problem solving. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 35: Venn overlap
Repair only the layer that failed. Observed trace: Student counts overlap twice.
Debugging move: Mark region accounting.
Why it matters: Representation prevents double counting. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 36: set membership
Do not erase the whole solution. Observed trace: Student places item in wrong region.
Debugging move: Repair criterion before counting.
Why it matters: Classification/model error precedes arithmetic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 37: probability denominator
Mark the first line where validity breaks. Observed trace: Student counts outcomes incorrectly.
Debugging move: Build complete sample space.
Why it matters: Probability computation depends on model completeness. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 38: tree diagram
Separate model from arithmetic. Observed trace: Branch omitted.
Debugging move: Mark missing branch.
Why it matters: Later probability can be perfectly calculated on incomplete space. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 39: rate table
Ask what the learner believed at that line. Observed trace: Student swaps per-unit and total.
Debugging move: Label units in each column.
Why it matters: Unit meaning controls proportion. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 40: proportion additive thinking
Repair only the layer that failed. Observed trace: Student adds same amount instead of multiplying by scale factor.
Debugging move: Mark relation type.
Why it matters: Multiplicative structure is upstream. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 41: direct/inverse confusion
Do not erase the whole solution. Observed trace: Student assumes inverse because one variable falls.
Debugging move: Test ratio/product invariant.
Why it matters: Trend alone is weak model evidence. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 42: unknown position
Mark the first line where validity breaks. Observed trace: Student sees subtraction keywords but unknown is initial value.
Debugging move: Represent before choosing operation.
Why it matters: Keyword heuristics often create first wrong line. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 43: multi-step goal loss
Separate model from arithmetic. Observed trace: Student gets intermediate value then answers with it.
Debugging move: Write what each intermediate means.
Why it matters: State labels preserve target. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 44: extra information
Ask what the learner believed at that line. Observed trace: Student uses irrelevant number.
Debugging move: Mark data-selection line.
Why it matters: Not every given quantity belongs in the model. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 45: missing information
Repair only the layer that failed. Observed trace: Student invents a number.
Debugging move: State cannot determine or re-read.
Why it matters: Assumption can be first wrong line. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 46: keyword ‘altogether’
Do not erase the whole solution. Observed trace: Student automatically adds overlapping groups.
Debugging move: Model set/part relation.
Why it matters: Keywords are not operations. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 47: keyword ‘left’
Mark the first line where validity breaks. Observed trace: Student automatically subtracts.
Debugging move: Check whether ‘left’ describes remaining quantity after known change.
Why it matters: Context determines operation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 48: keyword ‘more than’
Separate model from arithmetic. Observed trace: Student confuses difference with times.
Debugging move: Use aligned bars.
Why it matters: Representation clarifies relation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 49: keyword ‘times’
Ask what the learner believed at that line. Observed trace: Student multiplies when phrase refers to time duration.
Debugging move: Use units and grammar.
Why it matters: Language ambiguity can cause model error. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 50: model choice
Repair only the layer that failed. Observed trace: Student draws bar for geometric layout.
Debugging move: Switch to spatial diagram.
Why it matters: A representation can be wrong even if neatly drawn. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 51: over-modeling
Do not erase the whole solution. Observed trace: Student spends time drawing for 7+8.
Debugging move: Use equation/mental method.
Why it matters: Efficiency is part of strategy selection. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 52: under-modeling
Mark the first line where validity breaks. Observed trace: Student holds four-stage problem mentally.
Debugging move: Externalise with table/bar.
Why it matters: Working memory failure can precede arithmetic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 53: bar labels
Separate model from arithmetic. Observed trace: Segments drawn but unlabeled.
Debugging move: Label quantity/unknown.
Why it matters: A model without semantics is fragile. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 54: equation labels
Ask what the learner believed at that line. Observed trace: x introduced but not defined.
Debugging move: State what x represents.
Why it matters: Symbol meaning matters. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 55: working backwards
Repair only the layer that failed. Observed trace: Student keeps applying forward operations.
Debugging move: Represent final state and reverse transitions.
Why it matters: Direction of reasoning can be first issue. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 56: before-after
Do not erase the whole solution. Observed trace: Student mixes initial and final values.
Debugging move: Use state table.
Why it matters: Temporal state must be externalised. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 57: constant total
Mark the first line where validity breaks. Observed trace: Transfer problem recalculates everything.
Debugging move: Identify invariant total.
Why it matters: Missing invariant is model-selection error. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 58: constant difference
Separate model from arithmetic. Observed trace: Student assumes both quantities change independently.
Debugging move: Track shared change/difference.
Why it matters: Invariant recognition supports reasoning. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 59: same total different groups
Ask what the learner believed at that line. Observed trace: Student adds totals twice.
Debugging move: Use whole-part representation.
Why it matters: Part-whole structure matters. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 60: guess-check random
Repair only the layer that failed. Observed trace: Student tries numbers without record.
Debugging move: Use organised table and update rule.
Why it matters: Strategy organisation is the first repair. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 61: working too compressed
Do not erase the whole solution. Observed trace: Student skips step where error happens mentally.
Debugging move: Write one operation per line.
Why it matters: Visible work makes diagnosis possible. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 62: working too verbose
Mark the first line where validity breaks. Observed trace: Student creates many unnecessary transformations.
Debugging move: Simplify after mechanism is stable.
Why it matters: Clutter can create copy errors. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 63: mental arithmetic overreach
Separate model from arithmetic. Observed trace: Student refuses written work and slips.
Debugging move: Externalise high-risk operations.
Why it matters: Strategy should match load. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 64: calculator dependence
Ask what the learner believed at that line. Observed trace: Primary task expects non-calculator paper skills where applicable.
Debugging move: Practise appropriate mental/written computation.
Why it matters: Tool availability is part of assessment context. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 65: checking by reread
Repair only the layer that failed. Observed trace: Student stares at same work.
Debugging move: Use inverse operation/estimate/alternate representation.
Why it matters: Checking should produce new evidence. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 66: inverse check
Do not erase the whole solution. Observed trace: Addition answer checked by subtraction.
Debugging move: Build operation-pair habits.
Why it matters: Verification can be systematic. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 67: substitution check
Mark the first line where validity breaks. Observed trace: Unknown solved; substitute into relation.
Debugging move: Use original equation/model.
Why it matters: Checking should return to source. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 68: estimate check
Separate model from arithmetic. Observed trace: Exact answer unreasonable.
Debugging move: Use magnitude benchmark.
Why it matters: Reasonableness can catch arithmetic/model errors. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 69: unit check
Ask what the learner believed at that line. Observed trace: Answer number plausible but unit wrong.
Debugging move: Include unit in final-state line.
Why it matters: Communication is part of correctness. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 70: question coverage
Repair only the layer that failed. Observed trace: Student answers first of two tasks.
Debugging move: Tick each requested part.
Why it matters: Multi-part interpretation precedes computation. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 71: support level
Do not erase the whole solution. Observed trace: Tutor points to exact wrong line.
Debugging move: Later ask student to find it unaided.
Why it matters: Diagnosis skill should transfer to learner. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 72: teacher correction
Mark the first line where validity breaks. Observed trace: Tutor crosses out whole solution.
Debugging move: Mark first break and preserve correct earlier work.
Why it matters: Protecting valid reasoning improves metacognition. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 73: student correction
Separate model from arithmetic. Observed trace: Learner rewrites complete solution from scratch.
Debugging move: First identify which lines were still valid.
Why it matters: Revision should be surgical. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 74: error emotion
Ask what the learner believed at that line. Observed trace: Student feels entire question is failure.
Debugging move: Show that only one line broke.
Why it matters: Localising error protects confidence and learning. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 75: careless label
Repair only the layer that failed. Observed trace: Parent says careless.
Debugging move: Name copy, sign, unit, scale, operation or target error.
Why it matters: Specific labels produce specific fixes. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 76: same answer wrong for different reason
Do not erase the whole solution. Observed trace: Two students both get 12.
Debugging move: Trace individual lines.
Why it matters: Final answer alone cannot diagnose. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 77: different answers same misconception
Mark the first line where validity breaks. Observed trace: Students make varied arithmetic after same wrong model.
Debugging move: Repair shared model.
Why it matters: Surface variation can hide common cause. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 78: same mechanism across topics
Separate model from arithmetic. Observed trace: Unit errors recur in speed, measurement and money.
Debugging move: Create cross-topic unit routine.
Why it matters: Mechanisms cut across chapters. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 79: chapter worksheet success
Ask what the learner believed at that line. Observed trace: Student gets topic-block work right.
Debugging move: Use mixed set to test model selection.
Why it matters: Blocked practice can hide selection weakness. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 80: fresh problem failure
Repair only the layer that failed. Observed trace: Student cannot transfer correction.
Debugging move: Return to relation and change surface gradually.
Why it matters: One corrected question is not mastery. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 81: immediate redo
Do not erase the whole solution. Observed trace: Student remembers answer route.
Debugging move: Use new numbers/context.
Why it matters: Memory can mimic learning. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 82: delayed retest
Mark the first line where validity breaks. Observed trace: Error returns after a week.
Debugging move: Space retrieval and add counterexample.
Why it matters: Durability matters. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 83: paper review
Separate model from arithmetic. Observed trace: Parent focuses only on mark.
Debugging move: Map lost marks to first wrong lines.
Why it matters: Paper becomes a diagnostic sample. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 84: full paper volume
Ask what the learner believed at that line. Observed trace: Student does many papers.
Debugging move: Pause when same first wrong line recurs.
Why it matters: Practice without repair rehearses error. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 85: revision plan
Repair only the layer that failed. Observed trace: Every topic receives equal time.
Debugging move: Allocate by recurrence and leverage.
Why it matters: Diagnostic evidence should shape schedule. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 86: AO1-like routine error
Do not erase the whole solution. Observed trace: Standard calculation fails.
Debugging move: Repair fact/procedure fluency.
Why it matters: Routine loss should not be dressed as reasoning issue. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 87: AO2-like application error
Mark the first line where validity breaks. Observed trace: Procedure known, context model wrong.
Debugging move: Practise translation/representation.
Why it matters: Application needs different repair. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 88: AO3-like strategy error
Separate model from arithmetic. Observed trace: Student cannot select route.
Debugging move: Use mixed, non-routine comparisons.
Why it matters: Reasoning/selection requires ambiguity. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 89: time pressure
Ask what the learner believed at that line. Observed trace: First wrong line occurs only late in paper.
Debugging move: Test fatigue and pacing.
Why it matters: Context can change mechanism. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 90: prompt pressure
Repair only the layer that failed. Observed trace: Student gets line right only after hint.
Debugging move: Record support level.
Why it matters: Correctness should not hide dependence. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 91: confidence mismatch
Do not erase the whole solution. Observed trace: Student is very certain about wrong first step.
Debugging move: Ask for evidence and alternative representation.
Why it matters: Calibration belongs in diagnosis. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Redo with new numbers. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 92: low confidence correct step
Mark the first line where validity breaks. Observed trace: Student changes valid work.
Debugging move: Teach evidence-based editing.
Why it matters: Checking can create first wrong line after a correct solution. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Use an alternate representation. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 93: historical Punggol wording
Separate model from arithmetic. Observed trace: Legacy URL remains.
Debugging move: Route current local intent to eduKatePunggol.com.
Why it matters: Archive owner should be diagnostic learning, not branch claim. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Explain why the original line was invalid. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 94: 2026 PSLE context
Ask what the learner believed at that line. Observed trace: Primary learner prepares under syllabus 0008.
Debugging move: Connect first-wrong-line diagnosis to AO1/AO2/AO3.
Why it matters: Official assessment objectives help interpret mechanism. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Return after delay. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
First-Wrong-Line Clinic 95: independence endpoint
Repair only the layer that failed. Observed trace: Student circles first wrong line before seeing answer key.
Debugging move: Fade tutor diagnosis.
Why it matters: The learner should eventually debug their own mathematics. Precise error localisation prevents the learner from practising things they already understand.
Layer check: classify the first break as task reading, representation, operation/model, arithmetic, interpretation or checking. Later wrong lines may simply inherit the earlier error.
Preservation check: identify what remained correct before the break. The learner should leave the correction knowing both what to keep and what to change.
Verification: Mix with a different problem type. A local correction becomes learning only when the same mechanism stays correct in a fresh task.
Support check: record whether the learner found the wrong line independently or after a prompt. Debugging independence is part of progress.
Exit criterion: the skill is stable when the learner can inspect a wrong solution, locate the earliest invalid step, explain it and repair the mechanism without rewriting everything.
Why Whole-Question Correction Can Be Wasteful
If a child chose the correct bar model, formed the correct equation and then made one subtraction error, reteaching the word problem can create frustration without addressing the cause. Conversely, if the arithmetic is flawless but the bar model is wrong, ten more computation drills will not help.
The first wrong line tells us where the intervention belongs.
Turn Error Review into Debugging
Ask the learner to use three marks: ✓ for lines that remain valid, ○ around the first wrong line, and → for the corrected move. This makes the solution history visible. The learner sees that an error is local and repairable rather than proof that the whole problem was incomprehensible.
Over time, the tutor should stop supplying the circle.
Link to AO1, AO2 and AO3
A first wrong line can also help interpret SEAB’s 2026 PSLE Mathematics assessment objectives. Routine fact/procedure breaks often sit closer to AO1; context translation and application failures often sit in AO2; strategy selection and inference failures often sit in AO3. The AO label does not replace mechanism diagnosis, but it helps organise patterns across a paper.
SEAB 2026 PSLE Mathematics syllabus 0008.
Historical Local Wording and Current Punggol Routing
This URL belongs to eduKateSG’s legacy Punggol archive. Current programme details should not be inferred from the old location wording. For current Punggol-facing information, use eduKatePunggol.com.
Related eduKateSG Routes
PSLE Mathematics 2026 | Diagnose AO1, AO2 and AO3 Before Chasing the Total Score.
Primary Mathematics | Bar Model, Table, Diagram or Equation?.
Frequently Asked Questions
What is the first wrong line?
The earliest step where a previously valid mathematical state becomes invalid.
Why preserve earlier correct lines?
They show what the learner already understands and prevent unnecessary reteaching.
Can the first wrong line occur before calculation?
Yes. Misreading the target or building the wrong representation may be the root error.
What if the model is correct but arithmetic is wrong?
Repair arithmetic rather than reteaching the whole topic.
What if the arithmetic is correct but answer is wrong?
Check representation, operation choice, units and interpretation.
Should the learner redo the same question?
They can, but a fresh analogous problem is stronger evidence of repair.
How does this connect to AO1/AO2/AO3?
The first wrong line helps identify whether the failure was routine procedure, application/translation or strategy/reasoning.
How should an error log be written?
Record the mechanism and first wrong line, not only the chapter name.
What is the end goal?
The learner can debug and repair their own mathematics before seeing the answer key.
Where should families look for current Punggol information?
Use eduKatePunggol.com for current local-facing information.
The Larger Lesson
A wrong answer is the end of an error trail, not necessarily the beginning.
Trace the working upward. Keep the valid lines. Find the first break. Repair that mechanism and test it somewhere new. The result is less practice, but better practice—because the learner is fixing the place where the mathematics actually went wrong.