A customization that turns AI into a learning companion instead of a code generator. It makes you think, predict, and reason — while AI guides, questions, and diagnoses.
Core idea: You try first. AI helps only after you commit to an answer.
Looking for a different AI agent? This repo has separate branches for each supported tool. Switch to the branch matching your agent — copilot, cursor, claude-code, opencode, or antigravity — to get the right configuration and code.
How It Works
You try → You predict → AI gives hints → You implement → You test → You explain → AI reviews → You retrieve later
AI never writes the solution for you. It asks questions, gives small hints, and tests your understanding. The harder you think, the more you learn.
Quick Start
- Clone or copy this repo into your project (or use it as a template).
- Open GitHub Copilot Chat in your editor.
- Type a slash command like
/hint, /debug, /explain, etc.
- Answer the questions Copilot asks you. Don't skip them — that's where the learning happens.
- Write the code yourself. AI will guide, not write.
Important!: Disable Copilot inline completions while learning. Use Chat mode only.
The 12 Prompts
Each prompt is a workflow. Invoke it with a /command in Copilot Chat.
/learn
The entry point. Tell it what you want to learn, and it picks the right workflow for you. Use this when you're not sure which prompt to use.
Use when: You're starting a session and don't know where to begin.
/hint
Your main problem-solving tool. First, you predict what should happen. Then, AI gives you the smallest hint needed — one level at a time, from a question all the way up to full code (only if you ask for it).
Use when: You're stuck on a problem, bug, or concept and want incremental help without being handed the answer.
/debug
Bug diagnosis through hypothesis testing. AI asks what you expected, what happened, and what you think is wrong — then guides you to find the bug yourself.
Use when: Your code doesn't work and you want to understand why, not just get a fix.
/autopsy
Post-mortem after fixing a bug. You fill in what happened, what you believed, what actually happened, and what you missed. AI classifies the bug and suggests prevention.
Use when: You just fixed a non-trivial bug and want to learn from it so it doesn't happen again.
/read
Understand unfamiliar code. AI asks you concrete questions one at a time: "What does this input produce?" "What happens after iteration 3?" You reconstruct the mental model yourself.
Use when: You're reading someone else's code, old code, framework internals, or library source.
/code-review
Educational code review. Before AI reviews your code, you identify the weakest part yourself. Then AI labels issues by severity and asks discovery questions instead of rewriting your code.
Use when: You've written something and want a senior-developer-style review that teaches you.
/test
Design tests before implementing. You state the contract, identify the smallest passing/failing inputs, and derive test cases. AI exposes ambiguities in your spec.
Use when: You're about to implement a feature and want to think through edge cases first.
/explore
Explore design space. You defend your current solution, AI offers conceptually different alternatives, then introduces constraints one at a time to stress-test your design.
Use when: You have a working solution and want to understand tradeoffs, or when you want to practice handling real-world constraints like scale, concurrency, or failure.
/arch
Architecture interview. AI asks one focused question at a time about requirements, state, interfaces, failure modes, etc. You sketch the design; AI challenges your assumptions.
Use when: You're designing a non-trivial feature and want to think through it before coding.
/explain
Teach-back test. You explain a concept in your own words, as if teaching a beginner. AI probes for gaps, vague terms, and contradictions — then gives a concise assessment.
Use when: You think you understand something and want to verify it.
/retrieve
Spaced retrieval practice. AI reads your learning logs (if they exist) and asks you a short mix of prediction, debugging, and application questions from past material.
Use when: You're starting a coding session and want a quick warm-up to reinforce what you've learned.
/api
Learn an API deeply. AI walks you through 7 questions: what problem it solves, what assumptions it makes, what alternatives exist, when not to use it, and its failure modes. Then it points you to official docs.
Use when: You encounter a new library, framework, or API and want real understanding, not just syntax.
The 4 Skills
Skills are reusable behaviors that work across multiple prompts. You don't invoke them directly, they shape how AI responds when relevant.
| Skill |
What it does |
| debugging |
Separates expected vs actual behavior, requires a hypothesis before suggesting causes, picks the smallest next experiment. |
| examination |
Tests understanding through prediction, explanation, application, and transfer. Corrects the smallest misconception first. |
| code-review |
Prioritizes correctness over style, asks discovery questions before rewrites, distinguishes bugs from preferences. |
| retrieval |
Mixes recent and older material, prefers prediction over definitions, adapts difficulty to your performance. |
Learning Logs (Optional)
A lightweight folder for recording meaningful learning events. You don't need to update these after every interaction, but only when something sticks, or at the end of the day.
learning/
├── mistakes.md # Bugs, misconceptions, recurring patterns
├── concepts.md # Durable understanding worth keeping
├── questions.md # Unresolved questions to revisit
└── review.md # Retrieval prompts and review metadata
The /retrieve prompt reads these files to personalize your review sessions.
Adaptive Behavior
The toolkit adapts to you:
- If you're solving things easily: AI asks deeper "why" questions, introduces harder constraints, and reduces unnecessary prompting.
- If you're struggling: AI lowers the hint level, revisits prerequisites, and creates targeted practice — without just giving you the answer.
Shipping Mode
This toolkit is for learning. When you need to ship:
Just say "ship this" or ask for a direct implementation.
AI will switch to normal engineering mode. The learning rules only apply when you invoke a learning prompt.
How It's Organized
.github/
├── copilot-instructions.md # Global learning philosophy
├── prompts/ # 12 user-facing workflows (slash commands)
├── instructions/ # Rules for learning log files
└── skills/ # 4 reusable AI behaviors
learning/ # Optional learning logs
Requirements
- GitHub Copilot (Chat mode) in your editor
- No other dependencies, scripts, or setup needed
Limitations
- Skills require a Copilot plan that supports custom skills. Prompts work everywhere.
- Learning logs are optional and manual. The toolkit works fine without them.
- Inline completions must be disabled manually in your editor settings.
- This is a prompt-based toolkit, not an app. It works through Copilot Chat conversations.
Philosophy
Make AI reduce the friction around learning programming without reducing the amount of thinking the learner has to do.
If you're not thinking, you're not learning.
它是一套定制配置，把 AI 变成学习伙伴而不是代码生成器：你先自己尝试和预测，只有在你给出答案之后 AI 才会提供帮助，用提问和提示引导你，而不是直接写出解答。