mahou

Plugin mahou from marketplace asermax-plugins in asermax/claude-plugins. Commands read from the repo's manifest — 5 days ago.

Skills (43)

• address-pr-review

  Works the review left on an open pull request. Fetches the live threads, verifies each finding against the code, settles them with the user, applies what they approve, then commits, pushes and resolves the threads. Use when a reviewer, a person or a bot, has commented on a PR. Typed by the user, or

• agentic-review

  Refines the code in a change before a human reads it. Runs four facet reviewers, a test reviewer when the change touches tests, and one conventions reviewer per wiki entry and per project rule file on each repository, fixes what they find without changing how the change looks or behaves, and repeats

• architecture-exploration

  Draws a system's architecture on a canvas and explores ways to change it with the user. It lays the options out side by side, draws a part they share step by step, and redraws the whole chosen option after each decision the user makes, until one architecture remains. The user edits the same canvas.

• basics

  Foundation for every mahou skill. Carries the philosophy and rules the agent follows when running any mahou skill. Load before running any other mahou skill.

• canvas

  Draws on a tldraw canvas run from a local app, which the user edits too, with low-fidelity screen mockups, storage cylinders, arrows and free text, and exports it as an SVG. Use when the user asks for a mockup, a sketch or a diagram laid out in space, or when another skill loads it to draw. Mermaid

• changeset

  Loaded by other skills to establish which change is under review: the repositories, the base it is measured against, and the diff composed from them.

• code-blast-radius

  Traces what an already-written change reaches. Fans out a tracer per changed element, proves the one fact the change is safe because of by running the real code, and reports only the places where behavior changes for someone, each with how far its proof got. Use after code is written, before it is r

• commit-changes

  Commits the changes in the repository as conventional commits, grouping related files and confirming the grouping with the user before anything is committed. Use when the user asks to commit, or when another mahou skill reaches its commit step.

• create-pull-request

  Opens a pull request from a branch in one repository, detecting its base from commit distance and writing the title and body from every commit on the branch. Use when a branch is ready for review and the user asks for the pull request.

• design-tree

  Loaded by other skills that settle a definition with the user through rounds of questions. Carries the design tree: its format, the frontier, the question and answer rules, how the tree grows, and how a session ends. The loading skill says what the tree is about and how deep its questions go.

• design-with-canvas

  Runs the design skill on a canvas instead of in the chat. The canvas is the design tree, one section per branch with its leaves, its representation and its prose; questions, findings and readings are written on it, and the user answers with sticky notes. The recording at the end stays in the chat. U

• design

  Turns a settled problem definition into a system design. Works a design tree one area at a time, from data model to flows to rules, with the user settling every leaf. Hands the tree to mahou:write-documentation so the project's docs record it. Stays above endpoints, functions and files. Use after sh

• docs

  Loaded by skills and agents that read or write the project's own documentation. Carries how to find the docs folder, what its structure is made of, and the rule that the project's charter wins over anything a skill assumes.

• explore-with-canvas

  Runs the explore skill on a canvas instead of in the chat. The user asks with sticky notes, the skill lays out the answers freely on the canvas with their facts and diagrams, and a decision log grows in one place. Use when the user wants to build their understanding of a problem on a canvas.

• explore

  User-guided investigation mode. The user provides context to use as the basis and then steers the investigation one question at a time. The agent reads only that context up front and, for each question, dispatches a scout at exactly what the question needs. Use when the user wants to build their own

• fast-track

  Runs a canvas stage skill (shape-with-canvas, design-with-canvas, program-design-with-canvas, test-design-with-canvas) in fast-track mode. Every branch and part is laid out at once, decisions that earlier artifacts already show become settled leaves without a confirmation round, and only the open de

• guide

  Entrypoint to the mahou plugin when unsure which skill fits. Give it your goal in plain words and it identifies the matching skill and activates it with your request as context.

• human-review

  Collects the user's own annotations on a change, verifies each against the code, and settles every finding with them before anything is edited.

• implement-with-tdd

  Implements a change whose design and test design are settled the way mahou:implement does, but writes each repository's code test first. Per repository, a tester subagent writes the failing tests and validates each round, an implementer subagent writes the code, and this session relays every exchang

• implement

  Implements a change whose design and test design are settled, by delegating one subagent per repository with the full context: the tasks, the design notes, the test matrix rows for that repository, the repository rules and the report shape. Collects the results, then delegates the manual validation

• implementation-status-report

  Reports where an implement run stands, from the change's implementation-status.md. Gives, per repository, a short update against the previous report in the conversation, the highlights since then, and every open item with the context to settle it. Use in the middle of an implement or implement-with-

• init

  Seed a docs folder the project then owns: a charter, one folder per kind of note with its own index, and a note template. Re-run it later to add a folder. Use when a project has no docs charter yet, or when mahou:write-documentation or mahou:explore report the docs are not set up.

• land

  Takes a change from its branches to merged pull requests across one or more repositories, in the order that keeps production safe. Runs release-check first, opens every pull request, babysits them in parallel through review and rebase until they are merged, then walks the confirmed order, watching e

• learn

  The author's tool for growing the plugin from real sessions. When the user asks what the session has to teach, it collects the points where the session generated friction or changed the behavior of the flow that was running, gives a take on each, and drafts what the user picks. When the user names w

• lookup

  Loaded by other skills that need a fact from the project's code, its docs or the outside world while working with the user. Carries the routing between the scouts and the researcher, the rule for facts outside the project, and how a verified fact is told apart from an asserted one.

• one-page-design

  Draws a settled design as one page on a canvas, as a journey (what the user sees step by step, what gets stored on the way and how it is read back) or as an anatomy (what one thing is made of and where each of its parts comes from). The user edits the same canvas. Exports it as an SVG. Use when the

• program-design-with-canvas

  Runs the program-design skill on a canvas. Each part of a branch (screen layout, component tree, state) is drawn on the canvas for the user to correct, while the record file keeps the text representation. Use when the user wants to work a program design on a canvas.

• program-design

  Turns a settled system design, or a change proposed in the conversation, into a program design, the level between the design and the code. Works a design tree one repository at a time, proposing each branch's layout, components, state, call path, interfaces and files from the code and the convention

• prototype

  Loaded by other skills to show the user a screen element, or the options for a piece of the visual direction (palette, icons, logo, fonts), as a working HTML prototype and iterate it with them, round by round, until it matches what they want. Carries how the file is built and opened, and one referen

• rebase

  Brings a branch up to date with its base by fetching, rebasing, resolving, and verifying, then reports what moved. Never pushes.

• release-check

  Finds what breaks when the repositories of a change are released in a given order, and gives the order that breaks nothing. Compares each branch with the deployed version on both sides of every service boundary, including services the change does not touch, and runs code-blast-radius alongside. Use

• report

  Loaded by any skill that hands the user a report: findings, an investigation's answer, a summary of a change. Carries the shape a report should take.

• shape-with-canvas

  Runs the shape skill on a canvas instead of in the chat. The canvas is the shape tree, one section per branch with its leaves and its prose; questions, findings and readings are written on it, and the user answers with sticky notes. Once every branch is settled, the skill draws a breadboard of the p

• shape

  Finds the holes in a problem and solution definition and fills them with questions, working a design tree in rounds until nothing is left assumed. Stays at the level of behavior and decisions, never implementation. Use after the user has explored a problem and settled its first decisions, and before

• spike

  Answer a design question by building the smallest working version of the real thing and running it against reality. Throwaway code that never merges. Use when a question cannot be settled by reading or asking, like "will this work?" or "what shape should this be?", and only running code can answer i

• tasks

  Turns a settled design and its test-design trees into the tracker's task list: proposes new tasks, reshapes stale ones, drops superseded ones, and writes them through whatever mechanism the project declares, whether Linear, GitHub issues, or a local markdown file. The user settles every task. Use af

• telepathy

  Moves the conversation with the user out of the chat and into markdown files in the change's scratch folder, served as a web page the user reads and edits in the browser. Every edit the user makes reaches the agent as a message, and the agent answers by writing in the files. Use when the user asks f

• test-design-with-canvas

  Runs the test-design skill on a canvas instead of in the chat. The candidate roots are drawn on a map of the system for the user to pick, and each branch is drawn as a classification tree with its combination matrix under it; the user corrects with sticky notes or by voice. Use when the user wants t

• test-design

  Turns a settled design into the test cases and manual validations that prove it, before the implementation exists, using the Classification Tree Method (CTM): one tree per repository, entry points or flows as roots, classifications, partitions, then a combination matrix per branch with each row mark

• validate-setup

  Writes and keeps up `.mahou/validate.md`, the file mahou:validate reads to bring a project's system up, drive it, capture evidence and clean up, with one file per feature under `.mahou/validate/features/`. Learns each part from the repository, asks only what the repository does not show, and proves

• validate

  Runs a change's manual validation rows against the running system and leaves an evidence report. Takes the manual rows from mahou:test-design, or the scenarios the user names when there is no test design, drives each one through a browser, over HTTP, or on an Android device, records what it observed

• wiki

  Consult distilled knowledge about technologies, tools, and their gotchas before designing, choosing, or debugging with them. Reads the indexes first and loads only matching entries.

• write-documentation

  Write or update a note in the project's docs folder explaining how one part of the system works, following the project's own charter and templates. Use when the user wants something documented, a mechanism written up, a note brought back in line with the code, or when mahou:design hands over a settl

Subagents (14)

• altitude-reviewer

  Reviews one change for fixes made at the wrong depth. Writes findings to a file and returns the path. Makes no edits.

• code-scout

  Searches one repository for one question about its code and returns the answer with file and line references. Keeps the reading out of the caller's context. Makes no edits.

• compat-checker

  Checks one service boundary for version pairs that cannot run together. Given a caller and a callee, tests the new side against the deployed other side in both directions and reports only the pairs that break. Returns findings; makes no edits.

• consistency-checker

  After a change lands, checks one repository for leftovers of what the change replaced and for places where the code and the docs, or two parts of the code, disagree. Writes findings to a file and returns the path. Makes no edits.

• conventions-reviewer

  Reviews one change against one source of conventions, a mahou wiki entry or a project rule file. Writes findings to a file and returns the path. Makes no edits.

• docs-scout

  Searches a project's docs folder for one question about how something is meant to work or why it is the way it is, and returns what the notes say with their paths. Keeps the reading out of the caller's context. Makes no edits.

• documentation-reviewer

  Checks one documentation draft against the project's own charter and the template it was created from, and reports the departures. Makes no edits.

• efficiency-reviewer

  Reviews one change for wasted work it introduces. Writes findings to a file and returns the path. Makes no edits.

• program-design-reviewer

  Reviews one proposed part of a program design against the conventions of its root, the mahou wiki entries and the project rule files. Writes findings to a file and returns the path. Makes no edits.

• researcher

  Answers one question about a library, tool or platform outside the project: what exists, which versions, what each one does against a stated list of requirements. Reports facts with their sources and never recommends one. Keeps the reading out of the caller's context. Makes no edits.

• reuse-reviewer

  Reviews one change for code that re-implements something the codebase already has. Writes findings to a file and returns the path. Makes no edits.

• simplification-reviewer

  Reviews one change for unnecessary complexity it adds. Writes findings to a file and returns the path. Makes no edits.

• test-reviewer

  Reviews the tests one change adds or changes, for tests that pass when the behaviour breaks or fail when only the internals change, by making both edits in its own git worktree and running each test alone. Writes findings to a file and returns the path. Never edits the repository's checkout.

• usage-tracer

  Finds every user of one changed code element and reports only the users whose behavior changes. Returns findings; makes no edits.