playbooks-virtuoso

Acceptance criteria compliance checker. Maps code changes against acceptance criteria one-by-one, reporting PASS/FAIL/PARTIAL/UNTESTED per criterion. Delegate when you need to verify that implementation satisfies its specification before merging.

System architecture agent for technical design, component boundaries, API contracts, and ADRs. Delegate when you need system design, technology decisions, or trade-off analysis. Use proactively for design reviews.

Backend development agent for API implementation, data modeling, and testing. Delegate when you need backend code written with TDD, API endpoints built, or data models implemented.

Zero-context code reviewer. Reviews changes cold -- no spec, no project knowledge, no domain context. Catches what familiarity blinds you to. Delegate when you want a fresh-eyes pass before merging, or as part of a multi-perspective review.

Mid-workflow change management agent. Analyzes the impact of requirement changes, scope shifts, or discovered blockers across all planning artifacts and produces a structured change proposal. Delegate when things go wrong mid-implementation, when requirements change after planning, or when a blocker requires re-planning.

Audit project dependencies for security vulnerabilities, outdated packages, and license issues. Delegate for dependency health checks.

Generate or update documentation from code changes -- changelogs, API docs, migration guides. Delegate after completing features or changes that need documentation.

Frontend development agent for UI implementation, component architecture, and testing. Delegate when you need UI components built, API integrations wired, or accessibility issues fixed.

TDD implementation agent. Delegate when you have a concrete plan and want isolated red-green-refactor execution in a worktree.

Read-only deep exploration of a specific codebase area. Delegate when you need structured investigation of how something works, where something is used, or what a subsystem does.

Analyze database migration files and produce safe migration plans with zero-downtime strategies and rollback paths. Delegate before running migrations.

Product management agent for requirements gathering, PRD writing, prioritization, and acceptance criteria. Delegate when you need user stories, scope decisions, or prioritization analysis. Use proactively when requirements are unclear.

Project management agent using PRINCE2 principles for delivery planning, risk management, and progress tracking. Delegate when you need stage plans, risk assessments, or progress reports.

QA engineering agent for test planning, test case design, bug reporting, and release sign-off. Delegate when you need test plans written, bugs investigated, or release quality assessed. Use proactively after feature completion.

Pre-implementation readiness gate. Validates that requirements, design, and test plans are aligned and complete before implementation starts. Delegate when moving from planning to implementation, or when you need to verify that all prerequisites for a phase are met.

Scan code for structural health -- code smells, duplication, complexity hotspots, and refactoring opportunities. Delegate for codebase health assessments.

Code review agent. Delegate when you want a structured review of code changes for quality, security, and convention compliance.

Scrum Master facilitator for sprint planning, goal crafting, retrospectives, and impediment resolution. Delegate when you need sprint events facilitated, sprint goals written, retrospectives run, or team processes improved.

Find untested code paths in changed files -- missing test cases, uncovered edge cases, and integration gaps. Delegate after implementation to verify coverage.

Web accessibility patterns and WCAG 2.1/2.2 compliance for inclusive user interfaces. Use when the user asks to build accessible components, audit a UI for a11y issues, fix screen reader problems, implement keyboard navigation, check color contrast ratios, add ARIA attributes, create accessible forms, or establish accessibility standards for a team. Covers the POUR principles (Perceivable, Operable, Understandable, Robust), semantic HTML, focus management, and automated/manual a11y testing strategies.

REST and GraphQL API design principles for consistent, predictable, and evolvable APIs. Use when the user asks to design a new API, review an existing API, choose between REST and GraphQL, plan API versioning, define error response contracts, implement pagination, or establish API standards for a team. Covers resource modeling, endpoint naming, HTTP methods, status codes, authentication patterns, rate limiting, HATEOAS, and API evolution strategies.

CI/CD pipeline patterns and deployment strategies for automated, reliable software delivery. Use when the user asks to design a build pipeline, choose a deployment model (blue-green, canary, rolling), configure environment promotion, manage build artifacts, implement zero-downtime deployments, set up quality gates, or improve delivery workflow speed and reliability. Covers pipeline stage ordering, test parallelization, caching, secrets in CI, and rollback strategies.

Clean Architecture, Hexagonal Architecture (Ports and Adapters), and Domain-Driven Design fundamentals. Use when the user asks to design system architecture, define layer boundaries, apply DDD tactical patterns (entities, value objects, aggregates, repositories), structure a hexagonal application, enforce dependency rules, or evaluate whether a codebase needs architectural refactoring. Covers bounded contexts, use cases, domain services, and framework-independent design.

Database design patterns and data modeling for relational and NoSQL databases. Use when the user asks to design a database schema, normalize or denormalize tables, create indexing strategies, plan schema migrations, model temporal data, implement audit trails, set up table partitioning, or optimize data access patterns. Covers entity relationships, naming conventions, constraint design, migration safety, and performance-oriented schema decisions.

Systematic debugging methodology for finding and fixing bugs through root cause analysis. Use when the user encounters a bug, test failure, flaky behavior, production error, performance degradation, or integration failure. Covers the reproduce-investigate-hypothesize-fix-prevent workflow, evidence-based diagnosis, bug category strategies (logic errors, race conditions, memory leaks, integration failures), and post-mortem documentation.

Comprehensive skill for all 26 Gang of Four design patterns with practical implementations and real-world examples. Use when the user asks to apply a design pattern, refactor code using patterns, choose between competing patterns, or review existing pattern usage. Covers creational (Abstract Factory, Builder, Factory Method, Prototype, Singleton, Object Pool), structural (Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Private Class Data), and behavioral patterns (Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor, Null Object) with real-world examples, trade-offs, and anti-patterns.

Patterns for effective subagent delegation and parallel execution. Use when a task decomposes into independent subtasks, when research spans multiple areas, when building features that require coordinated specialist work, or when sequential execution is wasting time. Covers work decomposition patterns (fan-out/fan-in, map-reduce, pipelines, scatter-gather), precise subagent briefing, context and filesystem isolation, result synthesis, failure handling, and anti-patterns like agent sprawl and context bleed. Platform-agnostic but integrates with this project's agent roster (investigator, implementer, reviewer, refactor-scout, etc.). Triggers: 'delegate', 'parallelize', 'fan out', 'multi-agent', 'subagent', 'split this work'.

Git workflow patterns and version control best practices for teams of any size. Use when the user asks to choose a branching strategy (trunk-based, GitHub Flow, Git Flow, GitLab Flow), define commit conventions, set up PR workflows, plan release management, structure a monorepo, or establish team git standards. Covers branch naming, merge vs rebase, conventional commits, semantic versioning, changelog generation, and protected branch policies.

Microservices and distributed systems architecture patterns for scalable, resilient services. Use when the user asks to decompose a monolith, design service boundaries, implement saga orchestration, apply CQRS or event sourcing, configure circuit breakers, set up API gateways, handle eventual consistency, or evaluate monolith vs microservices trade-offs. Covers service decomposition strategies, inter-service communication (sync and async), data isolation, resilience patterns, and observability.

Application performance optimization patterns and profiling-driven methodology. Use when the user asks to optimize application speed, reduce latency, diagnose slow queries, fix N+1 problems, implement caching layers, profile memory usage, tune database queries, apply lazy loading, configure connection pooling, or set performance budgets. Covers CPU and memory profiling, caching strategies (application, HTTP, CDN), query optimization, indexing, and load testing approaches.

Comprehensive skill for 89 refactoring techniques and 22 code smells with practical examples. Use when the user asks to refactor code, detect code smells, improve code quality, reduce complexity, or clean up technical debt. Covers composing methods, moving features between objects, organizing data, simplifying conditionals and method calls, dealing with generalization, and detecting smells across bloaters, OO abusers, change preventers, dispensables, and couplers with before/after comparisons and step-by-step mechanics.

Scrum framework fundamentals, sprint goal writing, and agile ceremony facilitation. Use when the user asks to plan a sprint, write sprint goals, facilitate daily scrums, run sprint reviews or retrospectives, define scrum roles, manage the product backlog, or apply agile estimation techniques. Covers the three pillars (transparency, inspection, adaptation), scrum artifacts, goal-writing templates (SMART, FOCUS, FAB), and team velocity tracking.

Application security principles and OWASP Top 10 for building secure web applications. Use when the user asks to review code for security vulnerabilities, implement authentication or authorization, handle secrets or API keys, configure security headers, prevent injection attacks (SQL, XSS, CSRF), prepare for a security audit, or respond to a vulnerability report. Covers input validation, data protection, secrets management, session handling, and common security antipatterns.

SOLID principles for object-oriented design with multi-language examples (PHP, Java, Python, TypeScript, C++). Use when the user asks to review SOLID compliance, fix a SOLID violation, evaluate class design, reduce coupling, improve extensibility, or apply Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, or Dependency Inversion principles. Covers motivation, violation detection, refactoring fixes, and real-world trade-offs for each principle.

Execute a multi-task implementation plan by dispatching one fresh subagent per task with isolated context, then applying a two-stage review (spec compliance and code quality) before advancing. Use when you have a written plan with 3+ tasks, when tasks would otherwise cause context bleed, when you need reproducible per-task output, or when review gates are non-negotiable. Covers per-task briefing templates, the two-stage review rubric, structured hand-off between dependent tasks, and anti-patterns like shared long-context drift and skipped reviews. Complements dispatching-parallel-agents (for fan-out work) and executing-plans. Triggers: 'execute this plan', 'work through these tasks', 'dispatch per task', 'one-task-at-a-time', 'review-gated implementation'.

Stack-agnostic testing principles, strategies, and patterns for building reliable test suites. Use when the user asks to design a test strategy, choose between unit/integration/e2e tests, apply TDD, fix flaky tests, improve test quality, use test doubles (mocks, stubs, fakes, spies), or review tests for antipatterns. Covers the testing pyramid, test design heuristics, arrange-act-assert structure, test isolation, property-based testing, and common testing pitfalls.

Evidence-based completion discipline. Use before claiming any work is 'done', complete, finished, or ready — whether it is code, config, documentation, a migration, or a bugfix. Requires running verification commands (tests, lints, type checks, builds, smoke tests), capturing output, and citing concrete evidence rather than assertions. Covers tiered definitions of done, evidence patterns, verification checklists by task type, and common fake-completion failure modes. Triggers: 'done', 'finished', 'complete', 'ready', 'should work', 'it's working now', before closing a task, before writing a PR.

Composer dependency management playbook for safe, systematic package updates. Use when the user asks to update Composer dependencies, audit packages for security vulnerabilities, manage composer.lock, configure Dependabot or Renovate for automated updates, replace abandoned packages, or resolve version conflicts. Covers patch/minor/major update strategies, composer audit, semantic versioning constraints, lock file hygiene, and the changelog-first update workflow.

End-to-end workflow for finishing a development branch. Use when implementation is complete and the branch is ready to ship -- runs verification checks, reviews the diff, picks the integration path (direct merge, pull request, squash-and-merge, stacked PR), writes the PR/merge message, pushes to the remote, and cleans up branches and worktrees. Covers rebase vs merge vs squash decisions, pre-push checklists, stacked-branch handling, and recovery from common missteps like force-pushing the wrong branch or deleting an unmerged branch. Triggers: 'I'm done', 'ready to merge', 'ready to push', 'ready for review', 'wrap up this branch', 'finish this up'.

Step-by-step PHP version upgrade playbook for PHP 8.0 through 8.4+ with automated tooling. Use when the user asks to upgrade PHP to a new version, check PHP compatibility, fix deprecation warnings, run Rector for automated refactoring, audit code with PHPCompatibility, or plan a PHP migration strategy. Covers breaking changes per version, php.ini configuration updates, extension compatibility, Rector rule sets, testing strategies, and the changelog-first upgrade workflow.

End-to-end ticket workflow -- from ticket analysis through investigation, planning, TDD implementation, committing, and PR creation. Adapts to your environment via a supplement file created on first run. Use when starting work on a ticket, implementing a feature end-to-end, or following a structured development workflow from ticket to PR.

Manage git worktrees for isolated parallel development sessions. Create, list, switch between, and remove worktrees with safety checks for uncommitted changes and unpushed commits. Use when the user wants to work on multiple branches simultaneously, run parallel sessions, or isolate experimental changes.

Agent team role for system design and technical decision-making. Use when the user asks to design system architecture, define component boundaries, write Architecture Decision Records (ADRs), select technologies, define API contracts, or evaluate architectural trade-offs. Owns the "how" — translates product requirements into components, data flows, and technology choices.

Agent team role for backend implementation and service reliability. Use when the user asks to implement API endpoints, design data models, write backend services, create database queries, build service integrations, or write backend tests. Owns production backend code — translates architectural designs and API contracts into working, tested implementations.

Agent team role for UI implementation and frontend architecture. Use when the user asks to build UI components, implement responsive layouts, manage client-side state, integrate with backend APIs, ensure accessibility compliance, or write frontend tests. Owns the user-facing interface — translates design specs into working, accessible, performant components.

Agent team role for product ownership and requirements definition. Use when the user asks to write a PRD, gather requirements, define acceptance criteria, prioritize features, scope an MVP, write user stories, or make product trade-off decisions. Owns the "what" and "why" — translates business goals and user needs into clear, prioritized requirements for the engineering team.

Agent team role for project delivery management using PRINCE2 principles. Use when the user asks to plan project stages, manage risks, track progress, write highlight reports, handle exceptions, create work packages, or ensure continued business justification. Owns the "when" and "how much" — controls stages, timelines, resources, and escalates when tolerances are exceeded.

Agent team role for quality assurance and test management. Use when the user asks to create test plans, design test cases, perform exploratory testing, write bug reports, verify fixes, define test coverage requirements, or sign off on releases. Owns the quality gate — translates requirements and acceptance criteria into structured test strategies across the delivery pipeline.

Agent team role for Scrum Master facilitation, coaching, and servant leadership. Use when the user asks to facilitate scrum events, coach a team on self-management, resolve impediments, run retrospectives, improve team processes, or address scrum anti-patterns. Owns the "how we work" -- ensures the team applies scrum effectively, removes obstacles, and continuously improves.

Interactive tool to design a well-scoped sub-agent definition -- specialist, role, or team-lead -- with the right frontmatter, tool permissions, isolation, memory, and system prompt. Use when the user asks to create a sub-agent, write an agent file, design a specialized worker, scaffold a role agent, bootstrap an agent team, or turn a repeated delegation pattern into a reusable agent. Runs a six-phase questionnaire and outputs a ready-to-commit agent markdown file plus marketplace registration.

Interactive tool to generate tailored rules and instruction files for any AI coding agent. Use when the user asks to set up agent rules, configure Claude Code instructions, create Cursor rules, write Windsurf rules, generate Copilot instructions, or establish consistent AI coding standards for a team. Supports 13+ agents (Claude Code, Cursor, Windsurf, Copilot, Gemini, Codex, Cline, OpenCode, Continue, Trae, Roo Code, Amp) with global, team-shared, and dev-specific scopes. Defers to the `using-ecosystem` meta-skill for ecosystem discovery (skills, agents, recommendations) and runs an interactive questionnaire for workflow preferences.

Interactive pre-implementation design exploration. Use when the user has a vague idea, feature request, or problem statement but no written spec. Asks focused questions one at a time to surface goals, non-goals, constraints, success criteria, and risks, then produces a written spec and hard-gates implementation until approved. Use before writing any code, before planning, and before answering 'how should I build X'. Triggers: 'I want to build', 'I'm thinking about', 'help me figure out', 'let's brainstorm', 'help me spec out'.

Spawn and coordinate a pre-composed agent team from a team definition file. Reads team files from teams/, resolves agents and skills, picks the best spawning mode (peer or sequential), and runs the workflow. Use when the user asks to run a team, dispatch a development team, start a feature delivery, or coordinate multiple agents for a multi-phase task.

Interactive tool to scaffold a complete Claude Code plugin -- plugin.json manifest, skills, agents, hooks, MCP servers, LSP servers, and an optional marketplace.json catalog entry. Use when the user asks to create a plugin, build a Claude Code plugin, scaffold a plugin marketplace, convert an existing .claude/ configuration into a plugin, or package skills and agents for distribution. Runs a guided questionnaire, writes all required files to disk, and prints test instructions.

Write comprehensive pull request messages with structured technical documentation, testing instructions, and verification queries. Framework-agnostic with customizable templates. Use when writing or generating a PR description, preparing a pull request for review, or documenting code changes for teammates.

Generate a polished standalone HTML report summarizing changes, findings, debug investigations, or architectural decisions. Opens automatically in the browser. Use after completing work on a ticket, investigation, or debug session.

Write a stakeholder Slack/email update message. Use when the user wants to communicate project status, blockers, decisions, or release readiness to stakeholders.

Interactive tool to write high-quality tickets of the right type -- story, subtask, issue, bug, epic, or initiative -- each with its own structure, required fields, and quality checks. Use when the user asks to write a ticket, draft a user story, file a bug report, scope an epic, define an initiative, break work into subtasks, or convert a rough idea into a well-formed backlog item. Runs an interactive type selection and field-by-field questionnaire, then outputs a clean Markdown ticket ready to paste into Jira, Linear, GitHub Issues, Azure DevOps, or any tracker.

Ecosystem discovery advisor. Use when the user asks 'what skill should I use', 'what agent should I delegate to', 'which team fits this task', or when onboarding to available skills, agents, and teams. Scans ALL installed skills at runtime -- not limited to any single plugin or vendor. Triggers: 'which skill', 'which agent', 'what do I use for', 'orient me', 'what tools do I have'.

Comprehensive reference for all 33 Django framework components with Python 3.10+ and Django 6.0 patterns. Use when the user asks to implement, configure, or troubleshoot any Django component including Models, QuerySets, Views, Templates, Forms, Admin, Authentication, Caching, Testing, Middleware, Signals, or Deployment. Covers ORM patterns, class-based views, template tags, form validation, admin customization, async support, and Django best practices.

Comprehensive reference for the LangChain ecosystem including LangChain, LangGraph, and Deep Agents for Python 3.10+. Use when the user asks to build AI agents, implement RAG pipelines, configure chat models, create tool-calling agents, set up retrieval chains, manage conversation memory, orchestrate multi-agent workflows, or integrate with LLM providers (OpenAI, Anthropic, Google). Covers models, messages, output parsers, vector stores, embedding strategies, streaming, middleware, and LangGraph state machines.

Comprehensive reference for all 38 Symfony framework components with PHP 8.3+ and Symfony 7.x patterns. Use when the user asks to implement, configure, or troubleshoot any Symfony component including HttpFoundation, HttpKernel, DependencyInjection, Form, Validator, Cache, Messenger, Console, EventDispatcher, Workflow, Serializer, Security, Routing, Twig, Doctrine integration, or any other Symfony component. Covers APIs, configuration, best practices, and common pitfalls.

Symfony framework version upgrade guide using the deprecation-first approach. Use when the user asks to upgrade Symfony to a new minor or major version, fix deprecation warnings, update Symfony recipes, check bundle compatibility, migrate between LTS versions, or plan a Symfony version migration strategy. Covers PHPUnit Bridge deprecation tracking, recipe updates, bundle compatibility checks, version-specific breaking changes, and the changelog-first upgrade workflow.