kp-content-authoring

$npx mdskill add Tibsfox/gsd-skill-creator/kp-content-authoring

Generates complete knowledge pack content suites for educational agents.

  • Creates vision docs, modules YAML, activities JSON, and assessment frameworks.
  • Depends on file system access to knowledge pack directories.
  • Triggers on intents like pack creation or content file updates.
  • Outputs structured files directly into the pack's source folder.

SKILL.md

.github/skills/kp-content-authoringView on GitHub ↗
---
name: kp-content-authoring
description: "Generates knowledge pack content suites: vision documents, modules YAML, activities JSON, assessment frameworks, resource catalogs, and .skillmeta files. Shared by all 3 tier-specific author agents. Use when creating or updating pack content files."
metadata:
  extensions:
    gsd-skill-creator:
      triggers:
        intents:
          - "pack.*create|create.*pack"
          - "pack.*content"
          - "vision.*doc"
          - "module.*yaml"
          - "activit.*json"
          - "assessment.*framework"
        files:
          - "src/knowledge/packs/**/vision.md"
          - "src/knowledge/packs/**/modules.yaml"
          - "src/knowledge/packs/**/activities.json"
          - "src/knowledge/packs/**/assessment.md"
          - "src/knowledge/packs/**/resources.md"
          - "src/knowledge/packs/**/.skillmeta"
        contexts:
          - "knowledge pack authoring"
          - "educational content creation"
        threshold: 0.7
      token_budget: "2.0%"
      version: 1
      enabled: true
      plan_origin: "244-chipset-agent-definitions"
      phase_origin: "244"
---

# Content Authoring

## Purpose

Provides the content generation methodology for all 35 knowledge packs. This is the shared authoring skill loaded by KP-02 (core), KP-03 (applied), and KP-04 (specialized). It defines the pack file structure, content templates, quality standards, and parallel instruction patterns that enable token caching across packs.

## Capabilities

- Vision document generation following PACK-TEMPLATE.md structure (~40 pages per pack)
- Modules YAML with learning outcomes, topics, grade levels, time estimates, and prerequisite chains
- Activities JSON with grade-appropriate hands-on activities per module
- Assessment framework with rubric levels (Beginning, Developing, Proficient, Advanced)
- Resource catalog with categorized links by audience and grade level
- .skillmeta YAML generation with full KnowledgePackSchema compliance
- Grade level spanning: PreK through College+ with appropriate content differentiation
- Learning pathway support: Maker, Academic, Curiosity, Social, Parent-Guided

## Parallel Instruction Patterns (NFR-06)

The following instruction sections are identical across all 35 packs and should be cached:

1. **Pack file structure template** -- the 6-file directory layout is the same for every pack
2. **Vision document skeleton** -- section headings (Vision, Problem Statement, Core Concepts, Skill Tree, Modules, Assessment Framework, Parent Guidance, Resources) are reused
3. **Modules YAML schema** -- PackModuleSchema structure with time_estimates, prerequisite_modules, activities sub-objects
4. **Activities JSON schema** -- PackActivitySchema with grade_range, duration_minutes, materials, learning_objectives
5. **Assessment rubric template** -- 4-level rubric (Beginning, Developing, Proficient, Advanced) with formative/summative sections
6. **Resource catalog template** -- categorized sections (Young Learners, Older Learners, Parents, Deeper Study)
7. **.skillmeta boilerplate** -- common fields (version, status, copyright, gsd_integration, accessibility stubs, translation stubs)
8. **Grade level bands** -- Foundation (PreK-K), Elementary (1-5), Middle School (6-8), High School (9-12), College (13-16)

These 8 patterns are loaded once and reused across all pack generation sessions, reducing per-pack token overhead by ~60%.

## Key Modules

| Module | Purpose |
|--------|---------|
| `src/knowledge/types.ts` | Zod schemas defining pack data structures |
| `src/knowledge/skillmeta-parser.ts` | Validates generated .skillmeta against KnowledgePackSchema |
| `src/knowledge/vision-parser.ts` | Validates generated vision documents |
| `src/knowledge/activity-loader.ts` | Validates generated activities JSON |
| `src/knowledge/assessment-loader.ts` | Validates generated assessment markdown |
| `src/knowledge/resource-loader.ts` | Validates generated resource catalogs |

## Usage Examples

**Generate a pack content suite:**
```
For each pack (e.g., MATH-101):
1. Create src/knowledge/packs/math-101/ directory
2. Write vision.md using pack-specific content + shared template sections
3. Write modules.yaml matching ModulesFileSchema
4. Write activities.json as PackActivity[] array
5. Write assessment.md with 4-level rubric
6. Write resources.md with categorized links
7. Write .skillmeta matching KnowledgePackSchema
```

**Apply parallel instruction patterns:**
```
Before generating any pack, load:
- Pack file structure template (shared)
- Vision document skeleton (shared)
- Modules YAML schema (shared)
- Activities JSON schema (shared)
- Assessment rubric template (shared)
- Resource catalog template (shared)
- .skillmeta boilerplate (shared)
- Grade level bands (shared)
Then inject pack-specific: subject content, domain activities, subject-specific resources
```

## Dependencies

- Pack runtime API (src/knowledge/) for schema validation
- Domain-specific skill (core, applied, or specialized) for subject matter knowledge
- Pack template structure from delivery package

## Token Budget Rationale

2.0% budget reflects the comprehensive authoring methodology covering 6 file types, 8 parallel instruction patterns, and the pack generation workflow. This is the largest knowledge pack skill because it provides the reusable templates that reduce per-pack generation cost. Shared across 3 agents but loaded once per session.

More from Tibsfox/gsd-skill-creator

SkillDescription
3d-interaction-designDesign heuristics for three-dimensional interaction — input modalities (6DoF controllers, gaze, gesture, voice), selection and manipulation techniques (ray-cast, virtual hand, go-go, world-in-miniature), navigation (teleport, continuous, redirected walking), and feedback loops (haptic, audio, visual). Covers Fitts' law in 3D, discoverability vs affordance, safe-zone design, and comfort/simulator sickness mitigation. Use when designing VR/AR interactions, immersive walkthroughs, or any input system where the user's body is the controller.
accessibility-patternsProvides web accessibility best practices for semantic HTML, ARIA, keyboard navigation, color contrast, and screen reader patterns. Use when building UI components, reviewing accessibility, or when user mentions 'a11y', 'accessibility', 'ARIA', 'screen reader', 'keyboard navigation', 'WCAG'.
active-listeningActive listening techniques for effective communication. Covers attending behaviors, paraphrasing, reflective listening, clarifying questions, empathic response, barriers to listening, listening in conflict, and cross-cultural listening. Use when building listening skills, improving understanding in conversation, mediating disputes, or analyzing communication breakdowns.
adversarial-pr-reviewAdversarial spec-compliance PR review — cross-references diffs against approved specs, verifies runtime claims against source, detects competing PRs, audits scope/convention compliance. Use before merging.
agile-methodsAgile and Lean software development methodologies for iterative, adaptive project execution. Covers Scrum (roles, ceremonies, artifacts), Kanban (WIP limits, flow metrics), XP (TDD, pair programming, CI), SAFe overview, Lean Software Development (Poppendieck's 7 principles), user stories (INVEST criteria), estimation via story points and velocity, and the Agile Manifesto's values and principles. Includes Cynefin framework for methodology selection and GSD's relationship to Agile as a structured Lean variant.
algebraic-reasoningSymbolic manipulation, equation solving, and algebraic structures for mathematical reasoning. Covers distributive law, factoring, completing the square, linear through polynomial equation solving, systems of equations (substitution, elimination, Gaussian elimination, matrix methods), algebraic structures (groups, rings, fields), modular arithmetic, polynomial theory, and inequalities. Use when solving equations, simplifying expressions, working with algebraic structures, or performing symbolic manipulation.
algorithmic-awarenessUnderstanding how algorithmic systems shape what users see, know, and do -- from recommendation feeds to search ranking to credit scoring to hiring software. Covers the mechanics of recommendation systems, algorithmic bias and its sources, personalization's effects on information diets, opacity and accountability, AI limitations (hallucination, confident wrongness), and the human-in-the-loop question. Use when a learner needs to think critically about why particular content reached them.
algorithms-data-structuresAlgorithms and data structures from first principles through advanced analysis. Covers sorting (bubble, insertion, selection, merge, quick, heap, radix), searching (linear, binary, BFS, DFS, Dijkstra, A*), fundamental data structures (arrays, linked lists, stacks, queues, hash tables, trees, heaps, graphs, tries), complexity analysis (Big-O, Big-Omega, Big-Theta, amortized), recurrence relations, and algorithm design paradigms (divide-and-conquer, greedy, dynamic programming, backtracking). Use when analyzing, selecting, implementing, or comparing algorithms and data structures.
aminet-browserAminet search and browse: full-text search, category tree navigation, architecture filtering, package detail, and curated collections. Use when searching, browsing, or managing package collections.
aminet-emulatorFS-UAE emulator configuration and launch: hardware profiles, ROM management, WHDLoad integration, config generation, and state snapshots. Use when configuring emulation, managing ROMs, or launching Amiga software.