Manware's AI Learning Toolkit: slash commands that make Copilot question you instead of writing the code

The problem: an agent that answers before you have thought

Ask a coding assistant for help and you usually get the finished function. That is efficient and it is also the reason people report learning less from tools they use daily. Manware's AI Learning Toolkit is built around a single rule stated in the README: you try first, and the AI helps only after you commit to an answer. The audience is narrow and specific. It is for someone who already has an agent in their editor and wants to use it as a tutor for a language, a framework, or an unfamiliar codebase, rather than as a code generator. The README frames the project as a customization that turns AI into a learning companion instead of a code generator, and it makes you think, predict, and reason while the AI guides, questions, and diagnoses. There is no runtime, no server and no dependency graph here. What you are adopting is a set of instructions and workflows that shape how an existing agent responds.

How the toolkit works: prompts, skills and per-agent branches

The mechanism is prompt configuration, not software. The README documents twelve prompts, each invoked as a slash command in Copilot Chat, and four skills that are not invoked directly but shape responses when relevant. The loop it describes is: you try, you predict, AI gives hints, you implement, you test, you explain, AI reviews, you retrieve later. Concretely, /hint asks for your prediction first and then releases the smallest hint needed, one level at a time, escalating from a question up to full code only if you ask for it. /debug asks what you expected, what happened, and what you think is wrong, then guides you to the bug instead of naming it. /autopsy is the post-mortem: you fill in what happened, what you believed, what actually happened and what you missed, and the AI classifies the bug and suggests prevention. The four skills are debugging, examination, code-review and retrieval. According to the README, examination corrects the smallest misconception first, and retrieval mixes recent and older material and prefers prediction over definitions. The repository is organised around a .github/ directory holding copilot-instructions.md, which the README describes as the global learning philosophy, plus a learning/ folder. The README also states that each supported agent gets its own branch, listing copilot, cursor, claude-code, opencode and antigravity, and that you should switch to the branch matching your agent to get the right configuration. That is a real constraint: the default branch is copilot, so a Cursor or Claude Code user who clones the default branch is reading the wrong configuration.

Setting it up and running a first /hint session

There is no package to install. The README's Quick Start is a clone-or-copy step, then opening Copilot Chat in your editor, then typing a slash command. Before any of that, pick the branch for your agent. The README lists copilot, cursor, claude-code, opencode and antigravity, and says to switch to the branch matching your agent to get the right configuration and code. If you are on Copilot, the default branch already matches.

git clone https://github.com/i-am-manware/Manware-s-AI-Learning-Toolkit.git

The README also allows copying the files into an existing project or using the repository as a template, which is what you would do if you want the .github/ instructions to apply to code you already have. The README does not give a command for switching to the other agent branches, so if you are on Cursor or Claude Code, switch branches in your own client or re-clone with that branch name.

Once the files are in place, open Copilot Chat and start with the entry point rather than guessing which workflow fits. The README describes /learn as the entry point: tell it what you want to learn and it picks the right workflow for you.

/learn

What you should see is a conversation, not an answer. The README's own sequence for /hint is that you predict what should happen first, then the AI gives the smallest hint needed, one level at a time. The README adds an instruction that matters more than any setup step: disable Copilot inline completions while learning and use Chat mode only. If inline completions stay on, your editor will finish the line before the hint arrives, and the whole exercise collapses. When you are done learning for the day, the README suggests recording only what stuck in the optional learning/ folder, which contains mistakes.md, concepts.md, questions.md and review.md. The /retrieve prompt reads those files, if they exist, to build a short warm-up from past material.

Where it fails: skipped questions, missing logs and the wrong branch

The most likely failure mode is the one the README warns about directly. If you skip the questions Copilot asks, nothing here works, because the questions are the product. A developer under deadline pressure will skip them, and the toolkit degrades into an unusually verbose chat assistant. The optional learning logs are a second weak point. The README states that /retrieve reads your learning logs if they exist, so with an empty learning/ folder the spaced retrieval feature has nothing to draw on and cannot personalise review. That is a design choice rather than a bug, but it means the retrieval workflow is inert on day one and only becomes useful after you have written entries. Branch selection is a third trap. The README is explicit that each supported tool has its own branch, and a user who clones the default branch while running Cursor gets Copilot-flavoured instructions. Finally, the toolkit is the wrong tool when you actually need to ship. The README answers this with a mode switch: say ship this or ask for a direct implementation, and the AI switches to normal engineering mode, with the learning rules applying only when you invoke a learning prompt. That escape hatch is honest, but it also means the toolkit has no answer for someone who wants both speed and understanding in the same hour.

How it differs from plain Copilot Chat and from documentation-first tools

The comparison that matters is with the default behaviour of the agent you already have. Stock Copilot Chat is optimised to produce code; the README's own framing is that this toolkit makes the AI guide, question and diagnose instead. The difference is procedural. A default assistant answers your question. /hint requires your prediction before it answers, /debug requires your hypothesis before it suggests a cause, and /code-review requires you to name the weakest part of your own code before the AI labels issues by severity. The other family of alternatives is documentation-first learning: official docs, tutorials and courses. Those give you a correct explanation on demand, while this toolkit gives you a sequence of questions with no guaranteed explanation at the end. That is the trade. Documentation is faster when you want to know something; this is slower and is aimed at making the knowledge stick. The README's /api prompt sits between the two, walking through seven questions about a new library, including when not to use it and its failure modes, and then pointing you to official docs rather than replacing them.

Maintenance, licence and the cost of upgrading

The repository is not archived and the last push was on 2026-09-06, so the project has been touched recently. There are no releases retrieved for it, which fits a repository made of prompt files rather than versioned software. Upgrade cost is therefore low in the mechanical sense: there is no build, no lockfile and no migration, so pulling new commits means reviewing changes to instruction files in .github/ and any prompt definitions. The real cost is behavioural, not technical. Because the toolkit shapes how your agent responds, a change to copilot-instructions.md can alter the tone and strictness of every workflow at once, and you will notice it in a session rather than in a test suite. No licence is stated in the repository files described, and the licence field is unknown, so before you copy these files into a company project or redistribute them, check the repository for a licence file. Until that is clear, the safe reading is that no permission has been granted in writing.

Editorial conclusion

Adopt this toolkit if you are deliberately practising a language, a framework or an unfamiliar codebase and you want Copilot to withhold answers until you commit to one. Do not adopt it if your goal this week is throughput: the README itself tells you to disable inline completions while learning, which is the opposite of what a delivery deadline wants. Before you invest a session, verify three things: that your agent has a branch here (copilot, cursor, claude-code, opencode, antigravity), that you are willing to answer the questions rather than skip them, and that the repository's licence permits the use you have in mind, because no licence is stated in the repository files described.

Frequently asked questions

Official sources

1. i-am-manware/Manware-s-AI-Learning-Toolkit on GitHub
2. Issues
3. README