Programming Languages Claude Code Agents
50 agents in the Programming Languages category. Each installs in one command and drops straight into your .claude directory.
Python Pro
"Use this agent when you need to build type-safe, production-ready Python code for web APIs, system utilities, or complex applications requiring modern async patterns and extensive type coverage. Specifically:\\n\\n<example>\\nContext: Building a new REST API service that needs strict type safety, async database access, and comprehensive test coverage.\\nuser: \"I need to create a FastAPI service with SQLAlchemy async ORM, Pydantic validation, and 90%+ test coverage. Can you help?\"\\nassistant: \"I'll invoke the python-pro agent to design and implement your FastAPI service with full type hints, async context managers, comprehensive error handling, and pytest fixtures for 95% test coverage.\"\\n<commentary>\\nUse python-pro when building web services with FastAPI, Django, or Flask that require modern async patterns, type safety, and production-ready code quality. This agent specializes in setting up complete project architecture including ORM integration, validation, and testing frameworks.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating legacy Python code to Python 3.12+ with full type coverage and async refactoring.\\nuser: \"We have a large Python 2.7 codebase with no type hints. How do we modernize this to 3.12+ with type safety?\"\\nassistant: \"I'll use the python-pro agent to: analyze the codebase structure, add comprehensive type annotations, refactor blocking I/O to async/await, implement dataclasses for data structures, and add Mypy strict mode validation.\"\\n<commentary>\\nUse python-pro when modernizing codebases to leverage Python 3.12+ features like async generators, pattern matching, and strict typing. This agent handles incremental migration with proper pattern application and comprehensive testing.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Optimizing performance of a data processing pipeline that's bottlenecking on CPU and memory.\\nuser: \"Our Pandas data pipeline processes 100GB datasets and takes 4 hours. We need it optimized.\"\\nassistant: \"I'll invoke python-pro to profile the code with cProfile, refactor to NumPy vectorization, switch hot DataFrame paths to Polars, and use Dask for parallel processing. This includes memory-efficient generators and performance benchmarks to verify gains.\"\\n<commentary>\\nUse python-pro for performance optimization of data processing, CLI tools, and system utilities. This agent applies profiling techniques (cProfile, memory_profiler), implements algorithmic improvements, and adds benchmarks to verify gains.\\n</commentary>\\n</example>"
Typescript Pro
"Use when implementing TypeScript code requiring advanced type system patterns, complex generics, type-level programming, or end-to-end type safety across full-stack applications. Specifically:\\n\\n<example>\\nContext: Building an API client library that needs maximum type safety with generic request/response handling and discriminated unions for different API outcomes\\nuser: \"Create a type-safe API client library using TypeScript where callers get full type inference for requests and responses without casting. Need conditional types based on method names and discriminated unions for success/error responses.\"\\nassistant: \"I'll design a type-driven API client using advanced TypeScript features: generic constraints for request/response pairs, conditional types to infer response shapes based on endpoint, discriminated unions for Result<Success, Error> patterns, and type-safe builder for requests. This ensures zero-runtime type errors and full IDE autocomplete.\"\\n<commentary>\\nUse typescript-pro when building libraries, frameworks, or critical application code that demands advanced type patterns like conditional types, mapped types, template literal types, or type-level programming to prevent runtime errors through compile-time guarantees.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating a large monorepo from JavaScript to TypeScript with existing codebase, requiring graduated strict mode rollout and maximum type coverage without breaking changes\\nuser: \"We need to gradually migrate our 500k LOC JavaScript monorepo to TypeScript. Can't do it all at once. Need strategy for tsconfig setup with project references, incremental compilation, type coverage tracking, and handling legacy JS interop.\"\\nassistant: \"I'll architect a multi-phase migration: set up tsconfig with project references for isolated compilation, establish type coverage metrics and CI checks, implement type-only exports to prevent dependency bloat, configure allowJs/checkJs for gradual enforcement, and create migration guides for team onboarding.\"\\n<commentary>\\nInvoke typescript-pro for large-scale TypeScript adoption, complex build optimization, monorepo TypeScript architecture, or when you need sophisticated type system patterns beyond what standard TypeScript setup provides.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Full-stack application needs end-to-end type safety with shared types between Next.js frontend and tRPC backend, with code generation from database schema\\nuser: \"Set up full end-to-end type safety in our Next.js + tRPC stack. Want database schema types generated and shared with API layer, then validated at API boundary, with frontend getting full type inference without any type assertions.\"\\nassistant: \"I'll implement e2e type safety: generate TypeScript types from database schema using Prisma, use tRPC's type-safe routers for API contracts, configure strict TypeScript settings across frontend/backend, set up type tests for public APIs, and ensure all types flow from database through backend to frontend with zero runtime gaps.\"\\n<commentary>\\nUse typescript-pro when architecting end-to-end type-safe systems spanning multiple layers, integrating code generation with type systems, or requiring sophisticated type sharing between frontend and backend to eliminate type mismatches at runtime.\\n</commentary>\\n</example>"
Javascript Pro
"Use this agent when you need to build, optimize, or refactor modern JavaScript code for browser, Node.js, or full-stack applications requiring ES2025 features, async patterns, or performance-critical implementations. Specifically:\\n\\n<example>\\nContext: User has a legacy callback-based Node.js service and wants to modernize it with async/await, implement proper error handling, and optimize memory usage.\\nuser: \"I have an old Node.js service with callback hell. Can you refactor it to use modern async/await patterns and add proper error handling?\"\\nassistant: \"I'll use the javascript-pro agent to analyze your existing code structure, migrate to async/await patterns, optimize memory management, and ensure comprehensive error handling following modern JavaScript best practices.\"\\n<commentary>\\nUse javascript-pro when the task involves modernizing JavaScript code to leverage ES2025 features, async patterns, and performance optimization. This agent handles refactoring across both browser and Node.js environments with focus on clean, maintainable patterns.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User is building a performance-critical browser application with complex state management, event handling, and needs to implement Web Workers for heavy computation.\\nuser: \"I need help building a real-time analytics dashboard with Web Workers for data processing and optimized DOM updates. It needs to handle 1000s of data points.\"\\nassistant: \"I'll invoke the javascript-pro agent to architect the data flow with proper async coordination, implement Web Workers for computation offload, optimize DOM updates with event delegation, and ensure sub-16ms render performance.\"\\n<commentary>\\nUse javascript-pro for browser applications requiring advanced JavaScript patterns like Web Workers, performance optimization, and sophisticated asynchronous coordination. The agent specializes in avoiding common pitfalls like memory leaks and janky rendering.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User has a full-stack Node.js and browser codebase that needs testing infrastructure, proper JSDoc type coverage, and wants to leverage shared module patterns across frontend and backend.\\nuser: \"Set up comprehensive testing with Vitest, add JSDoc types for type safety, and create shared utilities that work in both Node.js and the browser.\"\\nassistant: \"I'll use the javascript-pro agent to configure Vitest with proper mocking strategies, add JSDoc type annotations for the entire codebase, establish shared module patterns using ESM, and ensure 85%+ coverage with integration tests.\"\\n<commentary>\\nUse javascript-pro for full-stack JavaScript projects needing testing infrastructure, type safety with JSDoc, module architecture, and cross-environment compatibility. The agent understands both browser APIs (DOM, Fetch, Service Workers) and Node.js internals (Streams, Worker Threads, EventEmitter).\\n</commentary>\\n</example>"
Sql Pro
"Use this agent when you need to optimize complex SQL queries, design efficient database schemas, or solve performance issues across PostgreSQL, MySQL, SQL Server, and Oracle requiring advanced query optimization, index strategies, or data warehouse patterns. Specifically:\\n\\n<example>\\nContext: User has a slow analytical query in PostgreSQL running against 100M+ row tables that joins 5 tables and uses window functions but takes 8+ seconds. Needs to meet <500ms SLA.\\nuser: \"My analytics query is taking 8 seconds and needs to run in <500ms. It's a complex join across 5 tables with window functions for running totals.\"\\nassistant: \"I'll use the sql-pro agent to analyze the execution plan, identify missing indexes, optimize window function usage with proper partitioning, rewrite the query for better join order, and implement covering indexes to reduce disk I/O.\"\\n<commentary>\\nUse sql-pro when you have slow queries requiring execution plan analysis, strategic index design, and query rewriting across large datasets. This agent specializes in transforming complex analytical queries to meet performance SLAs while maintaining correctness.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User is designing a new data warehouse schema with 500M+ daily rows and needs proper normalization, fact/dimension tables, and strategies for incremental loading and maintaining data integrity.\\nuser: \"Help me design a data warehouse schema for our analytics platform. We're loading 500M+ rows daily and need efficient star schema with proper slowly changing dimensions.\"\\nassistant: \"I'll invoke the sql-pro agent to design normalized fact and dimension tables optimized for OLAP queries, implement slowly changing dimension strategies, create efficient ETL patterns with MERGE statements, and design materialized views for common analytics queries.\"\\n<commentary>\\nUse sql-pro for database architecture and schema design tasks involving large-scale data warehousing. The agent masters star schema design, dimension table strategies, and ETL pattern optimization for efficient analytics.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User has a production database experiencing deadlocks and lock timeouts during peak load, needs isolation level tuning and concurrency optimization.\\nuser: \"Our database is experiencing frequent deadlocks during peak hours. We're running SQL Server with heavy concurrent transactions. How can we fix this without rewriting application logic?\"\\nassistant: \"I'll use the sql-pro agent to analyze lock contention patterns, optimize transaction scope, recommend isolation level changes, implement optimistic concurrency patterns, and add proper query hints for parallel execution tuning.\"\\n<commentary>\\nUse sql-pro for production performance issues like deadlocks, lock contention, and concurrency problems. The agent understands transaction isolation levels, deadlock detection, and can optimize for high-load scenarios across different database platforms.\\n</commentary>\\n</example>"
Golang Pro
"Use when building Go applications requiring concurrent programming, high-performance systems, microservices, or cloud-native architectures where idiomatic patterns, error handling excellence, and efficiency are critical. Specifically:\\n\\n<example>\\nContext: Building a gRPC-based microservice that handles thousands of concurrent requests with strict latency requirements and needs proper error propagation and graceful shutdown\\nuser: \"Create a gRPC service in Go that can handle 10k concurrent connections with sub-50ms p99 latency. Need proper context propagation for cancellation, comprehensive error handling with wrapped errors, and graceful shutdown that stops accepting new connections but drains existing ones.\"\\nassistant: \"I'll architect a gRPC service with streaming handlers, context-aware deadlines, wrapped error types for detailed error chains, interceptors for logging/metrics, worker pools for bounded concurrency, and a shutdown coordinator using context cancellation. This ensures low-latency responses, proper error tracing, and clean process termination.\"\\n<commentary>\\nInvoke golang-pro when building Go services where concurrency, error handling, and performance optimization are primary concerns—especially gRPC/REST APIs, microservices, and systems requiring context propagation and resource lifecycle management.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Optimizing a Go backend's data pipeline processing millions of events daily, with memory pressure and CPU hotspots\\nuser: \"Our Go event processor is hitting memory limits processing 1M events/day. Need to profile memory allocations, reduce GC pressure with object pooling, and benchmark critical paths. Current implementation does full unmarshaling for every event even when we only need a few fields.\"\\nassistant: \"I'll apply performance optimization techniques: use pprof to identify allocation hotspots, implement sync.Pool for frequent object reuse, benchmark processing pipeline with criterion-style comparisons, apply zero-allocation patterns for hot paths, consider using partial unmarshaling with json.Decoder for selective field extraction, and tune GC with GOGC tuning.\"\\n<commentary>\\nUse golang-pro when performance is a primary requirement—optimizing memory usage, reducing CPU load, implementing benchmarks, profiling code, or building systems where latency and throughput matter significantly.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Monorepo with multiple Go services needing shared error handling, logging patterns, and graceful inter-service communication with proper dependency management\\nuser: \"We have 5 microservices in a monorepo that need consistent error handling, structured logging, and service discovery. How do we organize shared code, manage go.mod dependencies, create reusable interfaces, and ensure all services follow the same patterns without tight coupling?\"\\nassistant: \"I'll structure the monorepo with separate modules for each service plus shared library packages for error types, logging setup, and interfaces. Use go.mod's replace directive for local dependencies, implement functional options pattern for service configuration, define small focused interfaces for service boundaries, and set up table-driven tests that validate all services implement required contracts.\"\\n<commentary>\\nInvoke golang-pro for architectural decisions spanning multiple Go projects, monorepo organization, establishing shared patterns across services, dependency management strategies, or when building frameworks that multiple Go teams will use.\\n</commentary>\\n</example>"
Php Pro
"Use this agent when working with PHP 8.3+ projects that require strict typing, modern language features, and enterprise framework expertise (Laravel or Symfony). Use when building scalable applications, optimizing performance, or requiring async/Fiber patterns. Specifically:\\n\\n<example>\\nContext: Developer needs to refactor a legacy PHP codebase to PHP 8.3 with strict types and modern patterns.\\nuser: \"I have a Laravel 10 project that's still using mixed types and older patterns. Can you help upgrade to PHP 8.3 with strict typing?\"\\nassistant: \"I'll analyze your Laravel project structure, identify upgrade opportunities, and refactor to PHP 8.3 with full strict type support, readonly properties, enums, and modern patterns while maintaining backward compatibility during migration.\"\\n<commentary>\\nUse php-pro when the task involves upgrading existing PHP codebases to modern PHP standards, strict typing, and framework-specific patterns. This is a core use case for architecture improvements.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Building a high-performance API with async job processing in Laravel.\\nuser: \"We need to implement async job processing with Swoole for our API to handle 10k requests per second. Can you design this?\"\\nassistant: \"I'll architect a Swoole-based queue system with Fiber coroutines, implement async job batching, optimize Eloquent queries with eager loading, configure OpCache, and set up performance monitoring to meet your throughput requirements.\"\\n<commentary>\\nUse php-pro when you need expertise in async programming patterns, Swoole/ReactPHP, Fiber implementation, or performance optimization for high-traffic PHP applications.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Ensuring code quality and security in a Symfony project with PHPStan analysis.\\nuser: \"Our Symfony project has technical debt. Can you enforce PHPStan level 9, improve test coverage, and fix security issues?\"\\nassistant: \"I'll run PHPStan analysis, implement strict type declarations across services and entities, increase test coverage to 85%+, audit dependencies for vulnerabilities, and apply SOLID principles to reduce complexity.\"\\n<commentary>\\nUse php-pro when you need to improve code quality, achieve high PHPStan levels, implement security best practices, or enforce PSR standards and design patterns in enterprise applications.\\n</commentary>\\n</example>"
Shell Scripting Pro
Write robust shell scripts with proper error handling, POSIX compliance, and automation patterns. Masters bash/zsh features, process management, and system integration. Use PROACTIVELY for automation, deployment scripts, or system administration tasks.
C Sharp Pro
Write idiomatic C# code with modern language features, async patterns, and LINQ. Masters .NET ecosystem, Entity Framework Core, and ASP.NET Core. Use PROACTIVELY for C# optimization, refactoring, or complex .NET solutions.
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.
React Specialist
"Use when optimizing existing React applications for performance, implementing advanced React 18+ features, or solving complex state management and architectural challenges within React codebases. Specifically:\n\n<example>\nContext: Production React app experiencing performance degradation with 8 custom hooks per component, large bundle size, and memory leaks\nuser: \"Our React dashboard is slow. Components re-render constantly, bundle is 850KB, and we have memory issues. Using 8 custom hooks in some places. How do we optimize?\"\nassistant: \"I'll analyze your component architecture and profiling data to identify unnecessary re-renders, implement useMemo/useCallback strategically, refactor hook composition to reduce overhead, implement code splitting for lazy loading, optimize state management, and set up Performance Observer for continuous monitoring. Let me first review your current components and profiling metrics.\"\n<commentary>\nUse react-specialist when you have existing React applications with performance problems, complex hook interactions, or architectural debt. This agent excels at diagnosing performance bottlenecks and implementing advanced React patterns to fix them.\n</commentary>\n</example>\n\n<example>\nContext: Migrating React 16 class components to React 18 with concurrent features and server components\nuser: \"Need to upgrade our React 16 codebase to React 18 and leverage Server Components. We have 200+ class components and currently use Redux. What's the best migration path?\"\nassistant: \"I'll create a migration strategy that gradually converts class components to functional components with hooks, implements useTransition for non-blocking updates, sets up Server Components with streaming SSR, migrates Redux to a more modern state solution like Zustand or React Context with useReducer, and establishes performance benchmarks to validate improvements at each step.\"\n<commentary>\nUse react-specialist when modernizing React applications across major version upgrades or migrating to new React paradigms like Server Components and concurrent rendering. This agent specializes in strategic architectural migrations.\n</commentary>\n</example>\n\n<example>\nContext: Building shared reusable hook library and component composition system for multi-team React monorepo\nuser: \"Create a shared hooks library with complex state management, form handling, API interactions, and error boundaries. 15 teams will use this. Need TypeScript, documentation, and strong patterns.\"\nassistant: \"I'll architect a comprehensive hooks library with useQuery for data fetching, useForm for form management, useAsync for async operations, useLocalStorage for persistence, error boundary patterns, and composition utilities. Each hook will have TypeScript generics, comprehensive tests (95%+ coverage), Storybook examples, JSDoc documentation, and peer dependency declarations for different React versions.\"\n<commentary>\nUse react-specialist when creating advanced React tooling, hook libraries, or patterns that multiple teams will consume. This agent designs production-grade abstractions with strong APIs and excellent DX.\n</commentary>\n</example>"
Nextjs Developer
"Use this agent when building production Next.js 14+ applications that require full-stack development with App Router, server components, and advanced performance optimization. Invoke when you need to architect or implement complete Next.js applications, optimize Core Web Vitals, implement server actions and mutations, or deploy SEO-optimized applications. Specifically:\\n\\n<example>\\nContext: A startup is building an e-commerce platform and needs a complete Next.js 14 implementation with server-side rendering, database integration, and Lighthouse score > 95.\\nuser: \"Build a Next.js e-commerce app with product catalog, shopping cart, checkout flow, and real-time inventory updates. Need server components for SEO, App Router structure, and Core Web Vitals > 90.\"\\nassistant: \"I'll architect this as a complete Next.js application. I'll design the App Router with route groups for organization, implement server components for product pages and SEO, create server actions for cart and checkout operations, optimize images and fonts, configure ISR for product listings, and set up monitoring to achieve your Lighthouse targets. I'll also implement database integration with Prisma and edge runtime compatibility.\"\\n<commentary>\\nUse nextjs-developer when building complete Next.js applications from architecture through deployment, especially when you need to optimize for search engines, implement server-side rendering, and achieve strict performance budgets. This agent handles the full stack including API routes, database integration, and production deployment.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: An existing React SPA needs to be migrated to Next.js 14 for better SEO and initial page load performance, with existing backend APIs to integrate with.\\nuser: \"Migrate our React SPA to Next.js 14. We have existing REST APIs at /api/v1 and need to maintain feature parity while improving SEO and first paint time.\"\\nassistant: \"I'll design a Next.js App Router structure that maps to your existing React components, implement server components for page templates to improve SEO, create API route middleware to proxy your existing endpoints, set up server-side data fetching with proper cache invalidation, and configure preview deployments for testing. I'll ensure zero-downtime migration and maintain all existing features while optimizing Core Web Vitals.\"\\n<commentary>\\nInvoke nextjs-developer when migrating existing applications to Next.js or when adding server-side rendering to frontend-only applications. This agent excels at integrating with existing backend APIs and optimizing for performance during migration.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A high-traffic SaaS application needs optimization—pages are slow, SEO metrics are poor, and the team needs to implement real-time features without rebuilding from scratch.\\nuser: \"Our Next.js app averages 3.5s LCP and we're ranking poorly in search. Need real-time notifications, improved performance, and better SEO. Currently using client-side routing and data fetching.\"\\nassistant: \"I'll audit your architecture and optimize it by migrating suitable components to server components, implementing streaming SSR for faster First Contentful Paint, configuring incremental static regeneration for SEO-critical pages, optimizing images and scripts, setting up server actions for real-time mutations, and implementing WebSocket support for notifications. I'll create a phased migration plan to achieve > 90 Lighthouse scores while adding real-time features.\"\\n<commentary>\\nUse nextjs-developer for performance optimization and architectural improvements to existing Next.js applications. This agent diagnoses performance bottlenecks and implements Next.js 14+ patterns like server components and streaming to improve metrics without full rewrites.\\n</commentary>\\n</example>"
Cpp Pro
"Use this agent when building high-performance C++ systems requiring modern C++20/23 features, template metaprogramming, or zero-overhead abstractions for systems programming, embedded systems, or performance-critical applications. Specifically:\\n\\n<example>\\nContext: Implementing a low-latency trading system that needs custom memory allocators and lock-free data structures.\\nuser: \"We need a high-frequency trading engine that processes 100k orders/sec with sub-microsecond latency. Requirements include custom memory management and lock-free queues.\"\\nassistant: \"I'll invoke cpp-pro to design lock-free concurrent data structures, implement custom allocators for deterministic performance, profile with perf to eliminate latency jitter, and ensure all zero-copy optimizations are in place. We'll use C++20 coroutines for async order handling and validate with AddressSanitizer.\"\\n<commentary>\\nUse cpp-pro when building latency-critical systems requiring lock-free programming, custom allocators, and zero-copy techniques. This agent handles high-performance concurrency, SIMD optimization, and CPU cache tuning to meet strict performance SLAs.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Refactoring a legacy C++ codebase to modern standards with compile-time safety using concepts.\\nuser: \"Our C++11 codebase is 500k lines with SFINAE everywhere. How do we modernize to C++20 with concepts and get compile-time safety benefits?\"\\nassistant: \"I'll use cpp-pro to migrate SFINAE to concepts, add designated initializers, implement ranges instead of raw iterators, add comprehensive static analysis, and validate all changes with Clang 18 and GCC 13. We'll set up strict compiler flags and ensure zero UBSan warnings.\"\\n<commentary>\\nUse cpp-pro for modernizing legacy codebases to C++20/23 standards. This agent refactors template code to concepts, applies designated initializers, and ensures C++ Core Guidelines compliance with full static analysis.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Developing an embedded real-time system with strict memory constraints and compile-time guarantees.\\nuser: \"Building an aerospace control system with 256KB RAM. We need compile-time computation, no dynamic allocation, and real-time guarantees. Can you help with C++20 constexpr?\"\\nassistant: \"I'll invoke cpp-pro to design the system with constexpr computation at build-time, eliminate heap allocation, implement RAII for stack resources, add Valgrind verification, and profile memory usage. We'll use static analysis to guarantee no runtime undefined behavior.\"\\n<commentary>\\nUse cpp-pro for embedded and real-time systems requiring compile-time computation, static memory allocation, and strict safety guarantees. This agent leverages constexpr, templates, and RAII to eliminate runtime costs and undefined behavior.\\n</commentary>\\n</example>"
Flutter Expert
"Use when building cross-platform mobile applications with Flutter 3+ that require custom UI implementation, complex state management, native platform integrations, or performance optimization across iOS/Android/Web. Specifically:\\n\\n<example>\\nContext: Building a feature-rich social media app that needs custom animations, platform-specific native features (biometric auth, camera), and 60fps performance on both iOS and Android\\nuser: \"We need a high-performance Flutter app with custom Material You animations, Face ID/fingerprint auth, camera integration, and guaranteed 60fps scrolling. How do we structure this to maintain performance across both platforms?\"\\nassistant: \"I'll architect the app using BLoC for state management to isolate business logic from UI, implement platform channels for biometric and camera access, use RepaintBoundary and const constructors to maintain 60fps performance, create custom widgets for complex animations with proper Tween configurations, and set up comprehensive widget and integration tests. This ensures platform consistency while allowing platform-specific optimizations.\"\\n<commentary>\\nUse flutter-expert when building cross-platform apps that require custom native features, complex animations, and strict performance requirements. This agent specializes in architecture that scales across multiple platforms while maintaining native performance.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating a legacy Flutter 2 app to Flutter 3+ with null safety, modern state management, and refactored widget hierarchy\\nuser: \"Our Flutter 2 app has unsoundness issues, uses an outdated Provider setup, and has 200+ build methods scattered across monolithic widgets. How do we modernize this to Flutter 3?\"\\nassistant: \"I'll implement a migration plan: first enforce null safety throughout with strict linting, refactor state management to Riverpod 2.0 for better performance and testability, decompose large widgets into focused composable components with proper const constructors, implement feature-based folder structure, add comprehensive widget tests (targeting 80%+ coverage), and set up golden tests for UI consistency.\"\\n<commentary>\\nUse flutter-expert when modernizing Flutter codebases to leverage newer versions, improve architecture, and reduce technical debt. This agent handles complex refactoring that improves both code quality and runtime performance.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Optimizing a Flutter app that's experiencing performance degradation with janky scrolling, high memory usage, and slow app startup\\nuser: \"Our Flutter shopping app has 120ms frame times during scrolling, uses 500MB memory, and takes 4 seconds to launch. We have ListView with custom widgets rendering thousands of items.\"\\nassistant: \"I'll profile the app using DevTools to identify expensive rebuilds and memory leaks, refactor ListViews to use ListView.builder with const widgets, implement image caching strategies, add RepaintBoundary around expensive widgets, use preload patterns for navigation, profile memory with DevTools to identify retain cycles, and establish performance benchmarks. We'll target 16ms frame times and sub-2s startup.\"\\n<commentary>\\nUse flutter-expert for performance optimization when apps suffer from jank, high memory consumption, or slow startup times. This agent applies DevTools profiling, widget optimization techniques, and platform-specific tuning to achieve native-quality performance.\\n</commentary>\\n</example>"
Vue Expert
"Use this agent when building Vue 3 applications that require Composition API mastery, reactivity optimization, or Nuxt 3 development with enterprise-scale performance concerns. Specifically:\\n\\n<example>\\nContext: User is building a data-intensive Vue 3 dashboard that needs to display thousands of real-time updates without performance degradation.\\nuser: \"I have a Vue 3 dashboard component that re-renders too frequently when receiving live data. The reactivity system is causing unnecessary DOM updates.\"\\nassistant: \"I'll analyze your reactivity patterns and implement optimizations using shallow refs, computed memoization, and watchEffect scope management to reduce unnecessary renders while maintaining live data accuracy.\"\\n<commentary>\\nUse vue-expert when you need to solve complex reactivity performance problems, optimize watch/computed chains, or implement efficient patterns for high-volume data updates in Vue 3 applications.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Team is migrating a multi-page application to Nuxt 3 with SSR and needs architecture guidance.\\nuser: \"We're moving our Vue app to Nuxt 3 and need help architecting SSR, API routes, and data fetching patterns. Also need guidance on build optimization.\"\\nassistant: \"I'll design your Nuxt 3 architecture with universal rendering, file-based routing, nitro server routes, and implement optimal data fetching with ISR strategies. I'll also configure bundle optimization and SEO support.\"\\n<commentary>\\nUse vue-expert when architecting Nuxt 3 applications, setting up SSR/ISR strategies, or optimizing universal rendering across server and client boundaries.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Developer needs to build reusable, type-safe components for an enterprise design system.\\nuser: \"I'm creating a component library for our design system. Need to ensure TypeScript safety, composability, and that components work well with Pinia state management.\"\\nassistant: \"I'll architect your component library using Composition API patterns, generic TypeScript typing for props/events, create composables for shared logic, and integrate seamlessly with Pinia stores using proper typing.\"\\n<commentary>\\nUse vue-expert when building enterprise component libraries, designing composables, implementing state management patterns, or establishing TypeScript best practices across large Vue 3 codebases.\\n</commentary>\\n</example>"
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.
Java Architect
"Use this agent when designing enterprise Java architectures, migrating Spring Boot applications, or establishing microservices patterns for scalable cloud-native systems. Specifically:\\n\\n<example>\\nContext: A team needs to refactor a monolithic Spring application into microservices with proper service boundaries and inter-service communication.\\nuser: \"We need to design a microservices architecture for our legacy Spring Boot monolith with 15 services. Current bottlenecks are the shared database and tightly coupled modules.\"\\nassistant: \"I'll analyze your current architecture, design service boundaries using domain-driven design, establish API contracts with OpenAPI specs, implement Spring Cloud patterns (API Gateway, Circuit Breakers with Resilience4j), and set up event-driven communication using Kafka. We'll also establish database per service strategy and create comprehensive test contracts.\"\\n<commentary>\\nUse the java-architect when redesigning application structure or establishing new architectural patterns at the system level. This agent excels at breaking down monoliths and designing distributed systems.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A company is upgrading to the latest Java LTS version and wants to leverage modern language features while modernizing their tech stack.\\nuser: \"We're on Java 11 with Spring Boot 2.7 and want to move to Java 21 with Spring Boot 3.3. Should we use virtual threads, records, and reactive programming?\"\\nassistant: \"I'll guide your migration plan: upgrade to Spring Boot 3.3 with native image support, introduce records for data carriers, implement virtual threads for improved throughput on I/O-bound services, evaluate WebFlux for APIs needing high concurrency, and set up GraalVM compilation for faster startup times.\"\\n<commentary>\\nInvoke the java-architect for technology stack decisions and major version upgrades. This agent evaluates trade-offs between modern features and your application requirements.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A startup needs to establish development standards for a new multi-module Spring Boot platform being built by distributed teams.\\nuser: \"We're building a new payment processing platform in Java. What architectural decisions should we make now to handle 1000 TPS and ensure 99.99% uptime?\"\\nassistant: \"I'll establish enterprise architecture patterns: implement hexagonal architecture with CQRS for event sourcing, set up comprehensive testing strategy (unit, integration with TestContainers, contract, performance with JMH), establish Spring Security with OAuth2, configure distributed tracing with Micrometer, and design for multi-tenancy from day one. This includes CI/CD pipeline design and cloud-native deployment readiness.\"\\n<commentary>\\nUse java-architect when building new systems that need to scale or when establishing architectural foundations for platforms. This agent prevents technical debt by designing for production requirements upfront.\\n</commentary>\\n</example>"
Kotlin Specialist
"Use when building Kotlin applications requiring advanced coroutine patterns, multiplatform code sharing, or Android/server-side development with functional programming principles. Specifically:\\n\\n<example>\\nContext: Building a cross-platform mobile application sharing business logic between Android and iOS using Kotlin Multiplatform Mobile (KMM)\\nuser: \"We're creating a social media app targeting both Android and iOS. How do we structure a KMM project to maximize shared code while maintaining platform-specific UI in Compose and SwiftUI?\"\\nassistant: \"I'll architect your KMM project with: shared business logic in common module using coroutines for networking, database layer with SQLite, and state management with MVI pattern. Android gets Jetpack Compose UI consuming shared ViewModels, iOS uses Swift wrappers around Kotlin code. Expected 70-80% code sharing with proper expect/actual boundaries for platform APIs.\"\\n<commentary>\\nUse kotlin-specialist when building cross-platform mobile applications with Kotlin Multiplatform Mobile. This agent structures gradle multiplatform builds, designs expect/actual abstractions for platform APIs, and ensures efficient code sharing between iOS/Android while maintaining idiomatic platform-specific UIs.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating legacy Android codebase to modern Kotlin with coroutines, Room database, and proper dependency injection\\nuser: \"Our Android app is 8 years old, written in Java with callback hell, no tests, and tight coupling. Can we modernize it to Kotlin with coroutines and architecture patterns without rewriting everything?\"\\nassistant: \"I'll execute a phased modernization: convert Java to Kotlin incrementally, replace callbacks with Flow-based coroutines for networking/database, implement MVVM with StateFlow, add Hilt for dependency injection, introduce Room with async migrations, and establish test framework with JUnit 5 and MockK. Each layer gets refactored with comprehensive tests.\"\\n<commentary>\\nInvoke kotlin-specialist for modernizing existing Android/Java codebases to Kotlin best practices. This agent handles incremental migrations preserving functionality while introducing coroutines, modern architecture patterns, and comprehensive testing frameworks.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Building a high-performance backend service using Ktor with complex business logic requiring functional programming patterns\\nuser: \"We need a Ktor backend for our API handling 10k requests/sec with complex validation pipelines, composed functional transformations, and strict type safety. How should we structure this?\"\\nassistant: \"I'll design a Ktor service leveraging: Arrow.kt for functional error handling and monadic compositions, Domain-Driven Design with sealed classes for business logic, Flow API for reactive pipelines, structured concurrency for request handling, and comprehensive integration tests with Kotest. Architecture uses functional composition for validation chains and type-safe builders for DSLs.\"\\n<commentary>\\nUse kotlin-specialist when building server-side applications requiring advanced functional programming, complex business logic transformations, or reactive pipelines. This agent applies Arrow.kt monadic patterns, creates expressive DSLs, and structures coroutine-based architectures for high-throughput services.\\n</commentary>\\n</example>"
Laravel Specialist
"Use when building Laravel 10+ applications, architecting Eloquent models with complex relationships, implementing queue systems for async processing, or optimizing API performance. Specifically:\\n\\n<example>\\nContext: Building a new Laravel 10 SaaS application from scratch with multi-tenancy, real-time features, and complex database design\\nuser: \"I need to build a Laravel 10 SaaS platform for task management. Requirements: multi-tenant architecture, real-time notifications via WebSockets, background job processing, Eloquent models with complex relationships, comprehensive API with rate limiting, and 90%+ test coverage.\"\\nassistant: \"I'll architect the complete Laravel application: design multi-tenant database schema with scoped Eloquent models, implement Scout full-text search, set up Laravel Echo with WebSockets for real-time updates, configure Horizon for queue management with job batching, create API resources with pagination and filtering, implement Sanctum authentication with rate limiting, write comprehensive Pest tests (90%+ coverage), and optimize with eager loading and caching strategies.\"\\n<commentary>\\nInvoke laravel-specialist when building complete Laravel applications from scratch requiring architectural decisions around database design, multi-tenancy, API structure, queue systems, and production-ready patterns. This agent excels at coordinating Laravel's ecosystem components (Eloquent, Horizon, Echo, Sanctum) into cohesive applications.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Existing Laravel application experiencing severe N+1 query problems, slow response times, and needs performance optimization without rewriting\\nuser: \"Our Laravel app has pages taking 5+ seconds to load due to N+1 query problems. We have deeply nested Eloquent relationships, missing indexes, and no caching. How do we profile and optimize without major refactoring?\"\\nassistant: \"I'll implement Laravel performance optimization: use Laravel Debugbar and Clockwork to identify N+1 queries, apply eager loading strategies with include/with, add missing database indexes through migrations, implement Redis caching with cache facades, set up query scopes for optimization, use selectRaw for expensive aggregations, enable query log in production safely, and benchmark critical endpoints before/after optimizations.\"\\n<commentary>\\nUse laravel-specialist for performance troubleshooting in existing Laravel applications, specifically addressing N+1 query problems, database optimization, caching strategies, and query profiling. This agent applies Laravel-specific optimization patterns including eager loading, database indexing through migrations, and proper cache invalidation.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Legacy Laravel 6 application needs modernization to Laravel 10 with async queues and newer patterns\\nuser: \"We have a Laravel 6.x app with 200k LOC. Need to upgrade to Laravel 10 incrementally while keeping production stable. Also need to migrate from queue database driver to Redis and adopt newer patterns like Actions and Jobs.\"\\nassistant: \"I'll create a phased modernization plan: establish comprehensive Pest test coverage, upgrade Laravel incrementally (6 to 7, 7 to 8, 8 to 9, 9 to 10), address deprecations in each phase, migrate from database queue to Redis, refactor controllers into Action classes and API resources, implement proper error handling with custom exceptions, update authentication to Sanctum, and set up CI/CD with Laravel Pint and PHPStan for code quality.\"\\n<commentary>\\nInvoke laravel-specialist for major Laravel version upgrades, modernizing legacy applications, integrating new queue drivers, and adopting contemporary Laravel patterns (Actions, Casts, custom middleware) while managing production stability and preventing regressions.\\n</commentary>\\n</example>"
Swift Expert
"Use this agent when building native iOS, macOS, or server-side Swift applications requiring advanced concurrency patterns, protocol-oriented architecture, and Swift-specific optimizations. Invoke for SwiftUI modernization, async/await implementation, actor-based state management, or memory safety concerns. Specifically:\\n\\n<example>\\nContext: An iOS team is migrating a UIKit app with outdated concurrency patterns to modern SwiftUI with proper async/await and actor-based state management.\\nuser: \"We have a legacy iOS app using callbacks and DispatchQueue. Need to modernize it to SwiftUI with proper concurrency. About 50k lines of code.\"\\nassistant: \"I'll analyze the existing architecture, identify concurrency pain points, then systematically migrate to async/await with actors. I'll refactor to SwiftUI components, implement proper error handling with typed throws, and ensure Sendable compliance throughout. Expect full test coverage, zero memory leaks, and MainActor optimization.\"\\n<commentary>\\nInvoke swift-expert when modernizing Swift codebases requiring deep architectural changes around concurrency patterns and UI frameworks. This agent optimizes for type safety and performance specific to Apple's Swift ecosystem.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A development team needs to implement complex protocol-oriented architecture with generics and associated types for a cross-platform SDK.\\nuser: \"Building an SDK that works on iOS, macOS, and Linux. Need heavily generic architecture with protocol composition, associated types, and proper abstraction boundaries.\"\\nassistant: \"I'll design protocol-first APIs leveraging associated types, conditional conformance, and type erasure patterns where needed. I'll implement for all platforms ensuring feature parity, create comprehensive API documentation, and build extensive test suites validating type safety and performance.\"\\n<commentary>\\nUse this agent when designing protocol-oriented Swift architectures, particularly when working with multiple platforms or building SDKs requiring sophisticated type system usage.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A server-side team needs to optimize performance bottlenecks in a Vapor backend experiencing memory issues under high load.\\nuser: \"Our Swift server in production has memory leaks under 1000 concurrent connections. Crash dumps show ARC issues. We need root cause analysis and fixes.\"\\nassistant: \"I'll profile using Instruments, identify retain cycles and reference issues, refactor to value semantics where appropriate, optimize closure captures, and implement proper connection pooling. I'll add memory monitoring, stress test the fixes, and provide profiling recommendations for production.\"\\n<commentary>\\nInvoke swift-expert for performance optimization, memory management issues, and advanced concurrency concerns in production Swift services.\\n</commentary>\\n</example>"
Angular Architect
"Use when architecting enterprise Angular 15+ applications with complex state management, optimizing RxJS patterns, designing micro-frontend systems, or solving performance and scalability challenges in large codebases. Specifically:\n\n<example>\nContext: Large-scale Angular application with 200+ components experiencing performance degradation, memory leaks in RxJS observables, and difficult state management with Redux\nuser: \"Our Angular dashboard has grown to 200+ components, pages load slowly, memory leaks on route changes, and our Redux-like state is unmaintainable. How do we restructure for performance and maintainability?\"\nassistant: \"I'll analyze your component architecture and RxJS usage to identify unsubscribed observables and unnecessary change detection cycles. I'll redesign state management with NgRx, implement OnPush change detection strategy, optimize RxJS operators with proper unsubscription patterns, implement lazy loading modules, and add bundle analysis to identify oversized features. I'll create a migration path that can be executed incrementally.\"\n<commentary>\nUse angular-architect when you have production Angular applications with systemic performance issues, RxJS memory leaks, or state management challenges. This agent excels at diagnosing architectural problems in large codebases and implementing enterprise patterns to fix them.\n</commentary>\n</example>\n\n<example>\nContext: Building a micro-frontend platform with Module Federation where 8 teams will independently deploy feature modules into a shared shell application\nuser: \"We need to build a micro-frontend architecture using Module Federation. 8 teams will develop independent features that load into a shared shell. We need shared dependencies, version management, and independent deployment strategies.\"\nassistant: \"I'll design a Module Federation architecture with a shell application, create shared library modules for common dependencies, implement dynamic remote loading with fallback strategies, design communication patterns between microfrontends using RxJS subjects and services, set up shared state management, and configure deployment pipelines for independent team releases. I'll include version compatibility checks and feature isolation patterns.\"\n<commentary>\nUse angular-architect when designing micro-frontend systems or multi-team Angular architectures. This agent specializes in enterprise-scale architecture decisions including module federation, shared dependencies, and deployment strategies.\n</commentary>\n</example>\n\n<example>\nContext: Enterprise application needs upgrade from Angular 12 with legacy patterns to Angular 18 with signals, and adoption of modern reactive patterns\nuser: \"Upgrade our Angular 12 application to Angular 18 with 150+ components, migrate from RxJS subjects to signals, adopt OnPush strategy across the board, and implement new control flow syntax. What's the migration strategy?\"\nassistant: \"I'll create a phased migration strategy that converts class components to functional components with signals, implements computed signals for derived state, replaces subject-based state with signal stores, adopts OnPush change detection gradually with testing validation, migrates to new control flow syntax (@if, @for), and updates RxJS patterns to work alongside signals. I'll establish metrics to validate performance improvements at each phase.\"\n<commentary>\nUse angular-architect when modernizing Angular applications across major version upgrades or adopting new paradigms like signals. This agent designs strategic architectural migrations with minimal disruption and measurable improvements.\n</commentary>\n</example>"
Python Mcp Expert
Expert assistant for developing Model Context Protocol (MCP) servers in Python
Spring Boot Engineer
"Use this agent when building enterprise Spring Boot 3+ applications requiring microservices architecture, cloud-native deployment, or reactive programming patterns. Specifically:\\n\\n<example>\\nContext: User needs to design and implement a microservices architecture with Spring Cloud components and requires expertise in service discovery, circuit breakers, and distributed tracing.\\nuser: \"I'm building a microservices platform with 8 services. I need Spring Cloud setup, API Gateway configuration, and circuit breaker patterns.\"\\nassistant: \"I'll use the spring-boot-engineer agent to architect your microservices platform with Spring Cloud Gateway, service discovery with Eureka, Resilience4j circuit breakers, and distributed tracing with Spring Cloud Sleuth.\"\\n<commentary>\\nUse this agent when you need comprehensive microservices architecture design with Spring Cloud components, including API gateway patterns, service discovery, circuit breakers, and observability setup.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Project requires reactive programming implementation for high-throughput APIs with non-blocking data access and backpressure handling.\\nuser: \"We need to optimize our APIs for high concurrency. Should we use WebFlux and how do we handle backpressure?\"\\nassistant: \"I'll use the spring-boot-engineer agent to guide you on implementing Spring WebFlux for non-blocking APIs, using Project Reactor (Mono/Flux), configuring R2DBC for reactive database access, and properly handling backpressure in your data flows.\"\\n<commentary>\\nUse this agent when modernizing your Spring Boot application to support reactive patterns, including WebFlux migration, Mono/Flux usage, backpressure strategies, and R2DBC integration.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Enterprise application needs production hardening including security configuration, cloud deployment optimization, and comprehensive testing strategy for GraalVM native compilation.\\nuser: \"We need to production-harden our Spring Boot app: Spring Security with OAuth2, GraalVM native image support, and 85%+ test coverage.\"\\nassistant: \"I'll use the spring-boot-engineer agent to implement Spring Security with OAuth2/JWT, configure GraalVM native compilation, set up comprehensive test suite using WebTestClient and Testcontainers, and establish health checks and graceful shutdown for Kubernetes.\"\\n<commentary>\\nUse this agent when hardening Spring Boot applications for production: implementing enterprise security patterns, configuring cloud-native features, optimizing for container deployment, and ensuring comprehensive test coverage with tools like Testcontainers.\\n</commentary>\\n</example>"
Embedded Systems
"Use when developing firmware for resource-constrained microcontrollers, implementing RTOS-based applications, or optimizing real-time systems where hardware constraints, latency guarantees, and reliability are critical. Specifically:\\n\\n<example>\\nContext: A team is building firmware for an STM32F4-based IoT sensor that must operate on battery power for 6 months with strict latency requirements.\\nuser: \"We need firmware for a temperature/humidity sensor running on STM32F4 with 48KB RAM. Must wake every 30 seconds, take measurements, transmit via LoRaWAN, then sleep to achieve 6-month battery life. Latency-critical interrupt from accelerometer must be handled in under 100 microseconds.\"\\nassistant: \"I'll design this with FreeRTOS for task scheduling, implement low-power sleep modes with configurable wake sources, optimize interrupt handlers for sub-100us response, create efficient sensor drivers with DMA, and profile power consumption to meet your 6-month target. I'll include watchdog protection and robust error recovery for field deployments.\"\\n<commentary>\\nUse this agent when implementing embedded systems with real-time constraints, power management requirements, and resource limitations. This agent handles RTOS configuration, interrupt latency optimization, DMA programming, and battery-aware sleep mode design.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: An existing bare-metal firmware needs conversion to use RTOS for better task management and timing predictability.\\nuser: \"Our ESP32 control loop runs bare metal with interrupt-driven state machine. We're seeing jitter in timing. Can we refactor to use FreeRTOS with deterministic task scheduling while keeping real-time guarantees?\"\\nassistant: \"I'll migrate your interrupt-driven architecture to FreeRTOS with priority-based task scheduling, implement task synchronization using semaphores, refactor your state machine into a scheduler-friendly task, set up timer callbacks for precise periodic execution, and add stack monitoring. I'll verify timing margins haven't degraded and provide profiling data showing latency improvement.\"\\n<commentary>\\nInvoke this agent when transitioning firmware from bare-metal to RTOS-based architectures. This agent refactors interrupt handlers into tasks, implements proper synchronization, and ensures real-time guarantees are maintained during the transition.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A real-time audio processing system needs optimization to handle high interrupt rates while managing memory efficiently on a limited embedded platform.\\nuser: \"Building audio DSP on ARM Cortex-M7 with 512KB RAM. Need to process 48kHz stereo with <5ms latency, handle USB audio in/out with DMA ring buffers, and implement real-time filter processing without memory fragmentation.\"\\nassistant: \"I'll design a fixed-size memory pool for audio buffers, implement DMA ring buffers for zero-copy USB streaming, set interrupt priorities to ensure audio ISR preempts non-critical tasks, optimize the DSP filter chains with SIMD intrinsics where available, and add CPU utilization monitoring. I'll stress-test with glitch detection to verify sub-5ms latency.\"\\n<commentary>\\nUse this agent for real-time performance-critical embedded systems requiring low latency, efficient memory management, and complex interrupt coordination. This agent excels at DMA optimization, lock-free buffer design, and ISR tuning to meet strict timing guarantees.\\n</commentary>\\n</example>"
Django Developer
"Use when building Django 4+ web applications, REST APIs, or modernizing existing Django projects with async views and enterprise patterns. Specifically:\\n\\n<example>\\nContext: Team needs to build a production-ready REST API with JWT authentication, role-based permissions, and async handlers for high-traffic endpoints\\nuser: \"We're building a real-time notification system using Django REST Framework with WebSockets. Need to handle 10k+ concurrent users with proper authentication and rate limiting.\"\\nassistant: \"I'll architect a scalable solution using Django 4.2, DRF with async views, Celery for background tasks, and Redis for caching. Setting up JWT authentication with custom permissions, WebSocket support via Django Channels, and optimized queries with select_related/prefetch_related patterns.\"\\n<commentary>\\nInvoke this agent when you need expertise in designing and implementing complex Django REST APIs with modern async patterns, authentication, and scaling considerations for production environments.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Legacy Django 2.x application needs performance optimization, migration to Django 4.2, and test coverage improvement\\nuser: \"Our Django 2.2 app is slow with 300ms response times. We need to migrate to Django 4, add tests, and optimize database queries.\"\\nassistant: \"I'll create a migration plan: upgrade Django incrementally, identify N+1 query problems with django-debug-toolbar, implement select_related/prefetch_related, add pytest-django tests (aiming for 90%+ coverage), and optimize the ORM with proper indexing and caching strategies.\"\\n<commentary>\\nUse this agent for Django modernization projects, performance troubleshooting, query optimization, and establishing testing best practices on existing codebases.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Building a multi-tenant SaaS platform with complex permissions, background job processing, and payment integration\\nuser: \"Building a SaaS app with multiple customer organizations, usage-based billing via Stripe, background email processing, and fine-grained permissions per tenant.\"\\nassistant: \"I'll implement multi-tenancy using django-organizations or custom middleware, DRF with tenant-scoped viewsets, Celery + Redis for async tasks, Stripe integration for billing webhooks, custom permission classes for tenant isolation, and comprehensive security hardening including CSRF, CORS, and rate limiting.\"\\n<commentary>\\nInvoke when implementing sophisticated Django features like multi-tenancy, payment processing, background job queues, and advanced permission systems that require deep framework knowledge.\\n</commentary>\\n</example>"
Dotnet Core Expert
"Use when building .NET Core applications requiring cloud-native architecture, high-performance microservices, modern C# patterns, or cross-platform deployment with minimal APIs and advanced ASP.NET Core features. Specifically:\\n\\n<example>\\nContext: Building a microservices platform with multiple .NET 10 services that need cloud-native deployment, health checks, and distributed tracing across services.\\nuser: \"I need to build a system with 5 microservices in .NET 10 using minimal APIs, each with OpenAPI documentation, containerized deployment, health checks, and distributed tracing. Services must support Kubernetes auto-scaling with graceful shutdown.\"\\nassistant: \"I'll architect your microservices platform with: minimal APIs endpoints using MapGroup for organization, OpenAPI integration with auto-documentation, containerized Dockerfile optimized for .NET 10, Kubernetes manifests with liveness/readiness probes, OpenTelemetry for distributed tracing, and graceful shutdown handlers. Each service will follow clean architecture with dependency injection and 80%+ test coverage.\"\\n<commentary>\\nUse dotnet-core-expert when building cloud-native microservices requiring modern .NET 10 features, cross-platform Kubernetes deployment, distributed system patterns, and high-performance APIs with extensive observability instrumentation.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating legacy ASP.NET Framework application to .NET 10 with need for Native AOT compilation and minimal startup time.\\nuser: \"We have a large ASP.NET Framework 4.8 application that needs to migrate to .NET 10. Requirements: reduce startup time from 3 seconds to under 500ms, support containerized deployment, and maintain feature parity. Can we use Native AOT?\"\\nassistant: \"I'll execute the migration with: code analysis to identify Framework-specific dependencies, refactor to .NET 10 compatible patterns, implement minimal APIs replacing legacy controllers, configure Native AOT compilation with required IsAotCompatible attributes, add performance benchmarks validating startup improvements, and set up containerized testing with the optimized binary.\"\\n<commentary>\\nInvoke dotnet-core-expert for large-scale migrations from older .NET frameworks to .NET 10, performance optimization through Native AOT, architectural modernization to minimal APIs, and leveraging modern C# features like records and pattern matching.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Building data processing service requiring Entity Framework Core with optimized queries, CQRS pattern, and high-throughput async operations.\\nuser: \"Our data processing service needs to handle 10k requests/second with Entity Framework Core using async/await, implement CQRS pattern with MediatR, optimize query performance, and maintain 85%+ test coverage with integration tests.\"\\nassistant: \"I'll design the service with: Entity Framework Core with query optimization (select projections, compiled queries), CQRS implementation using MediatR for separation of concerns, async throughout with proper context propagation, repository pattern for data access, xUnit integration tests with TestContainers for realistic database testing, and performance profiling to validate throughput goals.\"\\n<commentary>\\nUse dotnet-core-expert when implementing complex application patterns like CQRS+MediatR, optimizing Entity Framework Core for high-throughput scenarios, or building services requiring sophisticated async patterns and comprehensive testing strategies.\\n</commentary>\\n</example>"
Csharp Developer
"Use this agent when building ASP.NET Core web APIs, cloud-native .NET solutions, or modern C# applications requiring async patterns, dependency injection, Entity Framework optimization, and clean architecture. Specifically:\\n\\n<example>\\nContext: Building a production ASP.NET Core REST API with database integration, authentication, and comprehensive testing.\\nuser: \"I need to create an ASP.NET Core 8 API with EF Core, JWT authentication, Swagger documentation, and 85%+ test coverage. Should follow clean architecture.\"\\nassistant: \"I'll invoke csharp-developer to design a layered clean architecture with Domain/Application/Infrastructure projects. Implement minimal APIs with route groups, configure EF Core with compiled queries and migrations, add JWT bearer authentication, integrate Swagger/OpenAPI, and create comprehensive xUnit integration tests with TestServer.\"\\n<commentary>\\nUse csharp-developer when building production ASP.NET Core web applications needing proper architectural structure, async database access with EF Core, authentication/authorization, and comprehensive testing. This agent excels at setting up enterprise-grade API infrastructure and enforcing .NET best practices.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Optimizing performance of an existing C# application with memory allocations and async bottlenecks.\\nuser: \"Our ASP.NET Core API has 500ms p95 response times. We need profiling, optimization of allocations using ValueTask and Span<T>, distributed caching, and performance benchmarks.\"\\nassistant: \"I'll use csharp-developer to profile with Benchmark.NET, refactor to ValueTask patterns, implement Span<T> and ArrayPool for hot paths, add distributed caching with Redis, optimize LINQ queries with compiled expressions, and establish performance regression tests.\"\\n<commentary>\\nInvoke csharp-developer when performance optimization is critical—profiling memory allocations, applying ValueTask/Span patterns, tuning Entity Framework queries, implementing caching strategies, and adding performance benchmarks to track improvements.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Modernizing cross-platform application development with MAUI for desktop and mobile deployment.\\nuser: \"We're building a .NET MAUI app for Windows, macOS, and iOS. Need proper platform-specific code, native interop, resource management, and deployment strategies for all platforms.\"\\nassistant: \"I'll invoke csharp-developer to structure the MAUI project with platform-specific implementations using conditional compilation, implement native interop for platform APIs, configure resource management for each target platform, set up self-contained deployments, and create platform-specific testing strategies.\"\\n<commentary>\\nUse csharp-developer when developing cross-platform applications with MAUI, needing platform-specific code organization, native interop handling, or multi-target deployment strategies for desktop and mobile platforms.\\n</commentary>\\n</example>"
Rust Engineer
"Use when building Rust systems where memory safety, ownership patterns, zero-cost abstractions, and performance optimization are critical for systems programming, embedded development, async applications, or high-performance services. Specifically:\\n\\n<example>\\nContext: Designing a high-throughput async network service that must handle thousands of concurrent connections with minimal memory overhead and strict latency requirements\\nuser: \"Create a tokio-based async service that processes 50k concurrent TCP connections. Need proper ownership patterns to avoid allocations, async/await with custom Future implementations where needed, and memory-safe FFI bindings to a C library. Must be zero-unsafe-code in public API.\"\\nassistant: \"I'll architect the service with smart pointer patterns (Arc for shared state, Box for heap allocation), async task spawning with cancellation via select!, proper lifetime management for the FFI boundary, and unsafe blocks only in isolated wrapper crates with exhaustive MIRI verification. This ensures sub-microsecond latency with predictable memory usage.\"\\n<commentary>\\nUse rust-engineer when building async/concurrent systems with tight performance budgets, strict memory constraints, or complex ownership patterns that need careful lifetime management to achieve zero-allocation paths in hot code.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Implementing a systems programming project like a file parser, codec library, or embedded driver with complex unsafe code requirements and memory safety concerns\\nuser: \"Building a binary file parser that must handle untrusted input safely and efficiently. Need custom allocators for arena allocation, unsafe code for SIMD optimizations, careful bounds checking, and comprehensive testing with MIRI to catch undefined behavior. Should compile to both x86_64 and ARM targets.\"\\nassistant: \"I'll design the parser with safe abstractions over unsafe code blocks, use custom Allocator trait for arena patterns, implement SIMD intrinsics safely within isolated unsafe modules, validate all invariants, add fuzzing with cargo-fuzz, verify with MIRI, and ensure clippy::pedantic passes. Document all safety invariants thoroughly.\"\\n<commentary>\\nInvoke rust-engineer for systems-level code that requires unsafe blocks, custom memory management, SIMD intrinsics, embedded constraints (no_std), or cross-platform compilation where memory safety verification is non-negotiable.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Performance optimization for an existing Rust codebase hitting memory/CPU limits with profiling data indicating allocation hotspots and GC pressure\\nuser: \"Our parser is allocating 50MB per request. Profile shows most allocations in String building and Vec resizing. Need to apply Cow patterns, use custom types with SmallVec for stack allocation, benchmark against current implementation, and document the optimization tradeoffs.\"\\nassistant: \"I'll apply profiling with flamegraph, identify hot paths, replace allocating patterns with Cow<str> and SmallVec<[T; N]>, implement custom iterators to reduce intermediate allocations, add criterion benchmarks showing improvements, and verify with perf that cache behavior improves. Zero-allocation paths for critical code.\"\\n<commentary>\\nUse rust-engineer for performance-critical optimization work, benchmarking against baselines, zero-allocation optimizations, memory-efficient data structures, or when Rust's type system needs to encode performance guarantees at compile-time.\\n</commentary>\\n</example>"
Rails Expert
"Use when building or modernizing Rails applications requiring full-stack development, Hotwire reactivity, real-time features, or Rails-idiomatic patterns for maximum productivity. Specifically:\\n\\n<example>\\nContext: Building a new Rails 8.1 SaaS application from scratch with real-time notifications, multi-tenancy, and maximum developer velocity\\nuser: \"Create a new Rails 8.1 SaaS platform for collaborative project management. Need multi-tenant architecture, real-time collaboration via Hotwire/Turbo, background job processing, comprehensive tests, and deployment to Kubernetes.\"\\nassistant: \"I'll architect a complete Rails application: set up multi-tenancy with scoped models, implement Hotwire/Turbo for reactive UI without JavaScript, configure Action Cable for real-time updates, set up Sidekiq for background jobs, create comprehensive RSpec tests (95%+ coverage), add database indexing, and provide Docker/Kubernetes deployment configuration.\"\\n<commentary>\\nUse rails-expert when building complete Rails applications from scratch or when you need full-stack Rails development spanning database design, controller/view architecture, real-time features, and production-ready deployment setup. This agent understands Rails conventions deeply and delivers applications optimized for developer happiness and performance.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Upgrading a legacy Rails 4 application to Rails 8.1 while keeping the application running in production\\nuser: \"We have a Rails 4.2 application with 500k LOC. How do we upgrade to Rails 8.1 without breaking production? Need incremental approach, testing strategy, and how to adopt Hotwire gradually without rewriting all views.\"\\nassistant: \"I'll create a phased upgrade plan: establish comprehensive test coverage with RSpec, upgrade to Rails 5.0, then 6.0, then 7.0, then 8.1 incrementally, address deprecation warnings in each phase, migrate to Hotwire progressively by converting high-traffic pages first, update dependencies carefully, set up feature flags for A/B testing new pages, and maintain CI/CD throughout.\"\\n<commentary>\\nInvoke rails-expert for major Rails version upgrades, modernization efforts, or when you need to integrate new Rails features (Hotwire, encryption, etc.) into existing applications while maintaining production stability and preventing regressions through strategic testing.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Rails application experiencing N+1 query problems, slow page loads, and needs performance optimization without adding complexity\\nuser: \"Our Rails app is slow. Pages take 2+ seconds to load. We have N+1 queries, missing database indexes, and inefficient caching. How do we profile, identify bottlenecks, and optimize without massive refactoring?\"\\nassistant: \"I'll implement Rails performance optimization: use bullet gem to detect N+1 queries automatically, profile with rack-mini-profiler and New Relic, add strategic database indexes, implement fragment caching for views, use ActiveRecord includes/joins properly, add query result caching with Redis, benchmark critical paths with minitest, and monitor in production.\"\\n<commentary>\\nUse rails-expert when optimizing Rails application performance, addressing N+1 queries, implementing caching strategies, or tuning production Rails applications. This agent applies Rails-specific optimization techniques including database indexing, caching patterns (Russian doll caching), query optimization, and monitoring.\\n</commentary>\\n</example>"
Iot Engineer
"Use when designing and deploying IoT solutions requiring expertise in device management, edge computing, cloud integration, and handling challenges like massive device scale, complex connectivity scenarios, or real-time data pipelines. Specifically:\\n\\n<example>\\nContext: A smart city project needs to deploy 50,000 sensors across a metropolitan area with cellular and LoRaWAN connectivity, requiring edge processing to reduce cloud costs and real-time anomaly detection.\\nuser: \"We're building a smart city platform with 50,000 environmental sensors. We need hybrid connectivity (4G and LoRaWAN), edge gateways for data filtering, cloud data pipelines processing 100K messages/sec, and predictive maintenance analytics. How do we architect this?\"\\nassistant: \"I'll design a three-tier IoT architecture: device layer with LoRaWAN and 4G provisioning, edge layer with local aggregation and filtering reducing cloud traffic by 70%, and cloud tier with stream processing and analytics. I'll implement AWS IoT Core with device shadows for state management, edge Lambda functions for local ML inference, and Kinesis for real-time processing. This reduces cloud costs by 67% while achieving sub-second alerting on anomalies.\"\\n<commentary>\\nUse this agent when designing large-scale IoT deployments with 10,000+ devices, multiple connectivity types, edge processing requirements, and real-time analytics needs. This agent excels at architecture spanning device-to-cloud with cost optimization.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: A manufacturing company has 5,000 IoT devices collecting sensor data but struggles with device failures, missed updates, and inconsistent data quality. They need improved device management and reliability.\\nuser: \"Our manufacturing fleet has 5,000 devices sending telemetry. We have 2% unplanned downtime due to device failures, sporadic firmware update failures, and data quality issues. We need better device management, OTA updates, and monitoring. Current uptime target is 99.9%.\"\\nassistant: \"I'll implement a comprehensive device management solution: automated provisioning with certificate-based auth, staged OTA updates with rollback capability, health monitoring with predictive failure detection, and data quality validation pipelines. I'll set up Azure IoT Hub for centralized management, implement device twins for state tracking, add anomaly detection to predict failures 7 days in advance, and create automated remediation workflows. This achieves 99.95% uptime with zero unplanned downtime.\"\\n<commentary>\\nInvoke this agent when existing IoT deployments need reliability improvements, device management hardening, OTA update strategies, or predictive maintenance implementation. This agent focuses on operational excellence and system stability.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: An agricultural IoT startup is building a soil moisture and weather monitoring platform for farms but struggles with battery life, network coverage in rural areas, and processing high-frequency sensor streams efficiently.\\nuser: \"We have 10,000 soil sensors deployed on farms. Each collects temperature, humidity, and moisture every 60 seconds. Cellular coverage is spotty in rural areas, batteries must last 18 months, and farmers need real-time insights. Our cloud costs are unsustainable.\"\\nassistant: \"I'll architect a distributed solution with LoRaWAN for reliable rural coverage and ultra-low-power consumption, edge gateways aggregating data locally reducing cloud traffic by 95%, and intelligent batching protocols extending battery life to 24 months. I'll implement edge ML models predicting irrigation needs, reducing unnecessary data transmission. ThingsBoard handles device management and visualization, with local rule engines triggering alerts before data reaches cloud. This reduces bandwidth 95% and cuts cloud costs by 78%.\"\\n<commentary>\\nUse this agent for power-constrained IoT deployments with limited connectivity, high sensor densities, and the need for edge intelligence. This agent specializes in battery optimization, protocol selection, and edge processing to handle scale and cost challenges.\\n</commentary>\\n</example>"
CSharpExpert
An agent designed to assist with software development tasks for .NET projects.
Mongodb Performance Advisor
Analyze MongoDB database performance, offer query and index optimization insights and provide actionable recommendations to improve overall usage of the database.
Powershell 7 Expert
"Use when building cross-platform cloud automation scripts, Azure infrastructure orchestration, or CI/CD pipelines requiring PowerShell 7+ with modern .NET interop, idempotent operations, and enterprise-grade error handling. Specifically:\\n\\n<example>\\nContext: Team needs to automate Azure VM lifecycle management across multiple subscriptions with proper logging and error recovery.\\nuser: \"Create PowerShell scripts to provision, configure, and decommission Azure VMs across 5 subscriptions. Need idempotent operations, comprehensive logging, and -WhatIf/-Confirm support for safety.\"\\nassistant: \"I'll build a PowerShell 7 automation suite using Az module with subscription context handling, implement idempotent patterns with resource existence checks, add structured logging via Write-Host/Error, support -WhatIf/-Confirm parameters for safety, and include error recovery with retry logic and proper authentication using Managed Identity.\"\\n<commentary>\\nUse powershell-7-expert for cloud automation requiring multi-tenant orchestration, subscription/tenant context management, and enterprise safety patterns like WhatIf support and comprehensive error handling. This agent handles Azure-specific patterns and modern .NET interop.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Building GitHub Actions workflows that need cross-platform (Windows, Linux, macOS) CI/CD automation with complex orchestration logic.\\nuser: \"Set up GitHub Actions workflows using PowerShell that run on Windows, Linux, and macOS runners. Need to handle artifact management, environment-specific configurations, and integration with Azure DevOps.\"\\nassistant: \"I'll architect GitHub Actions workflows leveraging PowerShell 7's cross-platform capabilities: use $PSVersionTable and platform detection for environment-specific logic, implement artifact handling with consistent paths across OSes, create environment-specific config files, integrate Azure DevOps APIs via PowerShell SDK, and add comprehensive logging for CI/CD debugging.\"\\n<commentary>\\nUse powershell-7-expert when building CI/CD pipelines that require PowerShell's cross-platform capabilities and complex orchestration logic. This agent applies PowerShell 7 features like pipeline operators, null-coalescing, and modern exception handling for production-ready pipelines.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Enterprise needs advanced M365/Graph API automation for user provisioning and Teams governance across complex organizational hierarchies.\\nuser: \"Implement PowerShell automation for Graph API to provision M365 users, set up Teams, manage group memberships, and enforce governance policies. Need performance optimization for large-scale operations (10k+ users).\"\\nassistant: \"I'll build high-performance Graph API automation using PowerShell 7: parallelize user provisioning with ForEach-Object -Parallel, implement batch operations for efficiency, use .NET 6/7 HttpClient for Graph API calls, add comprehensive error handling with custom exception classes, cache authentication tokens, and implement retry logic with exponential backoff for reliability.\"\\n<commentary>\\nUse powershell-7-expert for enterprise M365/Graph automation requiring high performance, parallel processing, and modern .NET interop. This agent applies PowerShell 7 parallelism features and handles complex Graph API scenarios with proper rate limiting and batching.\\n</commentary>\\n</example>"
Typescript Mcp Expert
Expert assistant for developing Model Context Protocol (MCP) servers in TypeScript
README
A ready-to-install Claude Code component.
Dotnet Framework 4.8 Expert
"Use this agent when working on legacy .NET Framework 4.8 enterprise applications that require maintenance, modernization, or integration with Windows-based infrastructure. Specifically:\\n\\n<example>\\nContext: User has a legacy ASP.NET Web Forms application running on .NET Framework 4.8 that needs security updates and performance optimization.\\nuser: \"We have a 10-year-old Web Forms application with ViewState bloat and some outdated security patterns. How can we modernize it without a complete rewrite?\"\\nassistant: \"I'll use the dotnet-framework-4.8-expert agent to analyze the architecture, identify security vulnerabilities, and recommend modernization strategies while maintaining backward compatibility.\"\\n<commentary>\\nSince this involves legacy .NET Framework 4.8 Web Forms with specific modernization constraints, use the dotnet-framework-4.8-expert agent rather than a general C# developer.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User is implementing a WCF service that needs to interoperate with legacy Windows services and COM components.\\nuser: \"We need to create a WCF service that talks to our old COM objects and Windows services. What's the best approach?\"\\nassistant: \"I'll use the dotnet-framework-4.8-expert agent to design the WCF service architecture with proper interop patterns and Windows service integration.\"\\n<commentary>\\nWCF services with COM interop and Windows service integration are specialized concerns within .NET Framework 4.8. Use this agent for legacy Windows integration patterns.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: User has an enterprise application running on .NET Framework 4.8 with performance issues and legacy deployment constraints.\\nuser: \"Our ERP system is running slow on .NET Framework 4.8. We're locked into Windows Server 2012 R2. What optimizations are realistic?\"\\nassistant: \"I'll use the dotnet-framework-4.8-expert agent to identify bottlenecks, optimize database access, tune garbage collection, and work within your framework and infrastructure constraints.\"\\n<commentary>\\nLegacy enterprise applications with Windows infrastructure constraints require understanding of .NET Framework 4.8 specifics, not just general C# knowledge. Use this specialized agent.\\n</commentary>\\n</example>"
Elixir Expert
"Use this agent when you need to build fault-tolerant, concurrent systems leveraging OTP patterns, GenServer architectures, and Phoenix framework for real-time applications. Specifically:\\n\\n<example>\\nContext: Building a real-time chat application with WebSocket support, process supervision, and multi-node clustering.\\nuser: \"I need to create a Phoenix LiveView chat app with custom GenServer state management, WebSocket channels, and the ability to cluster across multiple nodes. What's the best approach?\"\\nassistant: \"I'll invoke elixir-expert to: design a supervision tree with GenServer for message routing, implement Phoenix Channels for WebSocket communication, set up LiveView for real-time UI updates, and configure libcluster for multi-node distribution with fault tolerance.\"\\n<commentary>\\nUse elixir-expert when building distributed, real-time applications that require OTP process management, Phoenix framework integration, and multi-node clustering. This agent specializes in designing supervision trees, implementing GenServer patterns, and optimizing BEAM VM performance for concurrent workloads.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Optimizing a high-throughput data processing pipeline for performance and memory efficiency.\\nuser: \"We have an Elixir pipeline processing 100K messages/second with memory bottlenecks. How do we optimize for throughput?\"\\nassistant: \"I'll use elixir-expert to: profile with :observer and Benchee, refactor to use Flow for parallel processing, optimize process hibernation, implement ETS caching for hot data, and tune BEAM scheduler settings for maximum throughput.\"\\n<commentary>\\nUse elixir-expert for performance optimization of concurrent systems, stream processing, and BEAM VM tuning. This agent applies profiling techniques, implements Flow/Broadway patterns for parallel data processing, and optimizes memory usage through process hibernation and ETS strategies.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Migrating a Phoenix monolith to a more resilient architecture with proper error handling and observability.\\nuser: \"Our Phoenix app crashes frequently due to poor error handling and we lack observability. How do we make it production-ready?\"\\nassistant: \"I'll invoke elixir-expert to: implement comprehensive error handling with tagged tuples and 'let it crash' philosophy, add Telemetry instrumentation and Logger configuration, set up supervision strategies for automatic recovery, implement circuit breaker patterns, and integrate LiveDashboard for observability.\"\\n<commentary>\\nUse elixir-expert when building production-ready applications that require robust error handling, observability, and the 'let it crash' philosophy. This agent designs proper Supervisor hierarchies, implements failure recovery patterns, and adds comprehensive monitoring with Telemetry and LiveDashboard.\\n</commentary>\\n</example>"
Rust Mcp Expert
Expert assistant for Rust MCP server development using the rmcp SDK with tokio async runtime
Microsoft Agent Framework Python
Create, update, refactor, explain or work with code using the Python version of Microsoft Agent Framework.
Powershell Ui Architect
"Use when designing or building desktop graphical interfaces (WinForms, WPF, Metro-style dashboards) or terminal user interfaces (TUIs) for PowerShell automation tools that need clean separation between UI and business logic. Specifically:\\n\\n<example>\\nContext: IT team has a mature Active Directory automation module but users are currently running commands from plain PowerShell. They want a GUI frontend so helpdesk staff can manage common AD operations safely without script knowledge.\\nuser: \"We have a well-structured PowerShell module for AD user provisioning and group management. Can you build a WinForms interface so our helpdesk can use it without command-line knowledge?\"\\nassistant: \"I'll design a WinForms UI that wraps your AD module with clear controls for user creation, group assignment, and password reset. The UI will include input validation, error handling with user-friendly messages, progress indicators for long-running operations, and audit logging that feeds into your existing module.\"\\n<commentary>\\nInvoke the powershell-ui-architect when you need to create a desktop GUI wrapper around existing PowerShell automation logic. This agent specializes in separating concerns so the UI is thin and the business logic remains pure and testable.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Operations team monitors multiple servers and needs a real-time dashboard displaying health metrics, alerts, and quick-action tiles for common administrative tasks.\\nuser: \"Build a modern dashboard using WPF and MahApps.Metro to display server health, CPU/memory usage, and tiles for common ops tasks like service restart or log collection. It needs theme support and should look professional.\"\\nassistant: \"I'll architect a Metro-style WPF dashboard with: tiles and flyouts for task access, real-time metrics binding to your PowerShell data providers, accent color theming support, background workers for non-blocking updates, and clean MVVM separation. Each tile will trigger your PowerShell modules securely.\"\\n<commentary>\\nUse the powershell-ui-architect for modern, polished UIs with professional appearance requirements. The agent excels at Metro design patterns, theming, and building dashboards that look enterprise-grade while maintaining maintainable code structure.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Automation scripts need to run on remote servers where graphical environments aren't available, but users need interactive menu-driven interfaces for safe task selection.\\nuser: \"Create a terminal menu system for our remote server automation where operators can select tasks, see status updates, and confirm actions. No GUI possible in these environments.\"\\nassistant: \"I'll build a resilient TUI using PowerShell console APIs with clear menu navigation, keyboard shortcuts for experienced users, input validation with helpful prompts, status indicators using text formatting, and graceful handling of terminal size constraints. The TUI will safely invoke your core automation modules.\"\\n<commentary>\\nInvoke the powershell-ui-architect for TUI design when graphical environments aren't available or when automation runs on headless systems. The agent designs accessible text-based interfaces that guide users safely through complex operations.\\n</commentary>\\n</example>"
Csharp Dotnet Janitor
Perform janitorial tasks on C#/.NET code including cleanup, modernization, and tech debt remediation.
Csharp Mcp Expert
Expert assistant for developing Model Context Protocol (MCP) servers in C#
Powershell Module Architect
"Use this agent when architecting and refactoring PowerShell modules, designing profile systems, or creating cross-version compatible automation libraries. Invoke it for module design reviews, profile optimization, packaging reusable code, and standardizing function structure across teams. Specifically:\\n\\n<example>\\nContext: DevOps team has dozens of standalone PowerShell scripts handling AD, DNS, and DHCP tasks. Leadership wants these consolidated into a maintainable module for the infrastructure team.\\nuser: \"We have 40+ PowerShell scripts scattered across shared drives. We need to consolidate them into a proper module with proper structure, documentation, and versioning.\"\\nassistant: \"I'll design a comprehensive module architecture with: public/private function separation, manifest with metadata and dependencies, helper library for shared logic, consistent error handling patterns, -WhatIf support, and organized dot-sourcing structure. I'll also create a migration checklist to refactor existing scripts into the module while maintaining backward compatibility.\"\\n<commentary>\\nInvoke powershell-module-architect when you need to transform fragmented scripts into a professionally structured, documented module. This agent excels at designing the overall module layout, establishing naming conventions, and planning the refactoring strategy.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Company standardized on PowerShell 7+ but has teams still using PowerShell 5.1 on legacy servers. Need a shared utility library that works across both versions.\\nuser: \"We need a helper library for common Active Directory and DNS operations that works on both PowerShell 5.1 and 7+. Our teams use both versions.\"\\nassistant: \"I'll design a cross-version compatible module using capability detection at module load time, version-specific code paths for features only in 7+, backward-compatible syntax throughout, comprehensive version checks in the manifest, and documented migration guidance for when teams upgrade. The module will gracefully degrade on 5.1 while using modern features when available.\"\\n<commentary>\\nUse powershell-module-architect when you need to design libraries that bridge version gaps across an organization. The agent specializes in compatibility strategy, version detection patterns, and designing modules that work reliably in heterogeneous environments.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Organization wants all engineers to have a consistent, fast-loading PowerShell profile with team-specific tools and shortcuts, but without bloating startup time.\\nuser: \"We need to design a standard profile for our infrastructure team that includes shortcuts for common tasks but doesn't slow down shell startup. Currently people have messy profile scripts everywhere.\"\\nassistant: \"I'll design a modular profile system with: lazy-import structure for heavy modules, separate config for core/utilities/shortcuts, efficient prompt function, per-machine customization capability, documentation for team members to add their own tools, and load-time optimization patterns. This keeps shell startup fast while providing ergonomic shortcuts.\"\\n<commentary>\\nInvoke powershell-module-architect when designing profile systems or organizational standardization. The agent will create the architecture, load-time strategies, and extensibility patterns that let teams standardize without performance penalties.\\n</commentary>\\n</example>"
Semantic Kernel Python
Create, update, refactor, explain or work with code using the Python version of Semantic Kernel.
Technical Content Evaluator
Elite technical content editor and curriculum architect for evaluating technical training materials, documentation, and educational content. Reviews for technical accuracy, pedagogical excellence, content flow, code validation, and ensures A-grade quality standards.
Go Mcp Expert
Expert assistant for building Model Context Protocol (MCP) servers in Go using the official SDK.
Ruby Mcp Expert
Expert assistance for building Model Context Protocol servers in Ruby using the official MCP Ruby SDK gem with Rails integration.
Powershell 5.1 Expert
"Use when automating Windows infrastructure tasks requiring PowerShell 5.1 scripts with RSAT modules for Active Directory, DNS, DHCP, GPO management, or when building safe, enterprise-grade automation workflows in legacy .NET Framework environments. Specifically:\\n\\n<example>\\nContext: Enterprise needs to automate bulk user creation and AD group membership from a CSV file with rollback capability and comprehensive logging.\\nuser: \"I need a PowerShell script to create 500 users from a CSV, add them to appropriate security groups, enable their accounts, and set initial passwords. Must have rollback support and detailed audit logging.\"\\nassistant: \"I'll create a production-safe PowerShell 5.1 script using RSAT ActiveDirectory module with: parameter validation, try-catch error handling, -WhatIf/-Confirm support for preview mode, pre-checks for group existence and user duplication, detailed transcription logging, and a rollback function to remove created objects. The script will validate domain membership and permissions before execution.\"\\n<commentary>\\nInvoke powershell-5.1-expert when you need to write safe, auditable PowerShell automation for AD operations with enterprise-grade error handling, logging, and rollback capabilities. This agent excels at building reliable scripts for infrastructure teams operating in Windows-only environments.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: DNS infrastructure team needs to batch-update DNS records across multiple zones with change validation and automatic rollback if issues detected.\\nuser: \"We need to update CNAME records for a service migration across 3 DNS zones. Must verify records update correctly and rollback automatically if validation fails.\"\\nassistant: \"I'll build a PowerShell 5.1 script using DnsServer RSAT module with: zone-by-zone record enumeration, backup exports before changes, dynamic PowerShell remoting to DNS servers, post-update validation via DNS queries, conditional rollback logic, and verbose logging. Each zone update will use -WhatIf preview before execution with approval gates.\"\\n<commentary>\\nUse powershell-5.1-expert for infrastructure change automation that requires careful validation, pre-flight checks, and safe rollback mechanisms. The agent specializes in multi-step workflows with error detection and enterprise safety patterns.\\n</commentary>\\n</example>\\n\\n<example>\\nContext: Windows Server team manages DHCP across multiple sites and needs automated scope management, reservation validation, and compliance reporting.\\nuser: \"Create a script to manage DHCP scopes and reservations across 5 sites, validate that reservations match our hardware inventory, and generate compliance reports.\"\\nassistant: \"I'll design a comprehensive PowerShell 5.1 automation using DhcpServer module with: multi-site scope enumeration via PowerShell remoting, reservation validation against inventory database, automatic scope backup, compliance report generation with CSV export, scheduled execution via task scheduler, and email notifications for failures. Includes verbose transcript logging for audit trails.\"\\n<commentary>\\nInvoke powershell-5.1-expert when you need to build repeatable, auditable infrastructure automation that must survive in legacy Windows environments without PowerShell 7+ features, and requires enterprise-grade logging and operational safety.\\n</commentary>\\n</example>"
Diffblue Cover
Expert agent for creating unit tests for java applications using Diffblue Cover.
Expert Cpp Software Engineer
Provide expert C++ software engineering guidance using modern C++ and industry best practices.
Rust Gpt 4.1 Beast Mode
Rust GPT-4.1 Coding Beast Mode for VS Code
Other Agents Categories
Catalog data and component content are sourced from the open-source davila7/claude-code-templates project (MIT license). ToolZip curates the listing and writes original descriptions; every component links back to its original source. Claude Code is a product of Anthropic. ToolZip is an independent catalog and is not affiliated with or endorsed by Anthropic.