requirements are ambiguous, incomplete, or need to be translated into technical specifications.

designing, reviewing, or implementing REST or GraphQL APIs - endpoints, contracts, versioning, rate limiting, or documentation.

migrating entire system architectures, transforming monoliths to microservices, adopting DDD/CQRS/Hexagonal, or redesigning application layers at system level.

you want to run iterative autonomous development with PRD and progress tracking, fresh context per iteration to avoid context rot.

designing cloud infrastructure, setting up IaC, configuring serverless functions, or planning cloud architecture.

designing database schemas, writing migrations, optimizing queries, or planning caching strategies.

encountering any bug, test failure, unexpected behavior, or error - before proposing fixes.

dependencies are outdated, have security vulnerabilities, need license compliance checks, conflict with each other, need major version upgrades, or require supply chain hardening.

building design systems, improving UI/UX, ensuring WCAG accessibility, or creating responsive layouts.

setting up Docker, Kubernetes, CI/CD pipelines, monitoring, or deployment infrastructure.

code needs documentation - API docs, architecture diagrams, user guides, ADRs, JSDoc/TSDoc comments, or onboarding materials.

a plan exists and tasks need to be executed with checkpoints, cost tracking, and verification.

onboarding onto an unfamiliar codebase, mapping project structure, or understanding how modules connect.

implementing payment processing, billing systems, invoicing, tax calculation, or financial reporting features.

adding multi-language support, extracting hardcoded strings, setting up translation workflows, or implementing RTL layouts.

implementing GDPR, LGPD, or privacy compliance - consent management, data retention, audit trails, or cookie policies.

creating marketing copy, landing pages, email campaigns, social media strategy, SEO content, or growth experiments.

decisions, preferences, or lessons need to persist across sessions - save and retrieve project memory.

a task requires coordinating multiple agents, managing dependencies between subtasks, or sequencing work across domains.

wanting to code collaboratively, think through problems out loud, or get continuous feedback while developing.

the application is slow, bundle size is large, queries are inefficient, memory leaks, or users report performance issues.

starting a feature that involves multiple files, unclear requirements, or architectural decisions - before writing any code.

defining product strategy, prioritizing features, writing user stories, analyzing feedback, or making product decisions.

code has grown complex, has duplication, violates patterns, or needs restructuring - from code smells to architecture-level refactoring.

you need to understand the cascading impact of a code change - who depends on it, what breaks, and what needs updating.

assessing a project for the first time, evaluating technical debt, or generating a health report.

implementing authentication, authorization, encryption, or auditing for OWASP compliance and security best practices.

triaging Sentry errors, analyzing recent issues, checking if fixes already exist, and creating prioritized fix PRs automatically.

creating a new project from scratch - any frontend, backend, and database combination.

creating support documentation, help center content, runbooks, incident response procedures, or customer-facing knowledge base articles.

implementing any feature or bugfix where correctness matters - before writing implementation code.

defining test strategy, improving coverage, setting up test infrastructure, or choosing testing patterns.

you need a comprehensive code audit covering security, performance, architecture, and dependencies before a release, major refactor, or compliance review.

you want to automatically triage errors from Sentry (or error logs), cross-reference them against the codebase and open PRs, prioritize by severity, and optionally create fix PRs.

you want to iteratively build a feature using a PRD as source of truth, with progress tracking and fresh-context iterations - the Autopilot technique for autonomous development.

starting a complex feature, exploring unclear requirements, or needing to challenge assumptions before committing to a design - before /plan.

about to start risky changes, before major refactors, or when you need a safe rollback point during multi-step implementations.

you need a comprehensive code review combining architecture, security, and test perspectives - especially before merging, releasing, or after major changes.

changes are ready to commit - generates conventional commit messages with scope detection and validation.

creating marketing copy for landing pages, email campaigns, product descriptions, or social media - with A/B variants and conversion-focused frameworks.

optimizing landing pages, signup flows, checkout processes, or any user-facing page for higher conversion rates - before A/B testing.

encountering any bug, test failure, unexpected behavior, or error - before proposing fixes. Use especially when previous fix attempts have failed.

reviewing frontend code for design consistency, accessibility compliance, responsive behavior, and UI/UX best practices - before deployment or after design system changes.

starting a new product, feature, or initiative and you need structured discovery before planning - covers market analysis, technical feasibility, architecture, and go-to-market strategy.

planning a feature and need to understand token cost, time estimate, or complexity before committing to implementation.

feature implementation is complete and the branch is ready for final validation, PR creation, or merge.

you want to stress-test code by having an adversarial reviewer try to break it - finding edge cases, security holes, race conditions, and logical flaws that normal reviews miss.

assessing overall project quality, onboarding onto a new codebase, or before major refactoring to establish a baseline.

the codebase has architectural issues like high coupling, circular dependencies, or unclear boundaries - but a full migration is not needed.

implementing a feature and want to understand the code as it's built - during onboarding, teaching, or learning a new pattern.

you need to lint the codebase and auto-fix issues - detects linter, runs it, and fixes what it can.

transforming a project's architecture pattern - e.g., Flat to Modular, MVC to Clean Architecture, Monolith to Modular Monolith.

switching a project or component between frameworks - React to Vue, Vue to Svelte, or any supported framework pair.

joining an unfamiliar codebase, starting on a new team, or needing to understand a project's architecture, conventions, and key modules quickly.

starting a new feature, refactor, or multi-step task - before writing any code. Use especially when scope is unclear or multiple files are involved.

translating a product idea, feature request, or stakeholder requirement into a structured PRD with user stories, acceptance criteria, and GitHub issues.

you need to retrieve a past decision, preference, or convention that was saved with /remember.

making a decision, choosing a convention, or learning a lesson that should persist across sessions.

auditing a website or web application for SEO issues - covering meta tags, structured data, content structure, Core Web Vitals indicators, and crawlability.

implementing any feature or bugfix where correctness matters - before writing implementation code.

first using Specialist Agent, onboarding a new team member, or wanting to explore available agents and skills.

about to claim work is complete, fixed, or passing - before committing, creating PRs, or moving to next task. Requires running verification commands and confirming output before making any success claims.

you need workspace isolation for parallel tasks, risky changes, or multi-feature development without branch switching.

creating a new skill, editing an existing skill, or verifying a skill works before deployment.