Commands 178 total

Comprehensive accessibility audit — automated axe scan, keyboard navigation check, color contrast review, ARIA audit, and prioritized CRITICAL/HIGH/MEDIUM issue backlog

Add production observability to a service — structured logging, metrics endpoint, health checks, and Sentry error tracking. Detects project type and adds the right libraries and middleware.

Audit a clarc agent file for quality across 8 dimensions — instruction clarity, model appropriateness, tool coverage, trigger precision, exit criteria, examples, overlap detection, and safety guardrails. Produces a scored JSON report. Use /agent-audit --all to audit all agents at once.

Guided workshop for designing a multi-agent system — task decomposition, agent roles, orchestration pattern, pseudocode, and failure handling strategy

Review high-confidence instincts and promote them to agent-specific overlay files (~/.clarc/agent-instincts/). Closes the continuous-learning-v2 feedback loop by making agents smarter over time.

Show the learned instinct overlay for a specific agent, or list all overlays with instinct counts.

Show agent usage statistics — top agents, heatmap, outcome ratio

Analyze raw user feedback (support tickets, NPS comments, app store reviews, survey responses) to identify top pain points, cluster themes, and generate idea seeds. Delegates to the feedback-analyst agent.

Android code review — Compose best practices, Hilt scoping, Room migrations, ViewModel/UiState patterns, Coroutine Dispatchers. Invokes the android-reviewer agent.

Generate or update arc42 architecture documentation with C4 diagrams for the current project. Reads the codebase and produces docs/architecture/arc42.md with PlantUML diagrams. Supports targeted section updates.

Design system architecture for a new project or feature. Delegates to the architect agent to produce component boundaries, C4 diagrams, ADRs, and scalability decisions.

Full interactive article pipeline — from raw idea to publish-ready draft. Walks through idea → outline → draft → review → polish step by step, pausing for confirmation at each stage.

Write a full article draft from an outline. Applies voice, banned-pattern rules, and section-by-section discipline. Third step of the article writing workflow.

Turn a raw topic or notes into a structured article brief — defines audience, angle, core argument, competitive gap, and voice. First step of the article writing workflow.

Build a section-by-section article outline from a brief or topic. Each section gets a purpose, evidence slot, and transition. Second step of the article writing workflow.

Final polish pass on an article draft — voice check, banned-pattern removal, SEO title/meta/headings, and formatting for the target platform. Fifth and final step before publishing.

Editorial critique for an article draft — structure, opening, voice, evidence, banned patterns, SEO basics. Delegates to the article-editor agent. Fourth step of the article writing workflow.

Install, configure, and deploy Backstage — from npx create-app to production with GitHub integration, TechDocs, and Docker Compose local dev

Bash/shell script review for safety, correctness, shellcheck compliance, and idiomatic style. Invokes the bash-reviewer agent.

From structured ideation frameworks — generate product ideas using JTBD, How Might We, analogy thinking, and constraint reversal. Produces concrete idea seeds without external research. For market-driven discovery (competitor features, Reddit/HN signals, trend analysis), use /discover instead.

Develop a visual brand identity for a product — generates color palette (with WCAG validation), typeface pairings, brand voice, mood board direction, and a starter Brand Guidelines structure.

Break down a feature, epic, or initiative into sprint-ready tasks. Produces user stories, acceptance criteria, story point estimates, and a prioritized task list ready to paste into Jira, Linear, or GitHub Issues.

Incrementally fix build and type errors with minimal, safe changes.

C code review for memory safety, C11/C17 idioms, opaque pointer patterns, and error handling. Invokes the c-reviewer agent.

cfp — write a conference talk proposal (Call For Papers abstract)

Design and run a chaos experiment — from hypothesis to tool-specific commands and experiment protocol

Review data visualizations for chart type appropriateness, WCAG accessibility (color contrast, ARIA), responsive behavior, and performance. Applies data-visualization skill.

Create or verify a workflow checkpoint — create, verify, list, and restore git-backed checkpoints with Memory Bank integration.

Interactive guide to The clarc Way methodology. Identifies your task type, recommends the right pipeline stage, and shows which commands and agents to use — with concrete examples for your current language.

claw — connect to a NanoClaw interactive REPL session. Persistent conversation history, named sessions, and optional skill context loading via the claude CLI.

Review a CLI tool implementation for ergonomics, error handling, exit codes, help text quality, and Unix composability. Applies cli-patterns and cli-ux skills.

Comprehensive code review — delegates to code-reviewer agent which routes to language specialists (typescript, go, python, java, swift, rust, cpp, ruby, elixir).

Audit the clarc command system for UX ergonomics — naming consistency, argument design, feedback loops, step count, agent invocation, overlap detection, missing commands, and built-in conflicts. Produces a tabular overview and issue list. Use /command-audit --all for a full system audit.

Compare clarc against competing AI engineering workflow systems (Cursor, Copilot, Windsurf, Aider, Devin, Continue.dev) — feature matrix, clarc-unique capabilities, and prioritized competitive gaps. Produces a strategic analysis report.

Analyze the current project stack and surface the most relevant clarc skills, agents, and commands for this codebase.

API contract break detection — classifies REST, GraphQL, and event schema changes as BREAKING / NON-BREAKING / ADDITIVE and produces a migration plan. Invokes the contract-reviewer agent.

Set up consumer-driven contract testing with Pact — write consumer pact, configure Pact Broker, set up provider verification, and add can-i-deploy gate to CI

Build C++ code with CMake or Make and run static analysis. Catches compilation errors, warnings, and cppcheck issues.

Comprehensive C++ code review for C++ Core Guidelines, memory safety, RAII, modern C++20/23, concurrency, and performance. Invokes the cpp-reviewer agent.

C# 12 / .NET 8 code review for nullable reference types, async/await, CQRS patterns, and security. Invokes the csharp-reviewer agent.

Set up Cursor IDE integration for clarc — creates .cursor/rules/ files for all installed languages and generates .cursorrules from common rules.

Audit a codebase's dark mode implementation — checks color strategy (not just CSS invert), elevation system, token structure, contrast ratios on dark surfaces, and common mistakes. Outputs a prioritized finding list with fixes.

Data Mesh architecture review — domain boundaries, data contracts, quality checks (Great Expectations/Soda), catalog registration, SLO definitions, PII governance, and cross-domain lineage.

PostgreSQL schema, query, and security review — indexes, RLS, schema design, anti-patterns. Invokes the database-reviewer agent.

Systematic technical debt inventory — complexity analysis, hotspot identification (Churn×Complexity), dependency age, test coverage gaps, and prioritized debt backlog

Full dependency audit — vulnerability scanning, license compliance, supply chain risk, and prioritized remediation report

Dependency audit and upgrade workflow — check for outdated packages, security vulnerabilities, and safely upgrade dependencies with verification. Supports npm, pnpm, yarn, bun, pip, poetry, go mod, and cargo.

Guide deployment strategy selection and execution for any target environment.

Get structured design critique for a visual design — from a screenshot path, URL description, or code. Invokes the design-critic agent.

Full design system audit — CSS tokens, dark mode, icon system, accessibility, and design-code consistency. Invokes the design-system-reviewer agent.

Design a Developer Experience survey — DX Core 24 questions, SPACE-aligned dimensions, Likert scale, anonymization, and action plan from results

From external market data — discover product opportunities by searching competitor features, user pain points on Reddit/HN, tech trends, and market gaps in a given domain. For structured ideation frameworks (JTBD, HMW, analogy thinking) without external research, use /brainstorm instead.

Review API documentation for completeness, quality, playground, code examples, changelog, navigation, and CI — produces a structured audit report with prioritised fixes.

Documentation strategy and platform design — audience analysis, platform recommendation (Mintlify/Docusaurus/Redoc/Scalar), Divio framework structure, OpenAPI extension config, changelog automation, and CI pipeline. Invokes the docs-architect agent.

Health-check for your clarc installation. Verifies agents, skills, commands, hooks, symlinks, MEMORY.md size, and available updates. Runs scripts/doctor.js.

Measure DORA Four Keys baseline for a team — deployment frequency, lead time, change failure rate, MTTR — with benchmark comparison and improvement priorities

Generate and run end-to-end tests with Playwright. Creates test journeys, runs tests, captures screenshots/videos/traces, and uploads artifacts.

Review event-driven code for idempotency, ordering guarantees, schema evolution compatibility, DLQ handling, and observability — produces prioritized findings

Review Edge Function code for runtime compatibility, bundle size, caching opportunities, and security — supports Cloudflare Workers, Vercel Edge, and Deno Deploy

Comprehensive Elixir/Phoenix code review for OTP patterns, Ecto queries, security (Sobelow), and idiomatic functional Elixir. Invokes the elixir-reviewer agent.

Monthly engineering health review — DORA trends, leading indicators, tech debt movement, DevEx pulse, and action items for next month

Evaluate a product idea before committing to build it. Delegates to the product-evaluator agent to assess problem clarity, user fit, feasibility, alternatives, and opportunity cost. Produces a structured Go/No-Go recommendation.

Facilitate an EventStorming workshop — Big Picture discovery, Process Level modeling, Design Level with aggregates and bounded contexts, producing a Domain Event Glossar and aggregate map

Cluster accumulated instincts into skills, commands, or agents — runs conflict detection first, groups instincts by trigger domain, scores clusters by confidence, and writes evolved files with --generate.

Design a statistically valid A/B test. Walk through hypothesis, metric selection, sample size calculation, assignment strategy, and analysis plan. Outputs a ready-to-use experiment spec.

Design solutions for a validated product idea — generates 2-4 concrete approaches with trade-off analysis and an Architecture Decision Record. Use after /evaluate returns Go. Delegates to the solution-designer agent.

Search all available skills by keyword and return the top matches with their descriptions. Use when unsure which skill covers a topic.

Audit cloud costs for a project — tagging coverage, rightsizing opportunities, savings plan potential, anomalies, and Infracost integration gaps

Flutter/Dart code review for widget architecture, performance, null safety, and accessibility. Invokes the flutter-reviewer agent.

Micro-Frontend architecture review — team boundaries, Module Federation config, shared dependencies, routing, state sharing, fallbacks, design system consistency, and CI/CD independence.

Review GitOps configuration for declarative correctness, sync strategy, secrets management, and progressive delivery readiness

Fix Go build errors, go vet warnings, and linter issues incrementally. Invokes the go-build-resolver agent for minimal, surgical fixes.

Comprehensive Go code review for idiomatic patterns, concurrency safety, error handling, and security. Invokes the go-reviewer agent.

Enforce TDD workflow for Go. Write table-driven tests first, then implement. Verify 80%+ coverage with go test -cover.

Create a Golden Path Backstage Scaffolder template for a standard service type — generates template.yaml, skeleton files, CI/CD, and catalog-info.yaml

Get a step-by-step workflow plan for a specific task using clarc components. Usage: /guide <task> — e.g. /guide add auth, /guide write E2E tests, /guide deploy to k8s

Audit the clarc hook system for coverage, reliability, and performance — event coverage, false positive risk, performance impact, error handling, dead references, dead hooks, missing critical hooks, and interaction conflicts. Analyzes hooks/hooks.json and scripts/hooks/*.js.

Configure clarc workflow hooks — enable/disable nudges, set cooldowns, view hook status. Creates/updates .clarc/hooks-config.json.

Show hook invocation statistics, performance metrics, and error rates from the hook log.

Audit a codebase for i18n completeness — find hardcoded user-visible strings, missing translation keys, RTL-incompatible CSS, and locale-sensitive formatting without Intl API.

IaC code review for Pulumi and AWS CDK — abstractions, security hardening, tagging, unit tests, multi-environment separation, drift detection, and compliance policy coverage.

Generate an icon system specification — library selection recommendation, token definitions (size/stroke/color), naming convention, accessibility rules, and a React icon component template. Use when starting a new project or auditing existing icons.

Capture and structure a raw product idea. Asks clarifying questions to fill gaps, then writes a structured idea document. First step in the product lifecycle before evaluation and solution design.

Design an Internal Developer Platform (IDP) for an engineering organization — guided discovery, component prioritization, make-vs-buy decision, and 90-day roadmap

Open and manage a production incident. Creates a structured incident document, guides root cause analysis, generates status page updates and Slack messages, and sets up a post-mortem after resolution.

Export instincts from project/global scope to a file

Import instincts from file or URL into project/global scope

Record an outcome (good/bad/neutral) for a specific instinct to adjust its confidence score

List registered projects and their instinct/observation counts — part of the continuous-learning-v2 system.

Promote project-scoped instincts to global scope

Ranked list of instincts by confidence with trend indicators (↑↓→) and decay candidates

Show learned instincts (project + global) with confidence

Add product analytics event tracking to an existing feature or file. Designs event taxonomy, chooses the right analytics call (track/identify/group), and instruments the code without breaking existing logic.

Comprehensive Java code review for idiomatic patterns, Spring Boot 4, hexagonal architecture, DDD, JPA, and security. Invokes the java-reviewer agent.

Kotlin code review for coroutines, null safety, sealed classes, and architecture patterns. Invokes the kotlin-reviewer agent.

Extract reusable patterns from the session, self-evaluate quality before saving, and determine the right save location (Global vs Project).

Audit the effectiveness of the clarc continuous-learning-v2 loop — instinct quality, conflict detector accuracy, evolution velocity, and learning coverage gaps. Produces a structured health report for the learning system.

Manage eval-driven development workflow — define, run, check results, and list evals for a feature. Supports eval-first development where behaviour is specified before implementation.

Browse and install curated MCP servers with one-line setup. Shows a table of available servers, what each does, and the exact config to add to ~/.claude.json.

Database migration workflow — plan, review, apply, and verify schema changes safely. Supports Drizzle, Prisma, Flyway, Alembic, golang-migrate. Guards against data-loss migrations reaching production.

MLOps audit — experiment tracking, model registry, serving SLOs, drift detection, retraining pipelines, A/B testing readiness. Invokes the mlops-architect agent.

Mobile release workflow — version bump, test, code signing, beta distribution (TestFlight / Firebase), and staged production rollout for iOS and Android.

Create a step-by-step modernization plan for a specific component — interface extraction, Branch-by-Abstraction, Strangler Fig, feature toggle cutover, and rollback strategy

[Requires codeagent-wrapper] Backend-focused multi-model workflow (Research→Ideation→Plan→Execute→Optimize→Review), Codex-led. Requires codeagent-wrapper + ace-tool MCP.

[Requires codeagent-wrapper] Multi-model collaborative execution — prototype from plan → Claude refactors and implements → multi-model audit and delivery.

[Requires codeagent-wrapper] Frontend-focused multi-model workflow (Research→Ideation→Plan→Execute→Optimize→Review), Gemini-led. Requires codeagent-wrapper + ace-tool MCP.

[Requires codeagent-wrapper] Multi-model collaborative planning — Context retrieval + Codex/Gemini dual-model analysis → step-by-step implementation plan.

[Requires codeagent-wrapper] Multi-model collaborative development workflow with intelligent routing — Frontend→Gemini, Backend→Codex. Full Research→Ideation→Plan→Execute→Optimize→Review cycle.

Generate onboarding documentation for an existing codebase — README, CONTRIBUTING.md, arc42 architecture docs, architecture tour, setup script validation, domain glossary, and GitHub onboarding issue template.

Orchestrate multiple agents for complex tasks — auto-selects coordination pattern (fan-out, split-role, explorer+validator, worktree, pipeline)

Design a multi-agent orchestration system for a complex task. Delegates to the orchestrator-designer agent to decompose the goal into agent roles, select a coordination pattern, and produce an implementation plan with pseudocode.

Set up open source project infrastructure for a GitHub repository — issue/PR templates, CODEOWNERS, CONTRIBUTING.md, label taxonomy, and branch protection configuration.

Set up an autonomous overnight development pipeline. Analyzes the feature, selects the right pipeline pattern (Sequential, Continuous Claude, Ralphinho, or Infinite Loop), then generates all required files. WAITS for user confirmation before creating files.

PHP 8.4+ code review for strict types, security, Laravel/Symfony patterns, and PHPStan compliance. Invokes the php-reviewer agent.

Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.

Write a Product Requirements Document from a validated idea and its Architecture Decision Record. Produces a spec directly compatible with /overnight and /plan. Final step before implementation.

Privacy Engineering audit — PII scan (Presidio), retention-policy check, data minimization, test-fixture scan, RTBF flow validation, consent-basis review, third-party data sharing.

Guided profiling workflow — detects language, recommends the right profiler, starts a session, and interprets the top hotspots with concrete next steps

Initialize a new project from a workflow starter-pack (rest-api, react-spa, python-pipeline, go-service, flutter-app, spring-boot)

Promote a project-local skill from .clarc/skills/<name>/ to global clarc (~/.clarc/skills/). Optionally opens a PR to upstream clarc.

Audit the prompt engineering quality of all clarc agents and commands. Delegates to the prompt-quality-scorer agent to score and rank each component across 6 dimensions.

Review a system prompt or prompt template for quality, safety, and effectiveness. Invokes the prompt-reviewer agent.

Comprehensive Python code review for PEP 8 compliance, type hints, security, and Pythonic idioms. Invokes the python-reviewer agent.

Run Python tests with coverage using pytest. Enforces 80%+ coverage and fails fast on the first error.

Interactive onboarding for new clarc users. Guides through the first 5 minutes: explains the most important workflows, recommends which commands to start with, and gives a practical tour with concrete examples.

R code review for tidyverse idioms, tidy evaluation, Shiny security, and renv lockfile management. Invokes the r-reviewer agent.

Safely identify and remove dead code with test verification at every step.

Cut a new release. Reads git history since the last tag, determines the version bump (semver), updates CHANGELOG, bumps version files, creates a git tag, and generates GitHub Release notes.

Inject or refresh the compact codebase map — hot files, key symbols, and directory structure. Improves Claude's codebase orientation without burning context on full file reads.

Resilience audit — failure mode analysis, missing circuit breakers, unprotected external calls, retry anti-patterns, and distributed system resilience gaps. Invokes the resilience-reviewer agent.

Comprehensive Ruby/Rails code review for idiomatic Ruby, Rails best practices, security (Brakeman), performance, and N+1 detection. Invokes the ruby-reviewer agent.

Look up the rule constraint AND the linked skill for a given topic — makes the two-layer rules/skills system navigable

Preview what has changed in clarc rules since your installed version — without applying changes. Dry-run mode for /update-rules.

Build Rust code and run Clippy lints. Catches compilation errors and lint warnings with minimal, surgical fixes.

Comprehensive Rust code review for ownership, borrowing, async correctness (Tokio), error handling (thiserror/anyhow), and performance. Invokes the rust-reviewer agent.

Run Rust tests with coverage. Enforces TDD workflow with table-driven tests and 80%+ coverage via cargo test and cargo tarpaulin.

Generate SBOM (Software Bill of Materials), run vulnerability scan, and set up attestation with cosign — full workflow from generation to CI integration

Scala code review for functional idioms, Cats Effect/ZIO patterns, ADT correctness, and null safety. Invokes the scala-reviewer agent.

Design an SDK architecture for an API. Delegates to the sdk-architect agent to recommend a generation strategy, error hierarchy, authentication patterns, backward compatibility policy, CI release process, and documentation site.

SDK Design Review — ergonomics, consistency, backward compatibility, error hierarchy, documentation coverage, multi-language generation, and VCR/contract test readiness. Invokes the sdk-architect agent.

Run comprehensive DevSecOps security scan — SAST (Semgrep), secrets (Gitleaks), dependencies (Trivy), container images, DAST (ZAP), and Policy-as-Code (OPA/Kyverno). Produces prioritized CRITICAL/HIGH report with fix plan.

Show estimated token usage and cost for recent clarc sessions

Manage Claude Code session history — list, load, alias, and edit sessions stored in ~/.claude/sessions/.

Generate GitHub Actions CI/CD workflows for the current project. Detects language, test runner, and deployment target, then creates build/test/lint, Docker, and deploy workflows.

Set up a complete local development environment for a new project. Generates devcontainer.json, .env.example, docker-compose.dev.yml for services, and a Getting Started section in the README.

Configure your preferred package manager (npm/pnpm/yarn/bun)

Analyze local git history to extract coding patterns and generate SKILL.md files. Local version of the Skill Creator GitHub App.

Analyze a clarc skill for prompt-engineering quality — actionability ratio, trigger precision, example completeness, internal consistency, length calibration, cross-reference validity, and freshness. Use /skill-depth --all to analyze all skills.

Show which agents depend on a skill and what would be affected by changing it

List all project-local skills in .clarc/skills/. Shows skill names, descriptions, and which ones override global clarc skills.

Generate a slide deck structure from a topic, document, or notes. Produces a Reveal.js HTML presentation or Markdown slide structure (Marp-compatible). Invokes the presentation-designer agent.

Define SLIs, SLOs, and error budgets for a service. Produces a complete SLO document with burn rate alert rules and deployment gating policy.

Audit an existing Storybook setup — story coverage, CSF version, accessibility, interaction tests, documentation quality, Chromatic integration, and prioritized improvement plan

Supply chain security audit — CI/CD pipeline security, GitHub Actions pinning, unsigned artifacts, SLSA compliance, and SBOM generation. Invokes the supply-chain-auditor agent.

Build Swift/Xcode projects and run static analysis. Catches compilation errors, warnings, and analyzer issues.

Comprehensive Swift code review for concurrency safety, SwiftUI best practices, protocol-based architecture, memory management, and security. Invokes the swift-reviewer agent.

Orchestrate a structured self-review of the entire clarc system. Three modes: quick (wiring + naming, ~5 min), components (all component analyzers, ~30 min), full (everything + competitive analysis, ~90 min). Produces a report in docs/system-review/.

Create a talk outline with time allocation, key points per section, speaker notes skeleton, and Q&A preparation questions.

Talk and presentation feedback — evaluates structure, timing plausibility, audience fit, narrative flow, clarity, and opening/closing strength. Invokes the talk-coach agent.

Enforce test-driven development workflow. Scaffold interfaces, generate tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.

Sync team clarc installation — pull latest clarc + private rules/skills, re-run team install

Analyze test coverage, identify gaps, and generate missing tests to reach 80%+ coverage.

Run an issue triage session — list open issues, suggest labels, identify stale issues, and generate standard close responses for out-of-scope or duplicate issues.

Type-check and lint TypeScript/JavaScript code. Runs tsc --noEmit and ESLint/Biome to catch type errors and style violations without building.

Comprehensive TypeScript code review for hexagonal architecture, DDD patterns, type safety, security, and performance. Invokes the typescript-reviewer agent.

Undo last clarc auto-checkpoint (restores files to state before last Edit/Write)

Analyze the codebase structure and generate token-lean architecture documentation in docs/CODEMAPS/.

Sync documentation with the codebase, generating from source-of-truth files.

Apply latest clarc rule updates from upstream. Skips user-modified files. Use --dry-run to preview, --force to overwrite user modifications.

Run comprehensive build, type, lint, test, and git verification on the codebase.

Set up visual regression testing for a project — detects project type, recommends tool (Chromatic/Playwright/Percy), installs, creates baselines, and configures CI

Build, optimize, and validate a WebAssembly module from Rust — wasm-pack build, wasm-opt size optimization, and JS integration check

Review WebAssembly/Rust code for correctness, performance pitfalls, unsafe memory management, and JS interop quality

Web performance audit — run Lighthouse, interpret Core Web Vitals, analyze bundle, identify quick wins, and set up regression prevention

WebRTC architecture review — P2P vs SFU vs MCU decision, TURN configuration, signaling robustness, simulcast, access token security, recording consent, and error handling.

Create a wireframe or user flow for a feature — generates ASCII/text wireframes, user flow diagrams, IA structure, and annotated specs. Use before writing UI code to validate structure and communicate intent.

Check whether clarc supports 6 critical end-to-end developer journeys — Idea-to-Production, Bug-to-Fix, New Developer Onboarding, Incident Response, Architecture Decision, and LLM App Development. Identifies which journey steps lack Command, Agent, or Skill coverage.

Zero-Trust security review for a service — mTLS enforcement, SPIFFE identity, NetworkPolicies, Authorization Policies, east-west traffic, and secret handling.