archcore
Star Install
Menu
Verified in part

Matt Pocock Skills + Archcore

Model the change with Matt Pocock Skills. Keep decisions and plans in Archcore.

How Matt Pocock Skills + Archcore work together

Matt Pocock Skills + Archcore keep every project decision in one place while the agent plans, designs, tests and reviews. Matt Pocock Skills supply the engineering discipline: grilling, domain modelling, TDD and code review. Archcore keeps the accepted decisions that constrain that work, and stores the design and new ADRs in Git.

Say you ask the agent to record that coupons never discount delivery. domain-modeling would write to docs/adr/ by default. With the instructions, the agent searches Archcore first and names the existing ADR if there is one. If the decision is new, it creates a draft ADR in .archcore/ for you to accept.

The benchmark note says what was measured. For the skills and their installation, see the Matt Pocock Skills repository.

Archcore ↗
Keeps project decisions, specifications and plans in Git so the agent can use them throughout the change.
Matt Pocock Skills ↗
Its skills help the agent question the plan, model the domain, design the code, work test-first and review the change.

From a request to a reviewed change

The instructions ask your agent to:

  1. Read the project decisions

    Before design work, the agent searches Archcore for accepted decisions, rules and plans. A conflict stops the work until you decide.

  2. Model and build the change

    Matt Pocock Skills drive grilling, domain modelling, test-first code and review. Questions an accepted record already answers are skipped, and the agent names the record.

  3. Keep decisions in one place

    New hard-to-reverse decisions become draft ADRs in .archcore/, not in a second ADR folder. A later session reads them before asking you again.

Matt Pocock Skills lead the engineering work; Archcore keeps the decisions and plan behind it.

See an example → See benefits and limits →

One request, start to finish

Request Introduce coupon discounts as a new subsystem in this quotation library. Use floating-point arithmetic for monetary intermediate values. Check existing project decisions and report any conflict before implementing.

  1. Archcore: The agent finds the accepted integer-cents decision, reports that floats conflict with it, and waits for your choice.

  2. Matt Pocock Skills: You keep integer cents, and the agent models the subtotal, delivery and coupon boundaries without asking again about settled choices.

  3. Archcore: The design is saved as .archcore/shop/coupon-discounts.spec.md, and after your approval its decisions become draft ADRs.

  4. Matt Pocock Skills: The agent builds the coupon test-first, runs the tests and reviews the change before it reports.

  5. Agent: A new session reads the spec and the ADRs and explains the coupon rules without asking you to repeat them.

This is what the instructions ask for, not a recorded run. These instructions completed the coupon feature in 3 of 3 runs with claude-sonnet-5.

Connect the two tools

1. Install Archcore and Matt Pocock Skills

Install Archcore and Matt Pocock Skills in the agent you use for this project.

2. Add instructions

CLAUDE.md / AGENTS.md / GEMINI.md 
### Archcore + Matt Pocock Skills

Applies when Archcore and Matt Pocock Skills are both available. A skill or tool that the session shows only by name counts as available.

1. Before you design, plan, or edit code, call `search_documents` on the task topic.
2. Treat each `accepted` record that `search_documents` returns as a constraint.
3. If the task conflicts with an `accepted` record, report the conflict to the user.
4. If the task conflicts with an `accepted` record, make no edit until the user decides.
5. When the request fully specifies a change and settles no new decision, skip `domain-modeling` and `codebase-design`.
6. When the request fully specifies a change, settles no new decision, and asks for no saved document, create no `.archcore/` record.
7. When the user asks for a saved design or specification, create it as an `.archcore/**/*.spec.md` record.
8. When the request names the behavior to test, treat that behavior as the agreed seam in `tdd`.
9. When the user asks to be grilled, invoke the `grilling` skill.
10. Before each `grilling` round, call `search_documents` on the decisions in that round.
11. During `grilling`, when an `accepted` record answers a question, name the record path instead of asking the question.
12. During `grilling`, write no code, tests, or `.archcore/` records.
13. After the user confirms shared understanding in `grilling`, record the settled decisions as this file directs.
14. When `domain-modeling` or `grill-with-docs` offers an ADR in a project with `.archcore/`, create it as `.archcore/**/*.adr.md`, not in `docs/adr/`.
15. If `docs/adr/` already holds ADRs, ask the user which location owns new ADRs before you write one.
16. Record an ADR only for a decision that is hard to reverse, surprising without context, and the result of a real trade-off.
17. When the change has an `.archcore/` spec or plan, record other settled design choices in that spec or plan.
18. Keep domain terms in `GLOSSARY.md`, as `domain-modeling` directs.
19. Before you record a decision, call `search_documents` for an existing record of it.
20. If an `accepted` record already states the decision, name that record instead of creating a new one.
21. Create every `.archcore/` record with status `draft`.
22. Set status `accepted` on a record only after the user explicitly accepts it.
23. When the user starts with `/to-spec`, `/to-tickets`, or `/wayfinder`, treat the issue tracker as the owner of the spec and tasks.
24. When the issue tracker owns the spec and tasks, create no `.archcore/` spec or plan for the same work.
25. When the user asks for a plan and the issue tracker does not own the work, run `/archcore:plan` after the design is settled.
26. When you run `code-review` and the change has an `.archcore/**/*.spec.md`, pass that path as the spec.
27. When you run `code-review`, add the `accepted` `.archcore/**/*.rule.md` records for the changed area to the standards sources.
28. When the spec is an `.archcore/` record, do not ask the user to run `/setup-matt-pocock-skills`.
29. Run the relevant tests and report the checks that passed or failed.
30. For a change that an Archcore record covers, name that record in the result and report any disagreement between the record and the code.
31. End a task that changed code or records with `Archcore: <records read or written>` or `Archcore: not used — <reason>`.
32. If the project has no `.archcore/`, do not call `init_project` unless the user asks to set up Archcore.
33. If more than one writable `.archcore/` is present, ask which project owns a new record before you write it.
34. If a Matt Pocock skill that this file names is unavailable, state the missing contribution and continue with the available tools.

3. Check in a new session

Start a new session in this project and ask your agent:

Confirm you can use Archcore and Matt Pocock Skills, and have read this project’s cooperation instructions.

If the agent reports a missing tool or instruction file, finish that setup before starting work.

Benefits & limits

One place for decisions, whichever skill writes them.

With these instructions, the agent named the existing ADR instead of writing a duplicate in 5 of 5 runs. Without them, it did so in 0 of 5.

A decision that an accepted ADR already records

The agent named the existing ADR in all five runs; without the instructions, every run wrote a second ADR and marked it accepted.

The ADR already stated the decision in one sentence, which made it easy to find.

A grilling round on a plan

Every round treated money as settled by the ADR and asked only about rounding and delivery.

At five runs, the difference from the no-instructions arm is not significant.

Start with Archcore.

Keep your project decisions ready for the next task.

Install Archcore →See how it works

Matt Pocock Skills + Archcore

Source & verification

Category
Engineering skills
Instruction revision
984efdd46e95
Source
Landing repository · src/recipes/matt-pocock/cooperation.md · This revision is not published yet.
Maintainer
Archcore maintainers
Page updated
October 23, 2026

Verification

Date Agent Model Scenario Outcome
October 23, 2026 Claude Code 2.1.308 claude-sonnet-5 Five-turn coupon feature with a float request that conflicts with an accepted ADR passed
October 23, 2026 Claude Code 2.1.308 claude-sonnet-5 A decision that an accepted ADR already records passed
October 23, 2026 Claude Code 2.1.308 claude-sonnet-5 A grilling round on a plan that an accepted ADR partly answers passed
October 23, 2026 Claude Code 2.1.308 claude-sonnet-5 A new decision in a project whose AGENTS.md names no ADR location failed
October 23, 2026 Claude Code 2.1.308 claude-sonnet-5 A fully specified one-line change passed
  • Tested with Claude Code 2.1.308, claude-sonnet-5, Archcore 0.13.1 and Matt Pocock Skills at commit 5beb35b. Other hosts and models were not tested.
  • When the request says a decision is settled, the agent may create the ADR as accepted. Check the status of new records.
  • The recipe does not install Matt Pocock Skills, and nothing enforces the instructions. Review tests, decisions and code before you accept a change.

Update or disconnect

To update, review changes to the instructions before replacing your copy. To disconnect, remove the added instructions from your project file. Both tools and their documents stay in place.