Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By archcore-ai
Capture, surface, and enforce architectural knowledge — document decisions as ADRs/RFCs, plan features across requirement tracks, audit documentation health, and enforce code alignment against project rules on file write.
npx claudepluginhub archcore-ai/pluginAudit Archcore documentation health; --deep for full audit, --drift for staleness.
Document a module, component, API, system, or technical topic.
Surface rules, decisions, specs, and patterns for a code area or topic.
Record a technical decision as an ADR or draft a proposal as an RFC.
Show available Archcore commands and how to use them.
Archcore documentation expert. Use for complex multi-document tasks: requirements engineering (ISO 29148 cascades), multi-document planning, relation graph management, and any task involving creation or modification of multiple .archcore/ documents.
Read-only documentation auditor. Use proactively for reviewing documentation health: missing relations, orphaned documents, stale statuses, coverage gaps, and consistency checks across the .archcore/ knowledge base.
Audit Archcore docs: dashboard (counts, status, relations, orphans), deep coverage audit, or drift detection (code/cascade/temporal staleness). Use for 'show status', 'documentation gaps', 'check if docs match code', or after a staleness warning. Not for creating docs.
Document a module, component, or system — automatically picks the right type (ADR, spec, doc, or guide). Use when you need comprehensive docs for a codebase element and don't want to choose the document type yourself.
Surface the rules, ADRs, specs, patterns, and reference docs that apply to a code area before changing it — or recap project focus when picking up work. Use for 'what rules apply to X', 'before I touch Y', 'what governs my current changes' (--git-changes), 'pick up where we left off'. With uncommitted changes in play you MAY run --git-changes once per task to load the rules for what you've touched (not per-edit). Not for creating docs, planning, or audits.
Record a decision: finalized → ADR (optionally rule + guide or spec + plan); open proposal → RFC. Use for 'we decided', 'record this decision', 'make it a standard', 'draft an RFC', 'should we switch to Y'. Not for feature planning or documenting existing code.
Show available Archcore commands and how to use them. Use when onboarding, exploring what skills are available, or when you're not sure which command to run.
Modifies files
Hook triggers on file write and edit operations
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Make your AI agent code with your project's architecture, rules, and decisions.
Architecture Decision Records authoring and management
AI-powered architecture documentation framework with ADRs, reviews, and pragmatic mode
Architecture Deep Research — scan a repo, draft a PRD, run live deep research, get a cited handoff. Use when picking a topology, retrieval architecture, event bus, storage engine, auth pattern, or any system-design decision before code lands.
Personal Claude Code + Codex dev stack: security hooks, AI-first code conventions, /security-review, /repo-map, /stack-check, portable statusline. Designed to complement other skills-based plugins, not replace them.
Interactive skill that analyzes a task, proposes an agent team composition, and creates the team after user confirmation
Make your AI agent code with your project's architecture, rules, and decisions.
Make your AI code like it already knows your repo.
Archcore gives coding agents the architecture, rules, and prior decisions of this repo — so new changes land where your project says they belong and follow the team's conventions, automatically.
Works in Claude Code, Cursor, and Codex CLI. One source of truth, in Git.
Describe what you want in plain English — Archcore routes it. The slash commands below are shortcuts to the same workflows.
| Command | Outcome | When to use |
|---|---|---|
/archcore:init | Make your repo legible to AI agents | First-time setup — seeds a stack rule, a run-the-app guide, and imports your CLAUDE.md / AGENTS.md / .cursorrules if present |
/archcore:context | Load what's already decided before you change code | Daily, before editing — pulls relevant rules, decisions, specs, patterns, and reference docs for a file, directory, or topic; or --git-changes for the rules governing your uncommitted changes |
/archcore:capture | Document what already lives in code | A module, API, pipeline, or integration has tribal knowledge but no doc yet |
/archcore:plan | Turn an idea into a scoped implementation plan | New feature, refactor, or initiative — pick depth with --track product|feature|sources|iso |
/archcore:decide | Record a decision and (optionally) make it a team rule | A decision was made — capture rationale, consequences, and turn it into an enforced standard |
/archcore:audit | Find stale, missing, or drifting docs | Health check — add --deep for a full audit, --drift for code/doc staleness |
/archcore:help | Navigate the skill catalog | When you forget which command fits |
Archcore plugins require the Archcore CLI on PATH — it serves the MCP server the plugin talks to.
# macOS / Linux / WSL
curl -fsSL https://archcore.ai/install.sh | bash
# Windows (PowerShell 5.1+)
irm https://archcore.ai/install.ps1 | iex
Verify: archcore --version · Update: archcore update · Docs: docs.archcore.ai/cli/install
Then add the plugin in your host:
Claude Code
/plugin marketplace add archcore-ai/plugin
/plugin install archcore@archcore-plugins
Cursor — requires Cursor 2.5+. Open Plugins, paste https://github.com/archcore-ai/plugin into Search or paste link, click Add Plugin. One-time MCP setup: copy docs/cursor.mcp.example.json into ~/.cursor/mcp.json (user-scoped) or .cursor/mcp.json (project-scoped).
Codex CLI — requires Codex CLI v0.117.0+.
codex plugin marketplace add archcore-ai/plugin
codex
# then run /plugins, open Archcore, select Install plugin
Claude Code — load the plugin for the current session:
claude --plugin-dir /path/to/plugin
Cursor — symlink the repo into Cursor's local plugins directory and reload the window:
ln -s /path/to/plugin ~/.cursor/plugins/local/archcore
# then in Cursor: Cmd/Ctrl+Shift+P → "Developer: Reload Window"
Cursor team rollouts — Dashboard → Settings → Plugins → Team Marketplaces → Import (paste the GitHub URL).
Open your project and try these three prompts. Each shows a different side of what your agent can now do.
Empty repo? Run
/archcore:initfirst — it seeds a stack rule, a run-the-app guide, and optionally imports your existingCLAUDE.md/AGENTS.md/.cursorrules.
1. "Before I change anything in src/auth/, what should I know?"
Your agent sees what's already decided for that path — before it touches the code.
2. "Add a new API handler and follow this repo's conventions." Your agent places the handler where your architecture says it belongs, instead of guessing.
3. "We picked PostgreSQL — record it as a team standard." The decision is captured, codified as a rule, and auto-applied to every future change in the same area. Decisions stop dying in chat scrollback.