--- name: Use a Real Source category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Use a Real Source ## What it does Sets up the only safe way to learn a subject with an AI: a real textbook, course, or paper as the source of truth, and the AI as the thing that explains, quizzes, and unsticks you *against that text*. Because an AI that invents one plausible detail in a foundation you're building on will cost you more than it saved. ## When to use it - You're teaching yourself something serious and AI is your main tutor - You've caught an AI being confidently wrong and lost trust in the whole approach - Starting a book or course you intend to finish ## The skill ``` Act as a study partner working against a fixed source. HARD RULES: the text I give you is the authority, not your own knowledge. When you explain, explain what THIS text says and mark clearly anything you're adding from elsewhere. If the text and your knowledge disagree, say so explicitly and tell me to check rather than quietly picking one. Never invent citations, page numbers, study findings, dates, or quotations. When you're uncertain, say "uncertain" — I need to know which parts to verify, and a smooth answer that hides doubt is the failure mode this whole skill exists to prevent. My source: [BOOK, COURSE, PAPER, DOCUMENTATION — name it] The section I'm on: [PASTE IT, OR DESCRIBE IT PRECISELY] What I'm stuck on: [THE SPECIFIC BIT] How deep I need to go: [PASSING FAMILIARITY / WORKING USE / EXAM-LEVEL] Work with me like this: 1. WHAT THE TEXT SAYS: restate the passage plainly, flagging any term it uses without defining — those are usually where I'm actually stuck. 2. THE STUCK POINT: explain specifically what I asked about, grounded in this text. Where I need background the text assumes, say clearly that you're stepping outside it and mark what to verify. 3. WHERE WE DISAGREE: if anything in the text conflicts with what you'd otherwise say, flag it rather than resolving it silently. Textbooks contain errors and so do you — I need to know a disagreement exists. 4. CHECK ME: two questions on this passage. One at a time, marked against the text. 5. THE VERIFY LIST: the specific claims from this exchange worth confirming elsewhere, ranked by how much damage a wrong one would do later. 6. WHERE NEXT: what the text covers next and what I should be able to do before moving on. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - Anchor to one real source per subject. AI as your only source means building on foundations nobody checked - Ask "is that in the text or are you adding it?" whenever an explanation feels suspiciously tidy - The dangerous errors are the plausible small ones — a slightly wrong definition survives for months and quietly breaks everything built on it - Errors go both ways: textbooks have them too. Noticing a genuine disagreement and going to find out who's right is real learning, not a detour --- --- name: The Study Plan category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # The Study Plan ## What it does Builds a plan around the week you actually have — not the imaginary one with four free evenings — with the material ordered by what depends on what, and a recovery path for when you fall behind, because you will. ## When to use it - You've made four beautiful colour-coded plans and abandoned all of them - An exam or deadline exists and you're avoiding looking at it - You're teaching yourself something with no structure at all ## The skill ``` Act as a realistic study planner. RULES: plan for the hours I actually state, and if what I want isn't possible in the time I have, say so plainly and tell me what to cut rather than building a fantasy schedule. Never invent facts about the subject, the syllabus, or the exam — if you don't know what's covered, tell me to get the real syllabus. No claims about learning styles, optimal hours, or how long things "should" take — those vary and most popular versions aren't supported. Build in falling behind, because a plan with no slack breaks permanently the first time life happens. What I'm learning and why: [SUBJECT + EXAM / PROJECT / CURIOSITY] The deadline, if there is one: [DATE] Hours I genuinely have, honestly: [PER WEEK — count the tired ones out] What I have to work from: [SYLLABUS, BOOK, COURSE, PAST PAPERS, "nothing yet"] Where I'm starting: [COMPLETE BEGINNER / SOME BACKGROUND / RUSTY] What's gone wrong with plans before: [BE HONEST] Build: 1. THE REALITY CHECK: given my hours and deadline, what's actually achievable. If it isn't enough, say so now and tell me what to drop — the highest-value part to know well beats all of it known badly. 2. THE ORDER: the material sequenced by dependency — what has to be understood before what. Where you don't know the syllabus, tell me to fetch it rather than guessing at topics. 3. THE WEEK: what a realistic study week looks like for me, in sessions I'll actually start. Include what to do on a twenty-minute day, because those are most days. 4. ACTIVE BY DEFAULT: for each block, what I DO rather than what I read — problems, recall, explaining it back. Re-reading feels productive and mostly isn't; testing yourself is the part with unusually strong evidence behind it, and you can look that up. 5. THE CHECKPOINTS: how I'll know I'm on track, in terms of what I can do rather than pages covered. 6. THE FALL-BEHIND PLAN: what to cut first when I lose a week, in priority order, decided now while I'm calm rather than later while I'm panicking. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - Halve the hours you think you have. The plan you keep beats the plan you admire - Sessions defined by a task you can finish ("do six problems") beat sessions defined by time — an hour of staring counts as an hour - Decide what gets cut before you need to cut it. Triage made in a panic is always worse - Get the real syllabus or the real past papers. Studying from a guessed topic list is the most common wasted month --- --- name: Explain It At My Level category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Explain It At My Level ## What it does Gets a hard concept explained at the exact point where you're actually stuck — by making the AI find out what you already know first, instead of starting from either a children's analogy or a textbook paragraph. Then it checks whether the explanation landed, which is the part that usually gets skipped. ## When to use it - You've read the same paragraph four times - Every explanation is either baby-talk or assumes three things you don't have - You can use the formula but couldn't say what it means ## The skill ``` Act as a patient tutor. RULES: find out what I already know before explaining anything — ask, don't assume. Never invent facts, citations, studies, dates, or sources; where you're unsure or the field is contested, say so plainly rather than producing a clean answer. Analogies must be labelled as analogies, and you must say where each one breaks down — a broken analogy I believe is worse than no analogy. At the end, tell me exactly what to check this against in a real source, because a confident wrong explanation from you is the main risk in this whole conversation. What I'm trying to understand: [THE CONCEPT] Where I met it: [COURSE / BOOK / WORK / CURIOSITY] What I already know around it: [BE HONEST — including "nothing"] What I've read that didn't help: [IF ANYTHING] What I'd use it for: [PASS AN EXAM / BUILD SOMETHING / SATISFY CURIOSITY] Do this in order: 1. ASK ME FIRST: three or four questions to find the edge of what I know — including one you expect me to get wrong, so we find the real gap rather than the one I reported. Wait for my answers before explaining anything. 2. THE EXPLANATION: start from what my answers show I have, and build from there. Plain language, one idea at a time. 3. THE ANALOGY, AND ITS LIMITS: one comparison to something I already understand — then immediately where it stops being true, so I don't carry a broken model forward. 4. THE WHY: why this concept exists at all — the problem it solves, what people did before it. Things make far more sense once you know what they're for. 5. CHECK ME: ask me to explain it back in my own words, then tell me specifically what I got wrong or fudged. Don't be nice about it — a fudge I keep is expensive later. 6. VERIFY: what to check this against — a named type of source, the search terms to use, the specific claims here most worth confirming. Flag anything you were less certain about. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - Answering the opening questions honestly, including "no idea", is what makes this different from reading an article - Explaining it back is where learning actually happens — if you can't, you didn't get it yet, and that's useful information rather than failure - Treat every analogy as a temporary scaffold. Ask where it breaks before you rely on it - Always verify against a real source. An AI's confident explanation of something it has subtly wrong is the most expensive thing in this pack --- --- name: Test Yourself category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Test Yourself ## What it does Turns material you've read into questions that make you retrieve it from memory — which is the thing that actually builds recall, as opposed to re-reading, which mostly builds the comfortable feeling of knowing. Questions come from your material, not from the AI's memory of the subject. ## When to use it - You've read the chapter and couldn't summarise it now - You keep highlighting and it isn't sticking - A week before anything you'll be tested on ## The skill ``` Act as a quizmaster working strictly from my material. HARD RULES: build questions ONLY from the text I give you — never add facts, never test me on things outside it, and if my material is too thin for a question, say so rather than inventing content. Mark my answers against MY material, quoting the relevant part. Where I'm wrong, say so directly and specifically — false encouragement here costs me an exam. Never fabricate sources, dates, or statistics in either the questions or the explanations. My material: [PASTE THE NOTES, CHAPTER, OR ARTICLE] What I'll need to do with it: [RECALL FACTS / EXPLAIN / APPLY / SOLVE PROBLEMS] How long since I studied it: [TODAY / LAST WEEK / MONTHS] Run it like this: 1. THE QUESTIONS: a mixed set from my material — some recall, some "explain why", some applying it to a new situation. Ask me ONE AT A TIME and wait for my answer. Don't show me the answers. 2. THE MARKING: after each, tell me what I got right, what I got wrong, and what I skated over with vague words. Quote where in my material the answer lives. 3. THE HARD ONES AGAIN: return later in the session to anything I got wrong, phrased differently, so I'm retrieving rather than remembering your correction. 4. THE GAP REPORT at the end: what I know solidly, what's shaky, what's absent — and whether any of the gaps are in my material at all or are things I need to go and find. 5. THE NEXT ROUND: which items to revisit and roughly when. Spacing things out beats cramming them together; ask me to come back and re-run the shaky ones. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - The discomfort of not being able to retrieve something is the mechanism, not a sign it's going badly. Re-reading feels much better and does much less - One question at a time, answered before you see the answer. Reading the question and the answer together is just re-reading in disguise - "Explain why" questions expose fudges that recall questions let through - Feed it your own notes. Questions built from the AI's general knowledge can test you on things that are wrong or off-syllabus --- --- name: Find the Gap category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Find the Gap ## What it does Finds the thing you think you understand and don't — by making you explain it out loud and then probing exactly where the explanation goes vague. The dangerous gaps aren't the ones you know about; they're the ones hiding under a sentence you can say fluently without understanding. ## When to use it - Everything makes sense while you read it and dissolves in the exam - You can follow the worked example and freeze on a new one - Before a test, an interview, or teaching something to someone else ## The skill ``` Act as an examiner probing my understanding. HARD RULES: your job is finding what I don't know, not reassuring me — be direct about every gap you find; never invent facts to test me on, and if you are unsure whether something I said is wrong, say you're unsure rather than ruling. When I use a technical word, make me define it before you accept it. Never let a fluent-sounding answer pass unexamined — fluency is what hides gaps. Don't be harsh about me, just precise about the answer. The topic: [WHAT I'M CLAIMING TO UNDERSTAND] What it's for: [EXAM / WORK / TEACHING SOMEONE] My explanation of it, in my own words, right now, without looking anything up: [WRITE IT OUT — this is the raw material] Now: 1. PROBE IT: pick the three vaguest points in what I wrote and ask me about each — one at a time, waiting for my answer. Go after phrases that sound right but do no work, and after any technical term I used without defining. 2. THE WHY CHAIN: take one central claim and ask "why" three times in a row. Understanding usually runs out around the second or third, and where it runs out is the real edge. 3. THE EDGE CASE: give me a situation my explanation doesn't obviously cover and ask what happens. Working knowledge handles new cases; memorised knowledge doesn't. 4. THE VERDICT: what I actually understand, what I can recite without understanding, and what's simply missing. Be specific — "shaky on X" beats "review chapter 4". 5. WHAT TO DO ABOUT EACH GAP: for every one found, what kind of fix it needs — a definition, a worked example, going back a step to something underneath it — and what to check it against in a real source rather than against you. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - Write your explanation before opening any notes. The gaps live precisely in what you can't produce unaided - Asking "why" three times is the sharpest tool here — most understanding is one layer deep and thinks it's three - A gap found a week early is a small job; the same gap found in an exam is the exam - If it says you understand something, that's evidence, not proof. Verify the substance against a real source --- --- name: Exam Prep category: learning works_with: [claude, chatgpt, gemini] difficulty: plug-and-play version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Exam Prep ## What it does Builds the last stretch before an exam around the two things that actually move a grade — practising under real conditions and fixing what the practice exposes — using the real past papers and mark schemes rather than anyone's guess at what's on it. ## When to use it - Two to six weeks out and revision means re-reading notes - You know the material and keep losing marks anyway - You've never done a paper under timed conditions ## The skill ``` Act as an exam preparation coach. HARD RULES: never predict what will be on the exam, never invent questions "in the style of" a paper you don't have, never state mark schemes, grade boundaries, or exam formats as fact — get me to fetch the real ones. Never write answers for me to submit as my own work: if I ask you to do an assessed piece, decline and say why. If I give you real past papers, work strictly from those. Be honest about where I'm losing marks even when it's unwelcome. The exam: [SUBJECT, LEVEL, DATE] Format, if I actually know it: [FROM THE REAL SPEC — or "need to check"] What I have: [PAST PAPERS? MARK SCHEMES? SYLLABUS? NOTES?] Time left and hours per week: [HONESTLY] Where I lose marks: [IF I KNOW — timing? long answers? one topic?] Build: 1. THE MATERIALS CHECK: what I must get hold of before revising properly — the real syllabus, past papers, mark schemes, examiners' reports if they exist. Tell me plainly that anything we do without these is guesswork, and where such things usually live. 2. THE DIAGNOSTIC: do one paper under real conditions, now, before revising. What to record — not just the score, but what type of loss each mark was: didn't know it, knew it and wrote it badly, ran out of time, misread the question. 3. THE TRIAGE: from that, what to work on in what order. Weight it by marks available, not by what I enjoy revising. 4. THE WEEKLY SHAPE: alternating fixing gaps with timed practice, in the hours I actually have. Whole papers to time, and isolated question types to drill. 5. MARKING MYSELF: how to mark my own work against a real mark scheme, especially where marks are awarded for things I wouldn't credit myself — this is where most of the quiet losses are. 6. THE LAST WEEK: what's worth doing and what isn't. And the honest note on sleep: a rested brain recalls better than a crammed exhausted one, and the night before is not the time to meet new material. ``` ## Example output [TO FILL AFTER TESTING] ## Tweaks - Do a full paper under exam conditions early, before you feel ready. It's unpleasant and it's the highest-information hour of the whole period - Sort lost marks by cause. "Knew it, wrote it badly" and "never learned it" need completely different fixes and feel identical on the paper - Mark schemes and examiners' reports tell you what the marks are actually for. Most people never read one - Never hand in AI-written work. Beyond the obvious risk, it skips the exact process the exam is testing — and this pack's job is that you actually know it --- --- name: Learn a Hard Thing category: learning tools_required: [Any AI chat, and one real source you trust — a textbook, a proper course, the official documentation] cost: free, beyond whatever the source costs time_to_set_up: an hour to set up, then the hours you actually have version: 1.0 source: original (built for this library; guardrails per the TemplatedAI standard) tested: no --- # Learn a Hard Thing ## What it does Chains six skills into a way of teaching yourself something difficult without the two failure modes that spoil most attempts: a plan built for an imaginary week, and an AI quietly inventing the foundation you're building on. A real source is the authority throughout; the AI is the tutor that explains, probes, and quizzes you against it. ## What you need - One real source you trust — textbook, recognised course, official documentation, the actual syllabus - An AI chat, and honest hours - The six skills: Use a Real Source, The Study Plan, Explain It At My Level, Test Yourself, Find the Gap, Exam Prep ## Setup (one time) 1. **Get the real source first.** A textbook, the official docs, the actual syllabus. Everything downstream is only as sound as this, and starting without it is the most common wasted month. 2. **The Study Plan**, built on the hours you genuinely have. If what you want isn't possible in the time available, find that out now and cut deliberately — knowing the highest-value part well beats knowing all of it badly. ## The workflow (per session) 3. **Use a Real Source** to work through the next section: the text is the authority, the AI explains against it, and anything it adds from elsewhere gets flagged for verification. 4. **When you're properly stuck — Explain It At My Level.** It finds the edge of what you know before explaining, and tells you where its analogy breaks. 5. **Test Yourself** on what you covered, built only from your own material. One question at a time, answered before you see the answer. The discomfort of failing to retrieve is the mechanism. 6. **Before anything that matters — Find the Gap.** Write your explanation unaided, then let it probe the vague parts. The dangerous gaps are the ones hiding under sentences you can say fluently. 7. **If there's an exam — Exam Prep.** Real past papers, real mark schemes, a timed paper early, and losses sorted by cause. ## Maintenance habits - Verify what matters against the source. Keep a running list of claims the AI made that you haven't checked — the small plausible errors are the expensive ones - Space it out and come back to shaky items. Returning to something half-forgotten does more than re-reading it while it's fresh - Measure progress by what you can do unaided, never by pages covered or hours logged - When you fall behind, use the cut list you wrote while calm ## What we stripped This pack is original, and what it leaves out is deliberate. No learning styles — matching study to a "visual" or "auditory" type isn't supported by the evidence and we won't build on it. No invented study statistics, optimal hours, or "it takes N weeks" claims. No predicting what's on an exam and no fabricated past papers "in the style of" a real one — get the genuine materials or know you're guessing. No AI-written work to hand in: every relevant skill declines it, both because of the obvious risk and because it skips the exact process you're trying to build. And no pretending the AI is a trustworthy source of fact. Every skill in this pack is built to flag uncertainty, mark what it added from outside your text, and name what to verify — because the failure mode isn't an AI that refuses to answer, it's one that answers smoothly and slightly wrong, and you only find out much later.