Manware-s-AI-Learning-Toolkit README

The project's README from github.com/i-am-manware/Manware-s-AI-Learning-Toolkit. As one markdown file: README.md.

Manware's AI Learning Toolkit

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

  1. Clone or copy this repo into your project (or use it as a template).
  2. Open GitHub Copilot Chat in your editor.
  3. Type a slash command like /hint, /debug, /explain, etc.
  4. Answer the questions Copilot asks you. Don't skip them — that's where the learning happens.
  5. 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:

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

Limitations

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.

Manware-s-AI-Learning-Toolkit (i-am-manware/Manware-s-AI-Learning-Toolkit)

Searching Database…

799 ·GitHub
Manware-s-AI-Learning-Toolkit
What is this?It is a customization that turns AI into a learning companion instead of a code generator: you try first and predict, and AI only helps after you commit to an answer, guiding you with questions and hints rather than writing the solution.
Is this an app, or just a set of prompts I drop into my editor?It is not an app; it is a prompt-based toolkit made of slash-command prompts and skills that you copy into your project and invoke inside GitHub Copilot Chat (or the equivalent chat mode for Cursor, Claude Code, opencode, or Antigravity).
How do I start using it?Clone or copy the repo into your project (or use it as a template), open Copilot Chat in your editor, and type a slash command like /hint, /debug, or /explain, then answer the questions it asks instead of skipping them.
Which coding agents does this work with, and do I need a special Copilot plan?It is built primarily for GitHub Copilot Chat mode, with separate branches configured for Cursor, Claude Code, opencode, and Antigravity; no other dependencies, scripts, or setup are needed.
Any limitations I should know about before relying on it?The reusable skills (debugging, examination, code-review, retrieval) need a Copilot plan that supports custom skills, though the slash-command prompts themselves work everywhere; inline code completions also need to be disabled manually, and the optional learning logs are manual with no automatic tracking.
What are the 12 prompts for?They cover a full learning workflow: /learn picks the right prompt, /hint gives graduated hints, /debug and /autopsy work through bugs, /read and /explain build understanding, /code-review and /test build discipline, /explore and /arch stress-test design, and /retrieve runs spaced-repetition review from your logs.
What if I just need working code right now instead of a lesson?You can say 'ship this' or ask for a direct implementation, and the AI switches to normal engineering mode, dropping the learning rules.
What are the 4 skills and how do they differ from the prompts?Skills (debugging, examination, code-review, retrieval) are behaviors that shape how the AI responds across multiple prompts automatically, rather than commands you invoke directly yourself.
Does the toolkit adapt to my skill level?Yes — if you're solving things easily it asks deeper 'why' questions and adds harder constraints, and if you're struggling it lowers the hint level and revisits prerequisites instead of just giving the answer.
What are similar projects?superpowers-zh, pstack, anti-slop, compound-engineering-plugin, hello-sdd, no-mistakes, superpowers, HERO-Anti-OverDefense
Which topics is it in?developer, prompt, antigravity, vscode-extension, github-copilot, code-review, debugging, opencode, prompt-engineering, skill, cursor, learning-resources
Creator
i-am-manware
Size
0.1 MB
Stars
799
Updated
CommitSep 06
Age
1mo
Commits · 90 Days