jacked

Use after adding several rules to CLAUDE.md, or when rules feel contradictory or stale. Audits for duplicates, contradictions, and vague directives. Companion to /learn.

Use before and after performance-sensitive changes. Captures web performance metrics, compares against baselines, flags regressions.

Use when browser MCP tools are failing, stuck, or unresponsive. Diagnoses connection issues, kills stale processes, and tests connectivity.

Use after a production deploy to monitor for regressions. Takes periodic screenshots, checks console errors, and compares performance against baselines.

Use after implementing security-sensitive changes — auth, RBAC, multi-tenancy, billing, credential handling. Systematic OWASP Top 10 + STRIDE threat model analysis.

Use this agent when you need to review recently written code changes with a focus on simplicity, readability, and future-proofing. This agent excels at identifying overly complex implementations and suggesting cleaner, more maintainable alternatives that accomplish the same goals. Perfect for post-implementation reviews, refactoring sessions, or when you want to ensure your code is easily understood by other developers. Examples: <example> Context: The user wants to review code they just wrote for simplicity and readability. user: "I just implemented a new feature for processing medical claims. Can you review it?" assistant: "I'll use the code-simplicity-reviewer agent to analyze your recent changes and suggest simpler approaches." <commentary> Since the user has written new code and wants a review focused on simplicity, use the code-simplicity-reviewer agent. </commentary> </example> <example> Context: After completing a complex implementation. user: "I've finished the reflexive batch processing logic but it feels complicated." assistant: "Let me use the code-simplicity-reviewer agent to examine your implementation and identify opportunities for simplification." <commentary> The user has completed code and is concerned about complexity, making this perfect for the code-simplicity-reviewer agent. </commentary> </example>

Use this agent when you need to review code for error handling, add comprehensive error management, or audit existing code for potential failure points. This agent excels at identifying missing error handling, suggesting custom exception hierarchies, and implementing defensive programming patterns. Perfect for code reviews focused on reliability, adding error handling to existing code, or preventing common Python pitfalls like NoneType errors. Examples: - <example> Context: The user wants to review recently written code for error handling issues. user: "I just implemented a new API client module" assistant: "Let me review this code for error handling and defensive programming practices" <commentary> Since new code was written, use the defensive-error-handler agent to review for potential error scenarios and suggest improvements. </commentary> </example> - <example> Context: The user is concerned about error handling in their codebase. user: "Can you check if we're properly handling errors in our data processing pipeline?" assistant: "I'll use the defensive-error-handler agent to audit the error handling in your data processing code" <commentary> The user explicitly wants error handling reviewed, so use the defensive-error-handler agent. </commentary> </example> - <example> Context: After implementing new functionality. user: "I've added the new claim validation logic" assistant: "Now let me review this for proper error handling and defensive programming" <commentary> New code should be reviewed for error handling, use the defensive-error-handler agent. </commentary> </example>

Use this agent when you've completed a design document, planning session, or code implementation and want a fresh, critical review. This agent operates in two modes: (1) Design Review Mode - when the recent work involved creating specs, design docs, or planning for features/bugs/enhancements, it performs independent research and validates assumptions; (2) Code Review Mode - when recent work involved actual implementation, it acts as CTO/CSO reviewing for security vulnerabilities, auth gaps, cross-org data leaks, and architectural soundness. Examples:\n\n<example>\nContext: User just finished creating a design document for a new billing export feature.\nuser: "Okay I think that design doc looks good, let's move on"\nassistant: "Hold up - before we proceed, let me use the double-check-reviewer agent to validate this design with fresh eyes and independent research."\n<commentary>\nSince the user just completed a design document, use the double-check-reviewer agent in Design Review Mode to independently validate assumptions and research alternatives.\n</commentary>\n</example>\n\n<example>\nContext: User just implemented several new API endpoints and database queries for multi-tenant data access.\nuser: "Alright that implementation is done, what's next?"\nassistant: "Before we move forward, I'm going to spin up the double-check-reviewer agent to do a security and architecture review of what we just built."\n<commentary>\nSince the user just wrote implementation code with multi-tenant implications, use the double-check-reviewer agent in Code Review Mode to audit for security, auth, and data isolation issues.\n</commentary>\n</example>\n\n<example>\nContext: User completed a feature implementation touching auth routes and user data.\nuser: "double check this"\nassistant: "On it - launching the double-check-reviewer to give this implementation the CTO/CSO treatment."\n<commentary>\nExplicit request for review after code implementation - use the double-check-reviewer agent in Code Review Mode.\n</commentary>\n</example>

Use this agent when you need help managing git branches, commits, and pull requests to maintain clean, reviewable code submissions. This includes: creating new branches for features or bug fixes, determining when to split work into separate PRs, writing comprehensive PR descriptions and commit messages, analyzing uncommitted changes to suggest logical groupings, and ensuring PRs stay focused and manageable in size (typically under 200-300 lines of changes). <example> Context: The user has been making multiple code changes with Claude and wants to organize them into proper PRs. user: "I've made a bunch of changes to the codebase - added a new reflexive processing feature, fixed several bugs in the ICD validation, and updated some documentation. Help me organize this into PRs" assistant: "I'll use the git-pr-workflow-manager agent to analyze your changes and create a proper branching and PR strategy" <commentary> Since the user has multiple types of changes that need to be organized into separate, reviewable PRs, use the git-pr-workflow-manager agent. </commentary> </example> <example> Context: User is about to start implementing a major new feature. user: "I'm going to add a new specialty module for cardiology to the KRAC system" assistant: "Let me use the git-pr-workflow-manager agent to help you set up the right branch structure before you start" <commentary> Since this is a major new feature that will need its own branch and PR, use the git-pr-workflow-manager agent to establish proper workflow from the start. </commentary> </example> <example> Context: User has been fixing bugs and wants to submit changes. user: "I've fixed 5 different bugs in the validation pipeline. Should I commit these?" assistant: "I'll use the git-pr-workflow-manager agent to help you organize these bug fixes into a proper PR" <commentary> Multiple bug fixes need to be properly documented and submitted as a cohesive PR, so use the git-pr-workflow-manager agent. </commentary> </example>

Use this agent when you need to manage GitHub issues and pull requests in a coordinated manner. This includes scanning open issues, analyzing and grouping related issues for efficient resolution, managing PR workflows, and ensuring proper issue tracking throughout the development cycle. The agent excels at identifying which issues can be resolved together, creating well-structured PRs, and maintaining clear communication about work progress. Examples: - <example> Context: User wants to review and organize their GitHub issues to work on them efficiently. user: "Can you help me organize my open GitHub issues and suggest which ones I should work on together?" assistant: "I'll use the issue-pr-coordinator agent to analyze your open issues and suggest logical groupings." <commentary> The user needs help organizing GitHub issues, which is exactly what the issue-pr-coordinator agent is designed for. </commentary> </example> - <example> Context: User has multiple related bug fixes and wants to create a PR. user: "I've fixed several related bugs in the authentication module. Can you help me create a proper PR?" assistant: "Let me use the issue-pr-coordinator agent to help you create a well-structured PR with proper issue linking." <commentary> Creating PRs with proper issue linking and organization is a core function of the issue-pr-coordinator agent. </commentary> </example> - <example> Context: User wants to check the status of their repository's issues and PRs. user: "What's the current state of our open issues and PRs?" assistant: "I'll launch the issue-pr-coordinator agent to scan and analyze your repository's current status." <commentary> Checking repository status and providing organized summaries is within the issue-pr-coordinator agent's capabilities. </commentary> </example>

Use when CLAUDE.md feels bloated or too long, when starting a new project, or when optimizing documentation for token efficiency. Audits content quality, extracts reference material to sub-docs, and enforces a token budget.

Use after implementing a feature, fixing a bug, or completing any non-trivial code change. Recursive multi-lens review that continues until all selected lenses pass clean.

Use when a branch has code changes that may have made documentation stale, after completing a feature, or before creating a PR. Diffs branch against base and maps changes to affected docs.

Use when starting any significant feature or non-trivial task that deserves a thorough development cycle. Triggers on "jack it up", "do this right", "full cycle", "build this properly", or when the user wants quality-first development over speed.

Use when the user mentions a past project like "configurator", asks to continue/resume previous work, says "how did I do X before", references past sessions, or starts work on a feature that may have been done before. Searches and loads context from past Claude Code sessions.