Commands Reference

ai-core-kit ships two kinds of slash command, split along the META vs CHILD boundary:

• META commands live in the kit’s own .claude/commands/ and operate on the kit itself or on a fork during setup. There are exactly two: /ack-build (build the kit) and /ack-init (initialize a fork).
• CHILD commands live under templates/commands/ and are rendered into a fork by /ack-init. These are the day-to-day delivery commands a child project’s developers invoke: the RPI trio plus the product-planning pair.

User-invocable skills (skill-creator, skill-validator, mcp-builder, cost-telemetry) are model- or human-invoked rather than slash commands; they are listed at the end for completeness and detailed in the Skills Catalog.

Slash commands are not the only surface, though — the create-ack CLI is the spine. Anything you can do from Claude Code or the site you can also do from one binary, in any terminal or CI runner.

The create-ack CLI — the spine

The kit’s guiding principle is that everything is reachable from the CLI, not only from Claude Code slash commands or this site. create-ack is a single binary (the @arthurghz/create-ack npm package) that you run with npx @arthurghz/create-ack@latest …, or install once with npm i -g @arthurghz/create-ack@latest.

It groups its work into subcommands. Scaffolding is the original command; the telemetry subcommands are thin wrappers over the stdlib-Python tools in telemetry/ — the same code documented in Observability, surfaced under one CLI so you never have to remember a python3 telemetry/<script>.py invocation.

Status, honestly. Scaffolding (new/scaffold) ships today (@arthurghz/create-ack@0.1.0). The telemetry engines under telemetry/ are real and run today via python3 telemetry/<script>.py … — the table shows the unified create-ack <verb> surface that wraps them so the CLI is the single spine. Until a subcommand is wired in your installed version, call the underlying tool directly; the flags and behavior are identical. Track parity in the roadmap.

Why the CLI, not just slash commands

Slash commands need a Claude Code session; the site is read-only. The CLI needs neither. A CI job, a cron entry, a teammate without Claude Code, or a quick create-ack cost --by feature between turns all reach the same capabilities. Cost stays offline everywhere — it is derived from local transcripts × a versioned pricing map, never a live API (there is no live cost API in hooks; issue #11008). DORA stays exact everywhere — it reads git history.

Per-feature vs per-branch cost attribution

create-ack cost (and aggregate.py) can attribute spend to a feature two ways, and the choice is yours:

• branch_prefix (the default, zero setup). A turn’s feature is inferred from the git branch it ran on: with --branch-prefix feat/, work on feat/order-intake buckets to order-intake. Nothing to maintain — but it is only as granular as your branches, and turns on main (or any non-prefixed branch) fall into the --default-bucket (e.g. unattributed).
• sidecar_map (precise, opt-in via create-ack feature). create-ack feature <contract-id> writes a sidecar entry {from: <now>, to: null, bucket: <contract-id>}; running it again (or with the feature finished) closes the open window. aggregate.py --sidecar-map <file> then attributes each turn by timestamp → contract, independent of branch. This is the only thing a session hook can record honestly — a timestamp→contract mapping, never a cost — so it pairs naturally with the contract gate’s C-NNN IDs.

Pick branch_prefix when your branches already track features; reach for create-ack feature when you want spend pinned to specific contracts regardless of how you branch. The two are mutually exclusive per run — a provided --sidecar-map overrides --branch-prefix.

META commands

/ack-build — META build orchestrator

Orchestrates the kit’s own self-build from bootstrap/ack.bootstrap.yaml. Reads the data-driven build config, validates it against its JSON-Schema, then drives the build phase-by-phase with a multi-agent team per phase (ground-truth -> author -> adversarial QA), surfacing per-phase status and cumulative offline cost, and stopping at every gate for approval.

Runs only inside the ai-core-kit META repo. It refuses unless both META sentinels are present (bootstrap/ack.bootstrap.yaml and docs/BOOTSTRAP.md). It is the inverse of /ack-init.

Arguments (all optional):

Guarantees and invariants:

• Cost is always offline. There is no live token/cost API in hooks (issue #11008). Cumulative spend is computed by telemetry/aggregate.py over ~/.claude/projects/**/*.jsonl times a versioned pricing.json. If the aggregator does not yet exist, it reports cost: unavailable (P6 pending) and proceeds — it never fabricates a number.
• Ground-truth is mandatory per phase. Each authoring phase clones meta.reference_repos for exact extraction and verifies primitives against code.claude.com/docs before writing.
• Layer discipline. /ack-build writes only META artifacts. If a worker would write a concrete project.manifest.yaml, a contract instance, or a contract-gate entry at the META root, that is a layer violation and is refused.
• done: is operator-managed. Authoring a phase does not flip its done flag — that is a human decision after reviewing QA.

See Building the Kit: /ack-build for the full walkthrough.

/ack-init — CHILD project initializer

Initializes a forked CHILD project. Asks the archetype first, runs an archetype-scoped deterministic interview, writes project.manifest.yaml (the single source of truth), renders the archetype template set, and wires opt-in hooks / MCP / telemetry / discovery. It is re-entrant and idempotent via managed-block merge.

This is /ack-init, not /init — the built-in init skill owns /init. Run it in a forked CHILD repo, never in the ai-core-kit META repo. It refuses (fail-closed, no override flag) if either META sentinel is present: a templates/archetypes/ directory or a docs/BOOTSTRAP.md file.

Arguments (all optional):

Step sequence:

1. META-repo guard — fail-closed if running inside ai-core-kit itself.
2. Detect mode & re-entrancy — interactive vs QA; probe whether a manifest already exists (re-run -> merge territory).
3. Freeze the contract, ask archetype first — cross-check that every interview question’s writes_to resolves to a real schema property (invariant I1); archetype is the branch axis (invariant I3).
4. Run the interview, write the manifest — the interview is the only writer; managed: is regenerated wholesale, user: is seeded once and preserved; validate against the schema before any irreversible write (fail-closed, invariant I6); compute manifest_hash last.
5. Render via the render engine against managed:.
6. Wire integrations per opt-in toggles using delimited managed-block merge (never blind-overwrite).
7. Emit a minimal child CLAUDE.md pointer and update the rendered_files[] ledger.

Archetype menu: backend-api and fullstack render deep (full question subset + template set); monorepo, library-sdk, infra-iac are schema-known and render a minimal core in v1 (a warning is printed when one is selected).

A user-invoked slash command cannot be invoked by name under claude -p. QA / non-interactive mode is reached by inlining the task and piping an answers file on stdin. The same META-repo guard, schema validation, and idempotent merge apply unchanged.

The producer/consumer model behind the manifest is covered in Manifest & Interview; the getting-started walkthrough is in Quickstart.

CHILD commands (rendered into a fork)

These ship under templates/commands/ and are rendered into a child project by /ack-init. They are the project team’s everyday delivery commands.

RPI: Research -> Plan -> Implement

The kit’s default delivery loop for non-trivial work. Each step has an approval gate (Research -> Plan -> Implement).

The RPI commands were re-authored for ai-core-kit from shanraisshan/claude-code-best-practice (MIT). See the License Ledger.

Product planning

/prd and /rice are original to ai-core-kit.

User-invocable skills

These are skills, not slash commands — the model invokes them when their description trigger matches, and a human can invoke them by name. The four that ship in the kit’s own .claude/skills/ (META build-tooling) are the most likely to be run directly:

CHILD payload skills (coding-standards, production-audit, language packs, and so on) are loaded by agents during delivery rather than invoked as commands. The full catalog with provenance and wiring triggers is in the Skills Catalog.

Command frontmatter

Every command file is markdown with YAML frontmatter. Only description is required; the linter warns on unrecognized keys and errors on the SKILL-forbidden keys. See Contributing for the full frontmatter conventions and the linter.

---
description: One-line, third-person summary of what the command does.   # REQUIRED
argument-hint: "[--flag] [<arg>]"                                       # OPTIONAL
allowed-tools: Read, Write, Bash(git status:*)                          # OPTIONAL
disable-model-invocation: true                                          # OPTIONAL (human-only)
---