Menu
Activate comprehension-building interaction mode that promotes genuine skill development over answer-seeking
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Baseado na classificação ocupacional SOC
Discord slash commands, approval routing, channel policy, button interaction patterns for OpenClaw/ARI Discord integration
Obsidian vault integration patterns — vault-analyzer.ts, /ari-vault-* commands, morning briefing snippet, PARA structure, read-only enforcement
OpenClaw plugin development patterns — hooks, manifest structure, plugin SDK, APEX/CODEX enforcement
NOVA's P1 PayThePryce pipeline — market signal ingest, card detection, price monitoring, script generation, thumbnail generation, video assembly, approval gate
CHASE's P2 Pryceless Solutions pipeline — lead discovery, 5-criteria audit, LLM qualification, Prompt Forge 4-pass lock, demo generation, outreach approval gate
NOVA's thumbnail generation pipeline — Ideogram V3 via Fal.ai (primary) + DALL-E 3 fallback, 4-variant strategy, Pokemon TCG copyright rules,
| 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"] |
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.
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 |
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.
User: /ari-learn-mode
User: learning mode
User: teach me [topic]
User: I want to understand [concept]
╔════════════════════════════════════════════════════════════════╗
║ 📚 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? ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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] │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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) ║
║ ║
╚════════════════════════════════════════════════════════════════╝
╔════════════════════════════════════════════════════════════════╗
║ ⚠️ 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% │ ║
║ └────────────────────────────────────────────────────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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. ║
║ ║
╚════════════════════════════════════════════════════════════════╝
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
}
┌─────────────────────────────────────────────────────────────┐
│ 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 │
│ │
└─────────────────────────────────────────────────────────────┘
| 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 |
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 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. │
│ │
└────────────────────────────────────────────────────────────────┘
Related Skills:
/ari-practice - Structured deliberate practice with ZPD calibration/ari-review - Spaced repetition for long-term retention/ari-think - Metacognitive reasoning and problem-solvingWhen 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 │
│ │
└─────────────────────────────────────────────────────────────┘