Worked examples accelerate concept mastery by showing each step, decision, and rationale. With Gemini, you can generate stepwise solutions, highlight common errors, and scaffold transfer to new problems. Recent evidence shows worked examples improve retention and transfer while reducing cognitive load in math and science contexts (Barbieri et al., 2023; Chen et al., 2023; see guidance from the Education Endowment Foundation, 2022).
What Are Worked Examples Student Prompts?
These are short instructions you paste into Gemini to produce fully explained, step-by-step solutions with annotations, checks, and transfer tasks. They’re for high school and college students, teachers, and professionals who want faster comprehension and fewer avoidable mistakes. They differ from “explainers” by emphasizing visible steps, decision points, and error-checking.
Explore sibling libraries like Explain Concepts and Study Guide Prompts. Try our AI Study-Guide Generator or Lecture-to-Notes next.
How to Use These AI Worked Example Prompts
Pick 3–5 prompts, paste your source (problem, passage, dataset, or diagram), then run the steps in Gemini. Export the output to Google Docs or CSV when done. New to AI note-taking? Read the Get Started with AI Note Taking.
Define + Annotate Steps (1–20)
Use these to build complete, annotated worked examples. Each prompt requests visible steps, brief justifications, and sanity checks so learners see the “how” and “why.” Ideal for math, science, programming, finance, and grammatical analysis.
- Create a worked example that solves the problem, labeling each step’s purpose.
- Show each calculation step, include the rule used, and provide a micro-check.
- Convert this multi-step question into a numbered solution with brief rationales per step.
- Demonstrate the full solution, highlighting decision points and why each choice was made.
- Produce a step-by-step derivation, citing identities or theorems used at each step.
- Construct a worked example with inputs, transformation steps, outputs, then a units check.
- Model the solution using pseudocode, annotating line-by-line logic and complexity notes.
- Show a statistical example with formulas, substitutions, and a final interpretation sentence.
- Provide a chemistry stoichiometry example, balancing steps and mole-ratio reasoning clearly.
- Create a worked grammar example, marking the function of each phrase and clause.
- Walk through an economics elasticity problem with definitions, substitution, and interpretation steps.
- Solve a geometry proof, stating givens, theorems applied, and a concise conclusion line.
- Demonstrate unit conversions across steps, including factor-label method annotations for clarity.
- Provide a circuits example with equations, substitutions, and a quick magnitude reasonableness check.
- Solve a limit problem, labeling the technique chosen and any algebraic simplifications applied.
- Show a data cleaning workflow, stepwise, with rationale for each transformation and filter setting.
- Demonstrate derivative computation, citing differentiation rules per term and simplifying carefully afterward.
- Create a SQL join example, annotating keys, join type choice, and result interpretation briefly.
- Provide a psychology methods example, mapping hypothesis, variables, and analysis selection decisions transparently.
- Solve a dimensional analysis task, listing base units and cancellation logic per step.
Self-Explanation + “Why This Step?” (21–40)
Prompt Gemini to justify the steps, not just show them. Self-explanations strengthen schema formation and reduce cognitive load during practice by connecting rules to concrete decisions.
- Present the worked example and add one-sentence “why” rationales after each step.
- For each move, name the governing concept, then explain why alternatives were weaker.
- Insert self-explanation prompts after steps and answer them concisely in plain language.
- Explain why each unit or symbol matters, and how misuse would change results.
- Add “assumptions noted” lines where relevant and justify why each assumption is reasonable.
- Describe common misconceptions for this step, then show a quick corrective explanation.
- After solving, write a short reflection linking each step to the core objective.
- Map each step to a specific formula, property, or definition with inline citations.
- Explain why boundary conditions or constraints matter here and influence chosen operations.
- For programming, justify algorithm choice and trade-offs versus simpler baseline approaches.
- Clarify why intermediate rounding is avoided or applied, and its impact on accuracy.
- Explain why a graph or table is appropriate and what pattern confirms correctness.
- State what would invalidate a step and how to detect that early during practice.
- Justify variable substitutions and confirm they preserve equivalence or intended constraints precisely.
- Explain chosen statistical test, assumptions, effect size meaning, and interpretation boundaries succinctly.
- Annotate physics free-body diagrams with why each force appears or is negligible.
- Explain differentiation versus integration choice and what the result represents physically or geometrically.
- Describe why this data preprocessing reduces bias or variance within the downstream model pipeline.
- Explain denominator choices in rates, proportions, or indices, and implications for comparison.
- Add a final “because” paragraph that summarizes the logic uniting all steps cohesively.
Common Errors + Fixes (41–60)
Good worked examples surface likely mistakes and show quick corrections. Use these to pre-empt pitfalls and attach short diagnostics learners can apply during practice.
- Insert a “likely error” after each step and demonstrate the correct alternative briefly.
- Show three frequent mistakes for this topic, each paired with a corrected mini-example.
- Produce a side-by-side incorrect versus correct solution, annotating where the logic breaks.
- Flag unit errors that often occur here and show a quick dimensional sanity check.
- Highlight algebra slips that change sign or magnitude, and fix them transparently stepwise.
- Show typical sampling mistakes and correct them with clearer inclusion or exclusion criteria.
- Identify misapplied statistical tests and present the proper test with assumption checks, succinctly.
- Show programming off-by-one pitfalls and provide fixed code with annotated boundary handling.
- Correct common calculus errors choosing product versus chain rule, with quick telltales.
- Show citation formatting mistakes and the corrected references in APA or MLA format.
- Contrast incorrect assumptions with validated assumptions and demonstrate impact on final results.
- Show misinterpreted graphs and their correct readings with annotations on axes and scales.
- Fix dimensional analysis mistakes by inserting the missing conversion factors and cancellations explicitly.
- Correct ambiguous variable naming in code and show clearer, safer naming conventions applied.
- Repair reasoning leaps by inserting missing intermediate statements and justifications between steps.
- Show unit mismatches in physics problems and fix with coherent SI conversions throughout.
- Contrast naive baseline solutions with robust methods, quantifying error reductions where possible.
- Spot logical fallacies in qualitative analysis and present corrected reasoning chains matter-of-factly.
- Identify rounding propagation errors and show how to bound or minimize accumulated drift.
- Provide a final checklist of error checks students should perform before submitting answers.
Faded Guidance + You-Try Next (61–80)
Use fading to gradually remove hints. Early steps are fully explained, later ones only cued. This supports independence without a sudden jump in difficulty.
- Provide a full worked example, then a similar problem with brief step cues only.
- Solve steps 1–3 completely; for steps 4–6, supply hints rather than solutions.
- Create three problems: fully worked, partially worked, then unguided with a check key.
- Show a solution path diagram, then remove labels and ask learners to reconstruct steps.
- Provide starter code and comments; hide comments in later tasks but keep tests visible.
- Give a solved statistics example; next, only list formulas and ask for substitutions.
- Offer a completed proof; next, provide givens and target, leaving the reasoning blank.
- Provide model paragraphs with annotations; remove annotations and request the next paragraph independently.
- Show a fully labeled diagram; later, provide an unlabeled diagram and prompt labeling choices.
- Create three calculus tasks with decreasing hint density and a final verification rubric.
- Provide a logic truth-table example; next, give statements only and request full tables.
- Solve a physics kinematics item; then provide variables and require learners compute outcomes.
- Create guided reading questions for a passage, then remove hints in subsequent questions progressively.
- Provide a complete lab analysis; next, give raw data only and request the analysis steps.
- Offer an annotated citation example; then supply sources only and request formatted references independently.
- Give a finished SQL query; next, share schema only and ask learners to write it.
- Provide a balanced reaction example; later, present formulas only and request balancing work shown.
- Offer a proved identity; later, give the identity and expect a full learner-written proof.
- Provide a model paragraph rewrite; next, supply criteria only and request the rewrite independently.
- Supply a completed proof sketch; next, show endpoints only and ask for the connecting logic.
Variations, Boundary Cases, and Representations (81–100)
After a baseline example, explore variant inputs, edge cases, and multiple representations. This improves transfer and robustness during exams and projects.
- Create a baseline example, then vary one parameter at a time and re-solve succinctly.
- Show an edge-case scenario and explain why the usual shortcut fails or needs adjustment.
- Provide numeric, graphical, and verbal versions of the same worked example for triangulation.
- Solve with two different methods, then compare efficiency, transparency, and error susceptibility briefly.
- Translate the example into a table, then into a short explanation suitable for slides.
- Create a parameter sweep showing how outputs shift across realistic input ranges, concisely.
- Provide a dimensional analysis variant that reaches the same result via different paths.
- Offer a simulation-backed example and compare with an analytical approach, noting divergences briefly.
- Show alternative factorizations or decompositions that simplify different parts of the same task.
- Present a counterexample demonstrating where the strategy fails and suggest a safer heuristic.
- Translate the solution into a short, correct analogy that preserves relationships faithfully.
- Provide a units-free symbolic solution, then substitute real values to confirm numeric equivalence.
- Solve using estimation first, then exact computation, and compare magnitudes for plausibility.
- Re-express the solution with matrices or vectors and explain benefits of that representation here.
- Show a dimensional homogeneity test confirming formulas remain valid under scaling transformations.
- Create dual-method solutions and include a short decision guide for method selection next time.
- Offer discrete versus continuous versions of the model and discuss when each is appropriate.
- Provide a dimensional estimate first, then refine with precise constants and measured values afterward.
- Translate the example into a flowchart so novices can follow control flow visually.
- Show a units-choice sensitivity check, reporting how results change across unit systems used.
Transfer, Practice Sets, and Exam Readiness (101–120)
Finish with transfer tasks and quick practice sets. Compare methods, explain choices, and build confidence for timed assessments and independent projects.
- Create five practice variants mirroring the worked example’s structure with concise answer keys.
- Write two-method solutions and add a decision rule for choosing between them quickly.
- Convert the example into a timed practice version with checkpoints and target durations.
- Provide a minimal-info variant that still allows solution with justified simplifying assumptions.
- Create an oral exam version: prompts, expected steps, and concise evaluation criteria checklist.
- Generate three trap questions that test understanding rather than rote pattern matching only.
- Turn the example into a worksheet with space for steps, reasons, and self-checks included.
- Compose a rubric for evaluating worked examples: correctness, clarity, justification, and transferability.
- Design peer-review questions that catch unclear steps, missing justifications, and notation inconsistencies quickly.
- Create a transfer task that applies the method in a novel, cross-topic scenario effectively.
- Generate a small dataset version of the problem and include a reproducible solution script.
- Provide exam-style distractors that look plausible and explain why they fail under scrutiny.
- Turn the example into a flashcard set: step cue on front, explanation on back.
- Create a minimal rubric for self-grading independent worked examples during revision sessions.
- Provide a five-minute “speed run” version including only essential steps and sanity checks.
- Build a mixed-methods comparison chart summarizing formulas, pros, cons, and typical pitfalls.
- Write a short reflection: which step felt hardest and how to practice it efficiently.
- Provide a “mistake hunt” version that intentionally hides one error for learners to detect.
- Convert the example into a one-page cheatsheet with steps, cues, and checks compactly.
- Create a final mixed practice set with spaced difficulty and short self-explanations required.
Printable & Offline Options
Print any section for class or study groups. Save Gemini outputs as PDFs for binders, or export tables to CSV for spaced practice. See all student prompt hubs at /students/prompts/.
Related Categories
- Explain Concepts Prompts
- Study-Guide Prompts
- Quiz & Flashcard Prompts
- Lecture-to-Notes Prompts
- Academic Writing Prompts
FAQ
How are worked examples different from regular explanations?
Worked examples show every step, the decision logic, and frequent checks. Explanations often skip operational detail. Use worked examples to reveal methods you can immediately imitate and adapt on similar tasks.
Do worked examples help beyond math?
Yes. They support science, programming, economics, and writing. The principle is step visibility plus justification. Studies show benefits for retention and transfer when steps and reasons are explicit (Chen et al., 2023).
What is fading and why use it?
Fading gradually removes hints. You start with a full model, then fewer cues, then independence. It reduces cognitive load while building autonomy, which aligns with evidence-informed practice recommendations (EEF, 2022).
How many examples should I practice?
Start with one full example, then 3–5 faded variants. Add 5–10 mixed problems for transfer. Keep a short rubric: correctness, clarity of steps, justification, and final check.
Can I combine worked examples with study guides?
Yes. Convert a worked example into a checklist or table, then link it to a topic study guide for exam-ready review. Try our AI Study-Guide Generator.
Final Thoughts
Worked examples show steps, reasons, and checks so learners move from copying to confident independence. Use the sections above to model, fade, and transfer effectively across subjects. Want more? Start AI note-taking instantly for free with our AI note taker.
References: Barbieri et al., 2023; Chen et al., 2023; Education Endowment Foundation, 2022.
::contentReference[oaicite:0]{index=0}
