Generates cascading hint sequences for educational problem types, progressing from general to specific without giving answers. Use for designing tutoring dialogues or scaffolded worksheets.
npx claudepluginhub garethmanning/claude-education-skills --plugin claude-education-skillsThis skill uses the workspace's default tool permissions.
Designs a cascading hint sequence for a specific problem type — a series of progressively more revealing hints that help students move past sticking points without simply giving them the answer. This is one of the most technically demanding aspects of intelligent tutoring system (ITS) design. The critical insight from VanLehn's (2011) meta-analysis is that the effectiveness of tutoring (human o...
Designs worked example fading sequences from fully worked examples through completion problems to independent practice for teaching procedures, algorithms, or multi-step processes to novice learners.
Guides empathetic AI-assisted teaching with boundaries, scaffolding from reflection prompts to targeted feedback for explaining concepts or helping struggling learners.
Provides UI/UX resources: 50+ styles, color palettes, font pairings, guidelines, charts for web/mobile across React, Next.js, Vue, Svelte, Tailwind, React Native, Flutter. Aids planning, building, reviewing interfaces.
Share bugs, ideas, or general feedback.
Designs a cascading hint sequence for a specific problem type — a series of progressively more revealing hints that help students move past sticking points without simply giving them the answer. This is one of the most technically demanding aspects of intelligent tutoring system (ITS) design. The critical insight from VanLehn's (2011) meta-analysis is that the effectiveness of tutoring (human or AI) depends heavily on the quality of the scaffolding — and hint sequences are the primary scaffolding mechanism. Get the sequence wrong and you either frustrate students (hints too vague, too few) or steal their learning (hints too specific, too early). The output includes the complete hint cascade (typically 3–5 levels from general strategic guidance to specific procedural nudge), a design rationale explaining the cognitive function of each level, trigger conditions (when each hint fires), and a bottom-out strategy (what happens when hints are exhausted). AI is specifically valuable here because designing effective hint sequences requires simultaneously anticipating student errors, calibrating hint specificity, and ensuring that each hint level provides just enough information to unstick the student without bypassing the cognitive work that produces learning.
VanLehn (2011) conducted the most comprehensive meta-analysis of tutoring effectiveness, comparing human tutoring, intelligent tutoring systems, and other approaches. He found ITS effect sizes averaging 0.76 — remarkably close to human tutoring (0.79) and substantially higher than "no tutoring" conditions. Critically, ITS effectiveness depended on the quality of the step-level interaction: systems that provided feedback and hints at each problem-solving step (inner loop) were much more effective than systems that only evaluated the final answer (outer loop). Aleven & Koedinger (2002) studied hint-seeking behaviour in the Carnegie Learning Cognitive Tutor and found that students often used hints suboptimally — either requesting hints too quickly (before attempting the problem) or too slowly (struggling unproductively). They found that training students in a metacognitive hint strategy ("try first, then ask for a hint, then explain the hint to yourself") significantly improved learning outcomes. Razzaq & Heffernan (2010) compared proactive hints (given automatically) with reactive hints (given on request) and found that the optimal approach depended on student proficiency: lower-performing students benefited more from proactive hints, while higher-performing students benefited from being allowed to struggle before requesting help. Shute (2008) reviewed formative feedback research and identified that effective feedback is specific, timely, and actionable — principles that apply directly to hint design. Wood, Bruner & Ross (1976) established the concept of scaffolding: providing temporary support that enables the learner to accomplish what they cannot do alone, then gradually withdrawing the support as competence develops.
The teacher must provide:
Optional (injected by context engine if available):
You are an expert in hint sequence design for intelligent tutoring systems, with deep knowledge of VanLehn's (2011) meta-analysis of ITS effectiveness, Aleven & Koedinger's (2002) research on hint-seeking behaviour, Razzaq & Heffernan's (2010) work on proactive vs. reactive hints, Shute's (2008) formative feedback principles, and Wood, Bruner & Ross's (1976) scaffolding framework. You understand that hint design is the hardest part of ITS design: too little help produces frustration and abandonment; too much help produces answer-copying without learning. The optimal hint sequence progressively reduces the cognitive work required while preserving as much productive struggle as possible.
CRITICAL PRINCIPLES:
- **Progressive specificity.** The first hint should be the MOST GENERAL — pointing the student toward the right strategy or concept without revealing the specific step. Each subsequent hint should be more specific, narrowing the cognitive search space while still requiring the student to do some thinking. The final hint (the "bottom-out hint") may reveal the specific step but should still require the student to execute it and understand why.
- **Each hint should do ONE thing.** A hint that says "Remember to isolate the variable by subtracting 7 from both sides and then dividing by 3" is not a hint — it's the answer in disguise. Each hint level should address ONE aspect of the sticking point.
- **Hints should address the CAUSE of the error, not just the symptom.** If a student gets 3x + 7 = 22 wrong, the hint should not just say "Try again" (too vague) or "x = 5" (the answer). It should address the likely CAUSE: "What operation will move the 7 to the other side?" — targeting the specific conceptual gap.
- **Trigger conditions matter as much as hint content.** When a hint fires is as important as what it says. Too early: the student doesn't get the chance to struggle productively. Too late: the student has given up. Design triggers based on observable behaviour: time elapsed, number of incorrect attempts, specific error patterns, or student request.
- **The bottom-out strategy must still produce learning.** When all hints are exhausted, the system cannot just shrug and move on. The bottom-out should provide the answer WITH a self-explanation prompt: "The answer is X because Y. In your own words, explain why Y leads to X." This converts the bottom-out from answer-giving to learning.
Your task is to design a hint sequence for:
**Problem type:** {{problem_type}}
**Common sticking points:** {{common_sticking_points}}
The following optional context may or may not be provided. Use whatever is available; ignore any fields marked "not provided."
**Student level:** {{student_level}} — if not provided, design for a general secondary school context.
**Subject area:** {{subject_area}} — if not provided, infer from the problem type.
**Delivery context:** {{delivery_context}} — if not provided, design for an AI tutoring system that can also be used by teachers.
**Number of hint levels:** {{number_of_hint_levels}} — if not provided, design 4 levels (strategic → conceptual → procedural → bottom-out).
**Final hint policy:** {{final_hint_policy}} — if not provided, design a bottom-out hint with self-explanation prompt.
Return your output in this exact format:
## Adaptive Hint Sequence: [Problem Type]
**Problem type:** [What students are solving]
**Common sticking points:** [Where they get stuck]
**Hint levels:** [How many levels, from general to specific]
### Hint Architecture
[Overview of the hint strategy — what each level does and why the sequence is ordered this way]
### Hint Sequence
For each level:
**Level [N]: [Hint type — Strategic / Conceptual / Procedural / Bottom-out]**
- **Hint text:** [Exactly what the student sees or hears]
- **Cognitive function:** [What this hint does — what cognitive work it performs for the student and what it preserves for them to do]
- **Trigger condition:** [When this hint fires — time, errors, request, behaviour]
- **Expected student response:** [What a student who benefits from this hint will do next]
- **If this hint doesn't help:** [What happens — escalate to next level]
### Bottom-Out Strategy
[What happens when all hints are exhausted — the specific design for revealing the answer while still producing learning]
### Trigger Conditions Summary
| Trigger Type | Condition | Hint Level Activated |
|---|---|---|
| [Type] | [Specific condition] | [Which level] |
### Adaptation Notes
[How the sequence adapts to different student profiles — stronger students may skip early levels; weaker students may need the full cascade]
**Self-check before returning output:** Verify that (a) hints are progressively more specific, (b) each hint does ONE thing, (c) hints address the cause of the error not just the symptom, (d) trigger conditions are specified, (e) the bottom-out still produces learning, and (f) the sequence preserves productive struggle.
Scenario: Problem type: "Solving linear equations with one unknown — specifically equations of the form ax + b = c, where students must isolate x. Example: 3x + 7 = 22" / Common sticking points: "Students forget to perform the same operation on both sides (they subtract 7 from the left but not the right). Students don't understand the inverse operation concept (they add when they should subtract, or vice versa). Students attempt operations in the wrong order (dividing by 3 before subtracting 7)." / Delivery context: "AI tutoring system — hints appear on screen when triggered" / Student level: "Year 8, first term of algebra"
Problem type: Solving linear equations with one unknown — isolating x in equations like 3x + 7 = 22 Common sticking points: Same-operation-both-sides errors, inverse operation confusion, wrong operation order Hint levels: 4 (strategic → conceptual → procedural → bottom-out)
The sequence moves from STRATEGIC (pointing toward an approach) through CONCEPTUAL (activating the relevant principle) to PROCEDURAL (indicating the specific step) to BOTTOM-OUT (revealing the step with self-explanation). At each level, the student retains some cognitive work:
Level 1: Strategic — "What's your goal?"
Level 2: Conceptual — "Which number first, and what's its opposite?"
Level 3: Procedural — "Do the same thing to both sides"
Level 4: Bottom-out — "Here's the step. Explain why."
The bottom-out hint reveals the complete solution but requires a self-explanation before the student can proceed to the next problem. The system presents two prompts:
If the student's self-explanation is accurate, proceed to the next problem (a similar equation, to test immediate application). If the self-explanation is inaccurate ("because 7 is smaller than 22"), provide a brief corrective explanation and then proceed. The bottom-out is NOT a failure state — it is a learning event. The self-explanation converts answer-giving into understanding-building.
| Trigger Type | Condition | Hint Level Activated |
|---|---|---|
| Time-based | 60 seconds with no progress | Level 1 |
| Error-based | Incorrect final answer with no working shown | Level 1 |
| Error-based | Incorrect operation (e.g., dividing before subtracting) | Level 2 |
| Error-based | Correct operation applied to only one side | Level 3 |
| Request-based | Student clicks "hint" button | Next level in sequence |
| Exhaustion | All previous hints delivered, still stuck | Level 4 (Bottom-out) |
For stronger students: If a student has successfully solved 3+ similar equations, skip Level 1 (they know the strategy). Start at Level 2 if they make an error — their sticking point is likely conceptual or procedural, not strategic.
For weaker students: If a student has needed the bottom-out hint on the previous 2 problems, consider switching from hints to a worked example — the student may lack the prerequisite knowledge that hints assume. Hints scaffold problem-solving; they don't teach foundational concepts.
For hint-abusers (Aleven & Koedinger, 2002): If a student rapidly clicks through hints without attempting the problem, insert a "try first" prompt before the first hint: "Have a go at the problem before asking for a hint. What's your best guess for the first step?" This addresses the metacognitive deficit: the student has learned to extract answers from hints rather than to think.
Hint sequences assume the student has the prerequisite knowledge to benefit from hints. A hint that says "What's the opposite of adding 7?" assumes the student understands inverse operations. If they don't, no hint in this sequence will help — they need direct instruction on the prerequisite concept. Hint sequences scaffold PROBLEM-SOLVING, not KNOWLEDGE ACQUISITION. A student who lacks foundational knowledge needs a different intervention.
The optimal hint trigger is still an open research question. Razzaq & Heffernan (2010) found that proactive hints help weaker students and reactive hints help stronger students, but the field has not converged on a definitive trigger model. The trigger conditions above are reasonable defaults, not empirically optimised thresholds. In a real ITS, these would need to be calibrated through A/B testing with the actual student population.
Hint quality depends on accurate diagnosis of the error. The hint sequence above assumes specific error patterns (wrong operation order, one-sided operation, inverse confusion). If the student's actual error is different (e.g., an arithmetic mistake on 22 - 7), the hints will miss the mark. Effective hint systems need error-specific branching, not just linear cascades — which is significantly more complex to design.