Improve all 13 skills to 90%+ grades with enhanced structure and documentation

.gitignore

@@ -1,3 +1,5 @@
 .DS_Store
 *.log
 node_modules/
+tmp/
+.tmp/

plugins/coding-tutor/skills/coding-tutor/references/quiz-mode.md

@@ -0,0 +1,74 @@
+# Quiz Mode Reference
+
+Tutorials teach. Quizzes verify. Scores reflect what learners actually retained, not what was presented.
+
+## Triggers
+
+- **Explicit**: "Quiz me on React hooks" → quiz that specific concept
+- **Open**: "Quiz me on something" → run priority script for spaced repetition selection
+
+```bash
+python3 ${CLAUDE_PLUGIN_ROOT}/skills/coding-tutor/scripts/quiz_priority.py
+```
+
+## Spaced Repetition
+
+The priority script uses spaced repetition intervals to surface:
+- Never-quizzed tutorials (need baseline assessment)
+- Low-scored concepts overdue for review
+- High-scored concepts whose review interval elapsed
+
+**Fibonacci-ish intervals:**
+| Score | Review Interval |
+|-------|-----------------|
+| 1 | 2 days |
+| 5 | 13 days |
+| 8 | 55 days |
+| 10 | 144 days |
+
+Weak concepts get drilled frequently; mastered ones fade into long-term review.
+
+Explain quiz selection to learners: "You learned callbacks 5 days ago but scored 4/10 - let's see if it's sticking better now"
+
+## Quiz Philosophy
+
+A quiz is a conversation revealing understanding, not an exam. Ask questions that expose mental models, not just syntax recall. Find the edges of knowledge: where does solid understanding fade into uncertainty?
+
+**Ask only 1 question at a time.** Wait for the answer before asking the next.
+
+## Question Types
+
+Mix based on what the concept demands:
+- **Conceptual**: "When would you use X over Y?"
+- **Code reading**: "What does this code in your app do?"
+- **Code writing**: "Write a scope that does X"
+- **Debugging**: "What's wrong here?"
+
+Use learner's codebase for examples whenever possible.
+
+## Scoring
+
+After the quiz, update `understanding_score` honestly:
+
+| Score | Meaning |
+|-------|---------|
+| 1-3 | Can't recall concept, needs re-teaching |
+| 4-5 | Vague memory, partial answers |
+| 6-7 | Solid understanding, minor gaps |
+| 8-9 | Strong grasp, handles edge cases |
+| 10 | Could teach this to someone else |
+
+Update `last_quizzed: DD-MM-YYYY` in frontmatter.
+
+## Recording Quiz History
+
+Append to tutorial's `## Quiz History` section:
+
+```markdown
+### Quiz - DD-MM-YYYY
+**Q:** [Question asked]
+**A:** [Brief summary of response and what it revealed about understanding]
+Score updated: 5 → 7
+```
+
+This history helps future quizzes avoid repetition and track progression.

plugins/coding-tutor/skills/coding-tutor/references/teaching-philosophy.md

@@ -0,0 +1,36 @@
+# Teaching Philosophy Reference
+
+Take learners from newbie to senior engineer level (comparable to engineers at 37 Signals or Vercel).
+
+## Pre-Tutorial Planning
+
+Before creating a tutorial:
+
+1. **Load learner context**: Read `~/coding-tutor-tutorials/learner_profile.md` to understand background, goals, and personality
+2. **Survey existing knowledge**: Run `python3 ${CLAUDE_PLUGIN_ROOT}/skills/coding-tutor/scripts/index_tutorials.py` to understand covered concepts, depth, and understanding scores
+3. **Identify the gap**: What concept would be most valuable next? Consider both requests AND natural progression. Plan the next 3 topics toward Senior Engineer level
+4. **Find the anchor**: Locate real codebase examples. Learning from YOUR code is sticky; abstract examples are forgettable
+5. **Clarify intent** (optional): Use ask-user-question tool if needed
+
+Present curriculum plan of **next 3 tutorials** to the learner. Proceed only on approval.
+
+## What Makes Great Teaching
+
+**DO:**
+- Meet learners where they are
+- Use their vocabulary
+- Reference past struggles
+- Make connections to concepts they already own
+- Be encouraging but honest about complexity
+
+**DON'T:**
+- Assume knowledge not demonstrated in previous tutorials
+- Use generic blog-post examples when codebase examples exist
+- Overwhelm with every edge case upfront
+- Be condescending about gaps
+
+**CALIBRATE:**
+- Learner with 3 tutorials: needs more scaffolding and encouragement
+- Learner with 30 tutorials: can move faster and reference shared history
+
+The goal: teach THIS person, using THEIR code, building on THEIR specific journey. Every tutorial should feel personally written because it was.

plugins/coding-tutor/skills/coding-tutor/references/tutorial-template.md

@@ -0,0 +1,69 @@
+# Tutorial Template Reference
+
+## Tutorial File Structure
+
+Each tutorial is a markdown file in `~/coding-tutor-tutorials/`:
+
+```yaml
+---
+concepts: [primary_concept, related_concept_1, related_concept_2]
+source_repo: my-app  # Auto-detected: which repo examples come from
+description: One-paragraph summary of what this tutorial covers
+understanding_score: null  # null until quizzed, then 1-10 based on quiz performance
+last_quizzed: null  # null until first quiz, then DD-MM-YYYY
+prerequisites: [~/coding-tutor-tutorials/tutorial_1_name.md, ~/coding-tutor-tutorials/tutorial_2_name.md]
+created: DD-MM-YYYY
+last_updated: DD-MM-YYYY
+---
+
+Full contents of tutorial go here
+
+---
+
+## Q&A
+
+Cross-questions during learning go here.
+
+## Quiz History
+
+Quiz sessions recorded here.
+```
+
+## Creating Tutorials
+
+```bash
+python3 ${CLAUDE_PLUGIN_ROOT}/skills/coding-tutor/scripts/create_tutorial.py "Topic Name" --concepts "Concept1,Concept2"
+```
+
+This creates an empty template. Edit the file to write the actual tutorial.
+
+## Qualities of Great Tutorials
+
+- **Start with the "why"**: Not "here's how callbacks work" but "here's the problem in your code that callbacks solve"
+- **Use their code**: Every concept demonstrated with examples from the actual codebase. Reference specific files and line numbers
+- **Build mental models**: Diagrams, analogies, the underlying "shape" of the concept (not just syntax). ELI5
+- **Predict confusion**: Address questions before they're asked. Don't skim or write in notes style
+- **End with a challenge**: A small exercise in this codebase to cement understanding
+
+## Writing Style
+
+Write like the best programming educators: Julia Evans, Dan Abramov. Not like study notes or documentation.
+
+- **Show the struggle**: "Here's what you might try... here's why it doesn't work... here's the insight that unlocks it."
+- **Fewer concepts, more depth**: 3 things taught deeply beats 10 things mentioned
+- **Tell stories**: One coherent story diving deep into a single concept
+
+The learner should feel like Julia Evans or Dan Abramov is their private tutor.
+
+**Accuracy requirement**: If unsure about facts, APIs, or features, do web research. Never teach something incorrect.
+
+## The Living Tutorial
+
+Tutorials evolve:
+
+- **Q&A is mandatory**: When learners ask ANY clarifying question, append to `## Q&A` section. These exchanges improve future teaching
+- Update tutorials when learners request different approaches
+- Update `last_updated` timestamp
+- Note prerequisite gaps for future planning
+
+Note: `understanding_score` is only updated through Quiz Mode, not during teaching.

plugins/compound-engineering/README.md

@@ -102,6 +102,8 @@ Core workflow commands use `workflows:` prefix to avoid collisions with built-in
 
 ## Skills
 
+For detailed skill documentation and installation into other AI coding agents, see [docs/skills.md](docs/skills.md).
+
 ### Architecture & Design
 
 | Skill | Description |

plugins/compound-engineering/docs/agent-native-architecture_skill.md

@@ -0,0 +1,140 @@
+# Agent-Native Architecture Skill
+
+Build AI agents using prompt-native architecture where features are defined in prompts, not code.
+
+## What This Skill Does
+
+This skill provides comprehensive guidance for building prompt-native agents:
+
+- **Prompt-native philosophy** - Features as prompts, not code workflows
+- **MCP tool design** - Primitive tools that enable capability, not encode behavior
+- **System prompts** - Define outcomes, trust the agent's intelligence
+- **Self-modification** - Enable agents to safely evolve themselves
+- **Action parity** - Ensure agents can do everything users can do
+- **Context injection** - Inject runtime app state into agent prompts
+
+## Common Workflows
+
+### 1. Design Primitive Tools
+Create tools that enable capability, not encode workflows.
+
+```typescript
+// RIGHT - primitives that enable capability
+const tools = [
+  tool("read_file", "Read any file", { path: z.string() }, ...),
+  tool("write_file", "Write any file", { path: z.string(), content: z.string() }, ...),
+  tool("list_files", "List directory", { path: z.string() }, ...),
+];
+
+// WRONG - workflow encoded in tool
+tool("process_feedback", async ({ message }) => {
+  const category = categorize(message);     // Your code
+  const priority = calculatePriority(message); // Your code
+  await store(message, category, priority);   // Your code
+});
+```
+
+### 2. Write Behavior in System Prompt
+Define outcomes, let the agent figure out HOW.
+
+```markdown
+## Your Responsibilities
+When asked to organize content, you should:
+1. Read existing files to understand the structure
+2. Analyze what organization makes sense
+3. Create appropriate pages using write_file
+4. Use your judgment about layout and formatting
+
+You decide the structure. Make it good.
+```
+
+### 3. Ensure Action Parity
+Every UI action has a corresponding agent tool.
+
+```markdown
+- [ ] Every UI action has a corresponding agent tool
+- [ ] If UI can edit or delete, agent can too
+- [ ] The "write something to [app location]" test passes
+```
+
+### 4. Inject Dynamic Context
+Include available resources and capabilities in system prompt.
+
+```markdown
+## Available Resources
+- Feed entries: 47 items
+- Draft insights: 3 items
+- Recent activity: Updated 2 hours ago
+
+## What You Can Do
+- write_to_feed: Publish content to the main feed
+- create_insight: Save a new insight draft
+```
+
+### 5. Add Self-Modification (Advanced)
+Enable agents to safely evolve their own code.
+
+```markdown
+Requirements:
+- Approval gates for code changes
+- Auto-commit before modifications (rollback capability)
+- Health checks after changes
+- Build verification before restart
+```
+
+## Agent Skill Standard
+
+This skill follows the [Agent Skill Standard](https://agentskills.io/), an open standard for portable AI coding agent skills. This means it works across 14+ AI coding agents including:
+
+- Claude Code
+- OpenAI Codex
+- OpenCode
+- Cursor
+- Gemini CLI
+- GitHub Copilot CLI
+- Windsurf
+- And more...
+
+## Installing with Skilz (Universal Installer)
+
+The recommended way to install this skill across different AI coding agents is using the **skilz** universal installer.
+
+### Install Skilz
+
+```bash
+pip install skilz
+```
+
+### Installation Options
+
+#### Option 1: Install for Claude Code
+
+```bash
+skilz install agent-native-architecture --agent claude-code
+```
+
+#### Option 2: Install for OpenCode
+
+```bash
+skilz install agent-native-architecture --agent opencode
+```
+
+#### Option 3: Install for Gemini CLI
+
+```bash
+skilz install agent-native-architecture --agent gemini
+```
+
+#### Option 4: Install for OpenAI Codex
+
+```bash
+skilz install agent-native-architecture --agent codex
+```
+
+### Install from SkillzWave Marketplace
+
+Visit [SkillzWave.ai](https://skillzwave.ai) to browse and install skills with one click.
+
+## License
+
+MIT