MM3beta

MM3 Pattern playbook

Six verbs. Five ways to use them.

A pattern is a small, named way of using a verb. Climb the ladder and the same six verbs do more: you start by using them, then share them, chain them, join them to your other tools, and finally let them run on a schedule.

These recipes are not installed into your AGENTS.md or your skill. The tool guides itself, so your footprint stays small. This is just how you could use it.

  1. 1×Coding agent
  2. 5×Senior engineer
  3. 10×Agentic engineer
  4. 25×Forward Deployed Engineer
  5. 50×Growth hacker

Under the hood

One shape behind loop, scan and drill

Three verbs share one idea: split something into pieces, ask every piece the same checklist, then go one layer down where it hurts. That is why one request can review a whole architecture, and why you can loop inside a loop.

How a sweep runs

1  decompose   over:  part  →  story        you write the tree
2  ask         one checklist per layer       asked of EVERY item
3  sweep       one call per layer            a verdict for each item
4  read        next:  the worst item         a pointer, not a guess
5  go down     drill --from "gateway/guest checkout"
               over: call: [cart-form, payment-token, receipt]
6  repeat      until you reach code, then class and replay
  • loopThe tree is ideas you write: parts and stories of a plan or a design. No code needed. This is how it reviews an architecture before it exists.
  • scanThe tree is code MM3 reads: file, then function, then call. each splits a layer into its next unit.
  • drillTakes one flagged item and goes one layer down. For ideas you list the sub-steps yourself; for code each finds them.

Every sweep answers with a verdict per item and a next: line pointing at the worst one. Follow it, and you are looping inside the loop.

Use

Coding agent / Vibe coder

“It runs. Ship it.”

Finds value in the first use, and again in every reuse.

One command. Nothing to learn first. Watch how little it takes.

view

Memoize

Ask the ledger before you ask a model. The same question on unchanged code comes back free.

mm3 view src/handlers

class

Smoke test

One quick verdict on what the agent just wrote, before you accept it.

mm3 template class > review.yaml
mm3 class review.yaml

replay

Regression test

After a fix, re-ask the same questions and see whether it held.

mm3 replay --parent MM3-0042 \
  --compare main..HEAD --expect injection

scan

Census

Same questions across every file, so the answers are comparable.

mm3 template scan > scan.yaml
mm3 scan scan.yaml

drill

Root cause

Don't guess at a failure. Go down into the one thing that flagged.

mm3 template drill --parent MM3-0060 \
  --from src/handlers/user.ts/findUser

loop

Decompose

Break an idea into parts and stories, then check every one in a single run. Add --dry-run to count the questions first.

mm3 template loop > plan.yaml
mm3 loop plan.yaml --dry-run

Standardize

Senior engineer

“Show me.”

Sees that the pattern matters as much as the tool: how checks are shared between people and between runs.

Same tool, now a shared habit. Watch the judgment move out of one head and into a file.

view

Provenance

Every claim carries its run id, so anyone can follow it back to the evidence.

mm3 view MM3-0042
# cite MM3-0042 in the PR description

class

Quality gate

The same checklist before every merge. Keep the request file in the repo.

mm3 class review.yaml
# read the failing category, then the next: line

replay

Golden master

Pin a verdict you trust and compare every later change against it.

mm3 replay --parent MM3-0042 \
  --compare v1.2.0..HEAD --expect injection

scan

Triage

Add a scale question so findings rank by severity, worst first, instead of an unordered map.

decisions:
  severity:
    pass: [none, low]
    10:
      scale: How severe is {function}?
      levels: [none, low, medium, high, critical]

drill

Runbook

Write down which flag leads to which drill, so the next person doesn't improvise.

access fails  ->  mm3 template drill \
  --parent <id> --from access

loop

Architecture review

Make the parts the components and ask each one the same questions: responsibility, dependency, testability. A whole design reviewed before code.

over:
  part: [gateway, payments, ledger]
ask:
  part:
    concerns:
      responsibility:
        pass: yes
        1: Does {part} own one clear responsibility?

Chain

Agentic engineer

“I direct. I verify.”

Links the patterns and the calls together, so the output of one becomes the input of the next.

Several calls, one flow. Watch how each result feeds the next move.

view

Cross-check

A helper agent says it did the work. Check its report against the ledger instead of taking its word.

mm3 agent delegate    # give helpers the rules
mm3 view MM3-0042     # verify each cited run

class

Escalate

A fail is not the end. Follow the next: line straight into a drill.

mm3 class review.yaml
# next: mm3 template drill --parent MM3-0001 --from access

replay

Suite

Replay a whole sweep, not one question. You get fixed, still and regressed for every item.

mm3 replay --parent MM3-0060 \
  --compare main..HEAD --expect injection
# MM3-0060 is a scan: fixed / still / regressed per item

scan

Fan-out

Give each agent its own folder. Merge what they find by run id.

mm3 scan scan-api.yaml     # agent A
mm3 scan scan-web.yaml     # agent B
mm3 report hits           # worst first

drill

Closed loop

Class finds it, drill pins it, replay proves the fix. One loop, three verbs.

class  ->  drill  ->  (fix)  ->  replay

loop

Stepwise refinement

A loop inside a loop. Drill into the weakest story and list its sub-steps yourself: the next layer, checked the same way.

mm3 loop plan.yaml
mm3 template drill --parent MM3-0003 \
  --from "gateway/guest checkout"
# then in drill.yaml:
#   over: {call: [cart-form, payment-token, receipt]}

Integrate

Forward Deployed Engineer

“Drop me in anywhere.”

Brings in more data and more tools, so decisions across a complex system get easier to make.

Now the ledger meets everything else you know. Watch the request carry its own context.

view

Join

Walk one run's lineage and see every drill, replay and outcome that hangs off it, in one place.

mm3 view MM3-0001
# lineage: scan, the drill below it,
# the replay that proved the fix

class

Decision record

A choice question turns a verdict into a decision among named options, kept with its evidence.

decisions:
  route:
    pass: [ship]
    5:
      choice: Where should this go?
      options: [ship, fix, block]

replay

Contract test

Replay the other team's checklist against your branch before you hand it over.

mm3 replay --parent MM3-0091 \
  --compare main..worktree --expect auth
# MM3-0091 holds their questions

scan

C4 map

Tag each request with the layers it touches. The report draws the architecture for you.

mdl:
  uses:
    - container:api -> component:auth -> code:verify
# then: mm3 report graph component:auth

drill

Postmortem

Drill the failure, then record the outcome and the bug it belongs to.

mm3 drill drill.yaml
mm3 outcome MM3-0042 held --by the-owner
# someone other than the asker confirms it

loop

Fitness function

Turn the design's key claims into questions on the real code, and rerun them every release.

mm3 loop plan.yaml             # the claims
mm3 class claims-on-code.yaml  # each release, on the real code

Anticipate

Growth hacker

“Make the loop run itself.”

Automates all of the above and reads the history early, so trouble is seen coming and not only handled after.

The full loop, on a schedule. Watch the ledger turn into a dashboard you read ahead of time.

view

Hotspot

Let history show where trouble clusters. A place that keeps failing is where the next problem will be.

mm3 report web
# writes .mm3/viewer.html: heat map and consensus map

class

Calibrate

Record whether verdicts held. Trust the kinds of verdict that do, and doubt the ones that don't.

mm3 outcome MM3-0002 held --by the-owner
mm3 report history

replay

Canary

Replay on every commit and watch the trend. A drift toward regressed is the early warning.

# in CI, on every commit
mm3 replay --parent MM3-0042 \
  --compare main..HEAD --expect injection
mm3 report history

scan

Drift watch

Re-sweep on a schedule against a baseline scan, and see what is moving before it breaks.

# weekly: MM3-0060 is the baseline scan
mm3 replay --parent MM3-0060 \
  --compare main..HEAD --expect injection

drill

Pareto

A few weak spots cause most of the failures. Rank them and fix those first.

mm3 report hits       # worst first
mm3 report patterns   # what keeps failing

loop

Pre-mortem

Before building, assume it failed and ask why. Healthy answers are no.

failure:
  pass: no          # a healthy answer is no
  1: Could "{story}" fail silently in production?
  2: Could "{story}" lose a customer's money?

Multipliers are a mental model, not a benchmark. “Anticipate” means reading your own history early: MM3 records and reports, and does not forecast. Commands are from mm3 help; run mm3 template <verb> for a filled-in start.