From learn-anything
This skill should be used when the Curriculum Architect has produced a learning plan and learning materials need generating, or on-demand when the Training Conductor needs new materials, or when the user invokes '/materials'. Orchestrates dedicated subagents to generate worked examples with fading, visual materials, SRS flashcard decks, assessment instruments, reference one-pagers, dependency graph visualizations, productive failure scenarios, interleaved practice sets, and encoding aids. All outputs conform to the system's JSON schemas and are exportable to Anki (.apkg), PDF, and Markdown.
npx claudepluginhub netrxn/learn-anything --plugin learn-anythingThis skill uses the workspace's default tool permissions.
Act as the production engine of a meta-learning system. Generate all the tangible learning materials: flashcard decks, exercises, reference sheets, assessments, and visualizations. Quality is make-or-break — bad materials produce bad learning.
Generates design tokens/docs from CSS/Tailwind/styled-components codebases, audits visual consistency across 10 dimensions, detects AI slop in UI.
Records polished WebM UI demo videos of web apps using Playwright with cursor overlay, natural pacing, and three-phase scripting. Activates for demo, walkthrough, screen recording, or tutorial requests.
Delivers idiomatic Kotlin patterns for null safety, immutability, sealed classes, coroutines, Flows, extensions, DSL builders, and Gradle DSL. Use when writing, reviewing, refactoring, or designing Kotlin code.
Act as the production engine of a meta-learning system. Generate all the tangible learning materials: flashcard decks, exercises, reference sheets, assessments, and visualizations. Quality is make-or-break — bad materials produce bad learning.
All state files live in learn-anything/<skill-slug>/. Read learn-anything/active-skill.json to find the active skill slug.
Before starting, read:
learn-anything/<skill-slug>/learning-plan.json — The curriculum: task classes, sequences, session templates, SRS schedulelearn-anything/<skill-slug>/knowledge-graph.json — The skill graph with learner overlay (for difficulty calibration and transfer-leveraged analogies)schemas/srs-cards.schema.json — Flashcard output formatreferences/card-design-guide.md — Card design principles and anti-patternsreferences/quality-rubrics.md — Quality checks for all material types../training-conductor/references/session-templates.md — Session templates (for designing template-aligned materials)Before proceeding, verify all required upstream state files exist and contain expected fields:
learning-plan.json exists and contains curriculum.task_classes (non-empty array)knowledge-graph.json exists and contains graph.verticesactive-skill.json exists and contains active fieldIf any required file is missing or its required fields are absent, report the issue to the user rather than proceeding with partial data.
Material Forge operates in two modes:
Full generation (after curriculum is created): Generate the complete material set for the initial curriculum — flashcards for all task classes, worked examples, reference materials, assessments, and the dependency graph visualization.
On-demand generation (during training): The Training Conductor requests specific materials for an upcoming session. Generate only what's needed for that session.
Material Forge acts as an orchestrator, dispatching dedicated subagents for each material type. Each subagent has its own context window, detailed templates, and QA checks.
Each subagent receives:
Each subagent runs its own quality check before returning results. Material Forge aggregates all outputs and does a final cross-check for:
After all subagents complete, verify all material types were generated for all applicable task classes. List any gaps and report to the user. Offer to regenerate missing materials via /materials.
For each task class in the learning plan:
references/card-design-guide.mdimage_svg field with inline SVG and set image_placement ("front", "back", or "both"). See references/card-design-guide.md for the visual heuristic, SVG constraints, and card field format. Not every card needs a visual — only add where a diagram meaningfully aids retrieval.Before finalizing any SVG, run this check:
Refer to references/card-design-guide.md for the complete color rules.
image_svg field. Do NOT substitute a Mermaid code block — Mermaid renders generically and cannot enforce the color contrast rules required for learning materials.Generate the anki_config once per plan:
import random
anki_config = {
"model_id_basic": random.randrange(1 << 30, 1 << 31),
"model_id_cloze": random.randrange(1 << 30, 1 << 31),
"model_id_reversed": random.randrange(1 << 30, 1 << 31),
"deck_id": random.randrange(1 << 30, 1 << 31)
}
Store in srs-cards.json and NEVER change these IDs.
Write the complete card set to learn-anything/<skill-slug>/srs-cards.json conforming to the schema. Then run the Anki export script at scripts/generate_anki.py (located within this skill's directory) with the srs-cards.json path as input to produce the .apkg file in the skill workspace.
For each task class, generate a fading sequence:
Adjust fading pace to learner level (from knowledge graph): novice = 1 step per 2 problems, intermediate = 1 per problem, advanced = 2 per problem.
Vary surface features across versions (different numbers, scenarios, contexts) while keeping the deep structure identical.
For each productive failure point flagged in the learning plan:
For each session that includes interleaving:
Prescriptive one-pager — For each task class or major concept cluster:
Practice one-pager — Companion to the prescriptive one-pager:
Generate as Markdown files. If PDF export is needed, use the pdf skill.
External resource list — Curated recommendations:
Generate a Mermaid flowchart showing the skill graph with mastery overlay:
flowchart TD
subgraph "Module: Fundamentals"
A["Variables (95%)"]:::mastered
B["Data Types (60%)"]:::developing
C["Control Flow"]:::not_started
end
A --> B
B --> C
classDef mastered fill:#22c55e,color:white
classDef developing fill:#eab308,color:black
classDef not_started fill:#d1d5db,color:black
Rules:
For each mastery gate in the learning plan, generate:
For delayed retention tests:
For transfer tasks:
For each vertex with difficulty_estimate > 0.5 or bloom_level in [remember, understand]:
Before presenting ANY material, run the four-check rubric from references/quality-rubrics.md:
If any check fails, regenerate before presenting.
For SRS cards specifically, also verify:
image_svg where diagrams would aid retrievalimage_placementBefore writing the output file, verify:
schemas/srs-cards.schema.json — all required fields present and correctly typedIf validation fails, fix the issue before writing. Do not write invalid JSON to the state file.
Save all materials to the skill workspace (learn-anything/<skill-slug>/):
srs-cards.json — Full flashcard set (schema-conforming)[plan-id].apkg — Anki export (generated by running the script)materials/ directory with:
Present a summary to the learner:
After writing srs-cards.json and materials/, the Dashboard Generator creates the progress visualization, then the system transitions to the LEARNING phase. Summarize for the learner: what materials were generated, how to import the Anki deck, and that training sessions are ready to begin.