Skills

Plugin

The plugin is 7 slash commands. Each one tells you up front what you get — not what’s happening inside.

Describe what you want in plain English (“before I touch src/auth/, what rules apply here?”) — Archcore routes it. The /archcore:* commands below are just shortcuts to the same workflows.

All 7 commands at a glance

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, and patterns for a file, directory, or topic; --git-changes scopes to 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:init

Outcome: Make your repo legible to AI agents.

/archcore:init
/archcore:init --mode=medium  # force the scale mode, overriding auto-detection

Run once per project. 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.

Pass --mode=small|medium|large to force the scale mode, overriding auto-detection.

If you already have CLAUDE.md, AGENTS.md, or .cursorrules, init also offers to import them — no existing context is lost.

After init, /archcore:capture and /archcore:decide take over for day-to-day work.

/archcore:context

Outcome: Load what’s already decided before you change code.

/archcore:context src/auth/
/archcore:context payment retries
/archcore:context where am I on the auth redesign?
/archcore:context --git-changes  # rules governing your uncommitted changes

Pulls the rules, ADRs, specs, and patterns tied to a path or topic — grouped by type, ranked by specificity — so the agent edits inside the lines your team has already drawn.

Pass --git-changes to surface the rules, decisions, specs, and patterns that govern your uncommitted git changes — “what rules apply to what I just edited.” Leave the command empty for current-focus pickup.

The same context is also injected automatically before any source-file edit (see How it works). Run the command explicitly when you want to see the full set, not just the top picks.

/archcore:capture

Outcome: Document what already lives in code.

/archcore:capture webhook delivery pipeline
/archcore:capture src/orders/inventory-sync.ts

Picks the right document type for you: adr if it’s a decision, spec if it’s a contract, doc if it’s reference material, guide if it’s a how-to. You approve before anything is written.

Use this when a module, API, pipeline, or integration has tribal knowledge but no doc yet.

/archcore:plan

Outcome: Turn an idea into a scoped implementation plan.

/archcore:plan auth redesign
/archcore:plan --track product auth redesign
/archcore:plan --track feature onboarding flow
/archcore:plan --track iso payment gateway compliance

Small ask → a single plan document. Bigger ask → a cascade you can drive to completion. Pick a depth with --track:

Track flows

--track	Flow	Use when
product	idea → prd → plan	Lightweight product flow — simple, fast, single feature or small team.
feature	prd → spec → plan → task-type	Full feature lifecycle with formal spec and a repeatable delivery pattern.
sources	mrd → brd → urd	Discovery-focused — market, business, then user inputs.
iso	brs → strs → syrs → srs	Formal ISO 29148 cascade with full traceability — regulated systems.

Each step creates a document through MCP, wires implements / related relations automatically, and pauses for your review before moving on. Stop at any step.

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

/archcore:decide

Outcome: Record a decision and (optionally) make it a team rule.

/archcore:decide use PostgreSQL as the primary database
/archcore:decide migration format

Creates an ADR with rationale, options considered, and consequences. After the ADR is recorded, the skill offers two continuations:

• Standard chain (adr → rule → guide, optionally + cpat) — when the decision implies a team standard that everyone needs to follow. Codifies the rule and writes the how-to guide.
• Architecture chain (adr → spec → plan) — when the decision needs formal specification and an implementation plan.

You approve each step. The relation graph is wired automatically (rule implements adr, guide related rule, spec implements adr, plan implements spec).

Use this whenever a decision was made — even a small one. Decisions stop dying in chat scrollback.

/archcore:audit

Outcome: Find stale, missing, or drifting docs.

/archcore:audit                # one-screen dashboard — counts, status, relation coverage
/archcore:audit --deep         # full audit, project-wide
/archcore:audit --deep tag:auth  # full audit, scoped to a tag
/archcore:audit --drift        # detect staleness (code drift, cascade drift, temporal)
/archcore:audit knowledge      # any non-flag filter implies --deep

Default returns a one-screen dashboard: counts by category, status, type, relation coverage, and a one-line issues summary. The dashboard is project-wide by design.

• --deep switches to the full audit — gaps, staleness, orphans, missing relations, prioritized recommendations.
• --drift looks for staleness signals: code drift (a doc references source that changed), cascade drift (a dependency was updated without the dependent being reviewed), and temporal drift (a doc hasn’t been touched in a long time).

Run the dashboard regularly; run --deep before a release or audit; run --drift after a big refactor.

/archcore:help

Outcome: Navigate the skill catalog.

/archcore:help

Lists every command with a one-line outcome. Use when you forget which command fits.

How a slash command activates

1. You type a slash command (/archcore:context) or describe an intent in plain English (“what rules apply to src/auth/?”).
2. The host matches your request to a skill definition shipped with the plugin.
3. The skill is loaded into the conversation — its description, guardrails, and relation rules become part of the agent’s working context.
4. The agent executes the skill, calling MCP tools as needed.

Every command ultimately resolves to MCP tool calls. The plugin never writes to .archcore/ directly — Write / Edit on .archcore/*.md is blocked by a PreToolUse hook, so all mutations go through create_document / update_document / add_relation.

Next steps

• Built-in agents — the two agents that back commands for complex multi-document flows.
• Document types — the 18 types these commands route to.
• Skills reference — one-page lookup of all 7 commands.