oss

WCAG accessibility audit and compliance checking

Write acceptance tests at system boundaries (Outside-In first tests)

Create Architecture Decision Records

Design API contracts before implementation (Outside-In starting point)

Security vulnerability scanning and penetration testing

Run the full ideate→plan→build→ship pipeline in one go, stopping only for interactive ideation Q&A

Performance benchmarking and load testing

Execute TDD plans with strict RED-GREEN-REFACTOR discipline

Deploy to production with canary rollout and monitoring

Create development documentation structure for a feature

A/B testing and experimentation framework

Feature flag implementation and management

Write minimal code to pass tests (London TDD GREEN phase)

Transform vague ideas into concrete, actionable designs through collaborative questioning

Incident response protocol for production emergencies

Validate that mocked interactions work in reality

Refine working features when they don't match original intent or when scope has changed

Display the status line legend and symbol meanings

Open source license compliance audit

Load testing at scale with k6

Configure API key for OSS Dev Workflow

Generate type-safe mocks for collaborators (London TDD)

Configure per-prompt model routing and view cost tracking

Monitor production health with real-time metrics and alerting

Analyze existing codebase and generate development documentation

[DEPRECATED] Use /oss:settings instead

Execute custom team commands with full observability

Execute OSS Dev Workflow commands

Save current work state for later resumption

Generate a TDD implementation plan with phased approach and test-first methodology

Incident postmortem analysis and documentation

GDPR/CCPA privacy compliance audit

View and manage the task queue

Execute ad-hoc tasks with TDD guarantees but skip optional workflow steps

Write failing test first, design interfaces through mocks (London TDD RED phase)

Clean up code while keeping tests green (London TDD REFACTOR phase)

Create a versioned release with changelog

Extract user stories and acceptance criteria from ideas

Continue work from a paused state

Sprint retrospective facilitation

Multi-perspective code review (correctness, security, performance, maintainability)

Emergency rollback to previous version with safety checks

Manage OSS notification and preference settings

Quality check, commit, create PR, and optionally auto-merge

Post-deployment smoke testing

Deploy to staging environment with safety checks

Validate built features through conversational user acceptance testing

Compare built UI against Figma design specs for pixel-perfect implementation

Manage the background watcher agent

Configure GitHub webhook for PR review notifications

View and manage your team's workflow configuration

Comprehensive codebase risk triage — severity-rated findings across security, performance, architecture, dependencies, and points of interest

View what changed since your last session (plugin version, prompt updates)

Chaos engineering and resilience testing

Simplify and refine code for clarity, consistency, and maintainability

Generate build context report answering what changed, why, and what it affects

Consumer-driven contract testing (Pact)

Cloud cost analysis and optimization

Design data schemas and relationships

Systematic debugging workflow

Check your subscription status and usage

Identify and prioritize technical debt

Manage Telegram notifications for OSS Dev Workflow

Run comprehensive E2E tests across critical user journeys

Distributed tracing analysis with OpenTelemetry

Verify safety and integrity of OSS encrypted prompts

UI quality review — usability heuristics, visual quality, design system compliance, interaction states

Create distinctive, production-grade frontend interfaces with high design quality

**This section enables per-prompt model routing. Include at the START of agent execution.**

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

World-class web analytics specialist mastering Google Analytics 4 (GA4), Google Tag Manager (GTM), Measurement Protocol, custom event tracking, and privacy-compliant analytics implementation across platforms.

Software architecture and design pattern specialist. Use PROACTIVELY when adding new features, refactoring code, or reviewing system design. MUST BE USED for architectural decisions and major code structure changes.

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

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

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.

Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.

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

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

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

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

Analyzes project dependencies, identifies conflicts, and manages dependency updates for optimal project health.

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

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

Creates comprehensive technical documentation from existing codebases. Analyzes architecture, design patterns, and implementation details to produce long-form technical manuals and ebooks. Use PROACTIVELY for system documentation, architecture guides, or technical deep-dives.

Reads and interprets Figma designs via MCP for pixel-perfect implementation

Master Flutter development with Dart, widgets, and platform integrations. Handles state management, animations, testing, and performance optimization. Deploys to iOS, Android, Web, and desktop. Use PROACTIVELY for Flutter architecture, UI implementation, or cross-platform features.

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

Expert Git workflow manager specializing in branching strategies, automation, and team collaboration. Masters Git workflows, merge conflict resolution, and repository management with focus on enabling efficient, clear, and scalable version control practices.

Write idiomatic Go code with focus on concurrency patterns, error handling, and performance. Masters goroutines, channels, interfaces, and the Go standard library. Use PROACTIVELY for Go development, systems programming, and microservices.

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

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

Expert iOS developer specializing in Swift 5.9+/6.0, SwiftUI, and UIKit. Masters @Observable patterns, Swift concurrency (actors, async/await, Sendable), SwiftData, MVVM architecture, and Instruments profiling. Use PROACTIVELY for iOS development, Swift programming, and native Apple platform work.

Write modern, performant Java code leveraging the latest JDK features. Expert in Spring Boot, enterprise patterns, JVM tuning, and comprehensive testing. Use PROACTIVELY for Java development, Spring Boot applications, and enterprise Java.

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

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

n8n workflow automation expert. Creates, debugs, and extends n8n workflows with production-ready JSON output. Use for any n8n automation tasks.

Expert Next.js developer mastering Next.js 14+ with App Router and full-stack features. Specializes in server components, server actions, performance optimization, and production deployment with focus on building fast, SEO-friendly applications.

Performance optimization specialist focusing on speed, efficiency, and resource usage. Use PROACTIVELY for cοde handling large datasets, complex algorithms, or user-facing performance. MUЅT BE USED before deploying performance-critical features.

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

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

Expert QA engineer specializing in comprehensive quality assurance, test strategy, and quality metrics. Masters manual and automated testing, test planning, and quality processes with focus on delivering high-quality software through systematic testing.

Expert React specialist mastering React 18/19 with modern patterns and ecosystem. Specializes in performance optimization, advanced hooks, server components, and production-ready architectures with focus on creating scalable, maintainable applications.

Expert refactoring specialist mastering safe code transformation techniques and design pattern application. Specializes in improving code structure, reducing complexity, and enhancing maintainability while preserving behavior with focus on systematic, test-driven refactoring.

Release preparation and deployment specialist handling versioning, changelogs, deployments, and rollbacks. MUST BE USED for all production releases. Use PROACTIVELY to prepare releases and ensure smooth deployments.

Rust language expert with deep borrow checker, async/tokio, and security auditing expertise. Generates borrow-checker-clean code, explains ownership concepts, audits unsafe blocks, and integrates with London TDD workflow. Use PROACTIVELY for Rust development, compiler errors, async patterns, or security review.

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

World-class SEO/AEO specialist mastering search engine optimization, answer engine optimization, schema markup, Core Web Vitals, and E-E-A-T enhancement. Automatically optimizes frontend work for both traditional search engines and AI-powered answer engines.

Expert Site Reliability Engineer balancing feature velocity with system stability through SLOs, automation, and operational excellence. Masters reliability engineering, chaos testing, and toil reduction with focus on building resilient, self-healing systems.

Use proactively for Swift and macOS desktop application development, debugging, testing, and architecture. Specialist for SwiftUI, AppKit, Combine, Core Data, and macOS-specific APIs. Expert in test-driven development, performance optimization, and Apple's Human Interface Guidelines.

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

Automated test generation and coverage specialist. Use PROACTIVELY when new code is written or modified. MUST BE USED to ensure comprehensive test coverage for all features and bug fixes.

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

Expert VisionOS/Apple Vision Pro developer with RAG-powered Apple documentation. Expert VisionOS developer specializing in spatial computing, immersive experiences, and Apple Vision Pro applications. Masters RealityKit, SwiftUI 3D, ARKit, and visionOS-specific APIs. Use PROACTIVELY for VisionOS app development, spatial UI design, 3D content integration, and immersive space creation.

11 hooks across 9 events