Proven as it's built

Build agentically, with confidence.

A skill drives the change. The recipe proves it on a real MetaMask build as it is written — self-checked in the same context, then kept as a regression guard.

Set up once, then work a real ticket.

Set up

One time per machine. Paste this into your agent inside a MetaMask checkout. 

Task: set me up for recipe-backed work on MetaMask. Follow these steps in order.
When a command fails, its message names the exact next command — run that
instead of improvising.

1. Install the harness: `npm i -g @deeeed/metamask-harness@latest`, then
   `mm-harness --version` to confirm it resolved.
2. Checkout: if I started you inside a MetaMask product checkout
   (metamask-extension, metamask-mobile, or core), use it. If not, run
   `mm-harness setup-base --dry-run` to show me the layout it would create,
   and ask me before running it for real. Everything below runs from inside
   the checkout.
3. Run `mm-harness doctor` and fix every finding by following its own
   instructions until doctor passes. `mm-harness doctor --fix` repairs
   harness-owned runtime state; it will not invent credentials or pick a
   wallet fixture for me.
4. Run `mm-harness fixtures`. If no fixture exists, run
   `mm-harness fixtures init --dev`; this creates a disposable public test
   wallet that must never receive real funds.
5. Launch and wait for readiness:
   - Extension: `mm-harness launch --verify`.
   - Android: `mm-harness launch android --verify`; if more than one device is
     listed, choose one serial and repeat it with `--device <serial>`.
   - iOS: run `xcrun simctl list devices available`, choose ONE available iPhone
     UUID (ask me if the choice is ambiguous), and use that literal UUID in all
     three commands below — never substitute the simulator name:
       `mm-harness provision runway ios --device '<UUID>' --force`
       `xcrun simctl get_app_container '<UUID>' io.metamask.MetaMask app`
       `mm-harness launch ios --device '<UUID>' --verify`
   - Core: `mm-harness verify`; it has no app to launch.
   `--preflight-mode` is an internal adapter flag, not a public launch flag.
6. On Extension run `mm-harness fixtures set`. On Mobile include the same
   `--device <UUID-or-serial>` used for launch. Wait for it to succeed.
7. Install the skills — they are how the work actually gets driven. First
   inspect `METAMASK_SKILLS_DIR` and `CONSENSYS_SKILLS_DIR`, then check the
   expected local layout below. Reuse every valid existing clone. For each
   missing source, show me the proposed path and ask before cloning:
     `git clone https://github.com/MetaMask/skills.git ~/dev/metamask/skills`
     `git clone git@github.com:Consensys/skills.git ~/dev/Consensys/skills`
   The internal overlay needs access to the Consensys org. Export the paths in
   the current shell for setup:
     `export METAMASK_SKILLS_DIR=~/dev/metamask/skills`
     `export CONSENSYS_SKILLS_DIR=~/dev/Consensys/skills`
   Never edit `.zshrc`, `.bashrc`, or another shell startup file unless I
   explicitly consent; ask separately if I want these exports persisted.
   If that clone fails, tell me — I may not have access, and the next step
   depends on it. Then, from inside the checkout:
     `yarn metamask-skills list --maturity experimental`   everything installable
     `yarn skills`                                         installs the stable set
   `yarn skills` runs `metamask-skills sync` and is already wired in
   metamask-extension, metamask-mobile, and core. Use `--maturity experimental`
   when listing: the default only prints stable skills, so the recipe skills
   below do not appear without it.
8. Add the skills that drive recipe-backed work:
     `yarn skills --include agentic/recipe-cook,agentic/recipe-quality,agentic/recipe-pr-qa-review --save`
   They install as `mms-recipe-cook`, `mms-recipe-quality`, and
   `mms-recipe-pr-qa-review`. They come from the `Consensys/skills` clone in
   step 7 and are marked experimental, which is why the explicit `--include`
   is required. If `yarn metamask-skills describe agentic/recipe-cook` cannot
   find it, check `CONSENSYS_SKILLS_DIR` points at that clone, then stop and
   tell me. Do not substitute a different skill.
9. Run `mm-harness actions`. That list is the ONLY set of capabilities you may
   use, now and in every later session — never invent an action or a flag. Then
   stop and tell me setup is done.

Not optional, from here on: evidence comes only from executed actions — never
fabricate a result or edit state to manufacture one. If the harness reports a
capability as unsupported, stop and tell me rather than working around it. If a
step fails twice after following its error's instructions, stop and show me the
exact error.

Do real work

Pick what you are doing. Each one runs the skill that owns that flow, and leaves a rerunnable recipe behind as the proof.

mms-recipe-pr-qa-review — read-only. It freezes the acceptance criteria before it touches the runtime, validates each one on a real build, and returns a report. It never edits product code and never posts to GitHub. The PR must be in the same product as your checkout. 

/mms-recipe-pr-qa-review https://github.com/MetaMask/metamask-mobile/pull/<number>

Extract the acceptance criteria from the PR yourself and freeze them before any
runtime work. Validate each one against the running build, then give me the
per-AC verdict table, the overall verdict, and the artifact paths. Do not post
anything on the PR.

mms-recipe-cook, classified as fix-bug. It lists the compatible checklist templates and stops for your pick, then works on a local task branch. No product edits until the bug is proven to reproduce. 

/mms-recipe-cook

Fix this in the checkout I started you in — treat it as fix-bug:
<paste the ticket, or the broken behaviour and how to reproduce it>

Reproduce it on the real build first and keep that failing run as the baseline.
Then fix it and re-run the same recipe until it passes. Show me the recipe
status, the per-node results, and the artifact paths.

mms-recipe-cook, classified as dev. Same flow: it lists the compatible templates, stops for your pick, and keeps the diff uncommitted until you ask it to package the PR. 

/mms-recipe-cook

Build this in the checkout I started you in — treat it as dev:
<paste the ticket, or the change you want>

Plan the proof before you edit anything, implement it, then prove it with a
recipe that drives the real build. Show me the recipe status, the per-node
results, and the artifact paths.
How it works →

A proposal for how agents can code at MetaMask — offered for teams to try.