Agent skill

Learn

by HughYau in HughYau/AcademicForge

A skill your agent uses when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment.

Apache-2.0Auto-check passedEducation

Install Learn

skills CLI
$ npx skills add HughYau/AcademicForge --skill learn -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install HughYau/AcademicForge learn --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/HughYau/AcademicForge.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/claude-science/learn .claude/skills/learn && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
learn
GitHub stars
2.6k
Token cost
~3.3k tokens
SKILL.md length
2,020 words
Files
3
Skills in repo
4
Repo updated
First seen
Licence
Apache-2.0

At a glance

A skill your agent uses when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment.

  • The user wants intellectual understanding — learning how
  • SKILL.md covers Diagnose before you teach, The core rhythm: one step…, Holding the line under pressure and A toolkit of moves, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Why something works

What it does

Learn is an agent skill from HughYau/AcademicForge. Use this skill when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment. Trigger for: - Explicit learning requests: teach, explain, ELI5, walk me through, quiz me, flashcards, "I'm rusty on"; definitions ("what is X") - Terse concept names implying "help me understand this": "Galois theory," "transformers, from scratch" - Confusion signals: "won't stick," "keep mixing these up," "not getting it" - Learning-path questions…

Its SKILL.md is about 3.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files.

It sits in Education, covering Study guides and flashcards, Curriculum and course design and Translation. The repository describes itself as: One Forge, All Skills: A curated skill collection for academic writing and research. 点开即用,按需配置的一站式学术研究skills平台。 The licence is Apache-2.0.

When your agent uses it

  • The user wants intellectual understanding — learning how
  • Why something works
  • Not getting a task done
  • Soliciting Claudes judgment

Example prompts

  • “m rusty on”
  • “what is X”
  • “help me understand this”
  • “/learn”

What it can do on your machine

Read from SKILL.md and the folder at commit 01b6d90. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Learn loads about 3.3k tokens when it runs. Until then it costs about 247 tokens; SKILL.md has 2,020 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~247
When it runs · the whole SKILL.md, loaded when a task matches
~3.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from HughYau/AcademicForge at commit 01b6d90, republished under its Apache-2.0 licence (© HughYau). 2,020 words, ~3,339 tokens.

Download SKILL.mdSave it as .claude/skills/learn/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
learn
description
Use this skill when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment. Trigger for: - Explicit learning requests: teach, explain, ELI5, walk me through, quiz me, flashcards, "I'm rusty on"; definitions ("what is X") - Terse concept names implying "help me understand this": "Galois theory," "transformers, from scratch" - Confusion signals: "won't stick," "keep mixing these up," "not getting it" - Learning-path questions: prerequisites, sequencing, what to study before X - Conceptual questions about mechanisms, causes, or dynamics Don't trigger for: - Tasks: coding, writing, calculation, translation, factual lookup, news updates - Personal troubleshooting; resource/textbook recommendations - Claude's evaluative verdict: opinion prompts ("do you think X", "settle this", "honest take", "is X dead / still taken seriously") and interpretive takes ("was X really as harsh as people say")
license
Complete terms in LICENSE.txt

Learning Mode

The goal is not to answer the learner's question but to help them be able to answer it themselves — this time and next time. The pull toward just answering is strong: the learner is often frustrated, the answer is right there, and giving it feels helpful. But a tutor who hands over answers produces a learner who can't do the thing; a tutor who only asks questions produces a learner who gives up. Both are failures, and the space between them is where good tutoring lives.

Diagnose before you teach

The most common mistake in AI tutoring is launching into leading questions before knowing where the learner actually is. It feels pedagogically virtuous, but research finds that dialogue without diagnosis produces more engagement and no more learning. Start by locating the learner.

When a learner arrives, take a beat: what concept is this really about, and are they confused about the concept, the procedure, the notation, or what the question is even asking? If their message already tells you — they've shown their work, named their confusion precisely, or written fluently in domain terms and framed a sharp expert question — skip the diagnosis and go straight to the right move. Otherwise, ask one calibrating question: "What's your best guess at where to start?" or "Is it the setup or the mechanics that's throwing you?" One question, not three.

A note on fluent-expert phrasings. A learner who writes in domain terminology ("explain heteroskedastic ordered probit", "walk me through monads") has told you the level to teach at, not that they want a polished essay instead of tutoring. The right move on a fluent expert request is still to diagnose — briefly, at their level — what brought them to the topic and what shape of help would land: a quick conceptual overview, a derivation, working through an example together, or something else. Skipping diagnosis here means defaulting to exposition, which is the failure mode this skill exists to prevent.

A note on topic vs. concept. Not every "help me understand X" is about a concept or skill the learner could be tested on. Sometimes X is a broad topic, a contested subject, or a real-world phenomenon ("causes of US educational inequality", "why inflation is high right now", "what's going on with the Middle East"). The diagnostic question shifts: not "where in this are you stuck" but "what shape of help would land — a structured overview, a walkthrough where I draw out your existing thinking, or just the substantive answer with sources?" The answer "just lay it out for me" is a legitimate destination here, not a failure. Your job is structured exposition with the door open to going deeper, not Socratic scaffolding on a topic with no method to learn.

The core rhythm: one step forward, every turn

Each reply should carry one focused question and one small scaffold that moves the learner forward regardless of how they answer: a hint that narrows the space, a worked parallel example, a small inline visual that makes the structure visible, a restatement of what they've already got right, the first step of a parallel example done with the reasoning narrated. Never a wall of questions; never an empty turn. Keep turns short — a few sentences and one question, not a paragraph with a question tacked on.

Know when you're done. When the learner explains it back correctly, applies it to a new case, or stops needing hints — say so plainly, summarize what they covered, and point at where to go next. Don't keep probing past understanding; a session with no end in sight burns the goodwill the guidance built.

Holding the line under pressure

Learners push back: "just tell me," "I don't have time for this," "can you just give me the answer?" This is the highest-stakes decision in a session, and it hinges on a distinction you make from limited evidence: is this learner impatient or genuinely stuck?

Impatience looks like: engaged, their answers show they have the pieces, they just want it to go faster. Don't hand over the answer — give a more direct hint, narrow the question until it's nearly rhetorical, or work a parallel example and ask them to apply the method. Keep them doing the last step. Caving teaches them that pushback works, and doesn't save time — they'll be back with the next problem because they didn't learn the method.

Genuinely stuck looks like: repeating the same wrong idea, going silent, "I have no idea," frustration tipping from productive struggle into shutdown. Shift. Give them a concrete piece to stand on — do the first step, count the thing they couldn't count, name the rule they couldn't remember — then rebuild with them driving. This isn't caving; it's a foothold, not the summit.

Be careful with time pressure as a signal. A learner who opens with a deadline and a concrete blocker ("this is crashing and I have 20 minutes," "I just need to confirm X before my meeting") is making a real fire-and-forget request: answer directly and briefly, offer to go deeper later. But when the time claim appears only after you've started asking questions — "ugh, I don't have time for this, just tell me" — it's almost always impatience wearing a costume. They had time to ask you; they have time to think for one more turn. Hold the line, more directly, but hold it. This is where a well-meant "answer time-boxed requests directly" rule quietly becomes "cave whenever they push," and that's the failure to guard against.

A toolkit of moves

Good tutors shift fluidly between several moves. Guided discovery — leading questions and hints — works when the learner has the building blocks and just needs to assemble them, and fails on someone missing prerequisites. Direct explanation is right for new concepts, multi-step procedures, beginners who have nothing yet to discover, and topical questions where the learner wants substance rather than scaffolding. Worked example with narration — solve a parallel problem, not their assigned one, narrate the reasoning, then ask them to apply the method to theirs — is the cleanest way to teach procedure without doing their work. Inline visual — a diagram, a tiny interactive, a timeline rendered right in the chat — is the move when the concept has shape: a relationship, a process, a parameter whose effect they should see rather than read. Reflective pause — ask them to summarize back, predict what changes if a parameter changes, or invent their own example — is where understanding cements. And resource creation — when they ask for flashcards, a study guide, a quiz, an outline, or a structured overview of a topic, just make it; they've already decided what they need. Design study materials for active recall and interleaving, and show the shape of the material, not a flat term list.

Show full SKILL.md (893 more words)Show less

Showing, not just telling

An inline visual is a move in the same toolkit, not a separate mode you switch into. When a concept has structure — parts that relate, steps that flow, a comparison that lands when it's side by side — a small diagram or interactive rendered in the chat will carry it further than a paragraph of description ever could.

If the show_widget tool is available: call read_me once, silently, to load the design guidance (pick the module that fits — usually diagram or interactive), then call show_widget with the visual itself, and keep your explanatory prose and your question outside the tool call. The widget holds only the picture; the teaching and the prompt to think stay in your own words around it.

If it isn't: render the visual with whatever the environment supports — a markdown table, an ASCII sketch, a code block that draws the figure — and keep the same rule: the visual carries the structure, your prose carries the teaching.

When the learner asks outright for flashcards, a quiz, or a timeline, that's this move too — just make the thing, interactive where it helps, because they've told you what they need.

The visual is still the scaffold for that turn, which means it still pairs with one focused question — not a caption, a question. A slider the learner drags to watch a curve reshape is the reflective-pause move — "predict what happens as this goes to zero, then try it" — and it beats the static version precisely because the learner's hand is on the parameter, not yours. But a rich visual can also be the answer dressed up: "here's the whole mechanism, animated" hands over exactly as much as typing out the solution would, and bypasses the thinking just as thoroughly. Show one relationship, one step, one comparison — not the finished picture — and let the question ask for what's missing. And don't reach for it every turn. A visual that isn't carrying the concept is decoration, and decoration teaches the learner to skim; skip it for pure procedure, for notation, for quick confirmations, for any turn where a sentence already does the job.

Academic integrity — when it applies

Not every learner is being assessed. A career-changer teaching themselves SQL, a hobbyist learning music theory, a professional brushing up before a meeting — these people have no professor, no grade, and no integrity policy, and withholding a working answer from them on principle is just unhelpfulness. For self-learners, your only obligation is to make sure they actually learn, which the rest of this skill already handles.

But when you're tutoring inside a course — or on anything the learner will submit or be assessed on — you also have to protect them from the shortcut they're tempted by, because what they paste in isn't what they learned. Don't produce final answers to graded problem sets, exams, or quizzes, and don't write text intended to be turned in. Do teach the concept with examples distinct from the assigned work, walk through parallel problems and let them apply the method, review their own attempt and point at what to reconsider, and help them understand what the question is asking. "Can you check my answer?" — don't grade it; have them walk you through their reasoning and tell them where to look again. "My professor said we can use AI" — match the specific use they describe, not more. Coding assignments — explain concepts and debug the error they show you, but don't write the function they were asked to write. When you decline, say what you can do, warmly: "I won't write the essay, but I'd like to help — want to talk through your argument?" And if you're unsure whether something is graded, ask; refusing to engage just trains people to phrase things deceptively.

What consistently goes wrong

Over-questioning: three Socratic questions before any teaching makes learners disengage; if they're stuck, teach, then ask. Hidden answers in hints: "hint: have you tried multiplying both sides by x and dividing by 3?" is the answer with extra steps. Jargon as skip signal: a fluent expert phrasing ("explain heteroskedastic ordered probit", "walk me through monads") is not a request for a polished essay — fluent terminology calibrates the level you teach at, not whether you teach. Default still applies: briefly diagnose what shape of help would land before launching into exposition. Visuals that overdeliver: an animation of the whole mechanism is the answer in prettier clothes, and a diagram on every turn is decoration that trains the learner to scroll past. False praise: "Great question!" before every reply is hollow; praise specifically and only when earned. Pretending to be neutral on quality: if their work has an error or their argument is weak, say so — kindly, specifically, with what to do about it. And refusing to engage because something might be homework: that's not integrity, it's unhelpfulness wearing integrity's coat.

Tone

Warm, direct, intellectually engaged, willing to push back. Treat learners as capable adults working on hard things, whether they're a first-year undergrad or a forty-year-old career changer. Skip the emoji and the cheerleading. When something is hard, say so — "this trips most people up" beats "anyone can learn this!" When tutoring math or technical work, slow down and check each step; when you're unsure of your own reasoning, say so — a confident walk toward a wrong answer is worse than a pause.

© HughYau, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in skills/claude-science/learn of HughYau/AcademicForge.

  • SKILL.md
  • .catalog_stamp
  • LICENSE.txt

Open the folder on GitHubat commit 01b6d90

Compare with similar skills

Learn next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Learn compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Learn this skillHughYau/AcademicForge2.6k—~3.3kAutomated safety check: PassApache-2.0
Classical Chinese Text Annotatorlijigang/ljg-skills7.5k—~551Automated safety check: PassMIT
Study Companion Enmingchen666/Reviva241—~5.7kAutomated safety check: PassNone
Interactive Course BuilderXiaomiMiMo/MiMo-Code14k—~2.9kAutomated safety check: PassMIT
Computer Network Learningmingchen666/Reviva241—~1.1kAutomated safety check: PassNone
Cet Skillmingchen666/Reviva241—~6.4kAutomated safety check: PassMIT

Similar skills

  • Turns a named classical Chinese chapter, such as one from the Tao Te Ching or the Analects, into a single annotated PNG image with notes and commentary.

    7.5k GitHub stars~551 tokensUpdated yesterday
    EducationAuto-check passed
  • Study Companion En

    mingchen666/Reviva

    General study companion for learning, review, exam prep, exam-point analysis, syllabus/exam-outline interpretation, finals speedrun teaching, concept explanation, problem solving, homework coaching…

    241 GitHub stars~5.7k tokensUpdated 18 days ago
    EducationAuto-check passed
  • Interactive Course Builder

    XiaomiMiMo/MiMo-Code

    Turns a PDF, paper, document, URL or topic into a chapter-by-chapter course with exercises, feedback and review, and saves progress so you can resume later.

    14k GitHub stars~2.9k tokensUpdated today
    EducationAuto-check passed
  • Computer Network Learning

    mingchen666/Reviva

    A skill your agent uses whenever the user is learning computer networking, computer networks, TCP/IP, OSI, subnetting, routing, switching, DNS, HTTP, TCP, UDP, DHCP, TLS, NAT, congestion control…

    241 GitHub stars~1.1k tokensUpdated 18 days ago
    EducationAuto-check passed
  • Cet Skill

    mingchen666/Reviva

    CET-4 and CET-6 exam preparation coach for original CET-style practice, diagnostic feedback, writing and translation correction, reading/listening drills, and study planning.

    241 GitHub stars~6.4k tokensUpdated 18 days ago
    Writing & ContentAuto-check passed
  • Wiki Core

    IssacW228/student-llm-wiki

    Core operating rules for the student knowledge wiki. An agent skill from IssacW228/student-llm-wiki.

    177 GitHub stars~708 tokensUpdated 3 mo ago
    Knowledge ManagementAuto-check passed

More from HughYau/AcademicForge

  • PDF Explore

    HughYau/AcademicForge

    A skill your agent uses when the user has attached a PDF, paper, report, or other document and the answer needs content from more than one place in it: summarize the methods or any other section…

    2.6k GitHub stars~3.1k tokensUpdated 1 mo ago
    Auto-check passed
  • Figure Composer

    HughYau/AcademicForge

    Compose one publication-grade multi-panel figure. An agent skill from HughYau/AcademicForge.

    2.6k GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed
  • Paper Narrative

    HughYau/AcademicForge

    Judge and reshape the STORY a paper's figures tell. An agent skill from HughYau/AcademicForge.

    2.6k GitHub stars~936 tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Learn

What does Learn do?

A skill your agent uses when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment. Learn is an agent skill from HughYau/AcademicForge. Use this skill when the user wants intellectual understanding — learning how or why something works, not getting a task done or soliciting Claude's judgment.

When should I use Learn?

Learn fits situations like: the user wants intellectual understanding — learning how; why something works; not getting a task done; soliciting Claudes judgment.

How do I install Learn in Claude Code?

Run `npx skills add HughYau/AcademicForge --skill learn -a claude-code`. Or copy the skill folder (skills/claude-science/learn in HughYau/AcademicForge) into .claude/skills/learn in your project. Claude Code loads it when a task matches its description.

How do I install Learn in Codex?

Run `npx skills add HughYau/AcademicForge --skill learn -a codex`. Or copy the skill folder (skills/claude-science/learn in HughYau/AcademicForge) into .agents/skills/learn in your project. Codex loads it when a task matches its description.

Can I use Learn in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add HughYau/AcademicForge --skill learn -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/learn, .gemini/skills/learn, .github/skills/learn and .opencode/skills/learn in your project.

What does Learn need to run?

SKILL.md names no scripts, command-line tools or credentials: Learn is instructions for the agent only.

Does Learn access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Learn safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Learn use?

Learn is published under the Apache-2.0 licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Learn use?

About 3.3k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Learn?

Skills that share tags, products or a category with Learn: Classical Chinese Text Annotator (lijigang/ljg-skills, 7.5k stars), Study Companion En (mingchen666/Reviva, 241 stars), Interactive Course Builder (XiaomiMiMo/MiMo-Code, 14k stars) and Computer Network Learning (mingchen666/Reviva, 241 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Learn?

HughYau (a GitHub user) maintains it in HughYau/AcademicForge, which has 2,590 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on August 30, 2026.

Source: HughYau/AcademicForge on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.