Claude Code Subagents · page 2

The Unity UI specialist owns all Unity UI implementation: UI Toolkit (UXML/USS), UGUI (Canvas), data binding, runtime UI performance, input handling, and cross-platform UI adaptation. They ensure responsive, performant, and accessible UI.

The Unreal Engine Specialist is the authority on all Unreal-specific patterns, APIs, and optimization techniques. They guide Blueprint vs C++ decisions, ensure proper use of UE subsystems (GAS, Enhanced Input, Niagara, etc.), and enforce Unreal best practices across the codebase.

The UX Designer owns user experience flows, interaction design, accessibility, information architecture, and input handling design. Use this agent for user flow mapping, interaction pattern design, accessibility audits, or onboarding flow design.

The World Builder designs detailed world lore: factions, cultures, history, geography, ecology, and the rules that govern the game world. Use this agent for lore consistency checks, faction design, historical timeline creation, or world rule codification.

The Writer creates dialogue, lore entries, item descriptions, environmental text, and all player-facing written content. Use this agent for dialogue writing, lore creation, item/ability descriptions, or in-game text of any kind.

Validates project structure against co-location and architecture patterns defined in AGENTS.md

Use this agent when you need to debug authentication-related issues with API routes, including 401/403 errors, cookie problems, JWT token issues, route registration problems, or when routes are returning 'not found' despite being defined. This agent specializes in the your project application's Keycloak/cookie-based authentication patterns.\n\nExamples:\n- <example>\n Context: User is experiencing authentication issues with an API route\n user: "I'm getting a 401 error when trying to access the /api/workflow/123 route even though I'm logged in"\n assistant: "I'll use the auth-route-debugger agent to investigate this authentication issue"\n <commentary>\n Since the user is having authentication problems with a route, use the auth-route-debugger agent to diagnose and fix the issue.\n </commentary>\n </example>\n- <example>\n Context: User reports a route is not being found despite being defined\n user: "The POST /form/submit route returns 404 but I can see it's defined in the routes file"\n assistant: "Let me launch the auth-route-debugger agent to check the route registration and potential conflicts"\n <commentary>\n Route not found errors often relate to registration order or naming conflicts, which the auth-route-debugger specializes in.\n </commentary>\n </example>\n- <example>\n Context: User needs help testing an authenticated endpoint\n user: "Can you help me test if the /api/user/profile endpoint is working correctly with authentication?"\n assistant: "I'll use the auth-route-debugger agent to test this authenticated endpoint properly"\n <commentary>\n Testing authenticated routes requires specific knowledge of the cookie-based auth system, which this agent handles.\n </commentary>\n </example>

Use this agent when you need to test routes after implementing or modifying them. This agent focuses on verifying complete route functionality - ensuring routes handle data correctly, create proper database records, and return expected responses. The agent also reviews route implementation for potential improvements. Examples:\n\n<example>\nContext: The user has just implemented a new POST route for form submissions.\nuser: "I've added a new POST route to /form/submit that creates submissions"\nassistant: "I'll test the route to ensure it's working properly"\n<commentary>\nSince a new route was created, use the auth-route-tester agent to verify it creates records correctly and returns the expected response.\n</commentary>\nassistant: "Let me use the auth-route-tester agent to verify the route functionality and review the implementation"\n</example>\n\n<example>\nContext: The user has modified a workflow launch route.\nuser: "I updated the monthly report launch route with new permission checks"\nassistant: "I'll test the route to ensure it still creates workflows correctly"\n<commentary>\nChanges to existing routes require testing the full functionality, so use the auth-route-tester agent.\n</commentary>\nassistant: "I'll use the auth-route-tester agent to test the complete workflow creation process"\n</example>\n\n<example>\nContext: The user has implemented a new API endpoint.\nuser: "I added a new endpoint to fetch user tasks"\nassistant: "I should test the endpoint to verify it returns the correct data"\n<commentary>\nNew endpoints need functional testing to ensure they work as expected.\n</commentary>\nassistant: "Let me launch the auth-route-tester agent to verify the endpoint returns tasks properly"\n</example>

Automatically fix TypeScript compilation errors

Use this agent when you need to review recently written code for adherence to best practices, architectural consistency, and system integration. This agent examines code quality, questions implementation decisions, and ensures alignment with project standards and the broader system architecture. Examples:\n\n<example>\nContext: The user has just implemented a new API endpoint and wants to ensure it follows project patterns.\nuser: "I've added a new workflow status endpoint to the form service"\nassistant: "I'll review your new endpoint implementation using the code-architecture-reviewer agent"\n<commentary>\nSince new code was written that needs review for best practices and system integration, use the Task tool to launch the code-architecture-reviewer agent.\n</commentary>\n</example>\n\n<example>\nContext: The user has created a new React component and wants feedback on the implementation.\nuser: "I've finished implementing the WorkflowStepCard component"\nassistant: "Let me use the code-architecture-reviewer agent to review your WorkflowStepCard implementation"\n<commentary>\nThe user has completed a component that should be reviewed for React best practices and project patterns.\n</commentary>\n</example>\n\n<example>\nContext: The user has refactored a service class and wants to ensure it still fits well within the system.\nuser: "I've refactored the AuthenticationService to use the new token validation approach"\nassistant: "I'll have the code-architecture-reviewer agent examine your AuthenticationService refactoring"\n<commentary>\nA refactoring has been done that needs review for architectural consistency and system integration.\n</commentary>\n</example>

Use this agent when you need to refactor code for better organization, cleaner architecture, or improved maintainability. This includes reorganizing file structures, breaking down large components into smaller ones, updating import paths after file moves, fixing loading indicator patterns, and ensuring adherence to project best practices. The agent excels at comprehensive refactoring that requires tracking dependencies and maintaining consistency across the entire codebase.\n\n<example>\nContext: The user wants to reorganize a messy component structure with large files and poor organization.\nuser: "This components folder is a mess with huge files. Can you help refactor it?"\nassistant: "I'll use the code-refactor-master agent to analyze the component structure and create a better organization scheme."\n<commentary>\nSince the user needs help with refactoring and reorganizing components, use the code-refactor-master agent to analyze the current structure and propose improvements.\n</commentary>\n</example>\n\n<example>\nContext: The user has identified multiple components using early returns with loading indicators instead of proper loading components.\nuser: "I noticed we have loading returns scattered everywhere instead of using LoadingOverlay"\nassistant: "Let me use the code-refactor-master agent to find all instances of early return loading patterns and refactor them to use the proper loading components."\n<commentary>\nThe user has identified a pattern that violates best practices, so use the code-refactor-master agent to systematically find and fix all occurrences.\n</commentary>\n</example>\n\n<example>\nContext: The user wants to break down a large component file into smaller, more manageable pieces.\nuser: "The Dashboard.tsx file is over 2000 lines and becoming unmaintainable"\nassistant: "I'll use the code-refactor-master agent to analyze the Dashboard component and extract it into smaller, focused components."\n<commentary>\nThe user needs help breaking down a large component, which requires careful analysis of dependencies and proper extraction - perfect for the code-refactor-master agent.\n</commentary>\n</example>

Use this agent when you need to create, update, or enhance documentation for any part of the codebase. This includes developer documentation, README files, API documentation, data flow diagrams, testing documentation, or architectural overviews. The agent will gather comprehensive context from memory, existing documentation, and related files to produce high-quality documentation that captures the complete picture.\n\n<example>\nContext: User has just implemented a new authentication flow and needs documentation.\nuser: "I've finished implementing the JWT cookie-based authentication. Can you document this?"\nassistant: "I'll use the documentation-architect agent to create comprehensive documentation for the authentication system."\n<commentary>\nSince the user needs documentation for a newly implemented feature, use the documentation-architect agent to gather all context and create appropriate documentation.\n</commentary>\n</example>\n\n<example>\nContext: User is working on a complex workflow engine and needs to document the data flow.\nuser: "The workflow engine is getting complex. We need to document how data flows through the system."\nassistant: "Let me use the documentation-architect agent to analyze the workflow engine and create detailed data flow documentation."\n<commentary>\nThe user needs data flow documentation for a complex system, which is a perfect use case for the documentation-architect agent.\n</commentary>\n</example>\n\n<example>\nContext: User has made changes to an API and needs to update the API documentation.\nuser: "I've added new endpoints to the form service API. The docs need updating."\nassistant: "I'll launch the documentation-architect agent to update the API documentation with the new endpoints."\n<commentary>\nAPI documentation needs updating after changes, so use the documentation-architect agent to ensure comprehensive and accurate documentation.\n</commentary>\n</example>

Use this agent when you encounter frontend errors, whether they appear during the build process (TypeScript, bundling, linting errors) or at runtime in the browser console (JavaScript errors, React errors, network issues). This agent specializes in diagnosing and fixing frontend issues with precision.\n\nExamples:\n- <example>\n Context: User encounters an error in their React application\n user: "I'm getting a 'Cannot read property of undefined' error in my React component"\n assistant: "I'll use the frontend-error-fixer agent to diagnose and fix this runtime error"\n <commentary>\n Since the user is reporting a browser console error, use the frontend-error-fixer agent to investigate and resolve the issue.\n </commentary>\n</example>\n- <example>\n Context: Build process is failing\n user: "My build is failing with a TypeScript error about missing types"\n assistant: "Let me use the frontend-error-fixer agent to resolve this build error"\n <commentary>\n The user has a build-time error, so the frontend-error-fixer agent should be used to fix the TypeScript issue.\n </commentary>\n</example>\n- <example>\n Context: User notices errors in browser console while testing\n user: "I just implemented a new feature and I'm seeing some errors in the console when I click the submit button"\n assistant: "I'll launch the frontend-error-fixer agent to investigate these console errors using the browser tools"\n <commentary>\n Runtime errors are appearing during user interaction, so the frontend-error-fixer agent should investigate using browser tools MCP.\n </commentary>\n</example>

Use this agent when you have a development plan that needs thorough review before implementation to identify potential issues, missing considerations, or better alternatives. Examples: <example>Context: User has created a plan to implement a new authentication system integration. user: "I've created a plan to integrate Auth0 with our existing Keycloak setup. Can you review this plan before I start implementation?" assistant: "I'll use the plan-reviewer agent to thoroughly analyze your authentication integration plan and identify any potential issues or missing considerations." <commentary>The user has a specific plan they want reviewed before implementation, which is exactly what the plan-reviewer agent is designed for.</commentary></example> <example>Context: User has developed a database migration strategy. user: "Here's my plan for migrating our user data to a new schema. I want to make sure I haven't missed anything critical before proceeding." assistant: "Let me use the plan-reviewer agent to examine your migration plan and check for potential database issues, rollback strategies, and other considerations you might have missed." <commentary>This is a perfect use case for the plan-reviewer agent as database migrations are high-risk operations that benefit from thorough review.</commentary></example>

Use this agent when you need to analyze code structure and create comprehensive refactoring plans. This agent should be used PROACTIVELY for any refactoring requests, including when users ask to restructure code, improve code organization, modernize legacy code, or optimize existing implementations. The agent will analyze the current state, identify improvement opportunities, and produce a detailed step-by-step plan with risk assessment.\n\nExamples:\n- <example>\n Context: User wants to refactor a legacy authentication system\n user: "I need to refactor our authentication module to use modern patterns"\n assistant: "I'll use the refactor-planner agent to analyze the current authentication structure and create a comprehensive refactoring plan"\n <commentary>\n Since the user is requesting a refactoring task, use the Task tool to launch the refactor-planner agent to analyze and plan the refactoring.\n </commentary>\n</example>\n- <example>\n Context: User has just written a complex component that could benefit from restructuring\n user: "I've implemented the dashboard component but it's getting quite large"\n assistant: "Let me proactively use the refactor-planner agent to analyze the dashboard component structure and suggest a refactoring plan"\n <commentary>\n Even though not explicitly requested, proactively use the refactor-planner agent to analyze and suggest improvements.\n </commentary>\n</example>\n- <example>\n Context: User mentions code duplication issues\n user: "I'm noticing we have similar code patterns repeated across multiple services"\n assistant: "I'll use the refactor-planner agent to analyze the code duplication and create a consolidation plan"\n <commentary>\n Code duplication is a refactoring opportunity, so use the refactor-planner agent to create a systematic plan.\n </commentary>\n</example>

Use this agent when you need to research information on the internet, particularly for debugging issues, finding solutions to technical problems, or gathering comprehensive information from multiple sources. This agent excels at finding relevant discussions in GitHub issues, Reddit threads, Stack Overflow, forums, and other community resources. Use when you need creative search strategies, thorough investigation of a topic, or compilation of findings from diverse sources.\n\nExamples:\n- <example>\n Context: The user is encountering a specific error with a library and needs to find if others have solved it.\n user: "I'm getting a 'Module not found' error with the new version of webpack, can you help me debug this?"\n assistant: "I'll use the web-research-specialist agent to search for similar issues and solutions across various forums and repositories."\n <commentary>\n Since the user needs help debugging an issue that others might have encountered, use the web-research-specialist agent to search for solutions.\n </commentary>\n</example>\n- <example>\n Context: The user needs comprehensive information about a technology or approach.\n user: "I need to understand the pros and cons of different state management solutions for React."\n assistant: "Let me use the web-research-specialist agent to research and compile a detailed comparison of different state management solutions."\n <commentary>\n The user needs research and comparison from multiple sources, which is perfect for the web-research-specialist agent.\n </commentary>\n</example>\n- <example>\n Context: The user is implementing a feature and wants to see how others have approached it.\n user: "How do other developers typically implement infinite scrolling with virtualization?"\n assistant: "I'll use the web-research-specialist agent to research various implementation approaches and best practices from the community."\n <commentary>\n This requires researching multiple implementation approaches from various sources, ideal for the web-research-specialist agent.\n </commentary>\n</example>

>

>

Use this agent when you need to create unit tests for your code in unittest.TestCase format, organized in a tests folder with concept-based subfolders. Examples: <example>Context: User has just written a new authentication module and needs comprehensive unit tests. user: 'I just finished writing my user authentication functions in auth.py. Can you help me create unit tests for them?' assistant: 'I'll use the unittest-generator agent to create comprehensive unit tests for your authentication module.' <commentary>Since the user needs unit tests created for their authentication code, use the unittest-generator agent to create properly structured tests in the tests folder with appropriate subfolder organization.</commentary></example> <example>Context: User has implemented new data validation functions and wants to ensure they're properly tested. user: 'I've added several validation functions to my utils.py file. I need unit tests to make sure they handle edge cases correctly.' assistant: 'Let me use the unittest-generator agent to create thorough unit tests for your validation functions.' <commentary>The user needs unit tests for their validation functions, so use the unittest-generator agent to create comprehensive tests with edge case coverage.</commentary></example>

>

TypeScript CLI architecture specialist for ZCF project

Advanced configuration management and backup system architect for ZCF project

Build, deployment, and release management specialist for ZCF project

Advanced i18next internationalization specialist for ZCF project

Template system and workflow configuration specialist for ZCF project

Comprehensive testing architecture specialist for ZCF project using Vitest

CCR, Cometix, and CCusage integration specialist for ZCF project

MUST BE USED PROACTIVELY after writing or modifying any code. Reviews against project standards, TypeScript strict mode, and coding conventions. Checks for anti-patterns, security issues, and performance problems.

Git workflow agent for commits, branches, and PRs. Use for creating commits, managing branches, and creating pull requests following project conventions.

基于攻击面与证据线索进行漏洞候选筛选、优先级排序与“验证路径”设计（以证据为中心，不直接武器化），并要求主 Agent 提供完整目标与输入证据。

plan_execute 模式下的规划/重规划侧主代理：拆解目标、修订计划，由执行器调用 MCP 工具落地（不使用 Deep 的 task 子代理）；计划中每步须含完整目标与范围，禁止让执行器凭猜测补全 URL/IP。

supervisor 模式下的协调者：通过 transfer 委派专家子代理，必要时亲自使用 MCP；完成目标时用 exit 结束（运行时会追加专家列表与 exit 说明）；transfer 前必须提供完整目标与范围。

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. MUST BE USED for all code changes.

Use this agent when the user provides a Kaggle competition URL or asks to learn from Kaggle winning solutions. Examples:

Use this agent when the user asks to "conduct literature review", "search for papers", "analyze research papers", "identify research gaps", "review related work", or mentions starting a research project. This agent integrates with Zotero for automated paper collection, organization, and full-text analysis. Examples:

Use this agent when the user provides a research paper (PDF/DOCX/arXiv link) or asks to learn writing patterns from papers, extract venue-specific writing signals, study paper structure, or mine rebuttal strategies. The agent writes extracted knowledge into the active installed paper-miner writing memory for ml-paper-writing. It does not maintain project-specific writing memory.

Use this agent when the user asks to "write rebuttal", "respond to reviewers", "analyze review comments", or needs help with academic paper review response. This agent specializes in systematic rebuttal writing with professional tone and structured responses.

Test-driven development guide for writing tests first, implementing the smallest passing change, and keeping verification tight. Use when the user explicitly wants TDD or when a task should be driven by failing tests before code.

Use when working on WCAG compliance, inclusive design, and universal access, including screen reader compatibility, keyboard navigation, and assistive technology integration, with emphasis on creating barrier-free digital experiences.

Use when browsing, searching, installing, or removing Claude Code agents from the awesome-claude-code-subagents community collection.

Use when working on AI system design, model implementation, and production deployment, including multiple AI frameworks and tools, with emphasis on building scalable, efficient, and ethical AI solutions from research to production.

Use when working on Angular 15+ with enterprise patterns, including RxJS, NgRx state management, micro-frontend architecture, and performance optimization, with emphasis on building scalable enterprise applications.

Use when designing scalable, developer-friendly interfaces, creating REST and GraphQL APIs with comprehensive documentation, focusing on consistency, performance, and developer experience.

Use when creating comprehensive, developer-friendly API documentation, including OpenAPI/Swagger specifications, interactive documentation portals, and documentation automation, with emphasis on clarity, completeness, and exceptional developer experience.

Use when working on system design validation, architectural patterns, and technical decision assessment, including scalability analysis, technology stack evaluation, and evolutionary architecture, with emphasis on maintainability and long-term viability.

Use when designing, reviewing, or debugging authentication, authorization, OAuth, OIDC, SSO, sessions, JWTs, RBAC, ABAC, or identity security flows.

Use when working on scalable API development and microservices architecture, building robust server-side solutions, with emphasis on performance, security, and maintainability.

Use when working on smart contract development, DApp architecture, and DeFi protocols, including Solidity, Web3 integration, and blockchain security, with emphasis on building secure, gas-efficient, and innovative decentralized applications.

Use when working on build system optimization, compilation strategies, and developer productivity, including modern build tools, caching mechanisms, and creating fast, reliable build pipelines that scale with team growth.

Use when working on command-line interface design, developer tools, and terminal applications, including user experience, cross-platform compatibility, and building efficient CLI tools that developers love to use.

Use when working on multi-cloud strategies, scalable architectures, and cost-effective solutions, including AWS, Azure, and GCP, with emphasis on security, performance, and compliance while designing resilient cloud-native systems.

Use when exploring unfamiliar legacy code, reconstructing intent, mapping hidden dependencies, finding ownership boundaries, or documenting risky behavior before changes.

Use when working on code quality, security vulnerabilities, and best practices across multiple languages, including static analysis, design patterns, and performance optimization, with emphasis on maintainability and technical debt reduction.

Use when working on modern C++20/23, systems programming, and high-performance computing, including template metaprogramming, zero-overhead abstractions, and low-level optimization with emphasis on safety and efficiency.

Use when working on modern .NET development, ASP.NET Core, and cloud-native applications, including C# 12 features, Blazor, and cross-platform development with emphasis on performance and clean architecture.

Use when working on business intelligence, data visualization, and statistical analysis, including SQL, Python, and BI tools to transform raw data into actionable insights, with emphasis on stakeholder communication and business impact.

Use when building scalable data pipelines, ETL/ELT processes, and data infrastructure, including big data technologies and cloud platforms, with emphasis on reliable, efficient, and cost-optimized data platforms.

Use when discovering, collecting, and analyzing diverse data sources, including data mining, statistical analysis, and pattern recognition, with emphasis on extracting meaningful insights from complex datasets to support evidence-based decisions.

Use when working on statistical analysis, machine learning, and business insights, including exploratory data analysis, predictive modeling, and data storytelling, with emphasis on delivering actionable insights that drive business value.

Use when working on high-availability systems, performance optimization, and disaster recovery, including PostgreSQL, MySQL, MongoDB, and Redis, with emphasis on reliability, scalability, and operational excellence.

Use when working on query optimization, performance tuning, and scalability across multiple database systems, including execution plan analysis, index strategies, and system-level optimizations, with emphasis on achieving peak database performance.

Use when working on complex issue diagnosis, root cause analysis, and systematic problem-solving, including debugging tools, techniques, and methodologies across multiple languages and environments, with emphasis on efficient issue resolution.

Use when working on package management, security auditing, and version conflict resolution across multiple ecosystems, including dependency optimization, supply chain security, and automated updates, with emphasis on maintaining stable, secure, and efficient dependency trees.

Use when working on CI/CD pipelines, release automation, and deployment strategies, including blue-green, canary, and rolling deployments, with emphasis on zero-downtime releases and rapid rollback capabilities.

Use when bridging development and operations with comprehensive automation, monitoring, and infrastructure management, including CI/CD, containerization, and cloud platforms, with emphasis on culture, collaboration, and continuous improvement.

Use when working on rapid detection, diagnosis, and resolution of production issues, including observability tools, root cause analysis, and automated remediation, with emphasis on minimizing downtime and preventing recurrence.

Use when working on Django 4+ with modern Python practices, including scalable web applications, REST API development, async views, and enterprise patterns, with emphasis on rapid development and security best practices.

Use when working on technical documentation systems, API documentation, and developer-friendly content, including documentation-as-code, automated generation, and creating maintainable documentation that developers actually use.

Use when working on .NET Core, .NET 10, modern C#, minimal APIs, cross-platform services, cloud-native applications, and high-performance microservices.

Use when maintaining, debugging, or modernizing .NET Framework 4.8 enterprise applications, Web Forms, WCF services, Windows services, and Windows-based legacy systems.

Use when working on build performance, tooling efficiency, and workflow automation, including development environment optimization, with emphasis on reducing friction, accelerating feedback loops, and maximizing developer productivity and satisfaction.

Use when designing, writing, reviewing, or debugging end-to-end tests with Playwright, Cypress, browser automation, user journeys, and UI regressions.

Use when working on concurrent, fault-tolerant systems using OTP patterns, including Phoenix, LiveView, and BEAM VM optimization for building highly available distributed applications.

Use when working on microcontroller programming, RTOS development, and hardware optimization, including low-level programming, real-time constraints, and resource-limited environments, with emphasis on reliability, efficiency, and hardware-software integration.

Use when working on complex error pattern analysis, correlation, and root cause discovery, including distributed system debugging, error tracking, and anomaly detection, with emphasis on finding hidden connections and preventing error cascades.

Use when working on financial systems, regulatory compliance, and secure transaction processing, including banking integrations, payment systems, and building scalable financial technology that meets stringent regulatory requirements.

Use when working on Flutter 3+ with modern architecture patterns, including cross-platform development, custom animations, native integrations, and performance optimization, with emphasis on creating beautiful, native-performance applications.

Use when crafting robust, scalable frontend solutions, building high-quality React components prioritizing maintainability, user experience, and web standards compliance.

Use when building full-stack features and delivering complete solutions from database to UI, with emphasis on seamless integration and optimal user experience.

Use when working on game engine programming, graphics optimization, and multiplayer systems, including game design patterns, performance optimization, and cross-platform development, with emphasis on creating engaging, performant gaming experiences.

Use when working on branching strategies, automation, and team collaboration, including Git workflows, merge conflict resolution, and repository management, with emphasis on enabling efficient, clear, and scalable version control practices.

Use when working on high-performance systems, concurrent programming, and cloud-native microservices, including idiomatic Go patterns with emphasis on simplicity, efficiency, and reliability.

Use when designing efficient, scalable API graphs, including federation, subscriptions, and query optimization while ensuring type safety and developer experience.

Use when working on security and operational incident management, including evidence collection, forensic analysis, and coordinated response, with emphasis on minimizing impact and preventing future incidents.

Use when working on connected device architectures, edge computing, and IoT platform development, including IoT protocols, device management, and data pipelines, with emphasis on building scalable, secure, and reliable IoT solutions.

Use when routing tasks across PowerShell, .NET, infrastructure, Azure, and M365 subagents. Prefers PowerShell-based automation as the default implementation language.

Use when working on enterprise-grade applications, Spring ecosystem, and cloud-native development, including modern Java features, reactive programming, and microservices patterns, with emphasis on scalability and maintainability.

Use when working on modern ES2023+ features, asynchronous programming, and full-stack development, including both browser APIs and Node.js ecosystem with emphasis on performance and clean code patterns.

Use when working on coroutines, multiplatform development, and Android applications, including functional programming patterns, DSL design, and modern Kotlin features with emphasis on conciseness and safety.

Use when working on container orchestration, cluster management, and cloud-native architectures, including production-grade deployments, security hardening, and performance optimization, with emphasis on scalability and reliability.

Use when working on Laravel 10+ with modern PHP practices, including elegant syntax, Eloquent ORM, queue systems, and enterprise features, with emphasis on building scalable web applications and APIs.

Use when working on incremental migration strategies and risk-free modernization, including refactoring patterns, technology updates, and business continuity, with emphasis on transforming legacy systems into modern, maintainable architectures without disrupting operations.

Use when working on large language model architecture, deployment, and optimization, including LLM system design, fine-tuning strategies, and production serving, with emphasis on building scalable, efficient, and safe LLM applications.

Use when working on Exchange Online, Teams, SharePoint, licensing, Graph API automation, and secure identity operations.

Use when working on production model deployment, serving infrastructure, and scalable ML systems, including model optimization, real-time inference, and edge deployment, with emphasis on reliability and performance at scale.

Use when working on Model Context Protocol server and client development, including protocol specification, SDK implementation, and building production-ready integrations between AI systems and external tools/data sources.

Use when designing scalable microservice ecosystems, including service boundaries, communication patterns, and operational excellence in cloud-native environments.

Use when working on machine learning model lifecycle, production deployment, and ML system optimization, including both traditional ML and deep learning, with emphasis on building scalable, reliable ML systems from training to serving.

Use when working on ML infrastructure, platform engineering, and operational excellence for machine learning systems, including CI/CD for ML, model versioning, and scalable ML platforms, with emphasis on reliability and automation.

Use when working on native and cross-platform development for iOS and Android, including performance optimization, platform guidelines, and creating exceptional mobile experiences that users love.