Archcore Plugin

Make your AI code like it already knows your repo.

Archcore gives coding agents the architecture, rules, and past decisions of this repo — so new changes land in the right place and follow team conventions.

It works across sessions, across agents, and across host tools. When your team makes a new decision, Archcore can turn it into a rule the next code change respects.

Install

No prerequisites. The plugin bundles a launcher that downloads the Archcore CLI on first use (cached between sessions).

Claude Code — inside claude:

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

Cursor — requires Cursor 2.5+. Archcore is not yet on the official Cursor Marketplace, so install directly from GitHub — open a new Agent chat and run:

/add-plugin archcore@https://github.com/archcore-ai/archcore-plugin

/add-plugin doesn't appear in autocomplete — type the full command.

Claude Code — load the plugin for the current session:

claude --plugin-dir /path/to/archcore-claude-plugin

Cursor — no --plugin-dir flag. Symlink the repo into Cursor's local plugins directory and reload the window:

ln -s /path/to/archcore-claude-plugin ~/.cursor/plugins/local/archcore
# then in Cursor: Cmd/Ctrl+Shift+P → "Developer: Reload Window"

Both manifests (.claude-plugin/plugin.json and .cursor-plugin/plugin.json) live at the repo root.

Cursor team rollouts — add the GitHub URL under Dashboard → Settings → Plugins → Team Marketplaces → Import.

Offline / BYO CLI — if you already have the Archcore CLI installed (via curl -fsSL https://archcore.ai/install.sh | bash, go install, etc.), the launcher respects it — a global install on PATH wins over the plugin-managed cache.

For fully offline environments: install the CLI manually and set ARCHCORE_SKIP_DOWNLOAD=1 to disable the launcher's auto-download. Alternatively, set ARCHCORE_BIN=/abs/path/to/archcore to pin an explicit binary.

Try these first

Install, open your project, and try these three prompts. Each shows a different side of what your agent can now do.

Empty repo? Run /archcore:bootstrap first to seed a stack rule, a run-the-app guide, and (optionally) imports from your existing CLAUDE.md / AGENTS.md / .cursorrules.

1. "Before I change anything in src/auth/, what rules and prior decisions apply here?"
Archcore loads the rules, ADRs, specs, and patterns tied to that path — grouped by type, ranked by specificity — before the agent edits code. Works the same way for a file, a directory, or a topic.

2. "Add a new API handler and follow this repo's conventions."
Archcore surfaces the relevant rule (e.g., "handlers live in src/api/handlers/") and injects it into context before the write. The agent places code where your architecture says it belongs, instead of guessing.

3. "We picked PostgreSQL — record it as a team standard so future database changes respect it."
Archcore records the decision as an ADR, codifies the constraint as a rule, and drafts a guide. Next time an agent edits database code, that rule is auto-injected — decision becomes an enforced constraint, not history buried in docs.

If any of these feels valuable, the rest of Archcore is more of the same, just structured.

What changes after install

Without Archcore, the agent:

• guesses your folder structure
• re-litigates decisions your team already made
• needs the same conventions repeated in every chat
• loses project truth the moment the session ends

With Archcore, the same asks produce code that:

• lands where your architecture says it belongs
• respects ADRs, specs, and rules already in Git
• follows team conventions loaded automatically on session start
• reflects new decisions as future guardrails, not markdown graveyards

Use Archcore when

• Your agent writes code, but not in the way this repo expects
• Your CLAUDE.md / .cursorrules / AGENTS.md keeps growing and drifting
• You work with 2+ agents or 2+ host tools (Claude Code + Cursor + Copilot)
• You want decisions, rules, and specs in Git — not in chat scrollback

Not for — chat memory, a prompt library, or a one-shot spec-to-code generator. Archcore is a repo truth layer for coding agents, not a methodology kit.

Supported hosts

The plugin uses open standards (Agent Skills, MCP) — skills, agents, and MCP tools are shared across hosts. Only hooks and manifests are host-specific.

How it works

1. Session starts — the session hook loads your project's document index and relations into context
2. You ask for something — "create a PRD for the auth redesign", "what ADRs relate to payments?", "audit the docs"
3. Skills activate — the agent matches your request to the right skill, which provides document-type knowledge, required sections, and relation guidance
4. MCP tools execute — all reads and writes go through archcore mcp, ensuring validation, template generation, and sync manifest updates
5. Hooks guard quality — direct .archcore/ writes are blocked (MCP-only), and every change is validated automatically

Mental model

Two pieces work together:

• Archcore CLI — the compiler. Reads .archcore/, builds the context graph, exposes it over MCP.
• Archcore Plugin — the runtime. Applies that context inside your AI agent — skills, guardrails, workflows.

What ships in the box

• 18 Skills — 11 intent commands, 6 multi-step tracks, 1 utility
• 2 Agents — a universal assistant and a read-only auditor
• Hooks — session-start context loading, MCP-only write enforcement, post-mutation validation, cascade staleness detection

The plugin ships a launcher that resolves the Archcore CLI (archcore mcp) and registers the MCP server automatically via the plugin's bundled .mcp.json. If the CLI isn't on PATH, the launcher downloads it on first use and caches it under $CLAUDE_PLUGIN_DATA/archcore/cli/ (survives plugin updates). An existing global archcore install on PATH always wins — no duplicate-server conflicts.

What you ask Archcore to do

Describe what you want in plain English — Archcore routes it to the right skill and document flow. The command is a shortcut, not the interface.

• Understand what applies before a change — /archcore:context
• Document a module, component, or API — /archcore:capture
• Record a finalized decision — /archcore:decide
• Establish a team standard — /archcore:standard
• Plan a feature end-to-end — /archcore:plan
• Review documentation health — /archcore:review
• Detect stale docs after code drift — /archcore:actualize
• See the project dashboard — /archcore:status
• Render the relation graph — /archcore:graph
• First-time onboarding — /archcore:bootstrap
• Navigate the system — /archcore:help

Document types (17)

Each type skill teaches the agent about one document type: when to use it, required sections, best practices, common mistakes, and how to relate it to other documents. The plan type is served by the /archcore:plan intent skill rather than a standalone type skill.

Invoke mainstream types directly: /archcore:adr, /archcore:prd, /archcore:spec, etc. The 7 niche types (mrd, brd, urd, brs, strs, syrs, srs) are hidden from / autocomplete to reduce cognitive load — reach them through /archcore:sources-track or /archcore:iso-track, or call mcp__archcore__create_document directly.

Tracks (6)

Tracks orchestrate multi-document flows. Each step builds on the previous one, with proper relations created automatically.

Invoke: /archcore:product-track, /archcore:architecture-track, etc.

Agents

archcore-assistant — Universal read/write agent for complex multi-document tasks. Creates and updates documents, manages relations, handles requirement cascades. Uses all 8 MCP tools.

archcore-auditor — Read-only background agent for documentation health. Detects coverage gaps, orphaned documents, stale statuses, broken relation chains, and naming inconsistencies. Safe by design — no write tools.

Guardrails

The plugin enforces the MCP-only principle: all .archcore/ operations must go through Archcore's MCP tools, never through direct file writes. This ensures every change is validated, templated, and synced.

• Session start — loads document index and relations into context, detects code-document drift
• Write blocking — intercepts and blocks direct Write/Edit calls targeting .archcore/
• Validation — runs archcore validate after every document mutation
• Cascade detection — warns when an updated document has dependents that may need review

Is Archcore like BMAD / Spec Kit / claude-mem / Memory Bank?

No — these solve different problems. Quick map:

Choose by what you need. Pick a methodology tool (BMAD, Superpowers, Spec Kit, Agent OS) for an opinionated dev flow. Pick a memory tool (claude-mem, Mem0, agentmemory, claude-brain) for session continuity in general-purpose agents. Pick Archcore when you want typed, queryable project truth — the decisions, rules, and architecture of this repo — that your coding agent respects on every request.

Philosophy

• Context is a first-class artifact — typed, validated, relation-aware Markdown in Git. Not a hidden prompt, not tribal knowledge.
• Opinionated workflows over raw tool access — skills route intent to the right document type and the right multi-step flow.
• Minimal effort at the boundary — the agent already knows the structure, so you describe intent, not schema.

Roadmap

• Deeper IDE integrations (VS Code, JetBrains)
• Additional hosts (GitHub Copilot, Codex CLI)
• Multi-agent coordination for long cascades
• Richer staleness and drift analytics

Uninstallation

Claude Code:

/plugin uninstall archcore@archcore-plugins

Cursor: remove from plugin settings.

License

Apache-2.0

Contributing

Issues and ideas: GitHub Issues