archcore
Star Install
Menu
Experimental

Superpowers + Archcore

Give Superpowers your project’s decisions. Keep new decisions in Git with Archcore.

How Superpowers + Archcore work together

Start with either tool. These instructions tell your agent to read existing project decisions before design work and save new decisions in Archcore. Superpowers keeps its own plans; Archcore documents reference them.

Archcore ↗
Keeps project decisions, rules, and specs in Git for your agent to use.
Superpowers ↗
Guides design and implementation through its own skills and plans.

From a new idea to the next session

The instructions ask your agent to:

  1. Read existing decisions

    At the start of brainstorming, the agent searches Archcore for decisions and rules that apply to your task.

  2. Review the design before code

    Superpowers guides the design. If the task conflicts with an accepted decision, the agent asks you how to proceed.

  3. Keep the decisions you approve

    After design approval, the agent records decisions as draft architecture decision records (ADRs) in Archcore. Accepting an ADR needs your explicit approval.

  4. Continue with project context

    The next session can find the saved design and decisions. Superpowers keeps its implementation plans in the repository.

Starting with /archcore:plan? That command finishes first. Superpowers can pick up design or execution work it leaves open.

See an example → See benefits and limits →

One request, start to finish

Request Introduce coupon discounts in this quotation library. Use floating-point arithmetic for the monetary intermediate values. Use superpowers:brainstorming for the design and superpowers:writing-plans for the plan. Check existing project decisions and report any conflict before implementing.

  1. Archcore: Brainstorming opens with a search of the project records, before the agent reads any repository file. It finds the accepted decision on integer cents, reports the conflict with the float request and stops. No file has changed.

  2. Superpowers: You keep integer cents. Brainstorming produces a design file under docs/superpowers/specs/. Until you approve that file, the agent writes no code, no tests and no records.

  3. Archcore: You approve the design file. The decisions it settles become draft ADRs. Accepting them is a separate step, and the money decision stays as it was.

  4. Superpowers: Writing-plans puts the execution plan in docs/superpowers/plans/. You ask for the implementation, the plan runs, the tests pass, and the new ADRs stay draft.

  5. Agent: A new session finds the design, the plan and the decision records and works from them, with draft decisions kept apart from accepted ones.

This is what the instructions ask for, not a recorded run. No verification record is attached to this instruction revision yet.

Connect the two tools

1. Install Archcore and Superpowers

Install Archcore and Superpowers in the agent you use for this project.

2. Add instructions

CLAUDE.md / AGENTS.md / GEMINI.md 
### Archcore + Superpowers

Applies when both plugins are loaded. A tool, skill, or command that the session shows only by name counts as loaded. An instruction naming only Archcore tools applies in any session with those tools.

1. If the host shows Archcore tools by name only, load their schemas before the first repository read.
2. When the user names a skill or `/archcore:*` command, load and follow that skill's own instructions, not a summary.
3. When any skill or plan step says to read the project, call `search_documents` before reading repository files.
4. After `/archcore:plan`, `/archcore:document`, `/archcore:review`, or `/archcore:init` is invoked, let that command finish before invoking `superpowers:brainstorming`.
5. When an `/archcore:*` command reports missing design or execution work, offer the matching Superpowers skill to the user.
6. If the user accepts that offer, pass the command's prepared inputs to the Superpowers skill.
7. When the user starts through a Superpowers skill, keep to that skill's steps instead of an `/archcore:*` command.
8. At the start of `superpowers:brainstorming`, call `search_documents` on the task topic before reading any repository file.
9. During `superpowers:brainstorming`, write no code, tests, or `.archcore/` records until the user approves a design file under `docs/superpowers/specs/`.
10. When `superpowers:brainstorming` writes a design file in a project with `.archcore/`, record the decisions it settles as `.archcore/**/*.adr.md`.
11. When `superpowers:writing-plans` covers work an `.archcore/**/*.spec.md` describes, set the plan's `Spec:` field to that path.
12. If a `docs/superpowers/plans/*.md` tracks the tasks of an `.archcore/**/*.plan.md`, report the overlap in the task result.
13. If a `docs/superpowers/plans/*.md` tracks the tasks of an `.archcore/**/*.plan.md`, keep the `.archcore/` plan as written.
14. Before any code edit, call `search_documents` on the affected area, including for a one-line change.
15. When prior work in the task answers a question the active skill asks, do not ask it again.
16. If supplied material leaves a required input unanswered, ask for that input before writing the artifact.
17. Before recording a decision in `.archcore/`, call `search_documents` for an existing record.
18. Create every `.archcore/**/*.md` record with status `draft`.
19. Set status `accepted` on an `.archcore/**/*.md` record only after the user's explicit acceptance in the task.
20. If a task conflicts with an `accepted` `.archcore/**/*.adr.md`, report the conflict to the user.
21. If a task conflicts with an `accepted` `.archcore/**/*.adr.md`, make no edit until the user decides.
22. If a document carries `read_only: true`, name its owning project instead of writing to it.
23. If more than one writable `.archcore/` is present, confirm the target project before writing a record.
24. If the project has no `.archcore/`, do not call `init_project` without the user's request.
25. If a Superpowers skill or Archcore tool the user names is unavailable, name the missing contribution in the task result.
26. End a task that changed code or records with `Archcore: <records read or written>` or `Archcore: not used — <reason>`.
27. If another connected recipe's instruction conflicts with an instruction here, report the conflict in the task result.
28. If another connected recipe's instruction conflicts with an instruction here, keep that recipe's applicable contribution.

3. Check in a new session

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

Confirm you can use Archcore and Superpowers, 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

Catch conflicts before code.

The instructions bring existing project decisions into design work. You resolve conflicts before implementation and approve new decisions before they become accepted records.

Design with project context

Brainstorming starts with a search for relevant decisions and rules.

You approve the design before code is written.

Conflicting or shared decisions

A conflict with an accepted decision needs your input. Read-only documents stay with their owning project.

If several projects are writable, the agent confirms where to save a record.

A new session

Saved designs and decisions give the next session context to continue.

Unanswered design questions still need your input.

Two implementation plans

Superpowers keeps its detailed execution plan. The Archcore plan stays as written.

You maintain any overlapping tasks across the two plans.

Starting with /archcore:plan

The command finishes before brainstorming begins.

Superpowers can take on design or execution work the command leaves open.

Start with Archcore.

Keep your project decisions ready for the next task.

Install Archcore →See how it works

Superpowers + Archcore

Source & verification

Category
Workflow skills
Instruction revision
1c1dd4f05e87
Source
Plugin repository · AGENTS.md · This revision is not published yet.
Maintainer
Archcore maintainers
Page updated
September 9, 2026

Verification

No joint run has been recorded for this instruction revision.

  • Instructions are copied from the Archcore + Superpowers section of AGENTS.md. CLAUDE.md imports that file.
  • This instruction revision has no linked verification record.
  • The recipe source is unpublished, so the text is pinned by digest rather than by an upstream revision.
  • Setup steps are written for five agents and checked on none of them.
  • Superpowers is not installed by this recipe. It has to be present and callable already.
  • This pair only. Two working pairs do not make a working triple.

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.