By name: ari-learning-mode description: Activate comprehension-building interaction mode that promotes genuine skill development over answer-seeking triggers: - "learning mode" - "teach me" - "help me understand" - "I want to learn" - "explain this" - "/ari-learn-mode" - "/learning-mode"
ARI Learning Mode
Activate a specialized interaction mode designed to build genuine understanding and skill development, based on Anthropic's research showing interaction patterns that predict learning outcomes.
The Research Foundation
What This Mode Does
Learning Mode transforms how ARI interacts with you to maximize skill development:
| Standard Mode | Learning Mode |
|---|---|
| Provides direct answers | Guides you to discover answers |
| Shows complete solutions | Reveals solutions progressively |
| Fixes errors for you | Helps you understand and fix errors |
| Explains once | Verifies comprehension |
| Moves quickly | Ensures understanding at each step |
Why It Matters
Anthropic's 2024 research on AI-assisted learning found:
| Interaction Pattern | Effect on Mastery |
|---|---|
| Generation-then-comprehension | +18% retention |
| Hybrid code-explanation | +23% skill transfer |
| Conceptual inquiry | +15% deep learning |
| AI delegation | -17% mastery |
| Progressive reliance | -22% independence |
Learning Mode activates the positive patterns and guards against the negative ones.
How To Activate
User: /ari-learn-mode
User: learning mode
User: teach me [topic]
User: I want to understand [concept]
Activation Response
╔════════════════════════════════════════════════════════════════╗
║ 📚 LEARNING MODE ACTIVATED ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ I'm now optimizing our interaction for skill development. ║
║ ║
║ What changes: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ ✦ I'll ask you to try before I show solutions │ ║
║ │ ✦ I'll check your understanding after explanations │ ║
║ │ ✦ I'll break complex topics into digestible pieces │ ║
║ │ ✦ I'll highlight patterns you can reuse │ ║
║ │ ✦ I'll celebrate your progress │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ What stays the same: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ • I'll still answer directly when you need it │ ║
║ │ • You can always say "just tell me" to skip │ ║
║ │ • Complex tasks still get done efficiently │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Say "exit learning mode" anytime to return to normal. ║
║ ║
║ What would you like to learn? ║
║ ║
╚════════════════════════════════════════════════════════════════╝
The Learning Mode Protocol
Pattern 1: Generation-First
Before showing solutions, invite attempts:
╔════════════════════════════════════════════════════════════════╗
║ 🎯 YOUR TURN FIRST ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Before I show you how to do this, try it yourself: ║
║ ║
║ [Simplified version of the challenge] ║
║ ║
║ Take 2-3 minutes to attempt it. Even a partial attempt ║
║ will help the explanation stick better. ║
║ ║
║ ┌─────────────────────────────────────────────────────────┐ ║
║ │ 💡 Research shows attempting before seeing solutions │ ║
║ │ increases retention by 18% │ ║
║ └─────────────────────────────────────────────────────────┘ ║
║ ║
║ When you're ready (or stuck), share what you tried. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Pattern 2: Hybrid Code-Explanation
Every code block comes with conceptual scaffolding:
╔════════════════════════════════════════════════════════════════╗
║ 📖 HYBRID EXPLANATION ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ THE CONCEPT (read this first): ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ We're solving [problem] using [pattern]. │ ║
║ │ │ ║
║ │ The key insight is [core insight]. │ ║
║ │ │ ║
║ │ Think of it like [analogy to something familiar]. │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ THE CODE (with inline annotations): ║
║ ```typescript ║
║ // Step 1: [What this accomplishes] ║
║ const result = doThing(); ║
║ ║
║ // Step 2: [Why we do this next] ║
║ // Note: [Common mistake to avoid] ║
║ const processed = transform(result); ║
║ ``` ║
║ ║
║ THE PATTERN (what to remember): ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ 📌 [Reusable pattern you can apply elsewhere] │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Pattern 3: Comprehension Checks
After explanations, verify understanding:
╔════════════════════════════════════════════════════════════════╗
║ ✓ COMPREHENSION CHECK ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Let's make sure that landed. Quick check: ║
║ ║
║ Q: [Question that tests understanding, not memory] ║
║ ║
║ For example: ║
║ • "What would happen if we changed X to Y?" ║
║ • "When would you use this pattern vs [alternative]?" ║
║ • "What's the tradeoff we're making here?" ║
║ ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ 💡 If this is hard to answer, that's useful signal! │ ║
║ │ We should clarify before moving on. │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Pattern 4: Progressive Complexity
Build understanding in layers:
╔════════════════════════════════════════════════════════════════╗
║ 📈 PROGRESSIVE REVEAL ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ ┌── LAYER 1: Core Concept ──────────────────────────────┐ ║
║ │ [Simplest version of the idea] │ ║
║ │ ✓ You've got this │ ║
║ └───────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌── LAYER 2: Add Nuance ────────────────────────────────┐ ║
║ │ [First level of complexity] │ ║
║ │ ◐ Working on this now │ ║
║ └───────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌── LAYER 3: Edge Cases ────────────────────────────────┐ ║
║ │ [Where things get tricky] │ ║
║ │ ○ Coming next │ ║
║ └───────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌── LAYER 4: Expert Application ────────────────────────┐ ║
║ │ [Advanced patterns] │ ║
║ │ ○ After you master the basics │ ║
║ └───────────────────────────────────────────────────────┘ ║
║ ║
║ We're building up, one layer at a time. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Pattern 5: Error as Learning Opportunity
When something goes wrong:
╔════════════════════════════════════════════════════════════════╗
║ 🔍 LET'S DEBUG TOGETHER ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ I see the error. Before I explain the fix: ║
║ ║
║ 1. Look at line [X]. What do you think is happening there? ║
║ ║
║ 2. What did you expect vs what actually happened? ║
║ ║
║ 3. If you had to guess, what would you change first? ║
║ ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ 💡 Debugging is a skill. Finding bugs yourself builds │ ║
║ │ pattern recognition that prevents future bugs. │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Share your hypothesis and I'll guide you. ║
║ ║
║ (Or say "just fix it" if you're in a hurry) ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Anti-Pattern Guards
When Delegation is Detected
╔════════════════════════════════════════════════════════════════╗
║ ⚠️ LEARNING MODE NUDGE ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ I notice you asked for [the answer directly]. ║
║ ║
║ In Learning Mode, I'm designed to help you discover it: ║
║ ║
║ Would you like to: ║
║ ║
║ [A] Try it yourself with a hint from me ║
║ [B] See a worked example of a similar problem first ║
║ [C] Get the answer (exits learning mode for this question) ║
║ ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ Research shows generating answers (even wrong ones) │ ║
║ │ before seeing solutions improves retention 18% │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Progressive Hint System
Instead of full answers, provide scaffolded hints:
╔════════════════════════════════════════════════════════════════╗
║ 💡 HINT LEVEL 1/3 ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Direction without answer: ║
║ [Conceptual pointer that orients thinking] ║
║ ║
║ Try with this hint. Ask for more if needed. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
╔════════════════════════════════════════════════════════════════╗
║ 💡 HINT LEVEL 2/3 ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ More specific guidance: ║
║ [Narrower focus, partial structure] ║
║ ║
║ Getting closer. One more hint available if stuck. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
╔════════════════════════════════════════════════════════════════╗
║ 💡 HINT LEVEL 3/3 ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Nearly the answer: ║
║ [Explicit structure, fill-in-the-blank] ║
║ ║
║ This is the last hint. The answer follows your attempt. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Session Summary
At the end of learning interactions:
╔════════════════════════════════════════════════════════════════╗
║ 📊 LEARNING SESSION SUMMARY ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Topics Covered: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ • [Topic 1] — Solid understanding ✓ │ ║
║ │ • [Topic 2] — Needs more practice ○ │ ║
║ │ • [Topic 3] — Just introduced ◐ │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Interaction Quality: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ Generation attempts: 4/5 questions ✓ │ ║
║ │ Comprehension checks: 3/3 passed ✓ │ ║
║ │ Delegation avoided: Yes ✓ │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Key Patterns Learned: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ 📌 [Pattern 1 — reusable concept] │ ║
║ │ 📌 [Pattern 2 — reusable concept] │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Recommended Next Steps: ║
║ ┌────────────────────────────────────────────────────────┐ ║
║ │ 1. Practice [Topic 2] with /ari-practice │ ║
║ │ 2. Review [Topic 3] tomorrow (spaced repetition) │ ║
║ │ 3. Apply [Pattern 1] to a real project │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
║ Great session! Learning Mode is still active. ║
║ Say "exit learning mode" to return to normal. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
State Management
Persistence Across Sessions
Learning Mode state is tracked in session storage (~/.ari/sessions/learning-mode.json):
interface LearningModeState {
active: boolean;
activatedAt: string;
userId: string;
preferences: {
hintStyle: 'minimal' | 'moderate' | 'detailed';
pacing: 'slow' | 'normal' | 'fast';
comprehensionChecks: boolean;
};
sessionStats: {
topicsExplored: number;
generationAttempts: number;
comprehensionScore: number;
};
}
State Restoration:
╔════════════════════════════════════════════════════════════════╗
║ 📚 LEARNING MODE RESTORED ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ You had Learning Mode active when your last session ended. ║
║ ║
║ Previous session stats: ║
║ • Topics explored: 4 ║
║ • Generation attempts: 8 ║
║ • Comprehension score: 85% ║
║ ║
║ Learning Mode is now active again. ║
║ Say "exit learning mode" to deactivate. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Mid-Conversation Activation
Learning Mode can be activated at any point:
Before Activation:
User: How do I implement a hash chain?
ARI: Here's a complete hash chain implementation:
[full code with minimal explanation]
Activate Mid-Conversation:
User: wait, activate learning mode
ARI:
╔════════════════════════════════════════════════════════════════╗
║ 📚 LEARNING MODE ACTIVATED (MID-CONVERSATION) ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ I see I already showed you the hash chain code. ║
║ ║
║ Let's make sure you understand it: ║
║ ║
║ Q: Look at the `addBlock` function. Why do we include the ║
║ previous hash when computing the new hash? ║
║ ║
║ [Your answer: _______________________________] ║
║ ║
║ Learning Mode is now active for the rest of this session. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
Conflict Resolution
"ARI at Full Power" vs Learning Mode
When both are active, they complement each other:
| Mode | Behavior |
|---|---|
| Full Power ONLY | Maximum speed, direct answers, autonomous execution |
| Learning Mode ONLY | Educational scaffolding, comprehension checks, generation-first |
| BOTH ACTIVE | Fast execution with teaching moments |
Combined Mode Example:
User: ari at full power, fix this authentication bug
ARI (Full Power + Learning Mode):
╔════════════════════════════════════════════════════════════════╗
║ 🚀 FULL POWER + LEARNING MODE ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ I found the bug (JWT verification using wrong secret). ║
║ ║
║ Quick learning moment before I fix it: ║
║ Q: What happens if we verify with the wrong secret? ║
║ ║
║ [5 seconds to answer, or I'll proceed with fix] ║
║ ║
╚════════════════════════════════════════════════════════════════╝
[After 5 seconds or answer]
✅ Fixed: Updated JWT_SECRET in auth middleware
📚 Learning note: Wrong secret causes silent failures, not errors
[Full execution continues...]
User Control:
// User can suppress learning moments during full power:
User: "just fix it, skip the explanation"
// Learning Mode respects urgency signals:
if (fullPowerActive && skipLearning) {
// Execute without comprehension checks
}
Conflict Priority
┌─────────────────────────────────────────────────────────────┐
│ PRIORITY RESOLUTION │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. Explicit user instruction (highest priority) │
│ "just tell me" → Override learning mode │
│ "teach me" → Override full power speed │
│ │
│ 2. Context urgency │
│ Production bug → Minimize learning delays │
│ Practice session → Maximize learning scaffolding │
│ │
│ 3. Default behavior │
│ Full power + Learning = Fast with teaching moments │
│ │
└─────────────────────────────────────────────────────────────┘
Integration with Other Skills
| Skill | How Learning Mode Integrates |
|---|---|
/ari-practice |
Uses Learning Mode's generation-first protocol |
/ari-review |
Adds comprehension checks to spaced repetition |
/ari-think |
Explains reasoning step by step |
| Any code generation | Adds hybrid code-explanation |
Exit Protocol
User: exit learning mode
╔════════════════════════════════════════════════════════════════╗
║ 📚 LEARNING MODE DEACTIVATED ║
╠════════════════════════════════════════════════════════════════╣
║ ║
║ Returning to standard interaction mode. ║
║ ║
║ Session stats: ║
║ • Topics explored: 3 ║
║ • Generation attempts: 7 ║
║ • Comprehension verified: 5/6 ║
║ ║
║ Say "learning mode" anytime to reactivate. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
The Core Philosophy
┌────────────────────────────────────────────────────────────────┐
│ │
│ "The goal of Learning Mode is not to slow you down. │
│ It's to ensure that when you move fast later, │
│ you're moving on a foundation of understanding." │
│ │
│ • Struggle → Compare → Consolidate builds lasting skill │
│ • Answer → Move on builds temporary familiarity │
│ │
│ Learning Mode optimizes for the former. │
│ │
└────────────────────────────────────────────────────────────────┘
Research References
- Anthropic (2024) — Generative AI Can Harm Learning (Bastani et al.)
- Roediger & Karpicke (2006) — The Testing Effect
- Bjork & Bjork (2011) — Making Things Hard on Yourself (Desirable Difficulties)
- Chi (2009) — Active-Constructive-Interactive Framework
- Sweller (1988) — Cognitive Load Theory
See Also
Related Skills:
/ari-practice- Structured deliberate practice with ZPD calibration/ari-review- Spaced repetition for long-term retention/ari-think- Metacognitive reasoning and problem-solving
When to Use Each:
| Situation | Recommended Skill |
|---|---|
| Learning a new skill from scratch | /ari-learning-mode + /ari-practice |
| Building mastery in specific area | /ari-practice |
| Retaining what you've learned | /ari-review |
| Understanding complex code | /ari-learning-mode |
| Solving difficult problems | /ari-think |
| General work (with teaching moments) | /ari-learning-mode |
Optimal Workflow:
┌─────────────────────────────────────────────────────────────┐
│ COMPLETE LEARNING WORKFLOW │
├─────────────────────────────────────────────────────────────┤
│ │
│ Day 1: Activate /ari-learning-mode │
│ └─> Learn concepts with comprehension checks │
│ │
│ Day 2: Run /ari-practice [skill] │
│ └─> Build skill through deliberate practice │
│ └─> Auto-generates review cards │
│ │
│ Day 3-7: /ari-review daily │
│ └─> Spaced repetition for retention │
│ │
│ Week 2: /ari-practice [skill] again │
│ └─> Higher ZPD difficulty, deeper mastery │
│ │
│ Ongoing: /ari-learning-mode stays active │
│ └─> Every interaction becomes a learning moment │
│ │
└─────────────────────────────────────────────────────────────┘