wicked-garden

Backward compatibility aliases for old multi-plugin command names

Ask questions about agentic patterns, frameworks, architectures, and best practices

Deep trust and safety audit for agentic systems with risk classification and compliance validation

Interactive agentic architecture design guidance with pattern recommendations and safety validation

Research, compare, and select agentic frameworks with interactive guidance and latest updates

Show available agentic architecture commands and usage

Full agentic codebase review with framework detection, agent topology analysis, and remediation roadmap

Approve a phase and advance to next stage

Archive or unarchive a crew project

Query and display evidence collected for a task.

Execute current phase work with adaptive role engagement

Run quality engineering gate analysis on a target.

Show available crew workflow commands and usage

Execute remaining work with maximum autonomy and guardrails

Configure engagement preferences for wicked-crew.

Start a new wicked-crew project with outcome clarification

Show current project status, phase, and next steps

Start interactive data analysis session for CSV/Excel files

Show available data engineering commands and usage

Sample a dataset and recommend public or custom ontologies based on the data

Show available delivery management commands and usage

Generate multi-perspective delivery reports from project data

Configure delivery metrics — cost model, commentary sensitivity, and sprint cadence

Architecture analysis and design recommendations

Systematic debugging session with root cause analysis

Generate or improve documentation for code

Show available engineering commands and usage

Review requested changes against codebase and recommend detailed implementation steps

Code review with senior engineering perspective on quality, patterns, and maintainability

Show all available wicked-garden domains and commands

Start a new brainstorm session with dynamic focus groups

Structured evaluation tool that uses real external LLM CLIs (Codex, Gemini, OpenCode, Pi) to get genuinely independent model perspectives. Unlike brainstorm (free-form creative exploration), council is a **rigid evaluation tool** for when you have defined options and need a verdict.

Get help with the wicked-jam plugin

Get multiple perspectives on a decision without synthesis

Quick exploration with fewer personas and one round

Revisit a past brainstorm decision and record its outcome

Show current kanban board state with projects and tasks

Add a comment to a task

Setup instructions and usage for wicked-kanban

Name the current session for better sprint/initiative organization

Quick task creation with optional project and priority

Check the Control Plane status for dashboard integration

Archive or delete a memory

Show available memory commands and usage

Show memory statistics

Store a memory for persistence across sessions.

Run contract assertions against plugin subprocess outputs

Run health probes against all installed plugins

Show available observability commands and usage

Query hook execution traces for the current session

Add a field to an entity/class and propagate to all affected files

Apply patches from a saved JSON file

Show available patch commands and usage

Create a new language generator for wicked-patch with scaffolding, tests, and validation

Show what would be affected by a change without generating patches

Remove a field and all its usages from the codebase

Rename a field/symbol across all usages in the codebase

GitHub Actions workflow generation and optimization

Audit evidence collection and compliance verification

Regulatory compliance check (SOC2, HIPAA, GDPR, PCI)

Error analysis and pattern detection

GitHub CLI power utilities for workflows, PRs, and releases

System health check and reliability assessment

Show available platform engineering commands and usage

Incident response and triage

Infrastructure review and IaC analysis

Security review and vulnerability assessment

Distributed tracing analysis for latency and dependencies

Define acceptance criteria from requirements and design

Facilitate stakeholder alignment and consensus building

Analyze customer feedback for themes, sentiment, and trends

Elicit and document requirements through structured discovery

Show available product management commands and usage

Aggregate customer feedback from available sources

Strategic analysis - ROI, value proposition, market, competitive

Generate actionable recommendations from customer feedback insights

UX and design quality review - flows, UI, accessibility, research

Run evidence-gated acceptance testing with Write → Execute → Review pipeline

Generate test code from scenarios or test plan

Show available quality engineering commands and usage

Generate comprehensive QE test plan for a feature or change

Review test quality, coverage, and test code best practices

Quality Engineering review - requirements, design, architecture, code, deployment

Generate test scenarios with happy paths, edge cases, and error conditions

File a GitHub issue for a bug, UX friction point, or unmet outcome

Validate scenario file format and structure

Show available E2E scenario commands and usage

List available E2E test scenarios with tool availability status

File GitHub issues from acceptance test failures with deduplication and grouping

Execute an E2E test scenario by orchestrating CLI tools

Install required CLI tools for running E2E test scenarios

Analyze dependencies and dependents of a symbol

Show symbol categories — types, layers, directory groupings, and cross-category relationships

Search code symbols only (functions, classes, methods)

Report on lineage coverage and identify symbols without full traceability

Search documents only (PDF, Office docs, markdown)

Show available search and code intelligence commands and usage

Find the most-referenced symbols in the codebase — classes, functions, and modules with the highest connectivity

Analyze what would be affected by changing a symbol (reverse lineage)

Find code that implements a documented feature/section

Build unified index for code and documents in a directory

Trace data lineage from source to sink (UI → DB or reverse)

Run quality crew to validate and improve index accuracy to >=95%

Find where a symbol is referenced and documented

Quick pattern reconnaissance for common code patterns (no index required)

Search across all code and documents

Detect and visualize the service architecture from infrastructure and code patterns

Show index statistics

Validate index accuracy using consistency checks

Configure wicked-garden connection and onboard the current codebase

Show the session state document and context assembly details for debugging.

Show available context assembly commands and usage

Intelligent onboarding that builds understanding of a codebase using parallel workflows. Indexes in the background while exploring in parallel, saves discoveries as memories, and validates navigability post-index.

Gather and display intelligent context from wicked-garden sources.

Five-layer architecture validation, agent topology analysis, orchestration patterns, and framework selection for agentic systems. Focus on structural soundness and scalability. Use when: architecture review, agent design, topology analysis, framework selection

Framework comparison, selection guidance, migration paths, ecosystem assessment, and latest framework updates. Live research capabilities for emerging frameworks. Use when: framework selection, migration, comparison, latest features

Pattern recognition, anti-pattern detection, refactoring recommendations, design pattern application, and code quality for agentic systems. Use when: code review, refactoring, patterns, anti-patterns, design quality

Token optimization, latency budgets, cost analysis, parallelization opportunities, caching strategies, and context window management for agentic systems. Use when: performance optimization, cost reduction, latency, token usage

Guardrails, prompt injection defense, PII protection, human-in-the-loop gates, output validation, and hallucination mitigation for agentic systems. Use when: safety review, guardrails, prompt injection, PII, validation

Sprint and iteration management. Tracks velocity, identifies blockers, manages capacity, and ensures predictable delivery cadence. Use when: sprint management, velocity, blockers, delivery cadence

Run Execution Gate (post-build). Verifies implementation works, tests exist and pass, and risks are mitigated.

Guide outcome clarification through structured inquiry.

Execute implementation tasks with quality and safety.

Coordinate multi-agent workflows and phase execution.

Progress monitoring and forecasting. Tracks task completion, burndown, milestone progress, and generates completion forecasts. Use when: task completion, burndown, milestone tracking, forecasting

Route to appropriate quality gate. Determines gate type from context, dispatches to gate-specific orchestrators, consolidates results.

Explore codebase and gather context for design decisions.

Perform basic code review and validation.

Status communication and executive reporting. Synthesizes delivery status into stakeholder-appropriate formats with decision support. Use when: status reports, executive updates, stakeholder communication

Run Value Gate (post-clarify). Assesses whether we should build this. Evaluates problem clarity, scope, testability, and early risks.

Data warehouse design, data modeling, lakehouse architecture, and governance. Ensures analytics infrastructure is scalable, cost-effective, and well-governed.

Data exploration, statistical analysis, insight generation, and visualization guidance. Helps understand what the data is telling you.

ETL pipeline design, data quality assessment, schema validation, and performance optimization. Reviews data architectures and ensures robust data engineering practices.

ML model development, training pipeline design, feature engineering, and deployment guidance. Ensures ML systems are robust, monitored, and maintainable.

Narrate codebase structure and architecture for orientation. Analyze directory layout, key modules, data flows, and technical decisions. Use when: codebase overview, architecture walkthrough, code navigation

Identify and recommend cloud cost optimizations. Right-sizing, reserved capacity, idle resource cleanup, and architecture cost improvements. Use when: cost reduction, right-sizing, savings opportunities, resource optimization

Sprint and project delivery management. Track velocity, plan sprints, manage scope, and coordinate cross-team dependencies. Use when: sprint planning, velocity tracking, scope management, project coordination

Design rigorous experiments with statistical analysis. Formulate hypotheses, select metrics, calculate sample sizes, and ensure experimental validity. Use when: A/B tests, experiments, hypothesis, sample size

Analyze cloud and infrastructure costs from billing data and project context. Identify cost drivers, anomalies, and budget variance. Use when: cloud costs, billing analysis, cost breakdown, budget tracking

Forecast costs, timelines, and resource needs based on historical data and current trends. Model scenarios and predict outcomes. Use when: cost forecast, timeline prediction, capacity planning, scenario modeling

Guide new developers through team onboarding. Analyze project health, explain delivery patterns, and identify starting points for contribution. Use when: new developer, onboarding, team orientation, getting started

Track and report progress against milestones, goals, and deadlines. Monitor completion rates, identify slippage, and forecast outcomes. Use when: milestone tracking, progress reporting, deadline monitoring, completion forecast

Risk tracking and escalation management. Identifies delivery risks, tracks mitigation progress, and manages dependency chains. Use when: delivery risks, escalation, dependency tracking

Coordinate progressive rollouts with risk management. Plan canary deployments, monitor metrics, define rollback criteria, and communicate with stakeholders. Use when: progressive rollout, canary deployment, feature flags

Generate multi-perspective stakeholder reports from delivery data. Analyze project status through Delivery, Engineering, Product, QE, Architecture, and DevSecOps lenses. Use when: stakeholder report, status update, steering committee, executive summary

Specialize in API documentation - OpenAPI specs, endpoint documentation, request/response examples, and error documentation. Create comprehensive, accurate API reference materials. Use when: API docs, OpenAPI specs, endpoint documentation, API reference

Backend engineering specialist focusing on APIs, databases, server-side patterns, data modeling, scalability, and integration design. Use when: APIs, databases, server-side code, data modeling, backend architecture

Design data models, storage strategies, and data flow patterns. Focus on schema design, data ownership, and persistence decisions. Use when: data models, database design, schema design, data flow, persistence

Debugging specialist focused on root cause analysis, error investigation, profiling, and systematic debugging strategies. Helps diagnose complex issues. Use when: debugging, error investigation, root cause analysis, stack traces, bug fixing

Frontend engineering specialist focusing on React, CSS, browser APIs, component design, performance, accessibility, and user experience patterns. Use when: React, CSS, browser APIs, frontend components, UI implementation

Design API contracts, service boundaries, and integration patterns. Focus on how components communicate and interoperate. Use when: API contracts, service integration, microservices, system boundaries

Senior engineering perspective on code quality, architecture patterns, maintainability, and implementation guidance. Reviews from developer mindset and provides mentorship on best practices. Use when: code review, refactoring, best practices, implementation guidance, code quality

Design end-to-end solutions with appropriate patterns, technology choices, and trade-offs. Focus on high-level architecture that balances requirements, constraints, and maintainability. Use when: system design, architecture decisions, technology choices, high-level design

Define component boundaries, module organization, and interface contracts. Focus on decomposition and dependency management. Use when: component boundaries, module organization, interface contracts, decomposition

Create clear, accessible technical documentation with proper structure, audience awareness, and practical examples. Focus on helping users understand and use the system effectively. Use when: documentation, technical writing, README, user guides

Runs structured multi-model council evaluations using external LLM CLIs. Each model responds independently to a fixed question scaffold, then Claude synthesizes.

Role-plays as focus group personas and synthesizes brainstorming discussions.

Maintain memory health - decay, archive, and cleanup operations. Use this agent when you need to run memory maintenance, clean up old memories, or check memory health. This agent handles the decay lifecycle (active -> archived -> decayed -> deleted) based on age, importance, and access patterns. <example> Context: User wants to clean up old memories. user: "Clean up old memories" assistant: "I'll run memory maintenance to archive and clean up stale memories." <commentary> Use memory-archivist to run the decay process and report what was archived/deleted. </commentary> </example> <example> Context: Session starts and maintenance should run. user: "Starting a new session" assistant: "Running memory maintenance in the background." <commentary> The archivist can be triggered at session start to keep the memory store healthy. </commentary> </example> <example> Context: User asks about memory health. user: "How many old memories do I have?" assistant: "Let me check the memory store health and identify stale memories." <commentary> Use memory-archivist to scan and report on memory status without necessarily deleting. </commentary> </example>

Extract and structure learnings from completed tasks. Use this agent when you need to analyze completed work and extract memories worth preserving. This agent identifies decisions made, problems solved, patterns discovered, and user preferences observed during a task. <example> Context: Claude just finished a complex debugging session. user: "Great, the bug is fixed!" assistant: "Let me extract learnings from this debugging session to remember for next time." <commentary> After completing significant work, use memory-learner to capture episodic (what happened) and procedural (how we fixed it) memories. </commentary> </example> <example> Context: User made an important architectural decision during the conversation. user: "Yes, let's go with PostgreSQL for the transaction support." assistant: "I'll store this decision and rationale as a memory for future reference." <commentary> Important decisions with rationale should be captured as decision-type memories. </commentary> </example> <example> Context: Claude discovered a useful pattern while implementing a feature. user: "That retry pattern worked well." assistant: "Let me save this pattern as a procedural memory for reuse." <commentary> Patterns and techniques that prove useful should be captured as procedural memories. </commentary> </example>

Search and retrieve relevant memories without overloading main context. Use this agent when you need to search the memory store for relevant context, find past decisions or learnings, or retrieve memories by tag or pattern. This agent runs with minimal tools (Grep, Glob, Read) for fast, focused search operations. <example> Context: User is working on authentication and Claude needs past context. user: "How did we handle JWT validation before?" assistant: "Let me search for relevant memories about JWT validation." <commentary> The user is asking about past decisions/implementations. Use memory-recaller to find relevant episodic or procedural memories. </commentary> </example> <example> Context: User is making an architectural decision. user: "We need to choose a database. What have we decided before?" assistant: "I'll search for past database decisions in the memory store." <commentary> Search for decision-type memories related to databases to inform the current choice. </commentary> </example> <example> Context: Claude encounters a familiar-seeming bug. user: "This auth error looks familiar..." assistant: "Let me check if we've encountered this before." <commentary> Search episodic memories for past bug fixes or issues related to authentication. </commentary> </example>

Audit evidence collector and control verifier. Gathers artifacts, validates controls, maintains audit trails, and generates compliance reports for certification audits. Use when: audit evidence, compliance artifacts, audit trails

Regulatory compliance expert. Evaluates code and systems against SOC2, HIPAA, GDPR, PCI requirements. Identifies violations and provides remediation guidance. Use when: SOC2, HIPAA, GDPR, PCI, regulatory compliance

CI/CD pipeline design, workflow automation, and deployment orchestration. Focus on GitHub Actions, GitLab CI, pipeline optimization, and deployment reliability. Use when: CI/CD, pipelines, GitHub Actions, deployment automation

Incident response specialist focused on rapid triage, root cause correlation, timeline reconstruction, and blast radius assessment during production incidents. Aggregates observability data for fast incident resolution. Use when: incidents, outages, triage, root cause, blast radius

Cloud infrastructure design, Infrastructure-as-Code, scalability, and platform reliability. Focus on AWS/GCP/Azure, Terraform, Kubernetes, and resource optimization. Use when: cloud infrastructure, IaC, Terraform, Kubernetes

Policy interpretation and requirements translation expert. Maps regulatory requirements to technical controls, performs gap analysis, and provides implementation guidance. Use when: policy interpretation, compliance requirements, controls

Privacy and data protection specialist. Detects PII/PHI, ensures GDPR compliance, implements privacy by design, and protects sensitive data throughout its lifecycle. Use when: PII, PHI, data protection, privacy by design, GDPR

Release management, versioning strategies, deployment coordination, and rollback procedures. Focus on semantic versioning, changelog generation, deployment strategies, and release orchestration. Use when: releases, versioning, deployment, rollback procedures

Security scanning and vulnerability assessment from DevSecOps perspective. Focus on OWASP compliance, secure coding practices, secrets management, and defensive security patterns. Use when: security review, vulnerabilities, OWASP, secure coding

Site Reliability Engineer focused on system health assessment, capacity planning, performance correlation, and proactive reliability improvement. Aggregates observability data from multiple sources for unified health view. Use when: reliability, system health, capacity planning, performance

Audit accessibility compliance - WCAG guidelines, keyboard navigation, screen readers, semantic HTML, and inclusive design patterns. Use when: accessibility, WCAG, keyboard navigation, screen readers

Facilitate stakeholder alignment and consensus building. Identify concerns, mediate trade-offs, and ensure shared understanding across teams. Use when: stakeholder alignment, consensus building, trade-off discussions

Evaluate business impact and ROI for technical investments. Assess strategic alignment, quantify costs and benefits, calculate payback periods, and provide investment recommendations. Use when: ROI, business case, strategic alignment, investment decisions

Analyze competitive landscape and market positioning. Conduct SWOT analysis, assess alternatives, evaluate competitive threats, and provide strategic positioning recommendations. Use when: SWOT analysis, competitive positioning, alternatives

Customer perspective specialist focused on empathy-driven insights. Use this agent when you need to understand customer needs, prioritize pain points, translate raw feedback into actionable insights, or ensure customer empathy in product decisions. This agent represents the voice of the customer with genuine advocacy and prioritization based on customer impact. <example> Context: Product team is deciding on next quarter features. user: "Which feature should we prioritize?" assistant: "Let me analyze customer feedback to identify top pain points." <commentary> Use customer-advocate to review feedback, identify patterns in customer needs, and recommend priorities based on customer impact and urgency. </commentary> </example> <example> Context: Engineering wants to deprecate a feature. user: "Can we remove the CSV export feature?" assistant: "Let me check customer usage and feedback on CSV exports." <commentary> Customer-advocate reviews support tickets, feature requests, and usage patterns to assess customer dependency and potential impact. </commentary> </example> <example> Context: Design is proposing a UX change. user: "Should we move the navigation to a sidebar?" assistant: "Let me find customer feedback about navigation pain points." <commentary> Search for customer complaints, feature requests, and usability feedback related to navigation to inform the design decision. </commentary> </example> Use when: customer needs, pain points, customer empathy, user feedback

Feedback analysis specialist for sentiment, themes, and trends. Use this agent when you need to analyze raw feedback data, extract themes, identify trends, perform sentiment analysis, or synthesize quantitative and qualitative insights from customer voice sources. <example> Context: Product manager wants to understand Q1 feedback themes. user: "What are the main themes in customer feedback this quarter?" assistant: "Let me analyze feedback data to extract key themes." <commentary> Use feedback-analyst to process all Q1 feedback, cluster by themes, score sentiment, and identify emerging patterns. </commentary> </example> <example> Context: Leadership wants to know if sentiment is improving. user: "Has customer sentiment improved since the redesign?" assistant: "I'll analyze sentiment trends before and after the redesign." <commentary> Compare sentiment scores from feedback before and after the redesign launch date, identify shifts, and quantify the change. </commentary> </example> <example> Context: Support team notices recurring complaints. user: "Are we seeing more complaints about performance?" assistant: "Let me check performance-related feedback trends." <commentary> Extract all performance-related feedback, analyze frequency over time, compare to historical baseline, identify if trending up or down. </commentary> </example> Use when: sentiment analysis, feedback themes, customer trends

Conduct market research and trend analysis. Size markets, segment customers, forecast adoption, identify trends, and assess market timing for investments. Use when: market research, market sizing, competitive landscape, trends

Strategic product thinking: roadmap planning, prioritization, trade-offs, and business value alignment. Balances customer needs with delivery capacity. Use when: roadmap, prioritization, product strategy, feature decisions

Elicit and document requirements with precision. Transform vague ideas into clear user stories with testable acceptance criteria. Use when: user stories, requirements, acceptance criteria, specifications

Review visual design consistency, component patterns, design system adherence, and UI polish. Focus on the visual layer and implementation quality. Use when: visual design, design system, UI consistency, component patterns

Discover and validate user needs. Create personas, map journeys, and ensure empathy-driven design. SOLE OWNER of user research activities. Use when: personas, user research, journey mapping, user needs

Analyze user flows, interaction patterns, and information architecture. Focus on the overall experience design and usability. Use when: user flows, interaction design, UX patterns, usability

Design and evaluate value propositions. Map customer benefits, assess differentiation, identify unique advantages, and guide positioning strategy for technical products. Use when: value proposition, differentiation, customer benefits

Follows structured test plans step-by-step, collecting evidence artifacts. Does NOT judge results. Does NOT grade pass/fail. Only executes and captures. Produces an evidence collection for independent review. Use when: acceptance test execution, evidence collection, test plan execution

Evaluates evidence artifacts against test plan assertions independently. Never sees execution happen — only gets the test plan and evidence report. Catches semantic bugs that self-grading misses. Use when: acceptance test review, evidence evaluation, test verdict

Reads acceptance scenarios and produces structured, evidence-gated test plans. Transforms qualitative criteria into concrete artifact requirements with assertions. Every step demands evidence. Every assertion is independently verifiable. Use when: acceptance testing, test plan generation, scenario verification design

Static code analysis focusing on testability, quality, and maintainability. Reviews code structure, identifies test coverage gaps, and assesses risk areas. Use when: static analysis, code quality metrics, testability, maintainability

Identify risks and failure modes. Assesses security, reliability, and operational risks. Updates kanban with risk matrix. Use when: risk identification, failure modes, technical risks, mitigation

Guide Test-Driven Development workflow. Teaches red-green-refactor cycle, test-first approach, and TDD best practices. Validates test quality. Use when: test-driven development, red-green-refactor, test-first approach

Generate test code and configure test automation infrastructure. Creates unit, integration, and e2e tests. Configures test runners, CI pipelines, and coverage. Use when: test generation, automated tests, test code, CI testing

Generate test scenarios from code. Identifies happy paths, error cases, and edge cases. Updates kanban with findings. Use when: test planning, what to test, test scenarios, coverage strategy

Full-capability scenario executor that can run both bash commands AND slash commands. Reads scenario markdown files, discovers tools, executes steps via Bash or Skill tool, and reports structured pass/fail results. Use instead of scenario-runner when scenarios contain slash commands (most wicked-garden scenarios do).

Autonomous scenario execution agent. Reads a wicked-scenarios markdown file, discovers required CLI tools, executes each step, and reports pass/fail results. Handles graceful degradation when tools are missing.

Browser automation via agent-browser CLI. Screenshots, scraping, accessibility audits, form automation, and live viewport streaming. Use when: - Taking screenshots or extracting page content - Automating web forms and UI interactions - Accessibility audits - Web scraping for AI agents - Testing web applications

Core agentic architecture patterns and anti-patterns for building robust multi-agent systems. Use when: "agent pattern", "multi-agent design", "how should I structure agents", "agentic anti-pattern"

Context window management, token optimization, and memory patterns for efficient multi-agent systems. Use when: "context window", "token optimization", "agent memory", "reduce token usage", "context engineering"

Five-layer architectural model for building production-grade agentic systems with clear separation of concerns. Use when: "agent architecture layers", "five layer", "agent system design", "separation of concerns agents"

Agentic framework landscape, comparison, and selection guide for choosing the right framework for your use case. Use when: "which agent framework", "compare frameworks", "LangGraph vs CrewAI", "framework selection"

Five-level maturity assessment model for agentic systems from prototype to optimized production. Use when: "agent maturity", "production readiness", "how mature is my agent", "agent assessment"

Systematic review methodology for agentic codebases with issue detection, analysis, and reporting. Use when: "review agentic code", "audit agent system", "check agent quality", "agentic code review"

Trust, safety, and control patterns for production agentic systems with human-in-the-loop gates and guardrails. Use when: "agent safety", "guardrails", "human-in-the-loop", "agent trust", "prompt injection defense"

Orchestrate multi-AI conversations with persistent context and audit trails. Use wicked-kanban as shared memory so Claude, Gemini, Codex, and OpenCode can collaborate. Use when: - Running multi-model analysis on architecture or design - Getting diverse AI perspectives on a decision - Need auditable AI-assisted decision making - Building consensus from multiple AI sources

Use the OpenAI Codex CLI for AI-assisted coding, code review, and multi-model collaboration. Codex excels at code generation, refactoring, and technical analysis. Use when: - Getting a second opinion on code or architecture - Code review from a different AI perspective - Complex refactoring analysis - Running parallel analysis with multiple AI models

Interface guide for the wicked-control-plane — the persistence backend for all wicked-garden domains. This skill should be used when the user needs to interact with the CP API, discover endpoints, or debug CP connectivity. Use when: "control plane API", "CP endpoint", "how to store data", "CP connectivity", "manifest discovery", "domain data persistence", "debug CP issue"

Adaptive engagement patterns for wicked-crew based on context, phase, and user preferences. Provides role inference, autonomy adaptation, and communication style adjustment. Use when the user mentions "autonomy", "just finish", "ask first", "adapt to my style", "preference profile", or when determining how to engage based on project context.

Crew-integrated quality gates for phase transitions. Runs QE checks at crew checkpoints (clarify, design, build) to validate readiness before advancing. Works within wicked-crew workflow context. Use when: "crew quality gate", "phase gate check", "ready to advance", "should we build this", "does it work", "crew QE checkpoint"

Core wicked-crew v3 workflow with capability-based orchestration. Smart decisioning analyzes input to determine specialists needed. Built-in fallbacks when specialists unavailable. Use when the user mentions "start a project", "clarify outcome", "design phase", "QE gate", "shift-left testing", "just finish", "approve phase", or needs structured software delivery workflow guidance.

Data analysis and insights generation: exploratory analysis, statistical methods, visualization guidance. Use when exploring datasets, finding patterns, or generating business insights. Use when: - "analyze this data" - "what patterns are in the data" - "generate insights from" - "exploratory data analysis" - "what does this data tell us"

Core data engineering capabilities: dataset profiling, schema validation, and data quality assessment. Use when analyzing datasets, validating schemas, or assessing data quality. Use when: - "profile this dataset" - "validate schema" - "check data quality" - "what's in this CSV/Excel file" - "analyze this data"

Machine learning model guidance: architecture review, training pipeline design, feature engineering, deployment. Use when developing ML models, reviewing model code, or designing ML systems. Use when: - "review this ML model" - "design ML training pipeline" - "how should I deploy this model" - "feature engineering advice" - "ML architecture guidance"

Interactive data analysis for large CSV/Excel files using DuckDB SQL queries. Provides intelligent sampling, schema detection, and query execution without loading files into memory. Use when: - Analyzing CSV, Excel, or other tabular data files - Exploring large datasets (GB-scale files) - Running SQL queries against local data files - Understanding data structure, types, and quality - Joining or aggregating across multiple files - Detecting data quality issues (nulls, duplicates, type mismatches)

Data pipeline design and review: ETL patterns, orchestration, performance optimization. Use when designing new pipelines or reviewing existing data workflows. Use when: - "design a data pipeline" - "review this ETL" - "optimize data processing" - "how should I orchestrate this" - "pipeline architecture"

Design statistically rigorous A/B tests and experiments. Formulate hypotheses, select metrics, calculate sample sizes. Discovers analytics and feature flag tools via capability detection. Use when: "design experiment", "A/B test", "hypothesis", "sample size", "what metrics", "test my feature", "should we experiment"

Multi-perspective project delivery reporting with persona-based analysis. Generates actionable reports from project data using 6 specialized stakeholder perspectives. Use when: - Generating delivery reports from project exports (Jira, GitHub, Linear, etc.) - Analyzing project status from multiple stakeholder perspectives - Creating sprint retrospective data or steering committee materials - Assessing quality, delivery, and risk metrics - Synthesizing project health across engineering, product, and operations Enhanced with: - wicked-garden:mem Stores insights across sessions

Plan and coordinate progressive feature rollouts. Risk assessment, canary deployments, feature flag management, rollback procedures. Discovers deployment tools via capabilities. Use when: "roll out feature", "progressive rollout", "canary deployment", "feature flag", "rollback plan", "launch feature", "deploy gradually"

Complete solution architecture design with patterns, decisions, and diagrams. Define overall system structure, technology choices, and architectural trade-offs. Use when: "design the architecture", "what's the overall structure", "architecture patterns", "technology stack", "system architecture"

Backend engineering specialist for APIs, databases, server-side patterns, data modeling, scalability, and integrations. Use when: "design an API", "database schema", "how to handle auth", "backend performance", "REST endpoint", "query optimization", "server-side architecture"

Systematic debugging and root cause analysis for investigating errors, diagnosing complex issues, and performance profiling. Use when: "debug this error", "why is this failing", "root cause analysis", "fix this bug", "investigate crash", "stack trace", "not working"

Audit documentation coverage and quality. Find undocumented code, assess documentation completeness, and provide coverage metrics. Use when: "audit docs", "check coverage", "find undocumented code", "documentation quality", "what's missing docs"

Senior engineering guidance on code quality, architecture patterns, and best practices. Use for implementation planning, code review, or general engineering questions about maintainability and design. Use when: "review this code", "how should I implement", "is this good practice", "code quality", "refactor", "clean up", "best practice", "design pattern"

Frontend engineering specialist for React, CSS, browser APIs, component design, accessibility, and performance. This skill should be used when the user asks about UI implementation, component review, or frontend-specific questions. Use when: "build a React component", "CSS layout issue", "frontend performance", "browser API", "component design", "accessibility check", "responsive design"

Generate documentation from code - extract types, comments, and signatures to create API docs, README files, and reference documentation. Focus on useful, actionable docs. Use when: "generate docs", "create documentation", "document the API", "generate README", "make docs from code"

Design API contracts, service boundaries, and integration patterns. Define how components and services communicate and interoperate. Use when: "API design", "service integration", "how do these communicate", "API contract", "integration pattern", "REST API", "GraphQL", "event schema"

Keep documentation in sync with code changes. Detect stale docs, identify documentation drift, and suggest updates when code changes. Use when: "check doc freshness", "sync docs", "find stale documentation", "update docs", "docs out of sync"

Define component boundaries, module organization, and interface contracts. Break down systems into cohesive, loosely-coupled components. Use when: "component design", "module boundaries", "how should we organize this", "component interfaces", "dependency management", "system decomposition"

Use the Gemini CLI for AI-assisted tasks, code review, and multi-model collaboration. Gemini provides a second perspective on code, designs, and decisions. Use when: - Getting a second opinion on code or architecture - Reviewing designs from a different AI perspective - Running parallel analysis with multiple AI models - Needing Gemini-specific capabilities (long context, etc.)

Capability router that decides which tools, skills, and agents to use for a task. Reduces cognitive load on the main agent by making tool selection decisions. Use this skill (or spawn as subagent) when: - Starting a complex task that might benefit from available integrations - Unsure what tools/skills could help with current work - Want to discover capabilities before executing - Building a task plan that should leverage available resources

Automated GitHub issue detection and filing from Claude sessions. Tracks tool failures and task completion mismatches. Files issues automatically at session end or on demand via /wicked-garden:report-issue. Use when: filing a bug, reporting UX friction, logging unmet outcomes, tool failures, report issue, create issue, something went wrong, not working as expected

Orchestrates AI-powered brainstorming sessions with dynamic focus groups. This skill should be used when the user wants to brainstorm, explore ideas, get feedback on concepts, or run a focus group discussion. Use when: "brainstorm this", "explore ideas", "get different perspectives", "focus group", "what do you think about", "pros and cons"

This skill should be used when the user asks to "track tasks", "create a task", "add a todo", "manage tasks", "show my tasks", "what should I work on", "move task to done", "update task status", or mentions persistent task tracking, kanban boards, or project management. Provides guidance for using wicked-kanban for persistent task management.

Memory storage, recall, and lifecycle management for maintaining context across sessions. This skill should be used when the user asks to "remember this", "store a decision", "recall what we did", "find past context", "save for later", "what did we learn", "what did we decide", or mentions persisting knowledge, decisions, or learnings. Use when: - "remember this for next time" - "store this decision" - "what did we do before" - "recall past context" - "save this pattern"

Plugin observability: health probes, contract assertions, and hook execution tracing. Monitor plugin ecosystem integrity, catch silent failures, and validate script outputs. Use when: "check plugin health", "are hooks working", "silent failures", "trace hook execution", "validate contracts", "plugin diagnostics"

Use the OpenCode CLI for AI-assisted coding with multiple models and providers. OpenCode supports various AI models and includes built-in MCP server management. Use when: - Getting a second opinion from different AI providers - Running parallel analysis with multiple AI models - Working with GitHub PRs and issues - Need a TUI-based AI coding session

Language-agnostic code generation and change propagation. Use this skill when adding fields to entities, renaming symbols across files, or propagating changes that affect multiple files. Triggered by: "add field", "rename everywhere", "propagate change", "generate migration", "update all references". This is the CODE MUTATION counterpart to wicked-search (which is read-only).

Use the Inflection Pi-Mono CLI for AI-assisted conversational reasoning and multi-model collaboration. Pi excels at empathetic perspective-taking, nuanced reasoning, and conversational analysis. Use when: - Getting a conversational/empathetic perspective on decisions - Evaluating user-facing copy or communication tone - Running multi-model council sessions for diverse reasoning - Needing a different reasoning style for balanced evaluation

Audit evidence collection and trail verification. Gathers artifacts, validates controls, generates audit reports, and maintains compliance documentation. Use when: "audit trail", "collect evidence", "audit report", "control testing", "compliance documentation"

Compliance analysis for regulatory frameworks (SOC2, HIPAA, GDPR, PCI). Checks code and architecture against compliance requirements, detects violations, and provides remediation guidance. Use when: "compliance check", "SOC2", "HIPAA", "GDPR", "PCI", "regulatory requirements", "audit", "is this compliant"

Error analysis and pattern detection from discovered error tracking sources. Aggregates errors across services, detects patterns, correlates with deployments, and assesses user impact. Use for error investigation and incident response. Use when: "error analysis", "error patterns", "production errors", "error investigation", "why are we seeing errors"

GitHub CLI power utilities - workflow debugging, PR management, release automation, and repo operations. Use when working with GitHub via CLI for anything beyond basic git commands.

Write secure, optimized GitHub Actions workflows. Use when creating CI/CD pipelines, automating deployments, or debugging workflow issues. Security-first approach with performance optimization.

Write secure, optimized GitLab CI/CD pipelines. Use when: "create CI/CD pipeline", "GitLab CI config", "fix pipeline", ".gitlab-ci.yml", "configure runners", "pipeline optimization"

GitLab CLI (glab) utilities - pipeline debugging, MR management, release automation. Use when working with GitLab via CLI for anything beyond basic git commands.

System health overview from discovered observability sources. Aggregates errors, performance metrics, and SLO status across services. Correlates with deployments and code changes. Use for proactive health monitoring and post-deployment validation. Use when: system health, health check, deployment health, production status, how is production

Policy interpretation and compliance guidance. Translates regulatory requirements into actionable controls, maps policies to code, and provides implementation guidance. Use when: "policy", "what does this mean", "how to implement", "policy guidance", "requirements translation"

Distributed tracing analysis for performance investigation and service dependency mapping. Analyze latency breakdowns, identify bottlenecks, map service calls, and correlate slow requests with code changes. Use when: "trace analysis", "distributed tracing", "latency investigation", "slow requests", "service dependencies", "performance tracing"

Define testable acceptance criteria from requirements and design. Bridge product requirements with QE test scenarios. Use when: "define acceptance criteria", "how do we know it's done", "what should QE test", "definition of done"

WCAG 2.1 Level AA accessibility audit and remediation guidance. Keyboard navigation, screen readers, semantic HTML, ARIA patterns. Use when: "accessibility", "a11y", "WCAG", "keyboard", "screen reader", "semantic HTML", "ARIA", "inclusive design", "disability"

Sentiment analysis, theme extraction, and trend detection from customer feedback. Use when: "what are customers saying about X", "feedback trends", "analyze customer feedback", "sentiment analysis", "customer themes", "what's the top complaint"

Visual design and UI consistency review process. Component patterns, design system adherence, responsive design, and visual polish. Use when: "design review", "UI review", "visual consistency", "design system", "component review", "polish", "responsive design"

Aggregate customer feedback from discovered sources across support, surveys, social, and direct channels. This skill should be used when the user needs to gather customer voice data to inform product decisions or understand sentiment. Use when: "listen to customers", "what are customers saying", "gather feedback", "customer sentiment", "aggregate feedback", "voice of customer"

Strategic product thinking for roadmap, priorities, and business value. Elicit requirements, define scope, and align stakeholders. Works standalone or integrated with wicked-crew. Use when: "product strategy", "requirements", "user stories", "what should we build", "prioritize features", "scope definition"

Deep requirements elicitation and user story definition. Transform vague ideas into clear, testable specifications. Use when: "write user stories", "define requirements", "what are the acceptance criteria", "clarify scope"

Strategic business analysis for technical investments. Evaluates ROI, value proposition, competitive positioning, and market alignment. Use when deciding if/how to invest in a technical project, feature, or capability. Provides decision support with business justification.

Generate actionable recommendations from customer voice insights. This skill should be used when the user needs to translate analyzed feedback into product priorities, feature recommendations, or strategic guidance. Use when: "what should we build", "product recommendations", "prioritize features", "translate feedback to action", "feature priorities from feedback"

UX and design quality reviews throughout delivery. User flows, accessibility audits, visual consistency, and user research. Works standalone or integrated with wicked-crew. Use when: "UX review", "accessibility audit", "user flows", "design review", "WCAG compliance", "a11y", "user research", "personas", "user journey"

Evidence-gated acceptance testing with three-agent separation of concerns. Writer designs test plans, Executor collects artifacts, Reviewer evaluates independently. Eliminates false positives from self-grading. Use when: "run acceptance tests", "verify it works", "did it pass", "test this scenario", "acceptance criteria", "validate the feature"

Shift-left QE strategy for test planning and quality analysis. This skill should be used when the user needs test scenarios, risk assessment, test plans, or coverage analysis outside of a crew workflow context. Use when: "test strategy", "what should I test", "test scenarios", "shift-left testing", "generate test plan", "test coverage", "risk assessment", "how do I test this"

Canonical README template and validation rules for Wicked Garden marketplace plugins. Use when writing, reviewing, or validating plugin READMEs.

Smart runtime execution for Python and Node scripts with automatic package manager detection. Use when: python script, node script, run script, execute python, uv run, poetry run, npm run, pnpm run

Guide for writing E2E test scenarios in the wicked-scenarios format. Covers scenario structure, frontmatter fields, step format, and best practices. Use when: - Creating new test scenarios - Understanding the scenario format - Choosing the right CLI tool for a test category

This skill should be used by plugin authors who need to access wicked-search graph data for symbol dependencies, file references, definitions, or call chains. Triggered by queries about "graph data", "symbol dependencies", "cross-plugin search", "file references", "call chain", "blast radius from cache", or "cached graph". Enables other plugins to query the code graph without direct wicked-search coupling, using StorageManager for efficient data sharing.

This skill should be used when searching code, finding documentation, understanding code-doc relationships, or performing impact analysis. Triggered by queries like "search code", "find function", "find class", "where is defined", "search docs", "PDF content", "cross reference", "impact analysis", "blast radius", "what calls this", "find all references". Prefer this over raw Grep/Glob for symbol search, impact analysis, code-doc cross-references, and understanding codebase structure.

Intelligent context gathering from wicked-garden sources. Assembles relevant context from mem, jam, kanban, search, and crew before responding. Use when: "context briefing", "gather background", "what do we know about", "resume where we left off", "catch me up", "what happened before"

Use this skill when writing, rewriting, or humanizing content. Removes AI tells while preserving meaning. Aligns output to team voice: direct, practical, action-oriented. Use when: - Writing or rewriting prose, technical docs, PRDs, slides - Humanizing AI-generated content or de-AI-ing text - Creating work items (Jira/Linear/GitHub Issues) - Drafting PR descriptions, commit messages, ADRs - Writing code comments, docstrings, READMEs

12 hooks across 7 events