# Worked Examples vs AI Hints: When Each Wins, and How to Judge

Ethan Price · August 25, 2026

> Worked Examples vs AI Hints: When Each Wins, and How to Judge. Start with a number that looks like an answer: 76%. It is the input-to...

| Takeaway | Detail |
| --- | --- |
| No head-to-head RCT exists yet | None of the 16 fetched sources reports a randomized trial comparing worked examples against AI-generated hints — no effect size, sample size, confidence interval, or p-value — so any tidy winner figure like 20% imported into this debate is borrowed from another domain. |
| Examples beat instructions — but so far only for machines | In the LEAP prompting study (PMC10760264), instruction-plus-example prompts substantially raised F1-scores over instruction-only baselines across tested models; before treating a gain like 40% as transferable, note it measures LLM task performance, not student post-tests. |
| Adaptive hints work through a user model, not scale | Adaptive hypermedia must meet three criteria — a hypertext system, a user model, and adaptation driven by that model — tailoring material to goals, abilities, and cognitive load; a product claiming uniform gains such as 76% for every learner is not describing this mechanism. |
| Recycled agent metrics are the biggest trap in this space | Paper Lantern's +20% answer quality, -40% tool calls, and -76% input tokens all measure research-informed coding agents; none comes from a worked-examples-versus-hints learning experiment, so repurposing them as tutorial-design evidence would be misattribution. |

Start with a number that looks like an answer: 76%. It is the input-token reduction Paper Lantern claims for its research-informed coding agents — impressive, and entirely beside the question of whether worked examples or adaptive AI hints produce larger post-test learning gains. The same holds for its 20% answer-quality lift and 40% reduction in tool calls: agent benchmarks, not classroom evidence.

The harder truth: no published randomized controlled trial directly compares worked examples against AI-generated hints on post-test scores. None of the 16 fetched sources contains such an effect size, confidence interval, or p-value. The closest hard evidence is indirect — the LEAP prompting study, where adding worked-style examples to instructions lifted F1-scores above instruction-only baselines across tested models. That is an LLM analogue of 'examples beat instructions,' not proof about human learners.

What survives scrutiny is mechanism. Adaptive hint systems earn their advantage the way adaptive hypermedia always has: by holding a user model — goals, abilities, prior knowledge — and adapting material to shape cognitive load. Judging any tutorial design therefore comes down to three checks: Is there a genuine user model? Did the numbers come from learners rather than software agents? And does the mid-lesson switch — worked example first, hints after errors — track measured mistakes instead of vendor percentages?

![Worked Examples vs AI Hints](https://static.mm-ais.com/article-images-ai/worked-examples-vs-ai-hints-when-each-wi-ai-7663e942.jpg)

## How It Works

Which design "wins" on a post-test is not a property of either design — it's a property of where the learner sits on the expertise curve at that moment. Both formats run on the same cognitive engine and differ only in who controls the load. A worked example hands over a fully solved problem so working memory spends its capacity extracting the solution schema instead of searching for one — the move Sweller's cognitive load tradition formalized as the worked-example effect. An adaptive AI hint does the opposite: it deliberately preserves the search, then meters out just enough information — a nudge, a subgoal, a partial constraint — to keep the struggle productive rather than overwhelming.

The switch point has a name: the expertise reversal effect. Guidance that accelerates novices actively impairs more advanced learners, because redundant support consumes the very capacity it was meant to free. Adaptive systems operationalize this with a learner model — most commonly some flavor of Bayesian knowledge tracing or a thresholded error-rate rule — that fades hints as estimated mastery climbs. The practical consequence for anyone building tutorials: "when to switch mid-lesson" is not answered by pedagogy alone. It is answered by whatever mastery threshold your platform ships with, and those defaults differ enough between vendors that reading the documentation is the difference between correct fading and premature withdrawal of support.

Two distinctions from the current literature sharpen the vocabulary. According to Mattie Farrer of ClickView, adaptive teaching differs from differentiation in exactly the way these two tutorial formats differ from each other: differentiation plans alternate routes for groups before the lesson starts — structurally identical to a fixed worked-example sequence — while adaptive teaching adjusts in real time from in-lesson evidence, which is the logic an AI hint engine implements. Separately, according to the LLM Instruction-Example Adaptive Prompting (LEAP) Framework — the only named AI-plus-examples mechanism appearing in the published corpus — adaptation in LLM-based tutors happens at prompt-construction time: the framework specifies how instruction and worked examples are reformatted into the model's prompts, meaning the pedagogical sequencing lives upstream of the model, not inside it.

One myth worth retiring here: the claim that conventional example-first instruction wastes money on unnecessary steps. The mechanism argues the opposite — for a novice, the "extra" step of studying a complete solution is precisely the load-reduction move that makes subsequent practice efficient. Waste appears only when examples persist past the reversal point, which is a tuning failure, not a design failure.

If you want to verify the head-to-head effect sizes yourself, go to the primary RCT reports rather than secondary summaries. The field's active venue is the Journal of Adaptive Learning Technologies, which per its issue listing has reached Volume 3, Number 4 in 2026. Reported gains vary by domain, prior-knowledge split, and hint granularity, so treat any single headline figure as provisional until you have checked the moderator variables in the original trial.

| Term | Mechanism | Design consequence |
| --- | --- | --- |
| Worked example | Fully solved problem studied before independent practice; removes search demands from working memory | Cheapest route to initial schemas for true novices |
| Faded (completion) problem | Example with the final step(s) blanked for the learner to finish | The standard bridge between studying and solving |
| Adaptive AI hint | Feedback metered by a learner model (knowledge-tracing estimate or error-rate threshold) | Preserves productive struggle; scales per learner |
| Expertise reversal effect | Guidance that helps novices impairs advanced learners | Sets the mid-lesson switch point; ignoring it makes examples backfire |
| Differentiation (Farrer, ClickView) | Pre-planned alternate routes assigned to groups before teaching begins | Static by design; mirrors fixed example sequences |
| Adaptive teaching (Farrer, ClickView) | Real-time adjustment driven by in-lesson evidence | Dynamic; mirrors AI-hint engines |
| LEAP Framework | Specifies how instruction and examples are adapted into LLM prompts | Sequencing lives upstream of the model, at prompt construction |

Concrete next action: before your next build, open your platform's mastery-threshold settings and record the exact criterion that triggers hint-to-example or example-to-practice transitions. If you cannot find that number in the documentation, the system's "adaptive" label is marketing, not mechanism.

![How It Works — Worked Examples vs AI Hints](https://static.mm-ais.com/article-images-ai/worked-examples-vs-ai-hints-when-each-wi-ai-2aebb7b8.jpg)

## Key Factors to Consider

Run any "adaptive AI hint" product through the three-part test that defines the field: according to the adaptive-hypermedia entry on Wikipedia, a system qualifies as adaptive only if it is a hypertext/hypermedia system, maintains a user model, and uses that model to change what the learner sees next. Most hint engines pass parts one and three and quietly fail part two — they branch on clicks and response latency, not on an estimated knowledge state. That is decision criterion one, because a switch rule keyed to a proxy is unfalsifiable: you cannot tell whether the hint logic or mere interruption moved your post-test.

Criterion two comes from an unlikely place. According to the stage-one design reported in the PMC-indexed study PMC10760264, researchers isolating which demonstration components drive LLM clinical-data extraction split task descriptions from examples, then tested the combinations — a factorial decomposition rather than a whole-format shootout. Port that discipline to tutorials: before adjudicating worked examples versus hints, run the description, the example, and the hint as separate arms. Whole-format A/B tests average over exactly the interactions you needed to observe.

Criterion three is construct alignment. According to the April 23 adaptive-content guide, adaptive content is sold as "not just about getting more conversions—it's a response to how people now use the internet," set against "old-style static content." Import that frame into courseware and you optimize the wrong dependent variable: conversion proxies reward interruption; post-test gains punish it. Vocabulary hides the same trap — Frontiers currently lists Alomari E's work on prompt-guided conditioning for clinically realistic synthetic pediatric data, where "adaptive" means steering generation outputs, not modeling learners. Always ask vendors which side adapts.

Now the numbers that matter, starting with the ones that don't. According to Paper Lantern's published benchmarks (paperlantern.ai), its +20% answer-quality gain, −40% reduction in tool calls, and −76% cut in input tokens all come from research-informed coding agents — efficiency telemetry for software agents, not effect sizes for human post-tests. Kill the budget myth here too: the belief that a conventional worked-example-first lesson wastes money on unnecessary steps gets the accounting backwards. A fully worked step carries roughly zero marginal delivery cost; the expensive artifact is adaptivity purchased without a user model, because you pay indefinitely for branching that never touches the learner-model variable. The only figure class entitled to move your switch decision is a post-test effect size computed inside prior-knowledge strata from an RCT — pooled averages bury the crossover covered earlier in this guide, so demand the stratified estimate or disregard the paper.

| Decision factor | Figure (source) | What it actually measures | Verdict |
| --- | --- | --- | --- |
| Adaptivity eligibility | 3 required criteria (Wikipedia, adaptive hypermedia) | User-model presence, not interface polish | Fail criterion 2 → ship worked examples |
| Pre-launch test design | 2 components isolated first (PMC10760264) | Description vs. example vs. combination | Factorial arms beat format A/B |
| Quality-lift claim | +20% (Paper Lantern) | Coding-agent answer quality | Exclude from tutorial ROI |
| Efficiency claim | −40% tool calls (Paper Lantern) | Agent workflow cost | Exclude |
| Cost claim | −76% input tokens (Paper Lantern) | Infrastructure spend | Exclude |
| Framing check | April 23 guide, conversion-first pitch | Marketing dependent variable | Reject for post-test decisions |
| Switch trigger | 1 admissible class: stratified post-test effect size (RCT) | Learning gain within a knowledge band | Adopt as the sole go/no-go figure |

Concrete next step: before your next procurement call, ask the vendor to print one learner's user model after a handful of items — an ability estimate with an uncertainty value, updated per response. If the demo shows a topic tag or a streak counter instead, you are evaluating branching content, and the rational spend is a tighter worked-example sequence until a real model exists.

![Key Factors to Consider — Worked Examples vs AI Hints](https://static.mm-ais.com/article-images-pixabay/worked-examples-vs-ai-hints-when-each-wi-a8475c1f.jpg)

## Common Mistakes

The expensive mistake in this decision isn't picking the wrong format — it's citing a head-to-head effect size that was never measured. Of the sixteen sources retrieved for this guide, none reports a randomized controlled trial comparing worked examples against AI-generated hints for learners: no effect size, sample size, confidence interval, or p-value for that specific pairing exists anywhere in the set. As of 2026, the field's favorite debate is outrunning its own evidence base, and two recurring errors show precisely where teams get burned.

**Pitfall 1: Laundering adjacent studies into classroom claims.** The closest match in the source set is the LEAP paper (Instruction-Example Adaptive Prompting), which demonstrates that adding worked-style examples to prompts lifts task performance — an "Instruction + Options + Examples" configuration substantially raised F1-scores over a plain "Instruction + Options" baseline across tested models. That is a genuine "examples beat instructions" result, and LEAP even formalizes the adaptive half with two prompt types: one inserted before the instruction, another before the examples. But the dependent variable is model output quality, not a human post-test. Cite it in a prompt-engineering spec and it holds; drop it into a slide justifying a tutorial redesign and you've committed a one-hop abstraction error. The screening trap compounds this: keyword searches on "adaptive" learning surface asymmetric adaptive clipping in GRPO, ventilator set-point adaptation, and stereo-matching cost aggregation — none of which involve learner instruction at all. And notice the popular myth runs backwards here: the conventional worked-example sequence is not the line item wasting money; the budget risk sits in procurement and switch policies built on evidence that was never collected.

**Pitfall 2: Treating "hint" and "worked example" as interchangeable labels.** Practitioner commentary on LinkedIn comparing assistive and adaptive technology states the general failure plainly — "the assistive vs. adaptive distinction is something teams often blur" — and the same blur infects this pair. Consider a platform that markets "adaptive AI hints" but whose escalation ladder terminates in fully worked solutions after repeated failed attempts. Key your mid-lesson switch rule to "hints requested" and your telemetry is silently counting worked-example exposure. Run an A/B test under that labeling and a null result gets read as "hints don't help," when the study never isolated a hint-only condition. The fix costs nothing: before wiring any switching logic, write down the exact intervention granularity (next-step hint, first-step hint, full solution) and the exact outcome unit (learner post-test score versus benchmark F1), then reject any citation whose units fail to match both columns.

| Claim you'll encounter | What the evidence actually is | Safe verdict |
| --- | --- | --- |
| "Worked examples beat AI hints — RCT-proven" | 0 of 16 retrieved sources contain that head-to-head learner trial | Unverified — demand the randomization unit before accepting any effect size |
| LEAP: added examples lift performance | F1-score gains over an Instruction + Options baseline across tested models | Valid for prompt design only; not a learner post-test |
| LEAP's "adaptive" component | Two prompt types — one before the instruction, one before the examples (soft vectors placed between task description and examples, Figure 3c) | Borrow the placement logic; do not import the gains |
| Product labeled "adaptive AI hints" | Escalation may end in full worked solutions (label blur, per the assistive-vs-adaptive commentary) | Audit the escalation ladder before keying switch rules to hint counts |
| Search hits on "adaptive" + learning | GRPO clipping, ventilator set-point adaptation, stereo-matching aggregation — no learner instruction | Screen out at the title stage |

![Common Mistakes — Worked Examples vs AI Hints](https://static.mm-ais.com/article-images-pixabay/worked-examples-vs-ai-hints-when-each-wi-4fd7803b.jpg)

## Insider Tactics

Change one default before you compare formats at all: make the second hint unreachable until the learner has typed at least one attempt. In the Cognitive Tutor geometry classrooms that Vincent Aleven and Kenneth Koedinger analyzed at Carnegie Mellon, a substantial share of students clicked straight through hint levels to the bottom-out answer — the fully worked solution — without processing the intermediate steps, and that click-through pattern tracked with weaker post-test performance. Current-generation systems such as ASSISTments and Carnegie Learning's MATHia log hint usage precisely so instructors can catch this behavior. Attempt-gating costs nothing to configure and applies whether your lesson opens with worked examples or with AI hints.

The mechanism: a gated hint converts passive answer-receipt into earned information. The learner commits to a step, succeeds or fails visibly, and only then receives the next scaffold — which functions as a self-explanation prompt, the ingredient Alexander Renkl's fading studies identify as what makes example study productive. Gating therefore lets a single lesson run both formats in series, dissolving the either-or purchasing decision instead of relitigating it.

Timing tip: let the learner model trigger the switch, not the clock. According to the Wikipedia entry on adaptive hypermedia, a system qualifies as adaptive only when it tailors links and content to a running model of each user's goals, preferences, and knowledge. Hold your mid-lesson handoff to that same bar: move from worked examples to hint-gated practice at the first unassisted correct step the model records, not at a fixed item count or minute mark. Exact thresholds vary by platform and domain, so read your vendor's mastery-model documentation rather than importing another course's schedule.

Two edge cases invert the playbook. For stronger learners, expect the expertise-reversal pattern Kalyuga and Sweller documented: scaffolding that accelerates novices depresses their scores, so open their lessons with unscaffolded problems and keep worked examples in reserve for the specific steps they miss. And when someone proposes trimming the example phase to compress seat time — the "unnecessary steps" argument — decline it. The example phase is where schemas form at the lowest cost per minute; deleting it does not save money, it relocates spending to remediation and retakes once post-test results arrive.

Action for this week: export your hint logs and count how many hint sequences terminated in a bottom-out answer with zero recorded attempts beforehand. Any nonzero count means attempt-gating is off — and correcting that setting is cheaper than re-licensing a different tutorial product.

| Learner-model signal | Tactic | Why it beats a fixed schedule |
| --- | --- | --- |
| First unassisted correct step logged | Switch the next item to hint-gated practice | Fires on demonstrated schema, honoring the model-driven definition of adaptivity |
| Hint opened before any attempt | Lock level-two hints behind one typed response | Blocks the bottom-out click-through Aleven and Koedinger tied to weaker outcomes |
| Repeated errors on the same step type | Drop back to a faded example with the final step blank | Rebuilds the missing sub-schema instead of stacking more hints |
| Learner clears the placement check easily | Invert the order: problems first, examples on demand | Avoids the expertise reversal Kalyuga and Sweller identified |
| Timed, high-stakes session approaching | Delay the switch by one extra practice cycle | Overlearning the steps protects performance under pressure |

![Insider Tactics — Worked Examples vs AI Hints](https://static.mm-ais.com/article-images-pixabay/worked-examples-vs-ai-hints-when-each-wi-05e786f8.jpg)

## Comparison

Cognitive Tutor geometry classrooms gave this field its closest thing to a controlled duel. In the trial Schwonke, Renkl, Aleven, and colleagues published in *Computers in Human Behavior*, students who studied worked examples embedded in the tutor posted statistically indistinguishable post-test scores from students who solved tutored problems — but the worked-example group got there in markedly less time at the tutor. Read that correctly: on raw post-test means, this rivalry usually ends in a tie. The tiebreakers live elsewhere — in minutes per competency, in who is sitting in the room, and in how fast the scaffolding should disappear.

The tie is the theoretically expected result, and the mechanism explains when it breaks. According to Wikipedia's adaptive-hypermedia entry, an adaptive system selects material by the learner's goals, abilities, needs, interests, and existing knowledge specifically to shape cognitive load. A worked example performs the same service with a fixed script: the author pre-computes the load for an imagined median novice. When the room actually resembles that imagined novice, the script wins because it costs nothing to run. When the room diverges — wider ability spread, unpredictable misconceptions — the script misprices load for part of the class, and adaptive selection starts paying rent. Kalyuga, Ayres, Chandler, and Sweller's expertise-reversal review (*Educational Psychologist*) supplies the flip side: as prior knowledge grows, the same scaffolding that carried beginners begins dragging stronger learners, so neither format's advantage is stationary across a unit.

Treat the tie as a cost question. If you've absorbed the claim that the conventional worked-example sequence wastes effort on unnecessary steps, the timing evidence runs the opposite way: those "redundant" studied steps are precisely what eliminates slow, failure-riddled practice attempts, and failed attempts are where the minutes go. Two practical consequences follow. First, whenever a study reports both arms, divide post-test gain by tutor minutes — arms almost never equate time-on-task, and the format that looked weaker on the mean frequently wins on gain per minute. Second, calibrate expectations: VanLehn's synthesis in *Educational Psychologist* found step-based intelligent tutors already approaching human-tutoring effectiveness, so marginal hint-quality improvements move the needle less than changing the ratio of studied examples to independent practice.

Defaults for a 2026 build: choose worked examples when the cohort is novice-heavy and the procedure is algorithmic; choose adaptive hints when one lesson must serve a wide ability spread or the task is open-ended enough that you cannot enumerate the error space in advance. Note the generative-AI shift — hint engines that compose guidance per response have relaxed the old requirement to hand-author an error taxonomy per problem, tilting open-ended tasks toward hints more than the pre-LLM literature suggests. Switch mid-lesson on evidence, not on a clock: after a fully worked step, issue the next one as a completion problem; if the learner completes two consecutive faded steps unprompted, retire that scaffold; if they stall, fall back to attempt-gated hints (second hint locked until a first attempt, as covered above). Those counts are starting defaults to tune against your own error logs, not constants from a trial.

| Decision situation | Pick | Evidence anchor and why it wins |
| --- | --- | --- |
| Novice-heavy cohort, algorithmic procedure | Worked examples, then faded completion problems | Studied steps cut failed-attempt time; Kalyuga et al. marks where the advantage stops |
| One lesson serving a wide ability spread | Adaptive AI hints | Adaptive-hypermedia principle (Wikipedia entry): selection keyed to ability and knowledge shapes load per learner |
| Fixed lab minutes, post-test imminent | Worked examples | Schwonke et al.: matched post-test at markedly lower tutor time |
| Open-ended task, error space unknown | Adaptive hints, LLM-generated | Pre-LLM tutors needed hand-authored error taxonomies; current generators remove that constraint |
| Advanced learners redoing basics | Neither format intact — strip steps | Expertise reversal: scaffolding flips from aid to drag as knowledge grows |
| Evaluating any head-to-head RCT you find | Judge gain per minute; read d against Cohen's conventions | Cohen's 0.2 / 0.5 / 0.8 are definitional benchmarks, not measurements; verify whether arms equated time-on-task |

Bottom line: for a single homogeneous novice cohort judged purely on post-test score, worked examples take it on efficiency; for anything heterogeneous or open-ended, adaptive hints take it; and the mid-lesson switch is the fading handshake above — completion problem, two unprompted successes, scaffold retired.

## What to do next

| Step | Action | Why it matters |
| --- | --- | --- |
| 1 | Demand the trial type before accepting any winning margin: check whether a cited study is a randomized controlled trial reporting an effect size, confidence interval, or p-va ``` Frequently Asked Questions Is there any randomized controlled trial that directly compares worked examples against AI-generated hints on post-test scores? No published randomized controlled trial directly compares worked examples against AI-generated hints on post-test scores — none of the 16 fetched sources contains such an effect size, confidence interval, or p-value. Can I use Paper Lantern's 76% input-token reduction as evidence for choosing hints over worked examples? Paper Lantern's +20% answer quality, -40% tool calls, and -76% input tokens all measure research-informed coding agents, so repurposing them as tutorial-design evidence would be misattribution. What did the LEAP prompting study actually show, and does it apply to human learners? In the LEAP study (PMC10760264), instruction-plus-example prompts substantially raised F1-scores over instruction-only baselines across tested models, but it measures LLM task performance, not student post-tests. How can I tell whether an 'adaptive AI hint' product really maintains a user model? A system qualifies as adaptive only if it is a hypertext/hypermedia system, maintains a user model, and uses that model to change what the learner sees next — and most hint engines quietly fail part two by branching on clicks and response latency rather than an estimated knowledge state. What should I check before building a mid-lesson switch from worked example to hints? Open your platform's mastery-threshold settings and record the exact criterion that triggers hint-to-example or example-to-practice transitions — commonly Bayesian knowledge tracing or a thresholded error-rate rule — because if you cannot find that number in the documentation, the system's 'adaptive' label is marketing, not mechanism. Doesn't making novices study fully solved examples waste effort on unnecessary steps? For a novice, the 'extra' step of studying a complete solution is precisely the load-reduction move that makes subsequent practice efficient, and waste appears only when examples persist past the expertise-reversal point — a tuning failure, not a design failure. Quick answers Has any randomized controlled trial directly compared worked examples against AI-generated hints on post-test scores? | No published RCT exists — none of the 16 fetched sources contains such an effect size, confidence interval, or p-value. |
| What did the LEAP prompting study find? | Adding worked-style examples to instructions lifted F1-scores above instruction-only baselines across tested models, though it measures LLM task performance rather than student post-tests. |  |
| What is the expertise reversal effect? | Guidance that accelerates novices actively impairs more advanced learners because redundant support consumes the very capacity it was meant to free, setting the mid-lesson switch point. |  |
| Why are Paper Lantern's metrics like +20% answer quality or -76% input tokens misleading in this debate? | They all measure research-informed coding agents, not a worked-examples-versus-hints learning experiment, so repurposing them as tutorial-design evidence would be misattribution. |  |
| How do adaptive AI hint systems decide when to fade support? | They use a learner model — most commonly Bayesian knowledge tracing or a thresholded error-rate rule — that fades hints as estimated mastery climbs. |  |

Also worth reading: **2026 Study: AI Worked Example Fading Cuts Novice Errors 34%**: [2026 Study: AI Worked Example](https://aitutorialmaker.com/blog/2026-study-ai-worked-example-fading-cuts-novice-errors-34.php) · **How to use AI in UX to achieve more with less and scale your design process**: [How to use AI in](https://aitutorialmaker.com/blog/how-to-use-ai-in-ux-to-achieve-more-with-less-and-scale-your-design-process.php) · **Step-by-Step Guide Converting 45, 90, and 180 Degrees to Radians Using Python and NumPy**: [Step-by-Step Guide Converting 45, 90,](https://aitutorialmaker.com/blog/step_by_step_guide_converting_45_90_and_180_degrees_to_rad.php)

### Related reading

- [Autoencoder Latent Size: Why 32 Dims Wins on MNIST (2026)](https://aitutorialmaker.com/blog/autoencoder-latent-size-why-32-dims-wins-on-mnist-2026.php)
- [React Native Lottie vs Animated: 15KB Decides, Not 50KB](https://aitutorialmaker.com/blog/react-native-lottie-vs-animated-15kb-decides-not-50kb.php)
- [Claude 2026 API Restructure: Hidden Costs of Cheaper Models](https://aitutorialmaker.com/blog/claude-2026-api-restructure-hidden-costs-of-cheaper-models.php)
- [PyEval-2026: GPT-4o Context Sinks, Claude 3 Edge Cases in Python Tutoring](https://aitutorialmaker.com/blog/pyeval-2026-gpt-4o-context-sinks-claude-3-edge-cases-in-python-tutoring.php)
- [2026 Study: AI Worked Example Fading Cuts Novice Errors 34%](https://aitutorialmaker.com/blog/2026-study-ai-worked-example-fading-cuts-novice-errors-34.php)
- [Cognitive Load Reduction Yields 40% Completion Gain (2026)](https://aitutorialmaker.com/blog/cognitive-load-reduction-yields-40-completion-gain-2026.php)

### Latest

- [Autoencoder Latent Size: Why 32 Dims Wins on MNIST (2026)](https://aitutorialmaker.com/blog/autoencoder-latent-size-why-32-dims-wins-on-mnist-2026.php)
- [React Native Lottie vs Animated: 15KB Decides, Not 50KB](https://aitutorialmaker.com/blog/react-native-lottie-vs-animated-15kb-decides-not-50kb.php)
- [Claude 2026 API Restructure: Hidden Costs of Cheaper Models](https://aitutorialmaker.com/blog/claude-2026-api-restructure-hidden-costs-of-cheaper-models.php)

Canonical: https://aitutorialmaker.com/blog/worked-examples-vs-ai-hints-when-each-wins-and-how-to-judge.php
Markdown: https://aitutorialmaker.com/blog/worked-examples-vs-ai-hints-when-each-wins-and-how-to-judge.php/index.md