Learning Modes

An interactive learning coach for AI coding-agent environments. It turns a normal "teach me about X" request into a guided practice session instead of a passive explanation.

This repo ships a behavior spec, not a runnable app. The main artifact is SKILL.md: a portable instruction file your coding agent can inspect and install or adapt using the native mechanism that fits your tool best.

The product is host-agnostic by design:

• Claude Code can use SKILL.md directly as a skill definition.
• OpenAI Codex can install it as a global skill or adapt it into the instruction layer that fits the workspace.
• OpenCode can port the same behavior into its equivalent instruction or agent file.

The goal is not host-specific packaging. The goal is one consistent learning experience across hosts, with the agent itself figuring out the right native install path.

What it does

When invoked for a learning-oriented request, Learning Modes presents a menu of 8 distinct coaching modes. The user picks one mode, provides a topic, and the AI runs an interactive session tailored to that learning style.

The sessions are designed to:

• ask, coach, and adapt instead of lecture
• keep turns short and interactive
• help the user practice, explain, retrieve, map, or simplify ideas
• end with a concrete takeaway, review, or next step

Why it exists

Most AI teaching defaults to explanation mode. That feels productive, but often produces weaker learning than guided practice.

Learning Modes pushes sessions toward active learning instead:

• questions instead of instant answers
• retrieval instead of rereading
• interleaving instead of repetitive blocked drills
• diagrams, analogies, and mental models instead of surface summaries
• study-strategy coaching when the real problem is how to learn, not just what to learn

Design principles

These modes are grounded in plain-language learning principles:

• Active recall: make the learner produce answers, summaries, and examples
• Elaboration: push deeper with "why?", "how?", and edge cases
• Interleaving: mix related concepts so the learner must choose what applies
• Scaffolding: adjust difficulty based on current understanding
• Dual coding: combine verbal explanations with visual structure
• Metacognition: reflect on whether the learning strategy is working

The 8 modes

#	Mode	Best for	Choose this when...
1	Socratic Drillmaster	Question-led reasoning and exposing weak understanding	You want to think your way to the answer instead of being told
2	Mixed Practice Architect	Interleaved drills and practice sessions	You want structured exercises, not just explanation
3	Mental Model Forge	Building reusable frameworks and principle maps	You want a topic to "click" as a system
4	Visual Thinking Translator	Diagrams, tables, and spatial explanations	The topic is easier to learn when you can see the structure
5	Active Recall Generator	Retrieval practice, flashcards, and escalating recall	You want to strengthen memory and test yourself actively
6	Meta-Learning Coach	Study strategy and real-time learning adjustments	You are stuck on how to study, not just what to study
7	Analogy Bridge Tutor	Mapping new concepts onto familiar domains	The topic feels abstract and you need a conceptual foothold
8	Simplified Learning Strategist	Beginner-friendly, step-by-step scaffolding	You want the topic rebuilt from simple language upward

Install with your agent

The preferred workflow is simple:

1. Give your coding agent this repo URL.
2. Tell it to use SKILL.md as the canonical behavior spec.
3. Ask it to install or adapt the skill using the mechanism that fits the current tool best.

Copy-paste prompt:

Use https://github.com/thecodefeels/skill-learning-modes as the canonical behavior spec.
Install Learning Modes using the native mechanism that fits this tool best.
Preserve the trigger boundary, the 8-mode menu, the pacing rules, and the mode behaviors from SKILL.md.
Do not turn it into a runnable app. Treat it as a portable behavior layer.
If this tool supports global skills, prefer a global install. Otherwise adapt it into the appropriate local instruction layer.

In practice, that means your agent should decide whether this belongs in a global skills directory, a repo-level instruction file, or another native skill mechanism.

Examples:

• Claude Code: load SKILL.md directly or install it into the local skills setup.
• OpenAI Codex: prefer a global skill install when supported, otherwise adapt it into AGENTS.md or the repo instruction layer.
• OpenCode: port SKILL.md into the agent or instruction file your setup already uses.

What should stay consistent

The behavior should stay the same across hosts:

• same 8-mode menu
• same trigger boundaries
• same pacing and interaction guardrails
• same mode goals and summaries

What your agent should not change

• Do not turn the interaction into a long lecture by default.
• Do not remove the mode chooser.
• Do not broaden the trigger so far that it hijacks normal task requests.
• Do not create host-specific variants with different learning behavior unless you intentionally want a fork.
• Do not require the human to know the exact install path if the agent can infer it safely.

First 60 seconds

Example:

User: help me understand database indexing

Assistant: Pick a learning mode:
1. Socratic Drillmaster ...
2. Mixed Practice Architect ...
...
8. Simplified Learning Strategist ...

User: 3

Assistant: Mental Model Forge. What topic and domain do you want to map out?

User: database indexing in PostgreSQL

Assistant: Great. Before we build the model, what do you already believe an index does, and where does your understanding feel fuzzy?

That first exchange should feel the same in Codex, Claude Code, and OpenCode even if the installation mechanics differ.

More example prompts

These are the kinds of requests that should make the skill feel immediately useful:

help me study TCP congestion control
quiz me on Python iterators
explain Kubernetes like I'm a beginner
help me practice SQL joins
teach me how public-key cryptography works

Example:

User: quiz me on Python iterators

Assistant: Pick a learning mode:
1. Socratic Drillmaster ...
2. Mixed Practice Architect ...
...
8. Simplified Learning Strategist ...

User: 5

Assistant: Active Recall Generator. What topic do you want to actively recall and test yourself on?

User: Python iterators and generators

Assistant: Great. We'll break that into a few subtopics. First: from memory, what's the difference between an iterable and an iterator?

When it should trigger

Learning Modes should activate on clear learning intent, for example:

teach me about X
help me understand Y
I want to learn Z
quiz me on W
help me study for X
give me flashcards on X
help me practice X
explain X like I'm a beginner

It should not overreach into requests where the user obviously wants:

• a direct factual answer
• task completion
• code execution
• debugging or implementation help without a learning goal

If the intent is ambiguous, the assistant should clarify whether the user wants an interactive learning session or a direct answer.

What this is not

This repo is not:

• a curriculum planner
• a spaced-repetition system with saved progress
• a passive lecture generator
• a replacement for factual verification when accuracy matters
• a host-specific plugin with three separate behavior definitions

Repository structure

File	Purpose
SKILL.md	Canonical learning-behavior spec
README.md	Product overview, host support, and usage guidance
LICENSE	MIT license

Everything public in the repo is intentionally lightweight. The point is to make the behavior easy to inspect, adapt, and ship.

Usage notes

• The assistant should keep sessions interactive rather than dumping long monologues.
• If the topic is too broad, it should narrow scope before teaching.
• If the user wants to switch modes, the menu should appear again.
• If the user says "done" or "that's enough", the assistant should wrap up with a concise takeaway.

License

MIT. See LICENSE.