Agent Reference

Your senior Rails developer who's seen too many "clever" solutions fail in production. Obsessed with code that's boring, predictable, and maintainable. Strict on existing code (because touching it risks everything), pragmatic on new isolated features (because shipping matters). If you've ever thought "this works but feels wrong," this reviewer will tell you why.

Key Principles

• Existing Code Modifications - Very strict. Added complexity needs strong justification.
• New Code - Pragmatic. If it's isolated and works, it's acceptable.
• Turbo Streams - Simple turbo streams MUST be inline arrays in controllers.
• Testing as Quality - Hard-to-test code = poor structure that needs refactoring.
• Naming (5-Second Rule) - Must understand what a view/component does in 5 seconds from its name.
• Namespacing - Always use class Module::ClassName pattern.
• Duplication > Complexity - Simple duplicated code is better than complex DRY abstractions.

claude agent kieran-rails-reviewer "Review the UserController"

What if DHH reviewed your Rails PR? He'd ask why you're building React inside Rails, why you need six layers of abstraction for a form, and whether you've forgotten that Rails already solved this problem. This agent channels that energy—blunt, opinionated, allergic to complexity.

Key Focus Areas

• Identifies deviations from Rails conventions
• Spots JavaScript framework patterns infiltrating Rails
• Tears apart unnecessary abstractions
• Challenges overengineering and microservices mentality

claude agent dhh-rails-reviewer

Your Pythonic perfectionist who believes type hints aren't optional and dict.get() beats try/except KeyError. Expects modern Python 3.10+ patterns—no legacy syntax, no typing.List when list works natively. If your code looks like Java translated to Python, prepare for rewrites.

Key Focus Areas

• Type hints for all functions
• Pythonic patterns and idioms
• Modern Python syntax
• Import organization
• Module extraction signals

claude agent kieran-python-reviewer

TypeScript's type system is a gift—don't throw it away with any. This reviewer treats any like a code smell that needs justification. Expects proper types, clean imports, and code that doesn't need comments because the types explain everything. You added TypeScript for safety; this agent makes sure you actually get it.

Key Focus Areas

• No any without justification
• Component/module extraction signals
• Import organization
• Modern TypeScript patterns
• Testability assessment

claude agent kieran-typescript-reviewer

Security vulnerabilities hide in boring code—the "just grab the user ID from params" line that ships a privilege escalation bug to production. This agent thinks like an attacker: SQL injection, XSS, auth bypass, leaked secrets. Run it before touching authentication, payments, or anything with PII. Your users' data depends on paranoia.

Security Checks

• Input validation analysis
• SQL injection risk assessment
• XSS vulnerability detection
• Authentication/authorization audit
• Sensitive data exposure scanning
• OWASP Top 10 compliance
• Hardcoded secrets search

claude agent security-sentinel "Audit the payment flow"

Your code works fine with 10 users. What happens at 10,000? This agent time-travels to your future scaling problems—N+1 queries that murder your database, O(n²) algorithms hiding in loops, missing indexes, memory leaks. It thinks in Big O notation and asks uncomfortable questions about what breaks first when traffic spikes.

Analysis Areas

• Algorithmic complexity (Big O notation)
• N+1 query pattern detection
• Proper index usage verification
• Memory management review
• Caching opportunity identification
• Network usage optimization
• Frontend bundle impact

claude agent performance-oracle

Every "small change" either reinforces your architecture or starts eroding it. This agent zooms out to see if your fix actually fits the system's design—or if you're bolting duct tape onto a crumbling foundation. It speaks SOLID principles, microservice boundaries, and API contracts. Call it when you're about to make a change that "feels weird."

Analysis Areas

• Overall system structure understanding
• Change context within architecture
• Architectural violation identification
• SOLID principles compliance
• Microservice boundary assessment
• API contract evaluation

claude agent architecture-strategist

Migrations can't be rolled back once they're run on production. This agent is your last line of defense before you accidentally drop a column with user data, create a race condition in transactions, or violate GDPR. It obsesses over referential integrity, rollback safety, and data constraints. Your database is forever; migrations should be paranoid.

Review Areas

• Migration safety and reversibility
• Data constraint validation
• Transaction boundary review
• Referential integrity preservation
• Privacy compliance (GDPR, CCPA)
• Data corruption scenario checking

claude agent data-integrity-guardian

Patterns tell stories—Factory, Observer, God Object, Copy-Paste Programming. This agent reads your code like an archaeologist reading artifacts. It spots the good patterns (intentional design), the anti-patterns (accumulated tech debt), and the duplicated blocks you swore you'd refactor later. Runs tools like jscpd because humans miss repetition that machines catch instantly.

Detection Areas

• Design patterns (Factory, Singleton, Observer, etc.)
• Anti-patterns and code smells
• TODO/FIXME comments
• God objects and circular dependencies
• Naming consistency
• Code duplication

claude agent pattern-recognition-specialist

Simplicity is violent discipline. This agent asks "do you actually need this?" about every line, every abstraction, every dependency. YAGNI isn't a suggestion—it's the law. Your 200-line feature with three layers of indirection? This agent will show you the 50-line version that does the same thing. Complexity is a liability; simplicity compounds.

Simplification Checks

• Analyze every line for necessity
• Simplify complex logic
• Remove redundancy and duplication
• Challenge abstractions
• Optimize for readability
• Eliminate premature generalization

claude agent code-simplicity-reviewer

Official docs are scattered. GitHub examples are inconsistent. Deprecations hide in changelogs. This agent pulls it all together—docs, source code, version constraints, real-world examples. Ask "how do I use Hotwire Turbo?" and get back patterns that actually work in production, not toy tutorials.

Capabilities

• Fetch official framework and library documentation
• Identify version-specific constraints and deprecations
• Search GitHub for real-world usage examples
• Analyze gem/library source code using bundle show
• Synthesize findings with practical examples

claude agent framework-docs-researcher "Research Hotwire Turbo patterns"

"Best practices" are everywhere and contradictory. This agent cuts through the noise by evaluating sources (official docs, trusted blogs, real GitHub repos), checking recency, and synthesizing actionable guidance. You get code templates, patterns that scale, and answers you can trust—not StackOverflow copy-paste roulette.

Capabilities

• Leverage multiple sources (Context7 MCP, web search, GitHub)
• Evaluate information quality and recency
• Synthesize into actionable guidance
• Provide code examples and templates
• Research issue templates and community engagement

claude agent best-practices-researcher "Find pagination patterns"

Your codebase has a history—decisions, patterns, mistakes. This agent does archaeology with git tools: file evolution, blame analysis, contributor expertise mapping. Ask "why does this code exist?" and get the commit that explains it. Spot patterns in how bugs appear. Understand the design decisions buried in history.

Analysis Techniques

• Trace file evolution using git log --follow
• Determine code origins using git blame -w -C -C -C
• Identify patterns from commit history
• Map key contributors and expertise areas
• Extract historical patterns of issues and fixes

claude agent git-history-analyzer "Analyze changes to User model"

Every repo has conventions—some documented, most tribal knowledge. This agent reads ARCHITECTURE.md, issue templates, PR patterns, and actual code to reverse-engineer the standards. Perfect for joining a new project or ensuring your PR matches the team's implicit style. Finds the rules nobody wrote down.

Analysis Areas

• Architecture and documentation files (ARCHITECTURE.md, README.md, CLAUDE.md)
• GitHub issues for patterns and conventions
• Issue/PR templates and guidelines
• Implementation patterns using ast-grep or rg
• Project-specific conventions

claude agent repo-research-analyst

Half of bug reports aren't bugs—they're user errors, environment issues, or misunderstood features. This agent systematically reproduces the reported behavior, classifies what it finds (Confirmed, Can't Reproduce, Not a Bug, etc.), and assesses severity. Saves you from chasing ghosts or missing real issues.

Classification Types

• Confirmed - Bug reproduced successfully
• Cannot Reproduce - Unable to reproduce
• Not a Bug - Expected behavior
• Environmental - Environment-specific issue
• Data - Data-related issue
• User Error - User misunderstanding

claude agent bug-reproduction-validator

Code review comments pile up. This agent reads them, plans fixes, implements changes, and reports back what it did. It doesn't argue with reviewers or skip hard feedback—it just resolves the work systematically. Great for burning through a dozen "change this variable name" comments in seconds.

Workflow

• Analyze code review comments
• Plan the resolution before implementation
• Implement requested modifications
• Verify resolution doesn't break functionality
• Provide clear resolution reports

claude agent pr-comment-resolver

Linters are pedantic robots that enforce consistency. This agent runs StandardRB, ERBLint, and Brakeman for you—checking Ruby style, ERB templates, and security issues. It's fast (uses the Haiku model) and catches the formatting noise before CI does.

Tools Run

• bundle exec standardrb - Ruby file checking/fixing
• bundle exec erblint --lint-all - ERB templates
• bin/brakeman - Security scanning

claude agent lint

Specs always have gaps—edge cases nobody thought about, ambiguous requirements, missing error states. This agent maps all possible user flows, identifies what's unclear or missing, and generates the questions you need to ask stakeholders. Runs before you code to avoid building the wrong thing.

Analysis Areas

• Map all possible user flows and permutations
• Identify gaps, ambiguities, and missing specifications
• Consider different user types, roles, permissions
• Analyze error states and edge cases
• Generate critical questions requiring clarification

claude agent spec-flow-analyzer

Style guides are arbitrary rules that make writing consistent. This agent enforces Every's particular quirks—title case in headlines, no overused filler words ("actually," "very"), active voice, Oxford commas. It's a line-by-line grammar cop for content that needs to match the brand.

Style Checks

• Title case in headlines, sentence case elsewhere
• Company singular/plural usage
• Remove overused words (actually, very, just)
• Enforce active voice
• Apply formatting rules (Oxford commas, em dashes)

claude agent every-style-editor

Design doesn't happen in one pass. This agent runs a loop: screenshot the UI, analyze what's off (spacing, colors, alignment), implement 3-5 targeted fixes, repeat. Run it for 10 iterations and watch rough interfaces transform into polished designs through systematic refinement.

Process

• Take focused screenshots of target elements
• Analyze current state and identify 3-5 improvements
• Implement targeted CSS/design changes
• Document changes made
• Repeat for specified iterations (default 10)

claude agent design-iterator

Designers hand you a Figma file. You build it. Then: "the spacing is wrong, the font is off, the colors don't match." This agent compares your implementation to the Figma spec, identifies every visual discrepancy, and fixes them automatically. Designers stay happy. You stay sane.

Workflow

• Extract design specifications from Figma
• Capture implementation screenshots
• Conduct systematic visual comparison
• Make precise code changes to fix discrepancies
• Verify implementation matches design

claude agent figma-design-sync

Before you ship UI changes, run this agent. It compares your implementation against Figma at a pixel level—layouts, typography, colors, spacing, responsive behavior. Uses the Opus model for detailed visual analysis. Catches the "close enough" mistakes that users notice but you don't.

Comparison Areas

• Layouts and structure
• Typography (fonts, sizes, weights)
• Colors and themes
• Spacing and alignment
• Different viewport sizes

claude agent design-implementation-reviewer

Andrew Kane writes READMEs that are models of clarity—concise, scannable, zero fluff. This agent generates gem documentation in that style: 15 words max per sentence, imperative voice, single-purpose code examples. If your README rambles, this agent will fix it.

Section Order

1. Header (title + description)
2. Installation
3. Quick Start
4. Usage
5. Options
6. Upgrading
7. Contributing
8. License

Style Guidelines

• Imperative voice throughout
• 15 words max per sentence
• Single-purpose code fences
• Up to 4 badges maximum
• No HTML comments

claude agent ankane-readme-writer