Plugin Quick Start

Plugin

Get the full Archcore experience inside Claude Code, Cursor, or Codex CLI. Seven outcome-focused slash commands, built-in agents, and guardrails — all on top of your repo.

Prerequisite (all hosts): install the Archcore CLI globally — one curl line on macOS/Linux, one PowerShell line on Windows. See the CLI install guide. The plugin calls archcore from your PATH in every supported host.

Then install the plugin (below). Cursor users do one extra step: register MCP from the docs/cursor.mcp.example.json template (Cursor doesn’t auto-register plugin-provided MCP).

1. Install the plugin

Claude Code

claude plugin marketplace add archcore-ai/plugin
claude plugin install archcore@archcore-plugins

Or from within Claude Code:

/plugin marketplace add archcore-ai/plugin
/plugin install archcore@archcore-plugins

Cursor

Requires Cursor 2.5+. Open Cursor → Plugins, paste https://github.com/archcore-ai/plugin into the Search or paste link field, and click Add Plugin. Cursor reads the repo’s marketplace.json and installs Archcore.

Then copy docs/cursor.mcp.example.json (from the plugin) into ~/.cursor/mcp.json (user-scoped) or .cursor/mcp.json (project-scoped):

{
  "mcpServers": {
    "archcore": {
      "type": "stdio",
      "command": "archcore",
      "args": ["mcp", "--project", "${workspaceFolder}"]
    }
  }
}

Keep the --project ${workspaceFolder} argument — without it, one project’s .archcore/ is read across every other Cursor window.

Codex CLI

Requires Codex 0.117.0+.

codex plugin marketplace add archcore-ai/plugin

MCP is auto-registered via the plugin’s .codex.mcp.json. Enable hooks for full coverage:

codex features enable plugin_hooks

plugin_hooks is currently under development in Codex (default off). Without it, commands, MCP tools, and agents work normally, but validation, cascade, precision, and pre-edit injection hooks won’t fire.

Restart your host so the session-start hook can run.

2. Verify

Open your project in a fresh conversation and run:

/archcore:help

You should see a list of the seven /archcore:* commands with their outcomes. If not, see plugin troubleshooting.

3. Make your repo legible (optional)

If .archcore/ doesn’t exist yet, the fastest way to seed something useful is:

/archcore:init

The command detects repo scale (small / medium / large) and seeds scale-appropriate documents: a stack rule, a run-the-app guide, an entry-point inventory (medium+), a top-level domain map (large), and a list of hotspot capture candidates. It also offers to import existing CLAUDE.md, AGENTS.md, or .cursorrules if you have any. Run this once per project.

Already have an .archcore/ directory? Skip ahead to step 4.

4. Record your first decision

Use /archcore:decide for an actual decision you’ve already made:

/archcore:decide use PostgreSQL as our primary database

If .archcore/ doesn’t exist yet, MCP initializes it on the first call — no archcore init needed.

The skill creates an ADR with rationale and consequences, then offers a follow-up cascade:

• Standard chain (adr → rule → guide) — if PostgreSQL becomes the mandated database, codify it as a rule and write the how-to guide.
• Architecture chain (adr → spec → plan) — if the decision needs formal specification and an implementation plan.

Accept whichever cascade fits. Each step pauses for your review.

Check the result:

ls .archcore/

You should see one or more linked documents, all validated.

5. See the context the agent now has

Before touching some code, ask Archcore what already applies:

/archcore:context src/db/

The skill loads the rules, ADRs, and patterns tied to src/db/ — so the agent edits inside the lines your team has already drawn. The same context is also injected automatically before each source-file edit; this command shows you the full set on demand.

6. Try a multi-step plan

For something bigger, drive a full cascade with /archcore:plan:

/archcore:plan --track feature event-driven orders

This walks you through a PRD, a spec, a plan, and a task-type — one document per step, with the right relations between them. You review each step before the next. Pick a different track when you need a different depth:

• --track product (idea → prd → plan) — lightweight.
• --track sources (mrd → brd → urd) — discovery-focused.
• --track iso (brs → strs → syrs → srs) — formal ISO 29148 cascade.

Default (no --track) routes a single /archcore:plan ask to the product flow.

What you get

• 7 outcome-focused commands — each one routes to the right document type for you. See Skills for the full catalog.
• Automatic context injection — before any source-file edit, the plugin greps .archcore/ for relevant rules, ADRs, specs, and patterns and injects them into context.
• Built-in agents — archcore-assistant for multi-document flows, archcore-auditor for reviews.
• Guardrails — direct .archcore/*.md writes are blocked; every mutation is validated; cascade staleness is flagged.

Next steps

• Plugin overview — what ships in the box.
• Skills — outcome, examples, and flags for each of the 7 commands.
• Document types — the vocabulary you’re using.