workflows

Shared template for gathering company context metadata. Used by `session-start`.

Shared templates for scaffolding documentation files based on active project traits. Used by `project-start` during the "Scaffold Trait-Conditional Documentation" step.

Show plugin usage analytics — command frequency, success rates, and duration trends

Generate Architecture Decision Records (ADRs) for documenting technology choices

Query the full context picture for any issue — what context was used, staleness status, and frequency analysis

Standardized bug reporting template that creates Linear issues with reproduction steps, severity, and environment details

Standardized code review for Brite projects

Scaffold a new domain plugin from the template

Pre-deployment validation checklist — run automated checks and confirm manual items before deploying

Verify the factual accuracy of a document against the actual codebase, correct inaccuracies in place

Compute and display the 5 compound knowledge flywheel metrics from accumulated decision traces

Guide for setting up a new Brite dev environment

Start a new Brite project with a guided interview

Review and promote flagged decision traces from project precedents to the org-level handbook

Capture plugin misbehavior as a regression test case and Linear issue with classification and reproduction steps

Sprint retrospective — review completed cycle, facilitate retro discussion, post status update

Self-verify work, simplify code, run review agents in parallel, fix P1s, report findings

Collaborative scoping session — discover what to build next, create Linear issues, prioritize

Comprehensive security audit and vulnerability assessment for any project

Start a work session — pull latest, pick a Linear issue, brainstorm, plan, execute

Audit and refactor a project's CLAUDE.md against best practices

Create PR, update Linear, compound learnings, best-practices audit, handbook drift check, suggest next issue

Run diagnostic checks on the plugin environment — CLI tools, MCP servers, hooks, agent dispatch

Sprint planning — pull backlog, review velocity, assign issues to cycles

Display Brite technology stack for tech decisions

Reviews frontend code for WCAG 2.1 compliance, keyboard navigation, ARIA usage, screen reader support, and responsive accessibility

Reviews code for coupling, SOLID violations, dependency direction, boundary violations, pattern consistency, and API surface issues

Reviews code changes against Company Decision Records (CDRs) for compliance violations, missing exceptions, and superseded patterns

Generates best-practices CLAUDE.md files

Reviews code for bugs, logic errors, edge cases, and code quality issues using P1/P2/P3 severity

Reviews database migrations, schema changes, query safety, and data integrity patterns for Prisma, Alembic, and raw SQL

Pre-filters trivial diffs to skip expensive review pipeline using lightweight analysis

Creates and validates Linear issues from project plans

Reviews code for performance issues including algorithmic complexity, database queries, memory leaks, bundle size, caching, and network efficiency

Refines project plans into agent-ready tasks

Orchestrates the full post-plan workflow across phases

Reviews Python and FastAPI code for type safety, async patterns, Pydantic v2 usage, error handling, and architectural correctness

Reviews code for security vulnerabilities, secrets exposure, auth issues, and OWASP Top 10 compliance

Reviews test code for coverage gaps, behavior-focused testing, flakiness risk, edge case coverage, and test structure quality

Reviews TypeScript, React, and Next.js code for type safety, component boundaries, hook rules, and framework patterns

Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

Audits and auto-fixes a project's CLAUDE.md against Anthropic best practices. Activates during ship phase — checks conciseness, enforces @import structure for detailed docs, auto-excludes bloat, identifies hook candidates, and auto-fixes structural issues. Flags content questions for developer review.

Socratic discovery and design exploration before planning. Activates when objective complexity criteria are met (2+ modules, 4+ tasks, 2+ approaches, or new patterns/integrations) — asks clarifying questions, explores alternatives and tradeoffs, produces a design document for approval. Pulls context from Linear issue description, linked docs, and existing CLAUDE.md learnings.

ESLint, Prettier, Ruff, mypy, and TypeScript strict mode configuration patterns. Use when setting up linting, formatting, or code quality tooling for a new project, reviewing existing configs, generating config files, or adding lint steps to CI. Triggers on tasks involving ESLint, Prettier, Ruff, mypy, Black, code style, linting, formatting, or code quality enforcement.

Captures durable knowledge after completing work so future sessions benefit. Activates during the ship phase — updates CLAUDE.md with architectural decisions and gotchas, writes session summary to auto-memory, updates docs if architecture or API changed. Only records genuinely durable facts, not session-specific noise.

Creates Linear issues from a refined project plan. Validates issues were created correctly with sufficient context for agent execution. Use after /refine-plan.

Executes a structured plan using subagent-per-task with TDD enforcement. Activates when given an approved plan to implement — launches fresh subagents for each task, enforces red-green-refactor, runs two-stage review per task, and checkpoints between tasks. Parallelizes independent tasks.

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

Build and implement distinctive frontend interfaces with production-grade code. Use when the user asks to code, build, create, or implement web components, pages, layouts, dashboards, or applications. This is the implementation skill — it writes actual HTML/CSS/JS/React code with bold aesthetic choices. Do NOT use for design system planning, palette selection, or style exploration — use ui-ux-pro-max for those.

Creates an isolated git worktree for task execution. Activates when starting work on a planned issue — sets up a new branch with Linear issue ID, runs project setup, and verifies a clean test baseline before coding begins.

Detects handbook content that has drifted from project reality after shipping. Activates during the ship phase — compares the shipped diff against handbook files via GitHub API, identifies stale or missing handbook content, and optionally opens a PR to the handbook repo with proposed updates.

Runs the full post-plan workflow. Refine plan, create Linear issues, setup CLAUDE.md. Use after /plan-project produces a v1 plan. Pauses between phases for optional review.

Searches project and org-level precedent INDEX files for relevant past decisions. Activates during brainstorming or planning when historical decisions may inform the current approach — searches by keyword against Decision and Tags columns, filters by category, lazy-loads full trace files on match.

Use when writing, reviewing, or refactoring FastAPI/Python backend code. Triggers on FastAPI endpoints, Pydantic models, SQLAlchemy queries, async Python code, or Python API architecture. Contains 38 architectural rules across 8 categories.

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

Refines a v1 project plan into agent-ready tasks with clear context, implementation steps, and validation criteria. Use after /plan-project has produced a v1 plan.

Generates a best-practices CLAUDE.md file for the project. Analyzes the codebase and applies Claude Code best practices for optimal agent performance. Use at project setup or after /create-issues.

Four-phase root cause analysis for bug investigation. Activates when debugging unexpected behavior, failing tests, or production issues — follows reproduce, isolate, analyze, fix with defense-in-depth. Uses condition-based waiting instead of arbitrary delays. Available anytime, not tied to the inner loop sequence.

Use when writing, reviewing, or refactoring test code. Triggers on Vitest tests, React Testing Library usage, MSW handlers, Playwright E2E tests, pytest fixtures, test structure decisions, or coverage configuration. Contains 46 testing rules across 12 categories.

Design system generation and UI/UX planning intelligence. Use when the user needs to choose a color palette, select fonts, generate a design system, plan a visual direction, or explore UI styles before implementation. Covers 50+ styles, 97 palettes, 57 font pairings across 9 stacks. Do NOT use for building/coding UI — use frontend-design for implementation.

Ensures tasks are genuinely resolved before marking them done. Activates at task checkpoints during plan execution — validates that fixes actually work, tests genuinely pass, and acceptance criteria are met. Prevents premature completion declarations.

Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".

Breaks work into bite-sized tasks before coding. Activates when a multi-step task needs planning — creates tasks small enough for a junior developer to follow (2-5 minutes each), with exact file paths, complete implementation details, and verification steps. References Linear issue context and project-specific test commands from CLAUDE.md.

8 hooks across 3 events