Agents & workflows
Skills tell Claude what to do. Agents tell Claude how to run a whole job — they plan, delegate, and report back, so you can hand off multi-step work in a single prompt.
Describe what you're working on and Sprout will search the whole catalog and build you a custom bundle.
Ruflo
Multi-agent orchestration platform for Claude Code — coordinate swarms, not just single agents.
The leading agent orchestration platform for Claude. Deploys 100+ specialized AI agents into coordinated swarms with HNSW vector memory, self-learning via SONA neural patterns, and federated comms across machines. Adds an MCP server, slash commands, hooks, and a daemon to Claude Code so agents don't just run — they collaborate.
Code Reviewer
Reviews your code changes for bugs, security holes, and weak spots before merge.
A senior reviewer that scopes your git diff, runs dependency and secret pre-checks, then reads the changed files and flags real problems — injection risks, missing error handling, untested edge cases, N+1 queries, and design smells — before code ships. Each finding comes with a severity tag, file:line, the concrete risk, and a fix, ending in a BLOCK/APPROVE merge call. Reach for it on a PR or pre-deployment review when you want depth beyond what linters catch.
Debugger
Tracks down the root cause of your bug instead of patching the symptom
A debugging specialist that works a bug from reproduction to root cause using a six-step fault-localization tree: reproduce, state observed vs. expected, rank hypotheses, falsify the top one with the cheapest experiment, then fix and add a regression test. For production incidents it starts with traces, correlated logs, and recent deploys/config changes before reading code. Reach for it on crashes, memory leaks, race conditions, and intermittent failures you can't pin down.
TypeScript Pro
Builds end-to-end type-safe TypeScript so bugs fail at compile time, not runtime
A senior TypeScript engineer for advanced type-system work — conditional and mapped types, template literals, discriminated unions, branded types, and generic constraints — to lock in compile-time correctness. Reach for it when designing type-safe API clients, sharing types end-to-end across a tRPC/Next.js stack, migrating a large JS codebase to strict TypeScript, or tuning tsconfig, project references, and bundle size.
Python Pro
Writes type-safe, tested, production-ready Python for your project
A senior Python specialist that writes idiomatic Python 3.12+ with full type hints, async I/O, and pytest coverage above 90 percent. Reach for it when building FastAPI/Django/Flask services, modernizing legacy code to strict typing and async, or profiling and optimizing data pipelines with NumPy, Polars, and Dask. It first reads your existing project conventions, then implements to match your style, tooling, and test framework.
Backend Architect
Designs your backend architecture and API contracts before you build the services
A backend architecture specialist for greenfield service design, monolith decomposition, and the upfront decisions that come before code: API paradigm choice (REST/gRPC/GraphQL/WebSocket), service boundaries via DDD bounded contexts, database schemas, event-driven communication, and observability. Reach for it when you need to design a new service, split a monolith with a strangler-fig plan, or settle data-consistency and scaling questions. It produces architecture diagrams, OpenAPI 3.1 or Protobuf contracts, schemas, and trade-off rationale rather than implementation code.
Security Auditor
Audits your systems and controls for security gaps and compliance findings
A senior security auditor that runs structured assessments across your code, infrastructure, and access controls — collecting evidence, identifying vulnerabilities, and mapping gaps against frameworks like SOC 2, ISO 27001, PCI DSS, HIPAA, and NIST. Use it for compliance reviews, pre-production audits, or post-incident analysis when you need risk-prioritized findings and a concrete remediation roadmap rather than a quick code scan. Read-only by design (Read, Grep, Glob), so it inspects and reports without touching your files.
React Specialist
Optimizes your React app and modernizes it to React 18+ patterns
A senior React engineer that diagnoses performance problems in existing React apps — unnecessary re-renders, oversized bundles, memory leaks — and fixes them with React.memo, useMemo/useCallback, code splitting, and concurrent features. Reach for it when you're profiling a slow dashboard, migrating class components to hooks and React 18 Server Components, or designing a shared hooks library for multiple teams.
Next.js Developer
Builds and tunes Next.js 14+ App Router apps for speed and SEO
A senior Next.js engineer that architects and implements full-stack App Router apps — server components, server actions, streaming SSR, ISR, and edge runtime — with a focus on Core Web Vitals and SEO. Reach for it when scaffolding a new Next.js 14+ project, migrating a React SPA to the App Router, or diagnosing slow LCP and poor search rankings on an existing app. It plans the route and rendering strategy, wires up data fetching and caching, and carries the work through to optimized deployment.
Full-Stack Developer
Builds a complete feature across database, API, and frontend in one coordinated pass
A senior full-stack engineer that builds features end-to-end across the TypeScript stack — Postgres/Drizzle schema, tRPC or Hono APIs, and Next.js 15 App Router with React Server Components — keeping types and Zod schemas shared so the layers stay in sync. Reach for it when a single feature touches database, API, and UI together: auth systems, real-time dashboards, RAG/AI search pipelines, or architectural refactors that must ship atomically. It plans the data flow and API contract first, then implements both sides against it and wires in auth, tests, and observability at every layer.
Frontend Developer
Builds production frontends in React, Vue, or Angular with tests and a11y baked in
A senior frontend engineer fluent in React 19, Vue 3.5, and Angular 20 (plus Next.js 15 and Nuxt 4) that scaffolds components, wires up state, and ships tests from the start. It picks modern defaults — Vite, TanStack Query, Zustand/Pinia/Signals, Vitest, Tailwind v4 — and holds the line on WCAG 2.2 AA and Core Web Vitals. Reach for it when building a new frontend app, migrating a legacy codebase across frameworks, or standing up a shared component library.
Go Pro
Writes idiomatic, concurrent Go and tunes it for low latency and high throughput
A senior Go engineer for building and optimizing concurrent, performance-sensitive Go systems — gRPC/REST microservices, CLI tools, and cloud-native services. It writes idiomatic code with proper context propagation, wrapped errors, and bounded-concurrency patterns, then hardens it with pprof profiling, sync.Pool object reuse, table-driven tests, benchmarks, and the race detector. Reach for it when goroutine lifecycle, GC pressure, p99 latency, or graceful shutdown actually matter.
Rust Pro
Writes idiomatic Rust with ownership, lifetimes, and safe concurrency in mind
A Rust expert that writes and refactors systems code with correct ownership, borrowing, and lifetime annotations, plus trait-based generic design. Reach for it on async/await with Tokio, safe concurrency (Arc, Mutex, channels), Result-based error handling, FFI, or squeezing out performance with zero-cost abstractions. It returns clippy-clean code with doc tests and criterion benchmarks.
SQL Pro
Tunes your slow SQL queries and schemas to hit performance targets
A senior SQL specialist for PostgreSQL, MySQL, SQL Server, and Oracle that reads execution plans, rewrites slow queries, and designs the right indexes to meet your performance SLAs. Reach for it when an analytical query crawls against large tables, when you're designing a data warehouse star schema, or when production hits deadlocks and lock contention under load.
Postgres Pro
Tunes your slow Postgres queries and keeps the database fast and reliable
A senior PostgreSQL expert that reads your EXPLAIN plans, finds missing or unused indexes, and tunes config (shared_buffers, work_mem, checkpoints, autovacuum) to cut query latency. Reach for it when production queries slow down, you're designing streaming or logical replication with automatic failover, or you need a backup and point-in-time-recovery strategy that meets specific RPO/RTO targets.
GraphQL Architect
Designs federated GraphQL schemas and kills N+1 query problems.
A GraphQL specialist that reads your existing schema and service boundaries, then designs Apollo Federation 2.10+ subgraphs, entity keys, and reference resolvers across services. Reach for it when you're composing a federated graph, fixing slow resolvers and N+1 queries with DataLoader, adding real-time subscriptions, or evolving a schema without breaking existing clients.
Refactoring Specialist
Restructures messy code without changing what it does.
A refactoring specialist that detects code smells — long methods, large classes, duplication, deep nesting — and applies catalog refactorings like extract method, replace conditional with polymorphism, and introduce parameter object to clean them up. It writes characterization tests first, then makes small incremental changes verified against the suite, so behavior stays identical while complexity drops. Reach for it when a module is hard to follow, duplicated across files, or carrying N+1 queries and other structural inefficiencies.
Test Automator
Builds the automated test framework that turns days of regression into minutes
A senior test automation engineer that designs and builds test frameworks, writes the scripts, and wires them into your CI/CD pipeline — across UI, API, mobile, and performance testing. Reach for it when you have manual test cases to automate, a flaky or slow suite to refactor, or new APIs that need contract and integration tests running on every commit.
Performance Engineer
Finds and fixes the bottlenecks slowing down your app, database, or infrastructure
A senior performance engineer that profiles your system to pinpoint bottlenecks — slow API responses, expensive queries, memory leaks, cache misses, thread contention — then implements and validates fixes against measured baselines. Reach for it when something is measurably slow, when a query regressed after a migration, or when you need to prove the system can handle projected traffic growth.
DevOps Engineer
Automates your infrastructure, pipelines, and deployments so releases ship fast and stay reliable.
A senior DevOps engineer that builds and hardens your delivery pipeline — Terraform/IaC modules, Dockerized services, GitHub Actions or GitLab CI with quality gates, and canary or blue-green rollouts with fast rollbacks. Reach for it when deployments are slow, manual, or flaky, or when you need monitoring, alerting, and incident runbooks stood up. It starts by assessing your current tooling and pain points, then automates incrementally toward measurable targets like sub-30-minute MTTR.
Kubernetes Specialist
Designs, hardens, and troubleshoots production Kubernetes clusters and workloads.
A senior Kubernetes specialist that designs production cluster architecture (multi-master control plane, etcd, node pools, availability zones) and hardens it with RBAC, network policies, Pod Security Standards, and CIS Benchmark compliance. Use it to set up HA clusters, configure autoscaling and resource quotas, build multi-tenant namespace isolation, wire up GitOps with ArgoCD or Flux, or diagnose pod evictions, performance bottlenecks, and security gaps in an existing cluster.
Describe what you're working on and Sprout will search the whole catalog and build you a custom bundle.