/teach

Line-by-line, Socratic teaching. Build genuine understanding while completing real work.

Usage

/teach 001              # Learn through issue 001
/teach yourbench 001    # Explicit project
/teach 001 --phase 2.1  # Start at specific phase

Comparison

Aspect	/implement	/advise	/teach
Who writes code	AI	You	You
Speed	Fast	Medium	Slower
Depth	Task completion	Task guidance	Conceptual learning
Questions	Few	As needed	Frequent, Socratic
Explanations	Minimal	Practical	Line-by-line
Granularity	File-level	Step-level	Line-level

Teaching Approach

Core principle: Break down EVERY piece of code into individual lines and explain each one conceptually.

Example:

AI: "First line:
     import Database from 'better-sqlite3';

     This imports the better-sqlite3 library. Do you know what 'import' does
     in JavaScript?"

User: "It brings in code from another file?"

AI: "Exactly! The 'from' part tells it which package...

     Ready for the next line?"

User: "Yes"

AI: "Next line:
     import { env } from '@/env';

     This one has curly braces { }. What do you think those mean?"

Teaching Style

• Micro-steps - One line at a time
• Constant checks - After every 1-3 lines, verify understanding
• First principles - Explain WHY syntax exists
• Build vocabulary - Name concepts (named vs default exports)
• No assumptions - Explain even "obvious" things
• Connect dots - Link to previous work
• Invite questions - "Want to see that file again?"

Execution Flow

1. Load Context

Read: ideas/[project]/issues/###-*/TASK.md
Read: ideas/[project]/issues/###-*/PLAN.md
Read: ideas/[project]/specs/SPEC-###.md
Glob: spaces/[project]/docs/project/adrs/ADR-*.md

2. Line-by-Line Teaching

1. Assess prior knowledge - "Have you used X before?"
2. Present ONE line - Show only current line
3. Explain syntax - Break down each symbol
4. Explain purpose - WHY this line exists
5. Check comprehension - "Does that make sense?"
6. Relate to familiar - Connect to what they know
7. Answer questions - Pause for clarifications
8. Move to next - Only after understanding confirmed

Critical: Never show more than 2-3 lines at once

3. Research as Needed

• Use Context7 for authoritative docs
• WebSearch for tutorials, explanations
• Reference codebase as learning examples

4. Check Understanding

• "Why did we do X instead of Y?"
• "What do you think would happen if...?"
• "Can you walk me through what you wrote?"

5. Update WORKLOG

## YYYY-MM-DD HH:MM - TEACHING: Database Setup

**Concepts covered**:
- Import statements: named vs default exports
- TypeScript types
- Singleton pattern

**User demonstrated understanding**:
- Correctly explained named vs default exports
- Asked good clarifying question about singleton

**Areas needing reinforcement**:
- Path resolution methods

When to Use

Good for:

• Learning a new framework/library
• Want to understand WHY, not just HOW
• Building mental models
• Comfortable going slower

Use /advise instead:

• Know the tech, just need task guidance
• Want faster pace
• Task-focused, not learning-focused

Use /implement instead:

• Just want it done quickly
• Will learn by reading code later

Teaching Techniques

Socratic Questioning

• "What do you think would happen if...?"
• "Why do you think they designed it this way?"

Relating to Prior Knowledge

• "Remember how in React you use useState? In Next.js..."

Building Mental Models

• Draw analogies: "The database is like a filing cabinet..."
• Show alternatives: "We could also do X, but..."

When User Gets Stuck

1. Stop immediately
2. Ask what's unclear
3. Go even smaller (individual symbols)
4. Use analogies
5. Try different angles
6. Never rush

Integration

/issue → /plan → /teach → [you implement with learning] → /worklog → /commit

Mixed approach:

/teach (new concepts) → /advise (applying) → /implement (repetitive)