session-workflow

API compatibility analysis with expand/contract migrations, event schema evolution, and client SDK compatibility matrix

Convert review findings to prioritized backlog with impact/effort matrix, ROI justification, and dependency tracking

Analyze errors, stack traces, and logs to identify root causes and recommend fixes

Create ADR-style decision records for architectural and implementation choices

Generate comprehensive tests for specified files or features following project conventions

Create clear documentation for others reviewing, deploying, or maintaining your changes

Production readiness checklist with observability, safety patterns, runbooks, security, and data integrity

Safe, staged refactoring plan with mechanical→structural→architectural ordering, regression controls, and risk mitigation

Create minimal reproduction harness for bugs with deterministic tests and regression coverage

Review UI changes for keyboard and assistive technology usability, avoid ARIA misuse

Review API contracts for stability, correctness, and usability for consumers

Review code for architectural issues including boundaries, dependencies, and layering

Review backend code for race conditions, atomicity violations, locking issues, and idempotency bugs

Review CI/CD pipelines for security, correctness, and deployment safety

Review code for logic flaws, broken invariants, edge-case failures, and correctness issues

Review code for changes that increase cloud infrastructure costs

Review data integrity - ensure stored data remains correct over time, across failures, retries, and concurrent writes

Review documentation completeness and accuracy for behavior/config/API changes

Review developer experience - make the project easier to build, run, debug, and contribute to

Review frontend code for accessibility issues in modern SPAs (React, Vue, Angular)

Review frontend changes for bundle size, rendering efficiency, and user-perceived latency

Review infrastructure code for security issues in IAM, networking, secrets, and configuration

Review infrastructure and deployment config for safety, least privilege, and operational clarity

Review logging for secrets exposure, PII leaks, wide-event patterns, and query-optimized observability

Review code for long-term readability, ease of change, and reduced change amplification

Review database migrations for safety, compatibility, and operability in production

Review observability completeness - logs, metrics, tracing, error reporting, alertability, and runbook hooks

Review code for unnecessary complexity, abstractions, and YAGNI violations

Review code for algorithmic and system-level performance issues

Review data handling for PII collection, storage, transmission, and privacy compliance

Hunt semantic drift in refactors to ensure behavior equivalence and prevent subtle bugs

Review changes for safe shipping with clear versioning, rollout, migration, and rollback plans

Review code for reliability, failure modes, and operational safety under partial outages

Review code for scalability issues under higher load, larger datasets, and more tenants

Review code for vulnerabilities, insecure defaults, and missing security controls

Enforce consistency with existing codebase style and language idioms to reduce cognitive load

Review dependency and build integrity risks, lockfiles, build scripts, and artifact provenance

Review test quality, coverage, and reliability to ensure changes are well-verified

Review user-facing text for clarity, consistency, actionability, and helpful error recovery

Slice large initiatives into shippable milestones with clear MVP

Set up wide-event logging with tail sampling to replace scattered logs with canonical log lines

Behavior-driven test matrix with unit/integration/contract/e2e mapping, CI budget analysis, and coverage gap identification

Triage and categorize pending findings in the file-based todo system

Generate comprehensive user-facing documentation from codebase analysis and docs review

Use this agent when you need to analyze code changes from an architectural perspective, evaluate system design decisions, or ensure that modifications align with established architectural patterns. This includes reviewing pull requests for architectural compliance, assessing the impact of new features on system structure, or validating that changes maintain proper component boundaries and design principles. <example>Context: The user wants to review recent code changes for architectural compliance. user: "I just refactored the authentication service to use a new pattern" assistant: "I'll use the architecture-strategist agent to review these changes from an architectural perspective" <commentary>Since the user has made structural changes to a service, use the architecture-strategist agent to ensure the refactoring aligns with system architecture.</commentary></example><example>Context: The user is adding a new microservice to the system. user: "I've added a new notification service that integrates with our existing services" assistant: "Let me analyze this with the architecture-strategist agent to ensure it fits properly within our system architecture" <commentary>New service additions require architectural review to verify proper boundaries and integration patterns.</commentary></example>

Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles. Examples: <example>Context: The user has just implemented a new feature and wants to ensure it's as simple as possible. user: "I've finished implementing the user authentication system" assistant: "Great! Let me review the implementation for simplicity and minimalism using the code-simplicity-reviewer agent" <commentary>Since implementation is complete, use the code-simplicity-reviewer agent to identify simplification opportunities.</commentary></example> <example>Context: The user has written complex business logic and wants to simplify it. user: "I think this order processing logic might be overly complex" assistant: "I'll use the code-simplicity-reviewer agent to analyze the complexity and suggest simplifications" <commentary>The user is explicitly concerned about complexity, making this a perfect use case for the code-simplicity-reviewer.</commentary></example>

You are the voice of every opinionated framework creator - DHH, Taylor Otwell, Guillermo Rauch, Adrian Holovaty - reviewing code and architectural decisions. You embody the philosophy: "The framework is omakase. Trust the chef. Convention over configuration. The majestic monolith."

Use this agent when you need to analyze code for design patterns, anti-patterns, naming conventions, and code duplication. This agent excels at identifying architectural patterns, detecting code smells, and ensuring consistency across the codebase. <example>Context: The user wants to analyze their codebase for patterns and potential issues. user: "Can you check our codebase for design patterns and anti-patterns?" assistant: "I'll use the pattern-recognition-specialist agent to analyze your codebase for patterns, anti-patterns, and code quality issues." <commentary>Since the user is asking for pattern analysis and code quality review, use the Task tool to launch the pattern-recognition-specialist agent.</commentary></example><example>Context: After implementing a new feature, the user wants to ensure it follows established patterns. user: "I just added a new service layer. Can we check if it follows our existing patterns?" assistant: "Let me use the pattern-recognition-specialist agent to analyze the new service layer and compare it with existing patterns in your codebase." <commentary>The user wants pattern consistency verification, so use the pattern-recognition-specialist agent to analyze the code.</commentary></example>

Use this agent when you need to analyze code for performance issues, optimize algorithms, identify bottlenecks, or ensure scalability. This includes reviewing database queries, memory usage, caching strategies, and overall system performance. The agent should be invoked after implementing features or when performance concerns arise. <example> Context: The user has just implemented a new feature that processes user data. user: "I've implemented the user analytics feature. Can you check if it will scale?" assistant: "I'll use the performance-oracle agent to analyze the scalability and performance characteristics of your implementation." <commentary> Since the user is concerned about scalability, use the Task tool to launch the performance-oracle agent to analyze the code for performance issues. </commentary> </example> <example> Context: The user is experiencing slow API responses. user: "The API endpoint for fetching reports is taking over 2 seconds to respond" assistant: "Let me invoke the performance-oracle agent to identify the performance bottlenecks in your API endpoint." <commentary> The user has a performance issue, so use the performance-oracle agent to analyze and identify bottlenecks. </commentary> </example> <example> Context: After writing a data processing algorithm. user: "I've written a function to match users based on their preferences" assistant: "I've implemented the matching function. Now let me use the performance-oracle agent to ensure it will scale efficiently." <commentary> After implementing an algorithm, proactively use the performance-oracle agent to verify its performance characteristics. </commentary> </example>

Use this agent when you need to perform security audits, vulnerability assessments, or security reviews of code. This includes checking for common security vulnerabilities, validating input handling, reviewing authentication/authorization implementations, scanning for hardcoded secrets, and ensuring OWASP compliance. <example>Context: The user wants to ensure their newly implemented API endpoints are secure before deployment. user: "I've just finished implementing the user authentication endpoints. Can you check them for security issues?" assistant: "I'll use the security-sentinel agent to perform a comprehensive security review of your authentication endpoints." <commentary>Since the user is asking for a security review of authentication code, use the security-sentinel agent to scan for vulnerabilities and ensure secure implementation.</commentary></example> <example>Context: The user is concerned about potential SQL injection vulnerabilities in their database queries. user: "I'm worried about SQL injection in our search functionality. Can you review it?" assistant: "Let me launch the security-sentinel agent to analyze your search functionality for SQL injection vulnerabilities and other security concerns." <commentary>The user explicitly wants a security review focused on SQL injection, which is a core responsibility of the security-sentinel agent.</commentary></example> <example>Context: After implementing a new feature, the user wants to ensure no sensitive data is exposed. user: "I've added the payment processing module. Please check if any sensitive data might be exposed." assistant: "I'll deploy the security-sentinel agent to scan for sensitive data exposure and other security vulnerabilities in your payment processing module." <commentary>Payment processing involves sensitive data, making this a perfect use case for the security-sentinel agent to identify potential data exposure risks.</commentary></example>

You are a super senior developer with impeccable taste and an exceptionally high bar for code quality. You review all code changes with a keen eye for conventions, clarity, and maintainability - regardless of language or framework.

Senior engineer review specialist for thorough file-by-file code review. Spawned by review skills to perform comprehensive reviews.

This skill should be used when analyzing errors, stack traces, and logs to identify root causes and implement fixes.

This skill should be used when managing the file-based todo tracking system in the .claude/todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

This skill should be used when writing code in any opinionated framework's distinctive style. It applies when writing framework-based applications, creating models/controllers/views, or any framework code. Triggers on code generation, refactoring requests, code review, or when the user mentions framework conventions. Embodies the philosophy of embracing framework conventions, fighting complexity, and choosing simplicity over cleverness.

This skill provides patterns for safe, systematic refactoring including extract, rename, move, and simplification operations with proper testing and rollback strategies.

Comprehensive code review running all 30 review commands in parallel

Architecture-focused review running 4 architecture review commands in parallel

Infrastructure-focused review running 6 infrastructure review commands in parallel

Pre-merge review running 5 critical review commands in parallel

Quick code review running 5 essential review commands in parallel

Security-focused review running 5 security review commands in parallel

UX-focused review running 4 user experience review commands in parallel

This skill provides patterns and best practices for generating and organizing tests. It covers unit testing, integration testing, test data factories, and coverage strategies across multiple languages and frameworks.

Design and implement wide-event logging with tail sampling for context-rich, queryable observability