# Deep Learning Protocol

Use this when asked to learn deeply about a topic.

## CRITICAL: Use Memory Tools ONLY

**NEVER use Write, Edit, or file tools during learning.**

All knowledge MUST be stored using Memory* tools:
- MemoryWrite - Store concepts, facts, skills
- MemoryRead - Recall what you've learned
- MemoryGrep - Search your knowledge
- MemoryEdit - Update existing knowledge

**Do NOT:**
- Write to disk files (Write, Edit, MultiEdit)
- Create temporary files
- Store knowledge anywhere except Memory

**Only use Memory* tools for persistence.**

## Steps

1. **Define Scope**
   - What does "knowing this" mean?
   - What should I be able to do with this knowledge?
   - What are the boundaries of this topic?

2. **Research Broadly** (Overview)
   - Official documentation (WebFetch)
   - Key concepts and terminology
   - Main use cases and applications
   - **Use MemoryWrite** to store concept entries for high-level understanding

3. **Research Deeply** (Specifics)
   - API details, syntax, configuration
   - Best practices and patterns
   - Common pitfalls and anti-patterns
   - **Use MemoryWrite** to store fact entries for concrete details

4. **Build Practical Skills**
   - How to set up / configure
   - How to use for common tasks
   - How to debug and troubleshoot
   - **Use MemoryWrite** to store skill entries with comprehensive tags

5. **Self-Test Understanding**
   - Use Think: "Can I explain this clearly without sources?"
   - Use Think: "Can I create a tutorial for this?"
   - Use Think: "What questions can't I answer yet?"
   - If unclear → gaps exist, continue researching

6. **Check Coverage**
   - MemoryGrep(pattern: "{topic keyword}")
   - Verify you have: concepts (how it works) + facts (specifics) + skills (how to use)
   - Missing category? → incomplete, fill gaps

7. **Identify Knowledge Gaps**
   - What aspects haven't I covered?
   - What questions would an expert be able to answer that I can't?
   - What real-world scenarios haven't I considered?
   - List gaps explicitly

8. **Fill Gaps**
   - Research each identified gap
   - Store new knowledge systematically
   - Re-test understanding

9. **Verify Completion**
   - Can explain topic clearly? ✓
   - Can apply it practically? ✓
   - Have concepts, facts, AND skills? ✓
   - Can handle edge cases? ✓
   - All gaps filled? ✓

10. **Report Completion**
    - Summarize what you learned (naturally, without mentioning memory)
    - Indicate you're ready to apply this knowledge
    - NEVER disclose memory system details

## Success Criteria

You're done learning when:
- You have stored concepts explaining how it works
- You have stored facts with concrete details
- You have created practical skills for using it
- You can explain the topic clearly using Think
- You can identify appropriate use cases
- You can anticipate common problems
- MemoryGrep shows comprehensive coverage

## Self-Testing Questions

Ask yourself:
- "What is X and how does it work?" (concept understanding)
- "What are the key APIs/tools/commands?" (factual knowledge)
- "How would I use X to solve Y?" (practical skills)
- "What are common mistakes?" (experience)
- "When should I NOT use X?" (boundaries)

If you can't answer confidently, you need more research.
