Specialized AI Agents
++ Instead of one generalist AI, Amplifier provides 20+ specialized agents, each expert in specific domains. + Each agent brings focused expertise, proven patterns, and domain-specific knowledge to accelerate your development. +
+🏗️ Core Development
++ Agents focused on building, architecting, and maintaining code with best practices and proven patterns. +
++ The master architect who embodies ruthless simplicity and Wabi-sabi philosophy. Operates in three powerful modes: + ANALYZE for problem decomposition, ARCHITECT for system design, and REVIEW for code quality assessment. + Creates clear specifications that guide implementation, focusing on essential patterns over unnecessary abstractions. +
+Key Capabilities
+-
+
- Analysis-first development approach +
- Modular "bricks & studs" architecture +
- Clean contract specifications +
- Complexity elimination strategies +
- 80/20 principle application +
- Philosophy compliance review +
📚 Practical Examples (click to expand)
+🎯 Simple: Design a New Feature
+"Use zen-architect to design a user notification system"+
→ Returns: Problem analysis, 3 solution approaches with trade-offs, modular specification
+🔧 Intermediate: Architecture Review
+"Have zen-architect review the auth module for complexity and suggest simplifications"+
→ Returns: Complexity score, philosophy alignment, specific refactoring recommendations
+🚀 Advanced: System Redesign
+"zen-architect: Analyze our monolithic app and design a modular migration strategy with clear boundaries"+
→ Returns: Module boundaries, migration phases, contract specifications, dependency graph
+🤝 Works Best With
+-
+
- modular-builder: Implements zen-architect's specifications +
- bug-hunter: Validates architectural decisions work correctly +
- api-contract-designer: Detailed API design after system architecture +
💡 Pro Tips
+-
+
- Always let zen-architect analyze before implementing +
- Request REVIEW mode for existing code assessment +
- Use for "stuck" moments - finds simpler paths +
- Specifications can be regenerated if requirements change +
+ The implementation specialist that builds from specifications with precision. Creates self-contained modules with clear boundaries, + automated testing, and regeneration-ready code. Follows the "bricks & studs" philosophy where each module is a complete, replaceable unit. +
+Key Capabilities
+-
+
- Contract-first implementation +
- Self-contained module creation +
- Automated conformance testing +
- Public/private interface separation +
- Regeneration-friendly structure +
- Test-driven development +
📚 Practical Examples
+🎯 Simple: Build from Spec
+"modular-builder: Implement the user authentication module from zen-architect's spec"+
→ Creates: Module structure, public API, tests, documentation
+🔧 Intermediate: Parallel Variants
+"Use modular-builder to create two cache implementations: Redis-based and in-memory"+
→ Creates: Two parallel modules with same contract, different implementations
+🚀 Advanced: Full Workflow
+"modular-builder: Build the payment processing module with Stripe integration, including retry logic, webhook handling, and comprehensive tests"+
→ Creates: Complete module with external integration, error handling, tests, fixtures
+🤝 Integration Workflow
+Complete Development Flow:
+1. zen-architect analyzes and creates spec +2. modular-builder implements from spec +3. test-coverage verifies edge cases +4. bug-hunter validates implementation +5. post-task-cleanup ensures hygiene+
+ The systematic debugger that finds root causes, not just symptoms. Uses pattern recognition, binary search debugging, + and proven methodologies. Tracks down race conditions, memory leaks, and those "impossible" bugs that only happen in production. +
+Key Capabilities
+-
+
- 5-why root cause analysis +
- Pattern-based bug detection +
- Binary search debugging +
- Race condition identification +
- Memory leak detection +
- Production issue diagnosis +
- Fix verification strategies +
📚 Practical Examples
+🎯 Simple: API Failure
+"bug-hunter: Find why POST /api/users returns 500 errors intermittently"+
→ Analyzes: Request patterns, error logs, database state, identifies root cause
+🔧 Intermediate: Performance Issue
+"Use bug-hunter to diagnose why the app slows down after 2 hours of runtime"+
→ Investigates: Memory patterns, connection pools, cache behavior, finds leak
+🚀 Advanced: Race Condition
+"bug-hunter: Users report duplicate charges but we can't reproduce it locally"+
→ Deploys: Timing analysis, transaction logs, identifies race window, provides fix
+⚠️ When to Use
+-
+
- Intermittent failures that are hard to reproduce +
- Performance degradation over time +
- "Works on my machine" problems +
- After deployment when issues surface +
- Complex multi-component failures +
+ The testing strategist that thinks like a hacker, user, and maintainer simultaneously. Identifies edge cases others miss, + builds comprehensive test pyramids (60% unit, 30% integration, 10% E2E), and ensures your code handles the unexpected gracefully. +
+Key Capabilities
+-
+
- Test pyramid strategy (60/30/10) +
- Edge case discovery +
- Mutation testing insights +
- Property-based test generation +
- Coverage gap analysis +
- Test fixture creation +
- Performance test design +
📚 Practical Examples
+🎯 Simple: Add Missing Tests
+"test-coverage: Add comprehensive tests for the UserService class"+
→ Creates: Unit tests, edge cases, mocks, fixtures, 90%+ coverage
+🔧 Intermediate: Integration Testing
+"Have test-coverage design integration tests for our payment flow with Stripe"+
→ Creates: API mocks, webhook tests, error scenarios, retry logic tests
+🚀 Advanced: Chaos Engineering
+"test-coverage: Create resilience tests simulating network failures, timeouts, and data corruption"+
→ Creates: Failure injection tests, recovery verification, monitoring checks
+🎯 Edge Cases to Test
+-
+
- Null, undefined, empty inputs +
- Boundary values (0, -1, MAX_INT) +
- Concurrent access scenarios +
- Network timeouts and retries +
- Malformed data handling +
- Permission and auth failures +
+ The API architect who designs contracts developers love. Creates consistent, intuitive APIs with proper versioning, + comprehensive error handling, and evolution strategies. Follows REST principles while pragmatically breaking them when it makes sense. +
+Key Capabilities
+-
+
- RESTful design principles +
- OpenAPI/Swagger specifications +
- Semantic versioning strategies +
- Idempotency patterns +
- Rate limiting design +
- Error response standards +
- HATEOAS when appropriate +
📚 Practical Examples
+🎯 Simple: CRUD Endpoints
+"api-contract-designer: Design REST endpoints for user management"+
→ Returns: OpenAPI spec, endpoints, status codes, request/response schemas
+🔧 Intermediate: Webhook System
+"Use api-contract-designer to create webhook contracts with retry and verification"+
→ Returns: Webhook payload specs, HMAC verification, retry policies, event types
+🚀 Advanced: API Evolution
+"api-contract-designer: Migrate v1 API to v2 with backward compatibility and deprecation strategy"+
→ Returns: Migration path, compatibility layer, deprecation timeline, client upgrade guide
+✅ API Best Practices
+-
+
- Use consistent naming (camelCase or snake_case) +
- Version via URL path (/v1/) or headers +
- Return proper HTTP status codes +
- Include request IDs for tracing +
- Implement pagination for lists +
- Use ISO 8601 for dates +
🔍 Analysis & Optimization
++ Agents specialized in security analysis, performance optimization, and system analysis for production-ready applications. +
++ The paranoid protector who thinks like an attacker. Performs comprehensive security audits, identifies OWASP Top 10 vulnerabilities, + and ensures defense-in-depth. Reviews authentication, authorization, data protection, and input validation with zero-trust mindset. +
+Key Capabilities
+-
+
- OWASP Top 10 vulnerability detection +
- Authentication & authorization review +
- SQL injection & XSS prevention +
- Secrets management audit +
- Encryption implementation review +
- API security assessment +
- Dependency vulnerability scanning +
📚 Practical Examples
+🎯 Simple: Auth Review
+"security-guardian: Review the login endpoint for security vulnerabilities"+
→ Checks: Password hashing, rate limiting, session management, CSRF protection
+🔧 Intermediate: API Security
+"Have security-guardian audit our REST API for authorization bypasses and data leaks"+
→ Analyzes: IDOR vulnerabilities, permission checks, data exposure, rate limits
+🚀 Advanced: Full Audit
+"security-guardian: Perform complete security audit including dependencies, secrets, and infrastructure"+
→ Delivers: Vulnerability report, risk matrix, remediation priorities, security roadmap
+🛡️ Security Checklist
+-
+
- ✓ Input validation on all user data +
- ✓ Parameterized queries (no SQL injection) +
- ✓ XSS protection (output encoding) +
- ✓ HTTPS everywhere +
- ✓ Secure session management +
- ✓ Rate limiting on all endpoints +
- ✓ Secrets in environment variables +
- ✓ Dependency vulnerability scanning +
+ The speed demon who makes everything faster. Identifies bottlenecks through profiling, implements caching strategies, + optimizes algorithms from O(n²) to O(n log n), and knows when to trade memory for speed. Thinks in microseconds, not milliseconds. +
+Key Capabilities
+-
+
- CPU & memory profiling +
- Algorithm complexity analysis +
- Database query optimization +
- Caching strategy design +
- Lazy loading implementation +
- Async/parallel processing +
- Memory leak detection +
📚 Practical Examples
+🎯 Simple: Slow Endpoint
+"performance-optimizer: The /api/search endpoint takes 5 seconds to respond"+
→ Optimizes: Adds indexes, implements caching, reduces N+1 queries
+🔧 Intermediate: Memory Issues
+"Use performance-optimizer to fix high memory usage in data processing pipeline"+
→ Implements: Streaming, chunking, garbage collection optimization, memory pools
+🚀 Advanced: System-Wide
+"performance-optimizer: Achieve 10x performance improvement for real-time analytics"+
→ Delivers: Architecture changes, caching layers, async processing, horizontal scaling
+⚡ Performance Targets
+-
+
- API response: < 200ms (p95) +
- Database queries: < 100ms +
- Page load: < 3 seconds +
- Memory usage: < 512MB baseline +
- CPU usage: < 70% sustained +
+ The data strategist who designs schemas that scale from 100 to 100 million records. Masters both SQL and NoSQL, + knows when to normalize vs denormalize, and creates migration strategies that work without downtime. +
+Key Capabilities
+-
+
- Schema design & normalization +
- Index optimization strategies +
- Query performance tuning +
- Sharding & partitioning +
- Migration without downtime +
- SQL vs NoSQL selection +
- Transaction design +
📚 Practical Examples
+🎯 Simple: Schema Design
+"database-architect: Design schema for e-commerce order system"+
→ Creates: Tables, relationships, indexes, constraints, sample queries
+🔧 Intermediate: Performance Fix
+"Have database-architect optimize our slow reporting queries (taking 30+ seconds)"+
→ Analyzes: Execution plans, adds indexes, rewrites queries, suggests materialized views
+🚀 Advanced: Scale Strategy
+"database-architect: Plan migration from single PostgreSQL to sharded cluster for 10x growth"+
→ Designs: Sharding strategy, migration phases, zero-downtime cutover, rollback plan
+💡 When to Choose
+-
+
- SQL: Complex relationships, ACID requirements +
- NoSQL: Flexible schema, horizontal scaling +
- Time-series: Metrics, logs, IoT data +
- Graph: Social networks, recommendations +
- Cache: Redis for sessions, hot data +
+ The connectivity expert who makes disparate systems talk seamlessly. Masters retry logic, circuit breakers, + and graceful degradation. Handles authentication flows, webhooks, and rate limits while keeping integrations simple and maintainable. +
+Key Capabilities
+-
+
- REST/GraphQL/gRPC integration +
- OAuth/JWT authentication flows +
- Webhook implementation +
- Circuit breaker patterns +
- Exponential backoff retry +
- Rate limit handling +
- MCP server connections +
📚 Practical Examples
+🎯 Simple: Payment API
+"integration-specialist: Connect to Stripe for payment processing"+
→ Implements: API client, webhook handler, idempotency, error handling
+🔧 Intermediate: Multi-Service
+"Use integration-specialist to orchestrate between CRM, email, and analytics services"+
→ Creates: Service adapters, event bus, failure isolation, monitoring
+🚀 Advanced: MCP Setup
+"integration-specialist: Set up MCP server for knowledge base with SSE events"+
→ Configures: MCP protocol, SSE streams, reconnection logic, state sync
+🔄 Resilience Patterns
+-
+
- Retry with exponential backoff +
- Circuit breaker (fail fast) +
- Bulkhead (isolate failures) +
- Timeout settings per service +
- Graceful degradation +
- Health check endpoints +
🧠 Knowledge & Insights
++ Agents that work with documentation, extract insights, and manage knowledge for better decision-making and learning. +
++ The revolutionary thinker who finds breakthrough connections others miss. Discovers simplification cascades, + identifies meta-patterns across domains, and creates "collision zones" where unrelated ideas spark innovation. + Turns complexity into elegant simplicity. +
+Key Capabilities
+-
+
- Cross-domain pattern recognition +
- Simplification cascade discovery +
- Revolutionary connection finding +
- Meta-pattern identification +
- Collision-zone thinking +
- Complexity reduction strategies +
- Innovation through synthesis +
📚 Practical Examples
+🎯 Simple: Pattern Discovery
+"insight-synthesizer: Find patterns in our error logs and user complaints"+
→ Discovers: Hidden correlations, root patterns, unexpected connections
+🔧 Intermediate: Simplification
+"Use insight-synthesizer to find ways to simplify our 15-module auth system"+
→ Identifies: Redundancies, cascade opportunities, 3-module solution
+🚀 Advanced: Innovation
+"insight-synthesizer: Connect our ML failures, API design, and UI issues to find breakthrough"+
→ Reveals: Meta-pattern, revolutionary approach, 10x simplification
+💡 When to Deploy
+-
+
- Stuck on complex problems +
- Need fresh perspective +
- Seeking radical simplification +
- Cross-domain challenges +
- Innovation opportunities +
- Pattern recognition tasks +
+ The time traveler who excavates the fossil record of ideas. Traces how concepts evolved, why paradigms shifted, + and which abandoned approaches might solve today's problems. Preserves institutional knowledge and prevents repeating past mistakes. +
+Key Capabilities
+-
+
- Temporal knowledge analysis +
- Decision lineage tracing +
- Paradigm shift documentation +
- Abandoned idea revival +
- Evolution pattern recognition +
- Context reconstruction +
- Institutional memory preservation +
📚 Practical Examples
+🎯 Simple: Decision History
+"knowledge-archaeologist: Why did we choose microservices over monolith?"+
→ Traces: Original requirements, decision points, trade-offs, evolution
+🔧 Intermediate: Pattern Evolution
+"Use knowledge-archaeologist to trace how our API design patterns evolved"+
→ Maps: Pattern genealogy, paradigm shifts, lessons learned, revival opportunities
+🚀 Advanced: Paradigm Analysis
+"knowledge-archaeologist: Find valuable abandoned ideas from our 5-year history"+
→ Discovers: Ahead-of-time ideas, changed contexts, revival candidates
+📜 What It Preserves
+-
+
- Why decisions were made +
- What alternatives were considered +
- Which constraints existed then +
- How requirements evolved +
- When paradigms shifted +
- What lessons were learned +
+ The knowledge miner who transforms documents into structured intelligence. Extracts atomic concepts, maps relationships, + and preserves productive tensions between conflicting viewpoints. Builds queryable knowledge bases from unstructured content. +
+Key Capabilities
+-
+
- Atomic concept extraction +
- Relationship mapping (SPO triples) +
- Tension preservation +
- Knowledge graph building +
- Multi-perspective tracking +
- Contradiction identification +
- Semantic clustering +
📚 Practical Examples
+🎯 Simple: Document Processing
+"concept-extractor: Process this architecture document into concepts"+
→ Extracts: Key concepts, relationships, definitions, dependencies
+🔧 Intermediate: Multi-Document
+"Use concept-extractor on all microservices documentation"+
→ Creates: Unified knowledge graph, service relationships, capability map
+🚀 Advanced: Conflict Analysis
+"concept-extractor: Extract and preserve tensions between these competing proposals"+
→ Maps: Conflicting viewpoints, trade-offs, productive tensions, decision space
+📊 Output Formats
+-
+
- Knowledge graph (NetworkX) +
- SPO triples (subject-predicate-object) +
- Concept hierarchy +
- Relationship matrix +
- Tension points documentation +
- Queryable JSON structure +
+ Preserves productive contradictions and identifies areas where ambiguity might be valuable. + Prevents premature optimization and maintains flexibility where needed. +
+Key Capabilities
+-
+
- Ambiguity identification +
- Flexibility preservation +
- Contradiction analysis +
- Decision deferral strategies +
+ Researches from content collection, finding relevant information and connecting ideas. + Acts as your intelligent research assistant for technical documentation and decisions. +
+Key Capabilities
+-
+
- Content research +
- Information synthesis +
- Relevance analysis +
- Reference tracking +
🔧 Meta & Support
++ Agents that help manage the development environment, create new specialized agents, and maintain codebase hygiene. +
++ The agent creator who designs new specialized experts for your unique needs. Analyzes your workflow, + identifies capability gaps, and creates custom agents with precise expertise. Your personal AI team builder. +
+Key Capabilities
+-
+
- Custom agent creation +
- Expertise specification +
- Workflow gap analysis +
- Tool integration design +
- Prompt engineering +
- Agent testing & validation +
- Performance optimization +
📚 Practical Examples
+🎯 Simple: Framework Expert
+"subagent-architect: Create a React + TypeScript specialist agent"+
→ Creates: Agent with React patterns, hooks expertise, TypeScript best practices
+🔧 Intermediate: Domain Expert
+"Use subagent-architect to build a healthcare compliance agent for HIPAA"+
→ Creates: Specialized agent with regulatory knowledge, audit capabilities
+🚀 Advanced: Workflow Agent
+"subagent-architect: Design multi-agent workflow for continuous deployment pipeline"+
→ Creates: Agent team with build, test, deploy, monitor specializations
+🎯 Agent Design Tips
+-
+
- Start with specific, narrow expertise +
- Define clear trigger conditions +
- Include concrete examples +
- Specify integration points +
- Test with real scenarios +
- Iterate based on performance +
+ The janitor who keeps your codebase pristine. Runs after tasks to remove debug code, eliminate unnecessary complexity, + update documentation, and ensure philosophy compliance. Your automated technical debt preventer. +
+Key Capabilities
+-
+
- Debug artifact removal +
- Complexity elimination +
- Documentation sync +
- Import optimization +
- Dead code removal +
- Consistency enforcement +
- Philosophy compliance +
📚 Practical Examples
+🎯 Simple: After Feature
+"post-task-cleanup: Clean up after implementing user registration"+
→ Removes: Console.logs, TODO comments, unused imports, test artifacts
+🔧 Intermediate: Module Review
+"Use post-task-cleanup to review and simplify the payment module"+
→ Simplifies: Removes abstractions, consolidates files, updates docs
+🚀 Advanced: Codebase Audit
+"post-task-cleanup: Full codebase hygiene check and philosophy compliance"+
→ Delivers: Cleanup report, technical debt list, simplification opportunities
+🧹 Cleanup Checklist
+-
+
- Remove console.log statements +
- Delete commented-out code +
- Remove TODO without action +
- Optimize imports +
- Delete unused variables +
- Update stale documentation +
- Enforce naming conventions +
How to Use Agents
+Automatic Invocation
++ Claude automatically selects and invokes the most appropriate agent based on your request. + Simply describe your task naturally, and the system will delegate to the right specialist. +
+Explicit Invocation
++ You can also explicitly request specific agents by name: +
+"Use zen-architect to design my user management system"
+"Have bug-hunter investigate the login timeout issue"
+"Deploy security-guardian to review the API endpoints"
+ Creating Custom Agents
+
+ Use the subagent-architect to create specialized agents for your unique needs,
+ or use the /agents command to create them interactively.
+