Learning Accelerator

---
name: Learning Accelerator
description: Learn new tech faster with Claude as your tutor
allowed-tools: Read, Bash, WebFetch, ToolSearch
model: sonnet
---

# Learning Accelerator

Learn in hours, not weeks.

## Learning Modes

### Just-In-Time Learning
```
"I need to use [thing] right now.
Show me the minimum to get started."

→ Practical, immediate
→ Learn by doing
→ Fill gaps as needed
```

### Exploratory Learning
```
"Teach me how [thing] works.
Start from fundamentals."

→ Conceptual foundation
→ Mental model building
→ Deeper understanding
```

### Reference Learning
```
"What are the patterns for [thing]?"

→ Best practices
→ Common pitfalls
→ Real-world usage
```

## Fast-Track Patterns

### New Framework (1 hour)
```
1. "What is [framework] and when to use it?" (5 min)
2. "Hello world example" (10 min)
3. "Build [simple thing] with it" (30 min)
4. "Common patterns and gotchas" (15 min)

Now: You can use it.
Later: Deepen as needed.
```

### New Language (2 hours)
```
1. "Syntax basics for [lang]" (15 min)
2. "How does [lang] differ from [known lang]?" (15 min)
3. "Build [simple project]" (60 min)
4. "Idiomatic patterns in [lang]" (30 min)

Now: You can write basic code.
```

### New Concept (30 min)
```
1. "Explain [concept] simply" (5 min)
2. "Show me an example" (10 min)
3. "When would I use this?" (5 min)
4. "What are the gotchas?" (10 min)

Now: You understand it.
```

## Learning Techniques

### Explain Like I'm...
```
"Explain async/await like I'm:
- A beginner" → Simple analogy
- A JS developer" → Compare to Promises
- An expert" → Implementation details
```

### Build to Learn
```
Don't just read—build.

"Teach me SwiftUI by building a todo app.
Explain each part as we go."

Learning sticks when you do it.
```

### Compare and Contrast
```
"How is SwiftData different from Core Data?"
"React vs SwiftUI—what transfers?"
"Compare REST vs GraphQL for my use case"

Leverage what you know.
```

### Rubber Duck Teaching
```
After learning something:
"Let me explain [thing] back to you.
Correct me if I'm wrong."

Teaching reveals gaps.
```

## Just-In-Time Lookups

### Quick Syntax
```
"Swift syntax for [thing]"
"SwiftUI modifier for [effect]"
"How to [task] in [framework]"
```

### Error Understanding
```
[paste error]
"What does this mean and how do I fix it?"

Claude explains + fixes.
```

### API Usage
```
"How do I use [API]?"
"Show me examples of [method]"

Use MCP tools for live docs:
- context7: Library documentation
- sosumi: Apple docs
```

## Documentation Workflow

### Before Coding
```
"What do I need to know about [API]?"

Claude fetches:
- Key concepts
- Common usage
- Gotchas
```

### During Coding
```
"How do I [specific task]?"

Just-in-time learning.
No context switch to browser.
```

### After Coding
```
"Did I use [thing] correctly?"

Claude reviews:
- Patterns followed
- Mistakes made
- Improvements possible
```

## Accelerated Debugging

### Error Learning
```
Every error is a lesson:

1. Understand the error
2. Learn why it happened
3. Know how to prevent it
4. Remember for next time
```

### Pattern Recognition
```
"Is this a common issue?"
"What usually causes this?"
"How do others solve this?"

Build pattern library faster.
```

## Learning Capture

### Save What You Learn
```
"Remember: [new understanding]"

→ Memory MCP stores it
→ Never re-learn it
→ Builds over time
```

### Create Skills
```
Learned a new workflow?

"Turn this into a skill"

→ Reusable next time
→ No re-explanation
```

## Anti-Patterns

### Don't
```
❌ Read docs for hours before starting
❌ Learn everything upfront
❌ Rely solely on tutorials
❌ Forget what you learned
```

### Do
```
✓ Start building immediately
✓ Learn just what you need now
✓ Ask Claude as you go
✓ Capture for future
```

## Quick Commands

```
"Quick start: [tech]" → Minimum to begin
"Deep dive: [concept]" → Full explanation
"Compare: [A] vs [B]" → Side by side
"Gotchas for [thing]" → Common pitfalls
```

Use when: Learning new tech, debugging unfamiliar code, expanding skills