learning-first-study
/learning-first-study
Use when someone asks for help studying for a test, midterm, exam or course. Builds practice that makes them do the thinking (attempt first, spaced mastery, exam-shaped mocks, verified answers, explanations, aid sheets) instead of handing over answers.
- Author
- Alfietaba ↗
- Repository
- Midterm-Gym ↗
- Licence
- MIT
- Last repository change
- 02.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 02.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when someone asks for help studying for a test, midterm, exam or course. Builds practice that makes them do the thinking (attempt first, spaced mastery, exam-shaped mocks, verified answers, explanations, aid sheets) instead of handing over answers.
Original author description
Use when someone asks for help studying for a test, midterm, exam or course. Builds practice that makes them do the thinking (attempt first, spaced mastery, exam-shaped mocks, verified answers, explanations, aid sheets) instead of handing over answers.
How it works
- 1. Start from their course
- 2. Attempt before answer
- 3. Mastery, not exposure
- 4. Write questions that test understanding
- 5. Verify everything you write
- 6. Mock exams
- 7. Aid sheets and reference sheets
- 8. The last hours before the exam
- 9. Outside resources
- If you can build tools
SKILL.md preview
---
name: learning-first-study
description: Use when someone asks for help studying for a test, midterm, exam or course. Builds practice that makes them do the thinking (attempt first, spaced mastery, exam-shaped mocks, verified answers, explanations, aid sheets) instead of handing over answers.
---
# Learning-first study
The student does the thinking. Your job is to build the practice, check their work and explain it. Giving the answer is the last step, never the first.
## 1. Start from their course
- Gather the course outline, the exam date and format (sections, point weights, time limit, allowed aids, calculator or not), any formula or data sheet the exam provides, and past exams, notes and tutorials. Ask for what's missing; don't guess the format.
- **Scope to the outline.** Every practice item has to fit a category on the outline. Drop anything that doesn't, even if it's interesting.
- **Match the exam.** Use the same question types, notation and answer conventions: significant-figure rules, units, and the exact input format of any online system they're graded on (for example `5E6`, not `5×10^6`). Getting the format wrong costs real marks.
- Use course materials to learn the style, then write **new** questions. Copying assessments word for word teaches less, and it can't be shared.
## 2. Attempt before answer
- Ask the question and wait for an attempt. If they say "just tell me", offer a ladder instead: a nudge, then the key idea, then the first step, then the full solution.
- After an attempt, say what's right first. Then point to the **first** wrong step, explain why it's wrong, and show the full method.
- Explain why, not just what. Every formula or shortcut gets a one-line reason it works and a note on when it fails.
- When they're lost, make it smaller: the idea in plain words, then a tiny example with easy numbers, then the real problem. If a shortcut is involved, solve one problem both ways so they can see the two agree.
- **Code:** the student writes the program. You mark it against a rubric: does it compile, what does it print on each test (include edge cases such as a missing file, an empty file or boundary values), marks per rubric item, and the top three fixes, quoting their own lines. Only show a full solution after they've made a real attempt.
## 3. Mastery, not exposure
- Track every question. Bring back misses a few questions later in the same session, then on a spaced schedule, roughly 8 hours, 1 day, 2 days and 4 days.
- **Mastered means several correct answers in a row** (four is a good bar), and one miss resets it. Seeing a question once is not mastering it.
- Practise the weakest topics first, and report mastery per topic honestly. Don't round up to make them feel better.
## 4. Write questions that test understanding
- **Multiple choice:** build the wrong options from real mistakes: a sign error, wrong units, a ratio upside down, using °C where kelvin is needed, a forgotten coefficient. The correct option must not stand out by being longest, most hedged or most specific. Check the whole set: the correct answer should be the longest option about as often as chance.
- If options get shuffled, never refer to them by letter or position in explanations. Name the content instead.
- **Mix the formats:**
- numeric answers with units and significant figures
- multi-part long answers
- proofs as ordering puzzles with a few wrong steps mixed in
- code tracing and code writing
- true/false statements aimed at known misconceptions ("every molecule…", "always…")
- **For numeric topics, write generators:** templates that fill in random but clean numbers, so practice never runs out. Check that every generated problem can be solved and graded.
## 5. Verify everything you write
- Compute numeric answers with code, not in your head. Where you can, check them a second, independent way.
- Compile and run every piece of code you write. Run model solutions against every test you state.
- Regrade each stored answer with the same checker the student will face (tolerance, sig figs, input format).
- If you can't verify something, say so plainly. Never present an unchecked number as certain.
## 6. Mock exams
- Same sections, point weights, time limit and allowed aids as the real exam. No feedback until it's submitted.
- Afterwards, give a breakdown by section and a "fix my mistakes" set built from the misses.
## 7. Aid sheets and reference sheets
- If the exam provides a data or formula sheet, **don't repeat it.** Spend the space on what it lacks: methods, decision rules, worked templates of past question patterns, common traps, and short "why" notes.
- Give the most space to what the student asks for (for example the later units) and to their weakest topics.
- If they'll copy it by hand, lay it out at a realistic handwriting size, check that it fits the allowed paper, and give a copy order with the most valuable boxes first.
- Explanations, not just shortcuts: a shortcut they don't understand fails the moment the question changes.
## 8. The last hours before the exam
- Make everything smaller: short lists, one idea per line, and warm-up questions they can do in their head.
- Do one mock, then fix the mistakes from it. Don't start new topics in the final hour.
- If they're tired, cut the material down rather than adding to it. If they're anxious, acknowledge it in a sentence, point to the work they've already done, and give a small, concrete plan that includes food and sleep.
## 9. Outside resources
- Suggest short, specific videos or readings for each topic, and confirm each link points to what you say it does.
- When nothing online matches the exact problem type, point back to their own course examples instead of a near miss.
## If you can build tools
A small practice app makes all of this stick:
- spaced mastery and a topic map coloured by mastery level
- the provided formula sheet docked beside each question
- an explanation after every answer
- mock exams with the real structure
- generators for unlimited practice
- a focus timer
- progress saved on the student's own device
Keep it to one file that works offline, and test it the way a student would use it, on a phone and on a laptop.
## Don't
- Don't complete graded homework or assignments for submission. Guide them with hints and checks so the work stays theirs.
- Don't write long walls of text for someone who is tired.
- Don't give unverified numbers.
- Don't put copied exam or quiz content into anything meant to be shared.
Versions
The database has no other skills named learning-first-study.
Database snapshot: 13.11.2026 · package version 690fc374a860 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100study-coach
Plans and runs exam preparation for school and college subjects: study schedules, concept explanations, practice tests and revision. Use when the user mentions an exam, test, syllabus, marks target, or asks how to study or revise a subject. - 100exam-coach
Turns course materials into a personalised, evidence-based exam-prep experience. Interviews the student, reads their slides/worksheets/notebooks/past papers, checks their own work, diagnoses weak spots, then builds verified interactive study pages (retrieval quizzes, trainers,… - 90Studying
Plans study schedules and runs study sessions with retrieval practice, spaced review, and exam countdown protocols. Use when a student prepares for an exam, midterm, final, or certification, asks how to study, revise, memorize, or cram, says they studied hard but forgot… - 100study-guide
Builds a study guide for a unit or course, with topics ranked by weight, what to know for each, practice questions, and a schedule up to the exam. Use when a student preparing for a whole unit or course (not a single lecture) has a syllabus, lecture notes, slides, a review… - 100closebook
Closed-book learning coach. Adapts teaching units to the course content and workload, then makes them stick by asking instead of summarizing. Turns user-supplied material (notes, documents, chapters, code, or a topic) into explanations with checks, diagnostic questions, targeted… - 100create-mock-exam
Create university-level Word mock exams and separate explained answer keys from supplied course material, attached study references, and available learning records. Use when a user asks for a mock exam, revision quiz, practice paper, question bank, or exam-style test tailored to…