clarc

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.

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.

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.

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.

Reviews a single 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 via /agent-audit or called by agent-system-reviewer during full system review.

Orchestrates a full clarc system review by synthesizing results from all component analyzers (agent-quality-reviewer, skill-depth-analyzer, command-auditor, hook-auditor), cross-component validators, and systemic effectiveness tools into a unified Priority Matrix with P0/P1/P2 classification. Uses Opus for deep architectural reasoning. Called by /system-review full.

Expert Android code reviewer specializing in Jetpack Compose best practices, Hilt DI scoping, Room migrations, ViewModel/UiState patterns, and Coroutine Dispatcher correctness. Use for all Kotlin/Android code changes. MUST BE USED for Android/Compose projects.

System design and architecture specialist. Use PROACTIVELY when users need HOW to structure the system — component boundaries, ADRs, C4/arc42 diagrams, scalability decisions. For task lists and implementation timelines (WHAT to build), use the planner agent instead.

Editorial critique for blog posts, essays, guides, and long-form articles — evaluates structure, opening strength, voice consistency, evidence quality, banned patterns, and SEO basics. Use after writing a first draft to get structured, actionable improvement feedback before publishing.

Reviews Bash/shell scripts for correctness, safety, idiomatic style, and portability. Checks set -euo pipefail, quoting, shellcheck issues, security (no eval, mktemp, path quoting), BATS test coverage, and formatting via shfmt. Invoked by code-reviewer for .sh/.bash/.zsh files.

Build error resolution specialist for any language — TypeScript, Go, Python, Java, and more. Use PROACTIVELY when builds fail, type errors occur, or compilation breaks. Fixes errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.

Expert C code reviewer specializing in C11/C17 idioms, memory safety (malloc/free discipline, no double-free), opaque pointer encapsulation, error code patterns, goto cleanup, safe string functions, and AddressSanitizer/Valgrind integration. Use for all C code changes. MUST BE USED for C projects.

Code review orchestrator. Detects the language of changed files and routes to the appropriate specialist reviewer (typescript-reviewer, go-reviewer, python-reviewer, java-reviewer, swift-reviewer, ruby-reviewer, elixir-reviewer, rust-reviewer, cpp-reviewer). Falls back to universal security and quality checks when no specialist exists. Use immediately after writing or modifying code.

Audits clarc commands for UX ergonomics across 8 dimensions — naming consistency, argument design, feedback loops, step count, agent invocation, overlap detection, missing commands, and built-in conflicts. Produces a tabellarische overview and issue list. Use via /command-audit or called by agent-system-reviewer.

Systematically researches competitors to map features, pricing, positioning, recent releases, and market gaps. Produces a feature matrix and opportunity list that feeds directly into idea discovery. Use with /discover or when asked to analyze the competitive landscape. For clarc vs. AI coding tools specifically → use workflow-os-competitor-analyst.

Reviews API changes for contract breaks. Given git diff of API definitions and existing consumer pacts, classifies each change as BREAKING / NON-BREAKING / ADDITIVE and produces a migration plan. Use when modifying any API (REST, event schema, GraphQL).

Expert C++ code reviewer specializing in C++ Core Guidelines, modern C++20/23, memory safety, RAII, and performance. Use for all C++ code changes. MUST BE USED for C++ projects.

Expert C# code reviewer specializing in C# 12/.NET 8 idioms, nullable reference types, async/await correctness, records, pattern matching, CQRS with MediatR, Entity Framework Core, SQL injection, mass assignment, secret management, Roslyn analyzers. Use for all C# code changes. MUST BE USED for C#/.NET projects.

Data Mesh architecture specialist. Analyzes business domains to identify data products, assigns ownership, recommends technology stack (Lakehouse, Catalog, Contract Testing), and creates a migration plan from centralized data warehouse to Data Mesh. Use when designing a new data platform or migrating an existing one.

PostgreSQL database specialist for query optimization, schema design, security, and performance. Use PROACTIVELY when writing SQL, creating migrations, designing schemas, or troubleshooting database performance. Incorporates Supabase best practices.

Reviews visual designs and gives structured critique covering composition, visual hierarchy, typography, color, brand coherence, and accessibility. Works from screenshots, wireframes, written descriptions, or code (HTML/CSS). Does not generate designs — evaluates existing ones.

Comprehensive design system audit — reviews CSS/token structure, dark mode implementation, icon system, accessibility compliance, design-code consistency, and component completeness. Routes findings across visual design dimensions and produces a prioritized remediation plan. Use when auditing a frontend codebase for design quality, before a major UI release, or when design system debt has accumulated.

Infrastructure and CI/CD security reviewer — scans Terraform, Dockerfiles, Kubernetes manifests, GitHub Actions workflows, and dependency lockfiles for misconfigurations, supply chain risks, and pipeline vulnerabilities. For application-code OWASP/injection/auth issues, use security-reviewer instead.

Documentation and codemap specialist. Use PROACTIVELY after structural changes, before releases, or when codemaps are stale. Runs /update-codemaps and /update-docs, generates docs/CODEMAPS/*, updates READMEs and guides.

Expert documentation strategy agent. Analyses audience, recommends platform (Mintlify/Docusaurus/Redoc/Scalar), structures docs via Divio framework, configures OpenAPI extensions, designs changelog automation, and outputs a full CI pipeline. Invoke when planning or overhauling API documentation.

End-to-end testing specialist using Vercel Agent Browser (preferred) with Playwright fallback. Use PROACTIVELY for generating, maintaining, and running E2E tests. Manages test journeys, quarantines flaky tests, uploads artifacts (screenshots, videos, traces), and ensures critical user flows work.

Expert Elixir/Phoenix code reviewer specializing in OTP patterns, Ecto queries, security (Sobelow), and idiomatic functional Elixir. Use for all Elixir code changes.

Analyzes qualitative user feedback (support tickets, NPS comments, app store reviews, survey responses) to identify pain points, cluster themes, and generate structured idea seeds. Use when given raw user feedback data to extract product insights.

Analyzes cloud infrastructure configuration and costs to provide prioritized optimization recommendations with ROI estimates. Use when reviewing Terraform/Kubernetes configs for cost impact or preparing a FinOps audit report.

Reviews Flutter/Dart code for idiomatic patterns, performance (missing const, unnecessary rebuilds, RepaintBoundary), accessibility, null safety misuse, async errors, and platform-specific issues. Use for all Flutter/Dart code changes.

Micro-Frontend architecture specialist. Designs MFE system architecture — team topology, integration strategy selection, routing, shared state minimization, design system integration, and migration plan from monolith. Use when building multi-team frontend systems or evaluating MFE feasibility.

Designs GitOps setup for applications and organizations — repository structure, tool selection (ArgoCD vs Flux), environment strategy, secrets management, progressive delivery plan, and multi-cluster topology. Use when setting up or overhauling Kubernetes deployment workflows.

Go build error resolver — fixes go build, go vet, staticcheck, and golangci-lint failures with minimal surgical changes. Use when Go compilation fails. For non-Go build errors use build-error-resolver.

Expert Go code reviewer specializing in idiomatic Go, concurrency patterns, error handling, and performance. Use for all Go code changes. MUST BE USED for Go projects.

Audits the clarc hook system across 8 dimensions — event coverage, false positive risk, performance impact, error handling, dead references, dead hooks, missing critical hooks, and interaction conflicts. Analyzes hooks/hooks.json and all scripts/hooks/*.js files. Use via /hook-audit or called by agent-system-reviewer.

Expert Java code reviewer specializing in idiomatic Java 25+, Spring Boot patterns, security, JPA, and performance. Use for all Java code changes. MUST BE USED for Java/Spring Boot projects.

Reviews Kotlin code for correctness, idiomatic style, null safety, coroutine usage, architecture patterns, and security. Covers val/var discipline, sealed classes, coEvery/coVerify, CancellationException handling, SQL injection, and ktlint compliance. Invoked by code-reviewer for .kt/.kts files.

Designs MLOps infrastructure for ML projects — serving stack selection, monitoring setup, retraining strategy, A/B testing plan, and cost estimation. Use when deploying or operationalizing ML models.

Analyzes legacy codebases and creates prioritized modernization roadmaps. Uses Churn×Complexity hotspot analysis, identifies legacy indicators (God Classes, missing tests, outdated dependencies), recommends Strangler Fig vs. Branch-by-Abstraction vs. incremental rewrite, and creates phased migration plans with risk assessment.

Designs multi-agent systems for complex tasks. Given a goal, produces: task decomposition, agent role definitions, orchestration pattern selection, failure mode analysis, and implementation plan with pseudocode. Use for architecting new multi-agent workflows.

Multi-agent orchestration specialist. Decomposes complex tasks into subtasks, selects the optimal coordination pattern (fan-out, split-role, explorer+validator, worktree isolation, sequential pipeline), and synthesizes results. Use via /orchestrate or for any task requiring 3+ independent agents.

Analyzes profiling output and code for performance hotspots. Interprets pprof output, flamegraphs, Lighthouse reports, and identifies N+1 queries, unnecessary allocations, blocking I/O, and missing indexes. Provides concrete, prioritized optimization recommendations with expected impact estimates.

Expert PHP code reviewer specializing in PHP 8.4+ idioms, PSR-12 style, strict types, readonly classes, enums, value objects, repository pattern, Laravel/Symfony patterns, PHPStan level 9, SQL injection/XSS/CSRF prevention. Use for all PHP code changes. MUST BE USED for PHP projects.

Task decomposition and implementation planning specialist. Use PROACTIVELY when users need WHAT tasks to execute — produces PRDs, task breakdowns, timelines, and dependency maps. For HOW to structure the system (component design, ADRs, C4 diagrams), use the architect agent instead.

Designs Internal Developer Platforms (IDPs) for engineering organizations — scope definition, IDP component prioritization, make-vs-buy decision (Backstage vs SaaS), adoption strategy, and 90-day implementation roadmap. Use when a team wants to improve developer experience at scale.

Designs and structures presentations — creates slide decks, writes speaker notes, checks narrative flow, evaluates slide density, and ensures opening and closing land. Use for any slide deck creation or structural review.

Evaluates product ideas critically before any implementation begins. Assesses problem clarity, user fit, feasibility, competitive alternatives, and opportunity cost. Produces a structured Go/No-Go recommendation. Use when a user wants to validate whether an idea is worth building.

Evaluates the prompt-engineering quality of clarc agent and command instructions across 6 dimensions — specificity, completeness, output definition, ambiguity, safety coverage, and example density. Produces a ranked report of all agents/commands with scores and improvement suggestions for the lowest-scoring items.

Expert prompt engineer reviewing system prompts and prompt templates for clarity, injection vulnerabilities, ambiguity, token efficiency, and output consistency. Use when writing or auditing any LLM prompt.

Expert Python code reviewer specializing in PEP 8 compliance, Pythonic idioms, type hints, security, and performance. Use for all Python code changes. MUST BE USED for Python projects.

Expert R code reviewer specializing in tidyverse idioms, native pipe |>, purrr functional patterns, tidy evaluation, R6 classes, testthat, covr, SQL injection via DBI, Shiny input validation, renv lockfile management. Use for all R code changes. MUST BE USED for R projects.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Reviews code and architecture for failure modes, missing circuit breakers, unprotected external calls, retry anti-patterns, and resilience gaps. Use when adding external dependencies, designing distributed system components, or before chaos experiments.

Expert Ruby/Rails code reviewer specializing in idiomatic Ruby, Rails best practices, security (Brakeman), performance, and N+1 detection. Use for all Ruby code changes.

Expert Rust code reviewer specializing in ownership, borrowing, async with Tokio, error handling (thiserror/anyhow), and performance. Use for all Rust code changes. MUST BE USED for Rust projects.

Expert Scala code reviewer specializing in functional programming idioms, ADT correctness, effect system usage (Cats Effect/ZIO), null safety, and Scala 3 migration patterns. Use for all .scala and .sc file changes. MUST BE USED for Scala projects.

Designs SDK architecture for APIs — generation strategy (openapi-generator vs. Speakeasy vs. manual), error hierarchy, authentication patterns, backward compatibility policy, CI release process, and documentation site recommendation. Use when building or evolving a developer-facing SDK.

Security vulnerability detection and remediation specialist. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities.

Analyzes a clarc skill file for prompt-engineering quality across 7 dimensions — actionability ratio, trigger precision, example completeness, internal consistency, length calibration, cross-reference validity, and freshness. Produces a scored report. Use via /skill-depth or called by agent-system-reviewer during full system review.

Generates and compares multiple solution approaches for a validated product idea. Produces 2-4 concrete options with trade-off analysis and an Architecture Decision Record (ADR) recommending one approach. Use after product-evaluator has given a Go or Modify recommendation.

Lightweight Haiku-tier agent for summaries, boilerplate generation, routing decisions, and simple text transformations. Use instead of Sonnet for high-frequency, low-complexity tasks to reduce cost by 10–15×. NOT for code review, architecture decisions, or security analysis.

Analyzes repository structure for supply chain security risks — unpinned dependencies, missing SBOM, unsigned artifacts, suspicious install scripts, unverified GitHub Actions. Use before releases and when auditing security posture.

Expert Swift code reviewer specializing in Swift concurrency, protocol-based architecture, DDD patterns, SwiftUI best practices, and performance. Use for all Swift code changes. MUST BE USED for Swift/SwiftUI projects.

Reviews talk outlines, scripts, and slide decks — evaluates structure, timing plausibility, audience fit, clarity, narrative flow, and opening/closing strength. Use after drafting a presentation to get structured improvement feedback.

Test-Driven Development specialist enforcing write-tests-first methodology. Use PROACTIVELY when writing new features, fixing bugs, or refactoring code. Ensures 80%+ test coverage (configurable — check project's `.nycrc`, `vitest.config.ts`, or `pytest.ini` for the project's actual threshold).

Expert TypeScript/JavaScript code reviewer for frontend, backend, and full-stack — React, Next.js, Node.js, hexagonal architecture, DDD, type safety, security, and performance. Use for any .ts, .tsx, or .js code changes.

Researches and compares clarc against competing AI engineering workflow systems — Cursor, GitHub Copilot, Windsurf, Aider, Devin, and Continue.dev. Produces a feature matrix, identifies clarc-unique capabilities, and prioritizes competitive gaps. Use via /competitive-review or called by agent-system-reviewer.

Advanced accessibility patterns — screen reader testing (NVDA/VoiceOver/TalkBack checklists), automated testing (axe-core+Playwright, jest-axe, @axe-core/react dev warnings), and accessible component implementations (modal, table, form, data visualization).

Web Accessibility (WCAG 2.2): key success criteria (contrast, keyboard, focus, ARIA), ARIA patterns (aria-label/labelledby/describedby, roles, live regions, state attributes), keyboard navigation (focus trap, skip links, roving tabindex), screen reader testing (NVDA/VoiceOver/TalkBack), automated testing (axe-core, axe-playwright, jest-axe), and accessible component patterns (modals, tables, forms, data visualizations).

Architecture Decision Records (ADRs): when to write one, the standard template, how to document rejected alternatives with real reasoning, how to supersede outdated ADRs, and how to maintain a living ADR index. The reference for technical documentation that actually gets read.

Decision framework for resolving conflicts between clarc agents — priority hierarchy, conflict classes, escalation protocol, and real-world examples

How the agent evolution system works — capturing instincts, promoting them to agent overlays, approval workflow, rollback, and the full continuous-learning flywheel pipeline

Agent reliability anti-patterns — retrying non-retryable errors, fixed sleep vs exponential backoff with jitter, single timeout for all call stack levels, aggressive circuit breaker thresholds, using Opus for every call regardless of complexity.

Agent Reliability Patterns: retry with exponential backoff and jitter, timeout hierarchies (tool < agent < workflow), fallback chains, circuit breaker for agent calls, cost control (token budgets, model tiering), rate limiting, and observability (what to log per agent call).

Data & product analytics workflow: event taxonomy design, instrumentation (Segment, PostHog, Mixpanel, Amplitude, GA4), analytics pipelines, funnel and retention analysis, and dashboard design. Complements observability (infrastructure metrics) with product/user behavior tracking.

Advanced Android/Jetpack Compose patterns — Compose performance optimization (@Stable/@Immutable, derivedStateOf, key in LazyColumn, lambda capture hoisting), Coroutines with injectable dispatchers, and reference rules/skills.

Android/Jetpack Compose patterns — state hoisting, UDF with ViewModel/UiState, side effects (LaunchedEffect/rememberUpdatedState), Material Design 3 components, type-safe Navigation, Hilt DI, Room database, and Compose performance (derivedStateOf, key).

Android testing — Compose UI tests with semantic selectors, Hilt dependency injection in tests, Room in-memory database tests, Espresso, MockK, Coroutine test dispatcher, and screenshot testing.

Advanced API contract patterns — AsyncAPI 3.0 for event-driven systems and Consumer-Driven Contract Testing with Pact. Use after the core Contract-First workflow in api-contract.

Contract-First API design — write OpenAPI 3.1 or AsyncAPI 3.0 specs before implementation, generate or validate code against them, detect breaking changes in CI, and apply Consumer-Driven Contract Testing with Pact.

Advanced API design — per-language implementation patterns (TypeScript/Next.js, Go/net-http), anti-patterns (200 for everything, 500 for validation, contract breaking), and full pre-ship checklist.

REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

API documentation best practices — OpenAPI spec (paths, components, examples, x-webhooks), docs-as-code CI/CD, platform selection (Mintlify/Redoc/Scalar), interactive playgrounds, changelog automation with conventional commits.

Cursor and offset pagination, filtering operators, multi-field sorting, full-text search, and sparse fieldsets for REST APIs.

arc42 architecture documentation template (all 12 sections) combined with C4 diagrams (Context, Container, Component, Deployment) in PlantUML. The standard for architecture documentation in this setup. Maps each section to the Claude skills that help fill it.

Turn a raw idea into a structured article brief — defines audience, angle, core argument, competitive gap, and voice. Use before writing an outline or draft. The output of this skill is a brief that feeds directly into article-writing.

Write articles, guides, blog posts, tutorials, newsletter issues, and other long-form content in a distinctive voice derived from supplied examples or brand guidance. Use when the user wants polished written content longer than a paragraph, especially when voice consistency, structure, and credibility matter.

Asynchronous processing patterns: job queues (BullMQ, Celery, asynq), scheduled cron jobs, event-driven pub/sub, dead letter queues, retry with exponential backoff, and idempotency. Covers TypeScript, Python, and Go.

Authentication and authorization implementation patterns: JWT, sessions (httpOnly cookies), OAuth2/OIDC, API keys, RBAC, and MFA. Covers TypeScript, Python, Go, and Java with security-hardened code examples.

Autonomous loop patterns for Claude — sequential pipelines, NanoClaw REPL, infinite agentic loops, continuous PR loops, De-Sloppify, and Ralphinho RFC-driven DAG orchestration. Pattern selection matrix and anti-patterns.

Backstage patterns: Software Catalog (catalog-info.yaml, kinds, relations, lifecycle), TechDocs (MkDocs, techdocs-cli), Scaffolder templates (CSF3, steps, fetch:template, publish:github), custom plugins (frontend React, backend Express), GitHub App integration, and Chromatic CI.

Idiomatic Bash scripting patterns: script structure, argument parsing, error handling, logging, temp files, parallel execution, and portability. Use when writing or reviewing shell scripts.

Bash script testing with BATS (Bash Automated Testing System): test structure, assertions, setup/teardown, mocking external commands, CI integration, and coverage strategies.

C programming patterns (C11/C17): opaque pointer encapsulation, error handling via return codes and out-parameters, resource cleanup with goto, memory management discipline (malloc/free pairing, double-free prevention), safe string functions (snprintf, fgets, strncpy), Makefile patterns with auto-dependencies, bit manipulation, and AddressSanitizer/Valgrind integration. Use when writing or reviewing C code.

C testing patterns: Unity framework (TEST_ASSERT_*), CMocka mocking with __wrap_ and linker flag, Valgrind leak checking, AddressSanitizer, CMake CTest integration, test organization, and running tests with sanitizers. Use when writing or reviewing C tests.

Caching strategy patterns: Cache-Aside, Write-Through, Write-Behind, TTL design, cache invalidation, Redis patterns, CDN caching, HTTP cache headers, and cache stampede prevention. Caching is both a performance and correctness problem.

Chaos Engineering for production resilience: steady-state hypothesis design, fault injection tools (Chaos Monkey, Litmus, Gremlin, Toxiproxy, tc netem), GameDay format, and maturity model from manual to continuous chaos.

CI/CD pipeline patterns with GitHub Actions: build/test/lint workflows, environment gates, caching, security scanning, Docker builds, and deployment automation. Includes templates for TypeScript, Python, Go, and Java.

Reference guide for writing, testing, and configuring clarc hooks — PreToolUse, PostToolUse, SessionStart, SessionEnd patterns with suppression and cooldown.

Patterns for using clarc MCP server in multi-agent workflows, CI pipelines, and external tools

Staged learning path for clarc — Day 1 survival commands, Week 1 workflow integration, Month 1 advanced agents. Includes solo, team, and role-specific paths.

The clarc Way — opinionated end-to-end software development methodology. 8-stage pipeline from idea to shipped code: /idea → /evaluate → /explore → /prd → /plan → /tdd → /code-review → commit. Activate when a user asks how to structure their workflow, which commands to use, or when to use clarc.

CLI tool design patterns for Node.js (yargs/commander), Python (click/typer/argparse), Go (cobra/pflag), and Rust (clap). Covers argument design, subcommand structure, interactive prompts (inquirer/Ratatui), progress bars, exit codes, stdin/stdout/stderr composability, and --json output. Use when building any command-line tool.

CLI user experience patterns: error messages that guide (not just report), help text design, autocomplete setup, config file hierarchy (~/.config/<tool>), environment variable conventions, --json/--quiet/--verbose flags, and progress indication. The difference between a tool people tolerate and one they recommend.

Color theory beyond palette generation: color harmony rules (complementary, analogous, triadic, split-complementary), color psychology by industry, dark mode color strategy (perceptual lightness, not inversion), simultaneous contrast, color blindness design patterns, and HSL/OKLCH color space decisions. The reasoning behind color choices, not just the output.

Compliance and audit-log workflow: immutable audit trail design, SOC 2 / ISO 27001 / HIPAA / PCI-DSS control mapping, access control reviews, data lineage, and compliance automation in CI/CD. Complements gdpr-privacy and security-review.

Write CFP (Call for Papers/Proposals) abstracts and speaker bios that get accepted. Covers hook sentences, problem framing, audience-fit statements, concrete takeaways, and adapting to different CFP formats (200/300/500 words). Use when submitting to any technical conference or meetup.

Interactive installer for clarc — guides users through selecting and installing skills and rules to user-level or project-level directories, verifies paths, and optionally optimizes installed files.

Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.

Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.

Context window auto-management — signals, strategies, and recovery protocol. Detects approaching context limits and guides compact vs checkpoint decisions to prevent lost work.

Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.2 adds project-scoped instincts to prevent cross-project contamination.

Contract Testing: Consumer-Driven Contract Testing with Pact (REST, messaging, Pact Broker, can-i-deploy), OpenAPI contract testing with Prism mock server and dredd, schema compatibility (ajv, Protobuf wire rules, Avro + Schema Registry), and breaking change detection with oasdiff in CI.

Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching.

Claude API cost awareness — token estimation, cost drivers, and efficiency strategies for Claude Code sessions

Advanced C++ standards — concurrency (CP.*), templates & C++20 concepts (T.*), standard library (SL.*), enumerations (Enum.*), source files & naming (SF.*/NL.*), performance (Per.*), and a full quick-reference checklist. Extends cpp-coding-standards.

C++ coding standards (C++ Core Guidelines). Core rules for philosophy, interfaces, functions, classes, resource management, error handling, and immutability.

Advanced C++ testing patterns — parameterized tests, death tests, advanced gmock, matchers, test data factories, async/concurrent testing, CI/CD integration, Catch2, and anti-patterns. Use after mastering the basics in cpp-testing.

Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

CQRS and Event Sourcing: command/query separation with read model projections, Event Sourcing (append-only event log, aggregate reconstruction, snapshots), Outbox Pattern for atomic DB + event publishing, Saga Pattern (choreography and orchestration with compensating transactions), and temporal queries.

Creative direction for digital products: defining visual language, writing illustration style briefs, icon style guidelines, photography/image direction, motion language definition, and maintaining creative consistency across touchpoints. Use when defining what a product should look and feel like.

C# 12 / .NET 8 patterns: records, primary constructors, pattern matching, repository + CQRS with MediatR, value objects, Result<T> pattern, Minimal API, ASP.NET Core middleware, Entity Framework Core, nullable reference types, async/await with CancellationToken, Roslyn analyzers. Use when writing or reviewing C# code.

C# testing patterns: xUnit with [Fact]/[Theory], FluentAssertions, Moq mocking, NSubstitute, WebApplicationFactory integration tests, Testcontainers for real DB, Bogus fake data generation, Respawn DB reset, Coverlet coverage. Use when writing or reviewing C# tests.

CSS architecture for modern web apps: Tailwind conventions and when to break them, CSS Modules for complex components, responsive design system with container queries, fluid typography, and avoiding the most common Tailwind pitfalls.

Idiomatic Dart patterns: Sound Null Safety (?, !, ??, ??=, ?.), Extension Methods, Mixins with constraints, Sealed Classes (Dart 3) with exhaustive pattern matching, async/await/Stream/Future, Result pattern for error handling, Dart Macros (preview).

Dashboard architecture and UX: KPI hierarchy, information density decisions, filter patterns, drill-down navigation, real-time update strategies (polling vs. WebSocket vs. SSE), empty and loading states for charts, and responsive dashboard layouts. Use when designing or building any analytics dashboard.

Data engineering patterns: dbt for SQL transformation (models, tests, incremental), Dagster for orchestration (assets, jobs, sensors), data quality checks, warehouse patterns (BigQuery/Snowflake/Redshift), and modern data stack setup. Covers the ELT pipeline from raw ingestion to analytics-ready models.

Data Mesh architecture patterns — domain ownership, data products with SLOs, self-serve platform design, Delta Lake vs Iceberg, federated Trino queries, data contracts, OpenLineage, and migration from centralized data warehouse.

Data visualization implementation: chart type selection framework (when to use bar/line/scatter/pie/heatmap/treemap), D3.js patterns, Recharts/Chart.js/Victory integration, accessible charts (ARIA roles, color-blind safe palettes), responsive SVG patterns, and performance for large datasets. Use when implementing any chart or graph.

Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Django, TypeORM, golang-migrate).

Domain-Driven Design tactical patterns for Java 25+. Value Objects, Entities, Aggregates, Domain Services, Domain Events, Ubiquitous Language, and Bounded Contexts. Use when modeling domain logic in Java Spring Boot services.

Domain-Driven Design tactical patterns for Python — entities, value objects, aggregates, repositories, domain events, and application services using dataclasses and Pydantic.

Domain-Driven Design tactical patterns for TypeScript. Value Objects, Entities, Aggregates, Domain Services, Domain Events, Ubiquitous Language, and Bounded Contexts. Use when modeling domain logic in TypeScript backend services.

Systematic debugging methodology — reproduction, isolation, binary search, profiling, distributed tracing, memory leaks, and race conditions. A structured approach that prevents random guessing and finds root causes faster.

Dependency security and compliance: per-language vulnerability scanning (npm audit, cargo audit, pip-audit, govulncheck, OWASP Dependency-Check), license compliance (FOSSA, license-checker), transitive dependency risk, dependency confusion attacks, and Renovate/Dependabot setup.

Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

Design Operations: Figma file organization standards, design-to-dev handoff workflow, design QA checklist, design token sync pipeline (Figma Variables → Style Dictionary → CSS/Tailwind), design system versioning and governance, component audit methodology, and design-dev collaboration patterns. Bridges the gap between design tools and production code.

Design system architecture: design tokens (color, spacing, typography, radius), component library layers (Primitive → Composite → Pattern), theming with CSS Custom Properties and Tailwind, Storybook documentation, and dark mode. The foundation for consistent UI across an entire product.

Local development environment patterns: runtime version pinning with mise/asdf, environment variables with direnv, Dev Containers for consistent team environments, Docker Compose for local services, and pre-commit hooks.

Advanced developer onboarding — Architecture Tour (codebase walkthrough by request), anchor files, domain glossary, GitHub Issue onboarding checklist template, knowledge sharing patterns (pair programming, ADRs, Loom), and onboarding metrics (Time to First PR).

Day-1 productivity engineering — code archaeology (git/CodeScene/Sourcegraph), CONTRIBUTING.md patterns, automated setup scripts, architecture tour, domain glossary, onboarding metrics (Time to First PR)

DevSecOps patterns — shift-left security, SAST (semgrep/CodeQL), secrets detection (gitleaks/trufflehog), dependency scanning (trivy/grype), DAST, OPA/Falco policy-as-code, container security, and security gates per CI stage.

Advanced Django patterns — service layer, caching, signals, middleware, performance optimization (N+1, bulk ops), and DDD patterns (fat models, bounded contexts, domain events). Extends django-patterns.

Django architecture patterns, REST API design with DRF, ORM best practices. Core patterns for project structure, models, QuerySets, and ViewSets.

Advanced Django security — file upload validation (extension/size/storage), DRF API security (rate limiting throttles, JWT), Content Security Policy middleware, django-environ secrets management, security event logging, and production deployment checklist.

Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.

Django testing strategies with pytest-django, TDD methodology, factory_boy, mocking, coverage, and testing Django REST Framework APIs.

Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks before release or PR.

Docker and Docker Compose patterns for local development, container security, networking, volume strategies, and multi-service orchestration.

DORA Four Keys technical implementation: extracting metrics from GitHub/GitLab APIs, Google Four Keys open-source setup, LinearB/Faros/Haystack alternatives, Grafana DORA dashboard, PagerDuty/OpsGenie MTTR integration, quarterly review process.

DuckDB patterns for embedded OLAP analytics: in-process SQL on Parquet/CSV/JSON files, window functions, ASOF joins, dbt-duckdb integration, Dagster assets, Python/Node.js APIs, and performance tuning. Zero infrastructure required — analytical power without a server.

Playwright E2E test patterns for Web3 and blockchain features — mocking wallet providers (MetaMask, Phantom), testing wallet connection flows, and handling async blockchain confirmations.

Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.

Advanced Edge Computing patterns — streaming responses (TransformStream, Server-Sent Events), edge caching (Cache API, stale-while-revalidate), Miniflare testing, and common edge runtime mistakes (Node.js APIs, large npm packages, synchronous computation).

Edge Computing patterns: Cloudflare Workers (Durable Objects, KV, D1, R2, Wrangler), Vercel Edge Middleware (geo-routing, A/B testing, Edge Config), Deno Deploy, edge runtime constraints (no fs/child_process, bundle limits), streaming responses, edge caching (Cache API, stale-while-revalidate), and testing with Miniflare.

Advanced Elixir/Phoenix patterns — distributed Erlang clusters, CRDT-based state, Ecto multi-tenancy, event sourcing, Commanded framework, and RFC 7807 API errors.

GenServer, Supervisors, OTP patterns, Phoenix contexts, LiveView lifecycle, and Broadway for Elixir/Phoenix applications.

ExUnit testing patterns, Mox for mocking, StreamData for property-based testing, and Phoenix test cases for Elixir applications.

Email and notification architecture: transactional email with Resend/SendGrid, React Email templates, notification preferences (channel, frequency, opt-out), delivery tracking, in-app notifications, and push notifications. Covers the full notification stack.

Engineering effectiveness metrics: DORA Four Keys (Deployment Frequency, Lead Time, Change Failure Rate, MTTR), SPACE Framework (Satisfaction, Performance, Activity, Communication, Efficiency), Goodhart's Law pitfalls, Velocity vs. Outcomes, Developer Experience measurement.

Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles

Event-Driven Architecture: Kafka deep-dive (partitioning, consumer groups, exactly-once semantics, Schema Registry, DLQ, compacted topics), AWS EventBridge (content filtering, cross-account, archive/replay), Pub/Sub patterns (CloudEvents standard, fan-out, event versioning), and at-least-once delivery with idempotency.

A/B testing and experimentation workflow: hypothesis design, metric selection, sample size calculation, statistical significance, common pitfalls (peeking, SRM, novelty effect), and experiment lifecycle. Complements feature-flags (implementation) with statistical rigor.

FastAPI architecture patterns — async endpoints, Pydantic models, dependency injection, OpenAPI, background tasks, and testing with pytest + HTTPX.

Verification loop for FastAPI projects: type checking, linting, tests with coverage, security scans, and API schema validation before release or PR.

Feature flag patterns for safe feature rollout without deployment: boolean flags, percentage rollouts, user targeting, and flag lifecycle. Covers LaunchDarkly, Unleash, homegrown Redis-based, and trunk-based development.

Figma-to-code workflow: extracting design tokens from Figma Variables, syncing tokens with Style Dictionary, reading Figma files via API, handoff conventions, and maintaining parity between design and implementation. For teams with a designer.

FinOps and cloud cost engineering — visibility and attribution (tagging taxonomy), Infracost in CI/CD, OpenCost for Kubernetes, rightsizing recommendations, storage/network cost optimization, anomaly detection, and FinOps maturity model.

Flutter architecture patterns: BLoC vs. Riverpod decision framework, Widget composition (Composition over Inheritance, CustomPainter, Implicit/Explicit Animations), go_router navigation, Platform Channels, Isolates for background work, Flutter DevTools profiling, performance patterns (const widgets, RepaintBoundary, ListView.builder, Slivers).

Flutter testing: Widget Tests (testWidgets, WidgetTester, pump, pumpAndSettle, finders), Integration Tests (flutter_test driver), mocking with mocktail, Golden File Tests (visual regression, --update-goldens), BLoC testing (bloc_test package), coverage measurement and CI integration.

Apple FoundationModels framework for on-device LLM — text generation, guided generation with @Generable, tool calling, and snapshot streaming in iOS 26+.

Frontend patterns — React component composition, state management (useState/useReducer/Zustand/Jotai), Next.js App Router, performance optimization (memo/useMemo/lazy), form handling, error boundaries, and TypeScript patterns.

GDPR and data privacy implementation patterns: Right to Erasure, data retention policies, PII detection and anonymization, consent management, Data Subject Access Requests (DSAR), audit logs, and data minimization. Required for any EU-facing product.

AI-assisted design workflows: prompt engineering for image generation (Midjourney, DALL-E 3, Stable Diffusion, Flux), achieving style consistency across a generated asset set, post-processing AI outputs for production use, legal and licensing considerations, and when AI generation is and isn't appropriate. For teams integrating generative AI into their design workflow.

GitOps patterns — ArgoCD and Flux setup, Kustomize overlays per environment, SealedSecrets/ESO for secrets, multi-cluster topology, GitOps repository patterns (mono-repo vs poly-repo), and common pitfalls.

Advanced Go patterns — hexagonal architecture with full working examples, struct design (functional options, embedding), memory optimization, Go tooling (golangci-lint), Go 1.21+ slices/maps stdlib, and anti-patterns. Extends go-patterns.

Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.

Advanced Go testing — interface-based mocking, benchmarks (basic, size-parametrized, allocation), fuzzing (Go 1.18+), test coverage, HTTP handler testing with httptest, best practices, and CI/CD integration. Extends go-testing.

Go testing patterns including table-driven tests, subtests, test helpers, and golden files. Core TDD methodology with idiomatic Go practices.

GraphQL API patterns: schema-first design, resolvers, DataLoader for N+1 prevention, subscriptions, error handling, pagination, auth, and performance. For TypeScript with Apollo Server or Pothos.

gRPC + Protocol Buffers patterns — proto schema design, code generation, unary and streaming call types, error handling with gRPC status codes, interceptors, reflection, and client usage. For service-to-service communication where REST is insufficient.

Hexagonal architecture (ports & adapters) for Java Spring Boot. Package structure, port definitions, use case implementation, adapter patterns, and testing strategy. Use when structuring or reviewing Java services.

Advanced Hexagonal Architecture anti-patterns for TypeScript — domain importing framework dependencies, use cases depending on concrete adapters, HTTP handlers bypassing use cases, Zod validation inside the domain model. Each anti-pattern includes wrong/correct comparison with explanation.

Hexagonal architecture (ports & adapters) for TypeScript Node.js backends. Package structure, port definitions, use case implementation, adapter patterns, DI wiring, and testing strategy. Use when structuring or reviewing TypeScript backend services.

Create zero-dependency, animation-rich HTML presentations from scratch or by converting PowerPoint/PPTX files. Use when the user wants to build a presentation, convert a deck to web, or create slides for a talk/pitch.

Framework-specific i18n implementation: i18next + react-i18next (React/Next.js), next-intl (Next.js App Router), Django's i18n (gettext/makemessages), Rails I18n (YAML-based), Localizable.strings + SwiftUI (iOS), Android string resources, and Flutter's ARB format. Concrete setup and usage patterns for each.

Internationalization architecture: locale detection strategy, translation key organization (flat vs. namespaced), pluralization rules (CLDR), gender agreement, RTL layout (CSS logical properties), date/time/number/currency formatting (Intl API), and locale-aware sorting. Language-agnostic patterns applicable to any framework.

Skill: Modern IaC Patterns — Pulumi, AWS CDK, Bicep, cdktf

SVG icon system design: icon library selection (Lucide, Phosphor, Heroicons), custom icon brief writing, SVG optimization with SVGO, icon tokens (size, color, stroke), accessibility (aria-label, title, role), sprite sheet generation, icon naming conventions, and icon-to-code workflow. From picking an icon set to shipping accessible, performant icons.

How to proactively find product ideas: three distinct modes — Inbound (analyze user feedback), Outbound (competitive web research), and Creative (structured ideation). Connects discovery tools to the product lifecycle pipeline.

Illustration style definition for digital products: style brief writing (flat, isometric, line art, 3D, abstract), consistency rules for multi-illustrator teams, SVG illustration techniques, color consistency across scenes, AI-assisted illustration prompting (Midjourney, DALL-E, Stable Diffusion), and illustration do/don't patterns. From defining a style to maintaining it at scale.

Incident response process: severity levels, on-call workflow, runbook templates, communication guidelines (status page, Slack), blameless post-mortems, and resolution checklists.

Full lifecycle management for clarc instincts — capture, scoring, decay, conflict resolution, promotion, and removal

Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets.

Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications for fundraising. Use when the user wants outreach to angels, VCs, strategic investors, or accelerators and needs concise, personalized, investor-facing messaging.

Java coding standards and idioms for Java 25+ — naming, immutability, Optional, streams, exceptions, generics, records, sealed classes. Applies to plain Java, Spring Boot, Quarkus, and Jakarta EE projects.

Java testing patterns: JUnit 5, Mockito, AssertJ, Testcontainers for integration tests, and coverage with JaCoCo. Core TDD methodology for plain Java projects (non-Spring). For Spring Boot, see springboot-tdd.

JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.

Idiomatic Kotlin patterns: sealed classes, data classes, extension functions, coroutines, Flow, DSL builders, value classes, and functional idioms. Use when writing or reviewing Kotlin code.

Kotlin testing with JUnit 5, Kotest, MockK, coroutine testing, and Testcontainers. Covers TDD workflow, test structure, coroutine test utilities, and Spring Boot integration testing.

Production Kubernetes patterns: Deployments, Services, Ingress, HPA, resource limits, health probes, ConfigMap/Secret management, Helm charts, namespaces, and IaC with Terraform/Pulumi. Prevents the most common k8s production failures.

Visual layout and composition principles: grid systems (column, baseline, modular), Gestalt principles (proximity, alignment, contrast, repetition, enclosure), whitespace as an active design element, visual hierarchy construction, and focal point design. Use when making layout decisions, not just implementing them.

Legacy code modernization: Strangler Fig Pattern, Anti-Corruption Layer, Branch-by-Abstraction, Module Strangling, inkrementeller Rewrite vs. Big Bang (Entscheidungsframework), Seams für Testbarkeit, Database Migration Strategy (Dual-Write, Read Shadow).

iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit.

LLM application architecture: orchestration patterns, fallback chains, streaming responses, human-in-the-loop, guardrails, latency optimization, and observability. For teams building production AI features beyond simple single-shot API calls.

Load and performance testing with k6 (TypeScript/Go/any HTTP) and Locust (Python). Covers test types (smoke, load, stress, spike, soak), SLO thresholds, CI integration, and interpreting results.

Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Use when the user wants market sizing, competitor comparisons, fund research, technology scans, or research that informs business decisions.

Marketing asset design for developers: Open Graph / social media card specs and HTML generation, email template HTML/CSS patterns (table-based layout, Outlook compatibility, dark mode), banner and ad creative dimensions, print-safe PDF generation, and brand consistency across marketing touchpoints. From OG image code to email that renders in Outlook.

Async message queue and event streaming patterns — AWS SQS/SNS, Kafka, RabbitMQ. Covers producer/consumer design, idempotency, dead-letter queues, fan-out, ordering guarantees, and backpressure. The reference for service-to-service async communication.

Advanced Micro-Frontend patterns — testing strategy (unit per-remote, integration with mocked remotes, E2E full composition via Playwright), CI/CD independent deployments per remote, ErrorBoundary resilience, and monolith-to-MFE strangler-fig migration.

Micro-frontend patterns — team topology decisions, Module Federation (webpack/Vite), integration strategies (iframe/web components/JS orchestration), shared state minimization, design system integration, and migration from monolith.

MLOps lifecycle patterns — experiment tracking (MLflow/W&B), model registry, FastAPI serving with canary deployments, drift detection, fine-tuning workflows, retraining pipelines, DVC data versioning, and GPU autoscaling on Kubernetes.

Mobile CI/CD patterns — iOS/Android builds in CI (GitHub Actions/Fastlane), code signing for TestFlight/App Store, automated versioning, screenshot testing, Firebase App Distribution, staged rollouts, and crash-rate gates.

Motion and animation patterns for web: CSS transitions for simple interactions, Framer Motion for complex orchestrated animations, meaningful vs. decorative motion, prefers-reduced-motion (WCAG 2.3), page transitions, and layout animations. Motion should communicate, not decorate.

Advanced multi-agent patterns — capability registry, durable state (Redis/DynamoDB), task decomposition, testing multi-agent systems, pattern quick-selection guide, failure handling, cost management, and worktree isolation. Extends multi-agent-patterns.

Multi-Agent Systems: orchestration vs choreography, tool routing, state management, agent handoffs, parallelization (fan-out/fan-in), error handling in multi-agent workflows, Claude SDK patterns (Agent/Tool/Handoff), and observability with OpenTelemetry.

Multi-tenancy patterns for SaaS: row-level security (Postgres RLS), schema-per-tenant, tenant context middleware, data isolation testing, and migration strategies. Helps prevent cross-tenant data leaks.

Node.js backend architecture patterns — Express, Fastify, Next.js API routes, TypeScript services. API design, database optimization, caching, middleware. Not applicable to Python, Go, or Java backends.

NoSQL database patterns: MongoDB document design (embedding vs. referencing), DynamoDB single-table design with access patterns, Redis as primary store, and when to use each NoSQL database vs. Postgres.

Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images.

Production observability: structured logging, metrics (Prometheus/OpenTelemetry), distributed tracing, error tracking (Sentry), health checks, and alerting. Covers TypeScript, Python, and Go with code examples.

Open source project governance: GitHub issue/PR templates, CODEOWNERS, CONTRIBUTING.md structure, community health files, label taxonomy, branch protection rules, and automated CHANGELOG from Conventional Commits. For maintainers who want contributors to succeed without hand-holding every PR.

Autonomous overnight development pipeline. Analyzes a feature idea and selects the right pipeline pattern (Sequential, Continuous Claude, Ralphinho, or Infinite Loop). Generates all required files and waits for user confirmation before starting.

Performance profiling workflows: CPU profiling (pprof, py-spy, async-profiler, 0x), memory profiling (heap analysis, leak detection), flamegraph interpretation, latency analysis (P50/P99/P99.9), and profiling anti-patterns per language (Go, Python, JVM, Node.js).

PHP 8.4+ patterns: readonly classes/properties, enums, named arguments, match expressions, value objects, repository pattern, service layer with command/handler, Laravel controller/FormRequest, Symfony service wiring, Doctrine QueryBuilder, Fiber async. Use when writing or reviewing PHP code.

PHP testing patterns: PHPUnit 11 with mocks and data providers, Pest v3 with expectations and datasets, Laravel feature/HTTP tests with RefreshDatabase, Symfony WebTestCase, PHPStan static analysis, Infection mutation testing. Use when writing or reviewing PHP tests.

Write-time code quality enforcement using Plankton — auto-formatting, linting, and Claude-powered fixes on every file edit via hooks.

Platform Engineering: Internal Developer Platforms (IDP), CNCF Platform definition, Team Topologies, IDP components (Service Catalog, Self-Service Infra, Golden Paths, Developer Portal), platform maturity model, make-vs-buy (Backstage vs Port vs Cortex), adoption strategy, DORA correlation.

PostgreSQL database patterns for query optimization, schema design, indexing, and security. Based on Supabase best practices.

Presentation structure, narrative design, and slide layout principles. Covers the problem-solution-evidence arc, slide density rules (one idea per slide), slide type catalogue, opening hooks, and closing patterns. Use when structuring any slide deck — conference talk, demo, investor pitch, or team update.

SaaS pricing strategy patterns: value metric selection, usage-based vs. seat-based vs. flat-rate models, freemium conversion, pricing page design, packaging tiers, and the analytics to improve pricing. For product and technical founders.

Privacy engineering patterns — PII classification and inventory, GDPR consent flows, data minimization, right-to-erasure implementation, pseudonymization/encryption, privacy-by-design architecture, and DPIA checklist.

RFC 7807 / RFC 9457 Problem Details for HTTP APIs — standard error response format, Content-Type application/problem+json, extension fields, and per-language implementation patterns.

Full product development lifecycle from raw idea to shipped implementation. Covers idea capture, evaluation (Go/No-Go), solution design (ADR), PRD writing, and handoff to the implementation pipeline. Prevents building the wrong thing.

Argo Rollouts patterns for canary and blue/green deployments — traffic splitting, automated analysis with Prometheus metrics, rollback triggers, and GitOps integration.

How to create, manage, and share project-local skills — .clarc/skills/ structure, scope hierarchy, team workflow, and promotion to global clarc

System prompt architecture, few-shot design, chain-of-thought, structured output (JSON mode, response_format), tool use patterns, prompt versioning, and regression testing. Use when writing, reviewing, or debugging any LLM prompt — system prompts, user templates, or tool descriptions.

Advanced Python patterns — concurrency (threading, multiprocessing, async/await), hexagonal architecture with FastAPI, RFC 7807 error handling, memory optimization, pyproject.toml tooling, and anti-patterns. Extends python-patterns.

Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Advanced Python testing — async testing with pytest-asyncio, exception/side-effect testing, test organization, common patterns (API, database, class methods), pytest configuration, and CLI reference. Extends python-testing.

Python testing strategies using pytest, TDD methodology, fixtures, mocking, and parametrization. Core testing fundamentals.

R patterns: tidyverse data pipelines with dplyr/tidyr/purrr, native pipe |>, R6 classes, tidy evaluation with rlang {{, vctrs custom types, renv dependency management, ggplot2 visualization, functional programming with purrr::map/walk/reduce. Use when writing or reviewing R code.

R testing patterns: testthat 3e with expect_* assertions, snapshot testing, mocking with mockery and httptest2, covr code coverage, lintr static analysis, property-based testing with hedgehog, testing Shiny apps with shinytest2. Use when writing or reviewing R tests.

RAG (Retrieval-Augmented Generation) architecture patterns: chunking strategies, embedding models, vector stores (pgvector, Pinecone), retrieval pipelines, reranking, prompt engineering, evaluation, and LLM caching. The reference for building AI features on top of your own data.

React Native patterns: navigation (Expo Router), platform-specific code, local storage, push notifications (Expo), performance optimization, network handling, and bridging native APIs. For Expo-based React Native apps.

Real-time communication patterns: WebSocket with reconnection and presence, Server-Sent Events (SSE) for one-way streaming, long polling fallback, room-based pub/sub, connection state management, and operational concerns for real-time at scale.

Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases.

Release management: semantic versioning, conventional commits → CHANGELOG, git tagging, GitHub Releases, pre-release testing, and rollback procedures. Use /release to automate the process.

Compact codebase map injected at session start — file tree, key symbols, and hot files from git history. Closes the Aider-style context-awareness gap without tree-sitter dependencies.

Production resilience patterns: Circuit Breaker (Closed/Open/Half-Open), Bulkhead isolation, Retry with exponential backoff + jitter, Timeout hierarchies, Fallback strategies, Graceful Degradation, and Health Check patterns for Kubernetes and beyond.

Advanced Ruby patterns — DDD with domain objects, Sorbet type system, value objects, event sourcing, background jobs, and API response standards with RFC 7807.

Rails patterns, ActiveRecord best practices, Service Objects, Query Objects, Decorators, Form Objects, and idiomatic Ruby design.

RSpec testing patterns for Ruby and Rails — factories, mocks, request specs, feature specs, VCR, and SimpleCov coverage.

Advanced Rust patterns — zero-cost abstractions, proc macros, unsafe FFI, WASM, Axum web architecture, trait objects vs generics, and performance profiling.

Idiomatic Rust patterns, ownership idioms, async with Tokio, error handling with thiserror/anyhow, testing strategies, and hexagonal architecture in Rust.

Advanced Rust testing anti-patterns and corrections — cfg(test) placement, expect() over unwrap(), mockall expectation ordering, executor mixing (#[tokio::test] vs block_on), PgPool isolation with

Rust testing patterns — unit tests with mockall, integration tests with sqlx transactions, HTTP handler testing (axum), benchmarks (criterion), property tests (proptest), fuzzing, and CI with cargo-nextest.

Axum HTTP handlers, Serde serialization, async channels, iterator patterns, trait objects, configuration, and WebAssembly target for Rust web services.

Idiomatic Scala patterns: ADTs with sealed traits and case classes, typeclass pattern, Option/Either/Try error handling, for-comprehensions, Cats Effect (IO, Resource, Ref, Fiber), ZIO fundamentals, Scala 3 features (given/using, enums, extension methods, opaque types, union types). Covers both Scala 2.13 and Scala 3. Use when writing Scala, reviewing Scala code, or designing Scala domain models.

Scala testing with ScalaTest, MUnit, and ScalaCheck: FunSpec/FlatSpec test structure, property-based testing with forAll, mocking with MockitoSugar, Cats Effect testing with munit-cats-effect (runTest/IOSuite), ZIO Test, Testcontainers-Scala for database integration tests, and CI integration with sbt. Use when writing or reviewing Scala tests.

SDK design patterns — API ergonomics, backward compatibility (semantic versioning, deprecation), multi-language SDK generation (openapi-generator vs Speakeasy), error hierarchy design, SDK testing strategies, and documentation as first-class SDK artifact.

Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent.

Search implementation patterns: full-text search with Postgres tsvector, Typesense for production search, Elasticsearch for complex analytics, faceted search, autocomplete, typo tolerance, vector/semantic search, and relevance tuning.

Security anti-patterns — localStorage token storage (XSS risk), trusting client-side authorization checks, reflecting full error details to clients, blacklist vs whitelist input validation, using npm install instead of npm ci in CI pipelines.

Security patterns for Web3 and blockchain applications — Solana wallet signature verification, transaction validation, smart contract interaction security, and checklist for DeFi/NFT features.

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Scan your Claude Code configuration (.claude/ directory) for security vulnerabilities, misconfigurations, and injection risks using AgentShield. Checks CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions.

Advanced Serverless patterns — Lambda idempotency (Lambda Powertools + DynamoDB persistence layer), Lambda cost model (pricing formula, break-even vs containers), and CloudWatch Insights observability queries for cold starts, duration, and errors.

Serverless patterns: cold start optimization (Provisioned Concurrency, SnapStart, keep-warm), event source mapping (S3/SQS/DynamoDB Streams/EventBridge), AWS Step Functions, Lambda Powertools (logging/metrics/tracing), idempotency, cost model, and observability with X-Ray.

Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation.

SLI/SLO/SLA and error budget workflow: define service level indicators, set objectives, calculate error budgets, implement burn rate alerting, and use error budgets to gate risky deployments. Covers Prometheus, Datadog, and Google SRE methodology.

Spring Boot architecture patterns, REST API design, hexagonal (ports & adapters) architecture, data access, caching, async processing, and logging. Use for Java Spring Boot backend work.

Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.

Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.

Verification loop for Spring Boot projects: build, static analysis, tests with coverage, security scans, and diff review before release or PR.

SQL query patterns: parameterized queries, keyset pagination, UPSERT, window functions, CTEs, aggregation with FILTER, soft delete, audit trails, row-level security, and migration best practices. Use when writing or reviewing SQL queries and schema changes.

Workflow Starter-Packs — 6 battle-tested project archetypes (REST API, React SPA, Python Pipeline, Go Service, Flutter App, Spring Boot). Bootstraps a new project with the right structure, CI, testing, and clarc rules pre-configured.

Frontend state management patterns: TanStack Query for server state, Zustand for client state, URL state, form state with React Hook Form, and when to use what. Prevents over-engineering and the most common state bugs.

Storybook patterns: CSF3 (meta satisfies Meta, play functions, @storybook/test), addon ecosystem (a11y, interactions, docs), MSW integration for API mocking, Chromatic CI, storybook-test-runner for Jest/Playwright execution, and Storybook as living documentation.

Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.

Strategic Domain-Driven Design — Subdomain classification (Core/Supporting/Generic), Context Mapping (7 relationship patterns), Bounded Context design, and Event Storming. Language-agnostic. Use when designing system boundaries, decomposing a monolith, or planning a new multi-service architecture.

Pattern for progressively refining context retrieval in multi-agent workflows — avoids context-overflow failures when subagents cannot predict what context they need upfront.

Software supply chain security: SBOM generation (CycloneDX/SPDX with syft/grype), SLSA framework levels, Sigstore/cosign artifact signing, dependency hash pinning, reproducible builds, VEX documents, and SSDF compliance.

Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design.

Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types.

Advanced Swift patterns — property wrappers, result builders, Combine basics, opaque & existential types, macro system, advanced generics, and performance optimization. Extends swift-patterns.

Core Swift patterns — value vs reference types, protocols, generics, optionals, Result, error handling, Codable, and module organization. Foundation for all Swift development.

Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing.

Swift testing patterns: Swift Testing framework (Swift 6+), XCTest for UI tests, async/await test cases, actor testing, Combine testing, and XCUITest for UI automation. TDD for Swift/SwiftUI.

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

Prepare a talk from scratch: audience analysis, time boxing per section, outline structure, speaker notes, rehearsal strategy, Q&A preparation, and nervous system management. Use for conference talks, team presentations, demos, and webinars of any length.

TDD anti-patterns — writing code before tests, testing implementation details instead of behavior, using waitForTimeout as a sync strategy, chaining tests that share state, mocking the system under test instead of its dependencies.

Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.

Team Workflow OS — shared clarc setup for engineering teams. Covers shared rules distribution, private skill packs, team sync patterns, onboarding, and multi-developer conventions.

Engineering team process patterns: OKR definition and scoring, sprint planning and retros, roadmap structuring (now/next/later), feature breakdown into user stories with acceptance criteria, and engineering metrics (DORA, velocity). For product lifecycle see product-lifecycle skill.

Technical debt management: Ward Cunningham's quadrant (Reckless/Prudent × Deliberate/Inadvertent), Martin Fowler taxonomy, quantification with SonarQube/SQALE/radon, Churn×Complexity hotspot matrix (Code Maat), Interest Rate concept, debt ticket format, Buy-vs-Pay-Down decision framework, communicating debt to non-technical stakeholders.

Terraform in CI/CD — plan on PR, apply on merge, OIDC auth, drift detection, importing existing resources, common CLI commands, anti-patterns, and Terraform vs Pulumi vs CDK decision guide.

Infrastructure as Code with Terraform — project structure, remote state, modules, workspace strategy, AWS/GCP patterns, CI/CD integration, and security hardening. The standard for managing production infrastructure.

Test data management patterns: factory functions, fixtures, database seeders, test isolation strategies, and safely anonymizing production data for testing. Covers TypeScript, Python, and Go.

TypeScript, JavaScript, React, and Node.js coding standards — naming conventions, immutability, error handling, async patterns, component structure, API design. For language-agnostic principles see rules/common/coding-style.md.

TypeScript monorepo patterns with Turborepo + pnpm workspaces. Covers package structure, shared configs, task pipeline caching, build orchestration, and publishing strategy.

Advanced TypeScript — mapped types, template literal types, conditional types, infer, type guards, decorators, async patterns, testing with Vitest/Jest, and performance. Extends typescript-patterns.

TypeScript patterns — type system best practices, strict mode, utility types, generics, discriminated unions, error handling with Result types, and module organization. Core patterns for production TypeScript.

TypeScript testing patterns: Vitest for unit/integration, Playwright for E2E, MSW for API mocking, Testing Library for React components. Core TDD methodology for TypeScript/JavaScript projects.

Typography as a creative discipline: typeface selection criteria, type pairing (serif + sans, display + body), modular scale systems, line-height and tracking ratios, hierarchy construction, and web/mobile rendering considerations. The decisions behind design tokens, not the tokens themselves.

UX micro-patterns for every product state: Empty States, Loading States (skeleton screens, spinners, optimistic UI), Error States, Success States, Confirmation Dialogs, Onboarding Flows, and Progressive Disclosure. These patterns apply to every feature — done wrong, they're the biggest source of user confusion.

Run build → type-check → lint → tests in sequence; fail fast and fix each error before continuing; repeat until all quality gates pass. Use after significant code changes and before creating a PR.

Brand identity development: color palette construction (primary/secondary/semantic/neutral), logo concept brief writing, typeface pairings, brand voice definition, mood board direction, and Brand Guidelines document structure. Use when establishing or evolving a visual brand — not for implementing existing tokens.

Visual Regression Testing: tool comparison (Chromatic/Percy/Playwright screenshots/BackstopJS), pixel-diff vs AI-based comparison, baseline management, flakiness strategies (masks, tolerances, waitForLoadState), CI integration with GitHub Actions, and Storybook integration.

WebAssembly patterns: wasm-pack, wasm-bindgen (JS↔Wasm interop), WASI, Component Model, wasm-opt, Rust-to-WASM compilation, JS integration (web workers, streaming instantiation), and production deployment (CDN, Content-Type headers).

WebAssembly performance: wasm-opt binary optimization, size reduction (panic=abort, LTO, strip), profiling WASM in Chrome DevTools, memory management (linear memory, avoiding GC pressure), SIMD, and multi-threading with SharedArrayBuffer.

Web performance optimization: Core Web Vitals (LCP, CLS, INP), Lighthouse CI with budget configuration, bundle analysis (webpack-bundle-analyzer, vite-bundle-visualizer), hydration performance, network waterfall reading, image optimization (WebP/AVIF, srcset), and font performance.

Webhook patterns for receiving, verifying (HMAC), and idempotently processing third-party events. Covers Stripe, GitHub, and generic webhook patterns, delivery guarantees, retry handling, and testing.

WebRTC patterns — peer connection setup, ICE/STUN/TURN configuration, signaling server design, SFU vs mesh topology, screen sharing, media track management, and reconnect/ICE restart handling.

Wireframing and prototyping workflow: fidelity levels (lo-fi sketch → mid-fi wireframe → hi-fi prototype), tool selection (Figma, Excalidraw, Balsamiq), user flow diagrams, wireframe annotation standards, information architecture (IA) mapping, and the handoff from wireframe to visual design. For developers who need to communicate UI structure before writing code.

Zero-Trust security patterns — mTLS between microservices (Istio/SPIFFE), SPIRE workload identity, OPA/Envoy authorization, NetworkPolicy default-deny-all, short-lived credentials, service mesh security, and Kubernetes RBAC hardening.

24 hooks across 7 events