britenites

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

Standardized code review for Britenites projects

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

Guide for setting up a new Britenites dev environment

Start a new Britenites project with a guided interview

Self-verify work, 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, 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 Britenites technology stack for tech decisions

Generates best-practices CLAUDE.md files

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

Creates and validates Linear issues from project plans

Refines project plans into agent-ready tasks

Orchestrates the full post-plan workflow across phases

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

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 starting non-trivial work — 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. Simple bugs and fixes skip this automatically.

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.

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.

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.

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.

7 hooks across 3 events