Manware's AI Learning Toolkit: twelve commands built around withholding the answer

The default branch is copilot, and four other agents live on other branches

This is a customization rather than a program, and the repository layout says so before the README does. The whole tree is three entries: .github/, README.md and learning/. There is no source directory, no manifest and no build step, and the repository has no tagged releases at all, so there is no versioned artefact to pin.

The branching scheme is the interesting part. The project keeps a separate branch per supported agent, named copilot, cursor, claude-code, opencode and antigravity, and the instruction is to switch to the branch matching your agent to get the right configuration. The default branch is copilot, which means cloning without thinking lands you in the GitHub Copilot configuration no matter which tool you actually run.

That default is defensible for the author and awkward for everyone else. Anyone on Claude Code or OpenCode who clones and starts will get a Copilot-shaped configuration first and has to know the branch list exists before anything works as intended. The five names are only discoverable by reading the note near the top of the README.

The recorded metadata is sparse in the same way. The language and licence fields are both empty, there is no homepage, and the only other recorded values are 663 stars, 82 forks and 2 open issues, with the last push on 2026-09-06.

The loop commits you to a prediction before the model gives anything

The core idea is stated as one rule: you try first, and the AI helps only after you commit to an answer. Everything else in the repository is an implementation of that single constraint.

The loop it produces is eight steps long:

You try → You predict → AI gives hints → You implement → You test → You explain → AI reviews → You retrieve later

Read in order, the interesting part is that prediction and explanation are separate steps, and both of them belong to you. You predict before the hints arrive, so the model has something to react to rather than a blank page. You explain after the code runs, so the model has a claim to check rather than a diff to summarise.

That ordering is what stops the configuration degenerating into a chatbot. Without the predict step, a hint request is indistinguishable from a request for the answer, and there is nothing in the prompt files that could tell the two apart afterwards.

/hint escalates one rung at a time, and full code is the last one

/hint is named the main problem-solving tool, and its behaviour is described as a ladder. You first predict what should happen, and then the AI gives you the smallest hint needed, one level at a time, from a question all the way up to full code, and the parenthetical matters: only if you ask for it.

So the escalation is real and it is also opt-in. Nothing in the design stops the last request, and the full-code rung is named explicitly rather than left implied. Whether that is a feature depends on how much of the ladder you actually climb before asking for the answer.

What the ladder buys is that each rung is a separate, visible decision. A user who asks one question and works is behaving differently from a user who escalates to the top in a single turn, and the prompt structure keeps that difference observable in the conversation.

The rest of the twelve prompts follow the same escalation discipline without offering a code rung at all. /debug asks what you expected, what happened, and what you think is wrong, then guides you to the bug. /read asks concrete questions one at a time, such as what this input produces or what happens after iteration 3, and you reconstruct the mental model yourself.

Seven of the twelve prompts start by taking something away from you

The pattern across the command list is that the model withholds an artefact you would normally ask for. You name the weakest part of your own code before /code-review will label issues by severity, and it asks discovery questions instead of rewriting. You state the contract and identify the smallest passing and failing inputs before /test derives cases, and it exposes ambiguities in your specification. You defend your current solution before /explore will offer conceptually different alternatives, and it then introduces constraints one at a time to stress test the design.

/arch works the same way in the other direction. It asks one focused question at a time about requirements, state, interfaces and failure modes, you sketch the design, and it challenges your assumptions rather than offering one.

/explain inverts the whole thing as a teach-back test. You explain a concept in your own words as if teaching a beginner, and it probes for gaps, vague terms and contradictions before giving a concise assessment.

/api is the most structured of them, walking through seven questions covering what problem it solves, what assumptions it makes, what alternatives exist, when not to use it, and its failure modes, and only then pointing you at official documentation. /learn is the entry point that picks the workflow when you do not know which one you need.

The four skills are never invoked, they only bias the answer

Skills and prompts are separate mechanisms, and the distinction is stated rather than left to be inferred. Prompts are workflows you invoke with a slash command. Skills are reusable behaviours that work across multiple prompts, and you do not invoke them directly; they shape how the AI responds when relevant.

There are four. The debugging skill separates expected from actual behaviour, requires a hypothesis before it will suggest causes, and picks the smallest next experiment. The examination skill tests understanding through prediction, explanation, application and transfer, and corrects the smallest misconception first. The code-review skill prioritises correctness over style, asks discovery questions before rewrites, and distinguishes bugs from preferences. The retrieval skill mixes recent and older material, prefers prediction over definitions, and adapts difficulty to your performance.

One naming collision is worth flagging. There is a /debug command and a debugging skill, and they are not the same artefact. The command is something you type; the skill is a standing bias that applies whenever the model is reasoning about a fault, including inside commands you did not think of as debugging.

That is also the honest limit of the design. A skill can only shape a response when it happens to be relevant, and the repository documents no way to check that it fired.

Inline completions have to be switched off, or nothing else applies

The single most load-bearing instruction in the setup is not a prompt. It is an editor setting: disable Copilot inline completions while learning, and use Chat mode only.

The reason is not subtle. Inline completions offer code at the cursor without being asked. No slash command is involved, no prediction is required first, and no skill has an opportunity to apply. Every other mechanism in this repository operates inside a chat conversation, so an active inline completion bypasses the entire design without touching any of it.

This makes the enforcement a manual step that happens outside the tool the configuration lives in. A user who installs the branches, copies learning/ in, and starts typing has not been stopped from accepting the answer, because nothing here can stop them.

The quick start sequence reflects the same manual character. Clone or copy the repository into your project or use it as a template, open Copilot Chat, type a slash command, answer the questions rather than skipping them, and write the code yourself.

learning/ is optional, so /retrieve degrades to whatever you wrote

The optional part of the toolkit is a four-file folder meant for recording meaningful learning events. The instruction is deliberately loose: you do not need to update it after every interaction, only when something sticks or at the end of the day.

The four files divide by kind rather than by date. mistakes.md holds bugs, misconceptions and recurring patterns. concepts.md holds durable understanding worth keeping. questions.md holds unresolved questions to revisit. review.md holds retrieval prompts and review metadata.

/retrieve is the prompt that consumes them. It is described as spaced retrieval practice, and it reads your learning logs, if they exist, then asks a short mix of prediction, debugging and application questions drawn from past material. It is meant for the start of a coding session as a warm-up.

The parenthetical is the important part. Because the prompt tolerates the logs being absent, /retrieve will run against an empty folder and still produce questions, which means a session started before you have written anything gets the weakest version of spaced repetition without any signal that it is the weak version.

Shipping mode is one phrase away, and the phrase has to be yours

The toolkit adapts in two directions. If you are solving things easily, the AI asks deeper why questions, introduces harder constraints, and reduces unnecessary prompting. If you are struggling, it lowers the hint level, revisits prerequisites and creates targeted practice, explicitly without giving you the answer.

What the README does not say is how either state is detected. No metric, threshold or signal is named, so the adaptation is asserted as a behaviour of the configuration rather than specified as a rule you could check.

The escape hatch is blunt. For shipping, you say ship this or ask for a direct implementation, and the AI switches to normal engineering mode. The learning rules apply only when you invoke a learning prompt, so the default outside a learning command is ordinary assistance.

That is the tension in the project stated plainly. The premise is that the AI never writes the solution for you, and full code is one request away on the /hint ladder and one phrase away in shipping mode. The safeguard is not a technical block, it is that both routes require you to take the step deliberately.

Editorial conclusion

Use this if you are deliberately practising something and want the model to withhold the answer, since the predict step only means something if you actually commit to one. Skip it if you want a working tool, because there is no code to run and nothing to install beyond copying a folder. Before you start, switch to the branch for your agent rather than sitting on the default copilot branch, turn off inline completions, and write to learning/ as you go, because /retrieve has nothing to draw on if you leave it empty.

Frequently asked questions

Official sources

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