By archcore-ai
Capture, maintain, query, and audit project architecture decisions, rules, specs, guides, and plans in a git-native .archcore/ knowledge base. Generate linked document cascades (ADR→rule→guide, requirements chains), detect staleness via git diffs, enforce integrity with hooks, and enable AI agents to code aligned with your conventions.
npx claudepluginhub archcore-ai/plugin --plugin archcoreAdmin access level
Server config contains admin-level keywords
Share bugs, ideas, or general feedback.
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.
Detect stale docs and suggest updates — cross-references code changes with documentation, checks the relation graph for cascade staleness. Use when docs may be out of date after a refactor, merge, or when a session-start staleness warning appeared. For coverage gaps use /archcore:review.
Advanced — End-to-end architectural design flow: ADR → spec → plan. Best for significant technical decisions that require a formal specification and an implementation plan. For a decision without a spec, use /archcore:decide. For codifying standards, use /archcore:standard-track.
First-time onboarding: detect repo scale (small / medium / large) and seed scale-appropriate `.archcore/` documents — stack rule, run guide, entry-point inventory (medium+), top-level domain map (large), hotspot capture candidates, and optional imports from existing agent-instruction files (CLAUDE.md, AGENTS.md, .cursorrules, etc.). Activate when user says 'bootstrap archcore', 'initialize archcore', 'set up archcore', 'seed archcore', 'first-time setup', 'what should I do first', or asks how to start after a fresh install. Do NOT activate for creating individual documents (use /archcore:capture, /archcore:decide, /archcore:standard), for feature planning (use /archcore:plan), for documentation audits (use /archcore:review), or for loading existing context (use /archcore:context).
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.
Load the rules, ADRs, specs, and patterns that apply to a code area before changing it — or summarize current project focus when picking up work. Activate when user says 'what rules apply to X', 'what should I know before touching Y', 'before I refactor Z', 'pick up where we left off', 'where is the payments work right now', 'what was I working on in X', 'load project context', 'show me the decisions/rules/specs for X'. Do NOT activate for creating documentation (use /archcore:capture, /archcore:decide, /archcore:standard), for feature planning (use /archcore:plan), for detecting stale docs (use /archcore:actualize), for health audits or current-state counts (use /archcore:review).
Record a decision — finalized (creates ADR, optionally rule + guide) or open proposal for team review (creates RFC). Activate when user says 'we decided', 'record this decision', 'draft an RFC', 'proposing X', 'should we switch to Y'. Do NOT activate for feature planning (use /archcore:plan), documenting existing code (use /archcore:capture), or making a full standard cascade (use /archcore:standard).
Advanced — Full feature delivery flow: PRD → spec → plan → task-type. Best for well-scoped features that need formal specification and a repeatable delivery pattern. For lightweight product planning, use /archcore:product-track.
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.
Advanced — Formal ISO 29148 requirements cascade: BRS → StRS → SyRS → SRS. Best for regulated systems, multi-team projects, or complex distributed systems requiring traceable, auditable requirements. For lighter product discovery use /archcore:sources-track.
Plan a feature or initiative — creates a requirements chain (idea → PRD → plan) for large scope, or a single plan document for focused work. Use when someone says 'let's plan', 'create a roadmap for', or 'I need to plan X'. Not for recording a decision — use /archcore:decide.
Advanced — Lightweight product requirements flow: idea → PRD → plan. Best for individual features, small teams, or rapid prototyping. For engineer-led feature delivery use /archcore:feature-track; for ISO requirements cascade use /archcore:iso-track.
Review documentation health. Default: compact dashboard (counts, status breakdown, relations, orphans). With --deep: full audit with coverage gaps, staleness, relation health, and prioritized recommendations. Activate when user asks 'show status', 'how many docs', 'dashboard', 'review the docs', 'audit the knowledge base', 'documentation gaps'. For code-drift detection use /archcore:actualize.
Advanced — Discovery requirements flow: MRD (market) → BRD (business) → URD (user). Best for product teams doing research, stakeholder alignment, or business analysis before committing to a product. Not for technical requirements — use /archcore:iso-track.
Advanced — Create an ADR → (optional CPAT) → rule → guide cascade to codify a team standard. Activate when user explicitly requests a standard cascade or a full 'decision to enforcement' chain. For a single decision without enforcement, use /archcore:decide; for mixed intent routing, use /archcore:standard.
Establish a team standard end-to-end — creates ADR → rule → guide chain for codifying practices. Activate when user says 'make this a standard', 'establish a convention', 'codify this practice'. Do NOT activate for recording a one-off decision (use /archcore:decide) or feature planning (use /archcore:plan).
Run plugin integrity checks — validates configs, scripts, skills, hooks, agents, and runs test suite.
AI-powered architecture documentation framework with ADRs, reviews, and pragmatic mode
Architecture Decision Records authoring and management
Make a codebase agent-ready by scaffolding AGENTS.md, ARCHITECTURE.md, and docs/ structure following progressive disclosure patterns. Creates CLAUDE.md as a symlink for Claude Code compatibility.
Interactive skill that analyzes a task, proposes an agent team composition, and creates the team after user confirmation
Makes a repo agent-ready: AGENTS.md, boundary tests, CI pipeline, GC scripts — based on OpenAI's harness engineering methodology
Architecture analysis, brainstorming, 12-Factor compliance, ADR generation, and LLM-as-judge comparison.
Modifies files
Hook triggers on file write and edit operations
Modifies files
Hook triggers on file write and edit operations
Share bugs, ideas, or general feedback.
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.
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/plugin
/plugin install archcore@archcore-plugins
or from terminal:
claude plugin marketplace add archcore-ai/pluginCopy command
claude plugin install archcore@archcore-plugins
Cursor — requires Cursor 2.5+. Archcore is not yet on the official Cursor Marketplace, so install from GitHub via the Plugins panel:
https://github.com/archcore-ai/plugin into the Search or paste link fieldCursor reads the repo's marketplace.json, shows the plugin, and installs it.
Claude Code — load the plugin for the current session:
claude --plugin-dir /path/to/plugin
Cursor — no --plugin-dir flag. 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"
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.
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.
Without Archcore, the agent:
With Archcore, the same asks produce code that:
CLAUDE.md / .cursorrules / AGENTS.md keeps growing and driftingNot 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.
| Host | Status | Install |
|---|---|---|
| Claude Code | Production | Plugin marketplace |
| Cursor | Implemented | Plugin marketplace |
| GitHub Copilot | Planned | — |
| Codex CLI | Planned | — |