メニュー
Generates a glossary from the learning graph's concept list with ISO 11179-compliant definitions (precise, concise, non-circular). Use after the learning graph concept list is finalized.
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
Generates illustrated graphic novel narratives about scientists, mathematicians, and historical figures for intelligent textbooks, with image prompts for each panel. Use when adding historical-figure or case-study stories to a textbook's Stories section.
Installs and configures intelligent-textbook infrastructure - scaffold a brand-new MkDocs Material textbook (init textbook), install any of 40 features (math, mascot, learning graph viewer, Google Analytics GA4, custom 404, kanban board), and generate book metrics. Routes to the appropriate installation guide.
Creates interactive educational MicroSims, routing to the best-matched generator - p5.js, Chart.js, Plotly, Mermaid, vis-network, timelines, maps, Venn, causal-loop/feedback-loop diagrams (CLD), concept-classifier sorting quizzes, infographic overlays with callout labels, and Docker Python labs (runnable code blocks). Generates complete MicroSim packages with HTML, JavaScript, CSS, documentation, and metadata.
Generates a comprehensive learning graph from a course description, including 200 concepts with dependencies, taxonomy categorization, and quality validation reports. Use this when the user wants to create a structured knowledge graph for educational content.
Wires Google Analytics 4 into an MkDocs Material site — creates a GA4 property, writes the Measurement ID into mkdocs.yml, verifies the tag, and deploys. Use when adding analytics to a textbook for the first time.
Generates detailed chapter content for an intelligent textbook — text, diagrams, MicroSims, and exercises at the appropriate Bloom's level. Use when a chapter's index.md exists with title, summary, and concept list.
SOC 職業分類に基づく
| name | glossary-generator |
| description | Generates a glossary from the learning graph's concept list with ISO 11179-compliant definitions (precise, concise, non-circular). Use after the learning graph concept list is finalized. |
| model | sonnet |
| license | null |
Generate a comprehensive glossary of terms from a learning graph's concept list with ISO 11179-compliant definitions.
This skill generates large files (2,000+ lines). Token cost matters far more than wall-clock time for teacher users on limited budgets.
Default approach: ONE serial Task agent that writes all definitions directly to a temp file. This is the most token-efficient method because:
| Component | Tokens | Notes |
|---|---|---|
| Agent overhead (system prompt + tools) | ~12K | Paid once for serial, 4× for parallel |
| Definition generation (350 terms) | ~19K | Unavoidable LLM work |
| Assembly (Python script) | ~700 | Trivial programming task |
| Total (serial) | ~31K |
Tokens per term: ~88 total, ~54 marginal (after subtracting one-time overhead).
The marginal cost is calculated as: (30,788 − 12,000) / 350 = ~54 tokens/term. Use this to estimate costs for glossaries of any size:
| Glossary size | Estimated total tokens |
|---|---|
| 100 terms | ~17K (12K overhead + 5.4K generation) |
| 200 terms | ~23K |
| 350 terms | ~31K (measured) |
| 500 terms | ~39K |
Each parallel agent pays the full ~12K system prompt overhead independently. For glossary generation, the definitions are completely independent — there is no speedup benefit that justifies the cost. The serial agent writes all terms in a single Write call and finishes in ~6 minutes, which is perfectly acceptable.
| Approach | Agent overhead | Generation | Assembly | Total | Waste |
|---|---|---|---|---|---|
| 1 serial agent (recommended) | ~12K (once) | ~19K | ~700 | ~31K | — |
| 4 parallel agents + script | ~48K (4×) | ~19K | ~700 | ~68K | +37K (119%) |
| 4 parallel agents + manual Edit | ~48K (4×) | ~19K | ~200K | ~267K | +236K (761%) |
Parallel execution more than doubles the token cost for zero quality benefit. For teachers on the Claude Pro plan (~200K token five-hour budget), the serial approach uses ~16% of their budget vs. 34% (parallel) or 100%+ (manual assembly).
NEVER use parallel agents for glossary generation. The token waste is not justified.
Always use the serial approach. Do not offer parallel as an option.
The assembly step (sorting and writing the final file) MUST always use a Python
script — NEVER manually emit glossary content through Edit/Write tool calls.
See logs/glossary-generation-very-inefficient.md for the full post-mortem.
This skill automates glossary creation for intelligent textbooks by converting concept labels from a learning graph into properly formatted glossary definitions. Each definition follows ISO 11179 metadata registry standards: precise, concise, distinct, non-circular, and free of business rules. The skill ensures consistency across terminology, validates cross-references, and produces alphabetically ordered entries with relevant examples.
Following a short definition you may provide a discussion of why the term is important in the textbook and an example of how the term is used.
Use this skill after the Learning Graph skill has completed and the concept list has been finalized. All markdown content in the /docs area can also be scanned looking for words or phases that might not be clear to the average high-school student.
The glossary relies on having a complete, reviewed list of concepts from the learning graph's concept enumeration phase. Specifically, trigger this skill when:
docs/learning-graph/02-concept-list-v1.md)Before generating definitions, assess the quality of the concept list:
docs/learning-graph/02-concept-list-v1.md)Calculate a quality score (1-100 scale):
User Dialog Triggers:
Read the course description file (docs/course-description.md) and any other markdonw files in /docs/**/*.md to understand:
Default approach (most token-efficient): Launch ONE Task agent that generates all definitions and writes them directly to a single temp file.
Task agent prompt:
"Generate ISO 11179-compliant glossary definitions for the following [N] terms.
Write ALL entries as markdown (#### headers with definitions, examples, and
discussion) to the file /tmp/glossary-raw.md using the Write tool.
Each entry uses #### for the term header. Do not return the content in your
response — just confirm the file was written and report the term count.
[Paste the full term list here]
[Paste course description context here for audience level]"
The single agent writes all definitions to one file. This pays system-prompt overhead only once (~12K tokens) and avoids all coordination costs. Proven at ~31K tokens for a 350-term glossary (~88 tokens/term total, ~54 tokens/term marginal).
Do NOT use parallel agents for glossary generation. See the TOKEN EFFICIENCY WARNING section above for why parallel execution should never be used — it more than doubles the token cost for zero quality benefit.
For each concept in the list, create a definition that follows ISO 11179 standards:
Precision (25 points): Accurately capture the concept's meaning
Conciseness (25 points): Keep definitions brief (target: 20-50 words)
Distinctiveness (25 points): Make each definition unique and distinguishable
Non-circularity (25 points): Avoid circular dependencies
Example Format:
For a concept "Learning Graph":
#### Learning Graph
A directed graph of concepts that reflects the order that concepts should be learned to master a new concept.
Learning graphs are the foundational data structure use for intelligent textbooks. They are used to guide
intelligent agents and recommend learning paths for students.
**Example:** In a programming course, the learning graph shows that "Variables" must be understood before "Functions," which must be understood before "Recursion."
For most concepts (target: 60-80%), include a relevant example:
Where appropriate, reference related terms:
CRITICAL: NEVER manually assemble the glossary through Edit/Write tool calls. Alphabetical sorting and file merging is a trivial programming task. Doing it manually through LLM text generation wastes 100,000+ tokens that cost real money.
MANDATORY APPROACH: Write and execute a Python script via the Bash tool that:
/tmp/glossary-raw.md (serial) or /tmp/glossary-part-*.md (parallel)#### headerssorted()docs/glossary.md in one passReference script (adapt paths as needed):
#!/usr/bin/env python3
"""Merge glossary parts into a single sorted glossary."""
import glob, os, re
entries = {}
# Support both serial (single file) and parallel (multiple files)
if os.path.exists('/tmp/glossary-raw.md'):
sources = ['/tmp/glossary-raw.md']
else:
sources = sorted(glob.glob('/tmp/glossary-part-*.md'))
for path in sources:
with open(path) as f:
content = f.read()
for block in re.split(r'\n(?=#### )', content):
block = block.strip()
m = re.match(r'#### (.+)', block)
if m:
entries[m.group(1).strip()] = block
sorted_terms = sorted(entries.keys(), key=lambda t: t.lower().lstrip('0123456789-'))
with open('docs/glossary.md', 'w') as out:
out.write('# Glossary of Terms\n\n')
for term in sorted_terms:
out.write(entries[term] + '\n\n')
print(f"Wrote {len(sorted_terms)} terms to docs/glossary.md")
Run this script with python3 /tmp/assemble_glossary.py via the Bash tool.
Total cost: ~500 tokens for the script + ~200 tokens for output = ~700 tokens
(versus 200,000+ tokens if done manually through Edit calls).
NEVER DO ANY OF THE FOLLOWING:
Formatting rules for the assembled file:
####) are allowed for glossary terms. Do not use ## section headers, ### subheadings, or any other header level inside the glossary. The only # header in the file is the page title (# Glossary of Terms). Everything else is ####.--- strings in the glossary. They are not needed.Create docs/learning-graph/glossary-quality-report.md with:
ISO 11179 Metadata Registry Compliance Metrics:
For each definition, score on 5 criteria (25 points each):
Overall Quality Metrics:
Readability:
Recommendations:
Perform final validation:
Success Criteria:
If - Glossary: glossary.md is not yet in the nav: of mkdocs.yml, add it
near the end (before License/Contact), following the canonical nav-editing
rules in $HOME/.claude/skills/book-installer/references/mkdocs-nav-editing.md.
Create docs/learning-graph/glossary-cross-ref.json for semantic search:
{
"terms": [
{
"term": "Learning Graph",
"related_terms": ["Concept Dependency", "Directed Acyclic Graph"],
"contrasts_with": ["Linear Curriculum"],
"category": "Educational Technology"
}
]
}
This JSON file enables future features like:
Use this rubric to score each definition (1-100 scale):
85-100: Excellent
70-84: Good
55-69: Adequate
Below 55: Needs Revision
Circular Definitions:
Too Vague:
Too Long:
Business Rules:
Undefined Terms:
Required:
docs/glossary.md - Complete glossary in alphabetical order with ISO 11179-compliant definitionsRecommended:
docs/learning-graph/glossary-quality-report.md - Quality assessment and recommendationsOptional:
docs/learning-graph/glossary-cross-ref.json - JSON mapping for semantic searchmkdocs.yml navigation if glossary link missingUser: "Generate a glossary from my concept list"
Claude (using this skill):
docs/course-description.md (~5K tokens)/tmp/glossary-raw.md (~19K tokens)/tmp/assemble_glossary.py (~500 tokens)docs/glossary.md (~200 tokens)grep -c "^####" docs/glossary.md (~100 tokens)mkdocs.yml navigation if needed (~500 tokens)Measured result (2026-03-14): 350 terms generated and assembled in ~31K total tokens. At ~88 tokens/term (or ~54 tokens/term after subtracting agent overhead), this is the most efficient approach possible.
REMEMBER: The subagent generates text (unavoidable LLM work). The assembly is
a programming task — use sorted(), not the Edit tool. NEVER use parallel agents.