subagents

Plugin subagents from marketplace agent-marketplace in zach-source/claude-marketplace. Commands read from the repo's manifest — 5 days ago.

Subagents (80)

• agent-creator

  Use this agent when the user asks to "create an agent", "generate an agent", "build a new agent", "make me an agent that...", or describes agent functionality they need. Trigger when user wants to create autonomous agents for plugins.

• agent-sdk-verifier-py

  Use this agent to verify that a Python Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a Python Agent SDK app has been created or modified.

• agent-sdk-verifier-ts

  Use this agent to verify that a TypeScript Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a TypeScript Agent SDK app has been created or modified.

• ai-engineer

  Build LLM applications, RAG systems, and prompt pipelines. Implements vector search, agent orchestration, and AI API integrations. Use PROACTIVELY for LLM features, chatbots, or AI-powered applications.

• api-documenter

  Create OpenAPI/Swagger specs, generate SDKs, and write developer documentation. Handles versioning, examples, and interactive docs. Use PROACTIVELY for API documentation or client library generation.

• architect-reviewer

  Reviews code changes for architectural consistency and patterns. Use PROACTIVELY after any structural changes, new services, or API modifications. Ensures SOLID principles, proper layering, and maintainability.

• backend-architect

  Design RESTful APIs, microservice boundaries, and database schemas. Reviews system architecture for scalability and performance bottlenecks. Use PROACTIVELY when creating new backend services or APIs.

• business-analyst

  Analyze metrics, create reports, and track KPIs. Builds dashboards, revenue models, and growth projections. Use PROACTIVELY for business metrics or investor updates.

• c-pro

  Write efficient C code with proper memory management, pointer arithmetic, and system calls. Handles embedded systems, kernel modules, and performance-critical code. Use PROACTIVELY for C optimization, memory issues, or system programming.

• claude-config-expert

  Expert in Claude Code and Claude Desktop configuration, hooks, MCP servers, permissions, and statusline customization. Specializes in settings.json schema, hook system (PreCompact, PreToolUse, PostToolUse, UserPromptSubmit), MCP server integration, and Nix-managed declarative configuration. Use PROA

• cloud-architect

  Design AWS/Azure/GCP infrastructure, implement Terraform IaC, and optimize cloud costs. Handles auto-scaling, multi-region deployments, and serverless architectures. Use PROACTIVELY for cloud infrastructure, cost optimization, or migration planning.

• code-architect

  Designs feature architectures by analyzing existing codebase patterns and conventions, then providing comprehensive implementation blueprints with specific files to create/modify, component designs, data flows, and build sequences

• code-explorer

  Deeply analyzes existing codebase features by tracing execution paths, mapping architecture layers, understanding patterns and abstractions, and documenting dependencies to inform new development

• code-reviewer

  Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issu

• code-simplifier

  Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality. This agent should be triggered automatically after completing a coding task or writing a logical chunk of code. It simplifies code by fol

• comment-analyzer

  Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes: (1) After generating large documentation comments or docstrings, (2) Before finalizing a pull request that adds or modifies comments, (3) When reviewing existing comments f

• content-marketer

  Write blog posts, social media content, and email newsletters. Optimizes for SEO and creates content calendars. Use PROACTIVELY for marketing content or social media posts.

• context-manager

  Manages context across multiple agents and long-running tasks. Use when coordinating complex multi-agent workflows or when context needs to be preserved across multiple sessions. MUST BE USED for projects exceeding 10k tokens.

• conversation-analyzer

  Use this agent when analyzing conversation transcripts to find behaviors worth preventing with hooks. Examples: <example>Context: User is running /hookify command without arguments\nuser: "/hookify"\nassistant: "I'll analyze the conversation to find behaviors you want to prevent"\n<commentary>The /h

• cpp-pro

  Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use PROACTIVELY for C++ refactoring, memory safety, or complex C++ patterns.

• customer-support

  Handle support tickets, FAQ responses, and customer emails. Creates help docs, troubleshooting guides, and canned responses. Use PROACTIVELY for customer inquiries or support documentation.

• data-engineer

  Build ETL pipelines, data warehouses, and streaming architectures. Implements Spark jobs, Airflow DAGs, and Kafka streams. Use PROACTIVELY for data pipeline design or analytics infrastructure.

• data-scientist

  Data analysis expert for SQL queries, BigQuery operations, and data insights. Use proactively for data analysis tasks and queries.

• database-admin

  Manage database operations, backups, replication, and monitoring. Handles user permissions, maintenance tasks, and disaster recovery. Use PROACTIVELY for database setup, operational issues, or recovery procedures.

• database-optimizer

  Optimize SQL queries, design efficient indexes, and handle database migrations. Solves N+1 problems, slow queries, and implements caching. Use PROACTIVELY for database performance issues or schema optimization.

• dbos-go-expert

  Expert in DBOS durable execution framework for Go. Specializes in building resilient, failure-recoverable applications with durable workflows, steps, queues, and workflow communication patterns. Use PROACTIVELY when building fault-tolerant Go applications, implementing saga patterns, or working with

• dbos-python-expert

  Expert in DBOS durable execution framework for Python. Specializes in building resilient, failure-recoverable applications with durable workflows, steps, transactions, queues, and workflow communication patterns. Use PROACTIVELY when building fault-tolerant Python applications, implementing saga pat

• debugger

  Debugging specialist for errors, test failures, and unexpected behavior. Use proactively when encountering any issues.

• deployment-engineer

  Configure CI/CD pipelines, Docker containers, and cloud deployments. Handles GitHub Actions, Kubernetes, and infrastructure automation. Use PROACTIVELY when setting up deployments, containers, or CI/CD workflows.

• devenv-expert

  Expert in devenv.sh for creating fast, declarative, reproducible developer environments. Master of ad-hoc shells, language configurations, services, processes, tasks, and git hooks. Deep knowledge of devenv.nix structure, SecretSpec integration, and cloud deployment. Use PROACTIVELY for development

• devops-troubleshooter

  Debug production issues, analyze logs, and fix deployment failures. Masters monitoring tools, incident response, and root cause analysis. Use PROACTIVELY for production debugging or system outages.

• dx-optimizer

  Developer Experience specialist. Improves tooling, setup, and workflows. Use PROACTIVELY when setting up new projects, after team feedback, or when development friction is noticed.

• error-detective

  Search logs and codebases for error patterns, stack traces, and anomalies. Correlates errors across systems and identifies root causes. Use PROACTIVELY when debugging issues, analyzing logs, or investigating production errors.

• frontend-developer

  Build React components, implement responsive layouts, and handle client-side state management. Optimizes frontend performance and ensures accessibility. Use PROACTIVELY when creating UI components or fixing frontend issues.

• go-repository-architect

  Expert in designing and implementing Go repository patterns for database access layers. Specializes in clean architecture, transaction handling, CRUD operations, soft-delete patterns, pagination, and building testable data access code. Use PROACTIVELY when designing repository interfaces, implementi

• golang-pro

  Write idiomatic Go code with goroutines, channels, and interfaces. Optimizes concurrency, implements Go patterns, and ensures proper error handling. Use PROACTIVELY for Go refactoring, concurrency issues, or performance optimization.

• graphql-architect

  Design GraphQL schemas, resolvers, and federation. Optimizes queries, solves N+1 problems, and implements subscriptions. Use PROACTIVELY for GraphQL API design or performance issues.

• incident-responder

  Handles production incidents with urgency and precision. Use IMMEDIATELY when production issues occur. Coordinates debugging, implements fixes, and documents post-mortems.

• ios-developer

  Develop native iOS applications with Swift/SwiftUI. Masters UIKit/SwiftUI, Core Data, networking, and app lifecycle. Use PROACTIVELY for iOS-specific features, App Store optimization, or native iOS development.

• java-pro

  Master modern Java with streams, concurrency, and JVM optimization. Handles Spring Boot, reactive programming, and enterprise patterns. Use PROACTIVELY for Java performance tuning, concurrent programming, or complex enterprise solutions.

• javascript-pro

  Master modern JavaScript with ES6+, async patterns, and Node.js APIs. Handles promises, event loops, and browser/Node compatibility. Use PROACTIVELY for JavaScript optimization, async debugging, or complex JS patterns.

• kubernetes-expert

  Master Kubernetes orchestration with deep knowledge of Helm, Kustomize, RBAC, CRDs, and operators. Expert in debugging pods, services, and networking issues. Handles multi-cluster management, GitOps workflows, and production troubleshooting. Use PROACTIVELY for K8s deployments, debugging, security,

• lazyvim-debugger

  LazyVim/Neovim configuration debugging specialist. Diagnoses plugin conflicts, LSP issues, keybinding problems, and performance bottlenecks. Use for any LazyVim configuration or runtime issues.

• legacy-modernizer

  Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compatibility. Use PROACTIVELY for legacy system updates, framework migrations, or technical debt reduction.

• legal-advisor

  Draft privacy policies, terms of service, disclaimers, and legal notices. Creates GDPR-compliant texts, cookie policies, and data processing agreements. Use PROACTIVELY for legal documentation, compliance texts, or regulatory requirements.

• mcp-validator

  Expert in Model Context Protocol (MCP) server API validation, specification compliance, and protocol implementation. Deep knowledge of versioning, JSON-RPC 2.0, capabilities negotiation, and schema validation. Use PROACTIVELY for MCP server development, API compliance checks, protocol debugging, or

• ml-engineer

  Implement ML pipelines, model serving, and feature engineering. Handles TensorFlow/PyTorch deployment, A/B testing, and monitoring. Use PROACTIVELY for ML model integration or production deployment.

• mlops-engineer

  Build ML pipelines, experiment tracking, and model registries. Implements MLflow, Kubeflow, and automated retraining. Handles data versioning and reproducibility. Use PROACTIVELY for ML infrastructure, experiment management, or pipeline automation.

• mobile-developer

  Develop React Native or Flutter apps with native integrations. Handles offline sync, push notifications, and app store deployments. Use PROACTIVELY for mobile features, cross-platform code, or app optimization.

• neovim-lazyvim-expert

  Specialized expert in Neovim configuration, LazyVim framework, LSP setup, and plugin debugging

• network-engineer

  Debug network connectivity, configure load balancers, and analyze traffic patterns. Handles DNS, SSL/TLS, CDN setup, and network security. Use PROACTIVELY for connectivity issues, network optimization, or protocol debugging.

• nix-expert

  Master Nix package management, flakes, and declarative system configuration. Expert in debugging Nix expressions, managing overlays, writing derivations, and solving dependency conflicts. Deep knowledge of nixpkgs, home-manager, and nix-darwin. Use PROACTIVELY for Nix configuration issues, flake dev

• otel-go-expert

  Expert in OpenTelemetry for Go. Specializes in distributed tracing, metrics, logging, context propagation, exporters (OTLP, Jaeger, Prometheus), and instrumentation patterns. Use PROACTIVELY when adding observability to Go applications, debugging distributed systems, or setting up telemetry pipeline

• otel-python-expert

  Expert in OpenTelemetry for Python. Specializes in distributed tracing, metrics, logging, automatic instrumentation, context propagation, and exporters (OTLP, Jaeger, Prometheus). Use PROACTIVELY when adding observability to Python applications, debugging distributed systems, or setting up telemetry

• payment-integration

  Integrate Stripe, PayPal, and payment processors. Handles checkout flows, subscriptions, webhooks, and PCI compliance. Use PROACTIVELY when implementing payments, billing, or subscription features.

• performance-engineer

  Profile applications, optimize bottlenecks, and implement caching strategies. Handles load testing, CDN setup, and query optimization. Use PROACTIVELY for performance issues or optimization tasks.

• php-pro

  Write idiomatic PHP code with generators, iterators, SPL data structures, and modern OOP features. Use PROACTIVELY for high-performance PHP applications.

• plugin-validator

  Use this agent when the user asks to "validate my plugin", "check plugin structure", "verify plugin is correct", "validate plugin.json", "check plugin files", or mentions plugin validation. Also trigger proactively after user creates or modifies plugin components.

• pr-test-analyzer

  Use this agent when you need to review a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or updated to ensure tests adequately cover new functionality and edge cases. Examples:\n\n<example>\nContext: Daisy has just created a pull request wi

• prompt-engineer

  Optimizes prompts for LLMs and AI systems. Use when building AI features, improving agent performance, or crafting system prompts. Expert in prompt patterns and techniques.

• python-pro

  Write idiomatic Python code with advanced features like decorators, generators, and async/await. Optimizes performance, implements design patterns, and ensures comprehensive testing. Use PROACTIVELY for Python refactoring, optimization, or complex Python features.

• quant-analyst

  Build financial models, backtest trading strategies, and analyze market data. Implements risk metrics, portfolio optimization, and statistical arbitrage. Use PROACTIVELY for quantitative finance, trading algorithms, or risk analysis.

• risk-manager

  Monitor portfolio risk, R-multiples, and position limits. Creates hedging strategies, calculates expectancy, and implements stop-losses. Use PROACTIVELY for risk assessment, trade tracking, or portfolio protection.

• rust-pro

  Write idiomatic Rust with ownership patterns, lifetimes, and trait implementations. Masters async/await, safe concurrency, and zero-cost abstractions. Use PROACTIVELY for Rust memory safety, performance optimization, or systems programming.

• sales-automator

  Draft cold emails, follow-ups, and proposal templates. Creates pricing pages, case studies, and sales scripts. Use PROACTIVELY for sales outreach or lead nurturing.

• search-specialist

  Expert web researcher using advanced search techniques and synthesis. Masters search operators, result filtering, and multi-source verification. Handles competitive analysis and fact-checking. Use PROACTIVELY for deep research, information gathering, or trend analysis.

• security-auditor

  Review code for vulnerabilities, implement secure authentication, and ensure OWASP compliance. Handles JWT, OAuth2, CORS, CSP, and encryption. Use PROACTIVELY for security reviews, auth flows, or vulnerability fixes.

• sequential-thinking

  Expert in structured multi-step reasoning and complex problem analysis

• silent-failure-hunter

  Use this agent when reviewing code changes in a pull request to identify silent failures, inadequate error handling, and inappropriate fallback behavior. This agent should be invoked proactively after completing a logical chunk of work that involves error handling, catch blocks, fallback logic, or a

• skill-reviewer

  Use this agent when the user has created or modified a skill and needs quality review, asks to "review my skill", "check skill quality", "improve skill description", or wants to ensure skill follows best practices. Trigger proactively after skill creation.

• sql-pro

  Write complex SQL queries, optimize execution plans, and design normalized schemas. Masters CTEs, window functions, and stored procedures. Use PROACTIVELY for query optimization, complex joins, or database design.

• sqlc-specialist

  Expert in sqlc for type-safe Go database access. Specializes in writing SQL queries that compile to type-safe Go, schema management, query annotations, and sqlc.yaml configuration. Use PROACTIVELY when working with sqlc projects, writing database queries for Go, or setting up type-safe database laye

• task-runner

  Execute project-local tasks from .claude/tasks/. Use when running /task:run commands or when task execution requires specialized handling.

• terraform-provider-specialist

  Expert in Terraform provider plugin protocol (gRPC) integration. Specializes in go-plugin lifecycle, terraform-plugin-go protocol implementation, provider binary management, and reading resources/data sources via providers. Use PROACTIVELY when working with Terraform providers programmatically, sett

• terraform-specialist

  Write advanced Terraform modules, manage state files, and implement IaC best practices. Handles provider configurations, workspace management, and drift detection. Use PROACTIVELY for Terraform modules, state issues, or IaC automation.

• test-automator

  Create comprehensive test suites with unit, integration, and e2e tests. Sets up CI pipelines, mocking strategies, and test data. Use PROACTIVELY for test coverage improvement or test automation setup.

• type-design-analyzer

  Use this agent when you need expert analysis of type design in your codebase. Specifically use it: (1) when introducing a new type to ensure it follows best practices for encapsulation and invariant expression, (2) during pull request creation to review all types being added, (3) when refactoring ex

• typescript-pro

  Master TypeScript with advanced types, generics, and strict type safety. Handles complex type systems, decorators, and enterprise-grade patterns. Use PROACTIVELY for TypeScript architecture, type inference optimization, or advanced typing patterns.

• ui-ux-designer

  Create interface designs, wireframes, and design systems. Masters user research, prototyping, and accessibility standards. Use PROACTIVELY for design systems, user flows, or interface optimization.

• zellij-expert

  Expert in Zellij terminal multiplexer configuration, layouts, plugins, and keybindings. Specializes in KDL configuration syntax, plugin integration (zjstatus, autolock, harpoon, room, ghost), custom layouts, and seamless integration with tmux workflows. Use PROACTIVELY for Zellij configuration issue

Similar plugins