Skill UI

This setup implements a pre-execution hook to safeguard code repositories by intercepting and blocking destructive Git operations (e.g., `git push`, `git reset --hard`, `git clean`). It prevents accidental or unauthorized data loss during automated code generation or tool use within AI environments, ensuring robust version control safety.

This guide details how to extend the Webiny CLI by adding custom commands using the `CliCommandFactory` pattern. Developers can define command structures, handle typed parameters, and implement custom logic for various tasks, including data migration, code generation, deployment scripting, or system health checks. It covers command definition, parameter handling, and formatted terminal output using the `Ui` service.

This utility serves as a Command Line Interface (CLI) alias for specialized AI code models, specifically mapping to the Claude Code `/pua:yes` command structure. It facilitates structured code generation or interaction by adopting a specific 'yes skill' protocol. It ensures that while switching to an encouragement-first narration, the system maintains strict verification red lines and handles configuration file updates while preserving unknown fields. Ideal for developers needing consistent, protocol-driven AI code assistance.

This skill provides a generic entry point for delegating self-contained, complex tasks to various LLM-powered sub-agents (Codex, Claude Code, Pi). It is designed to be used in meta-skill DAG steps for tasks like feature creation, PR reviews, code refactoring, or document generation, providing full tool surface access. It favors non-interactive CLI modes for reliable background execution.

This skill operates on two layers: the THINK layer enforces rigorous coding discipline (simplicity, surgical changes, goal-driven execution), and the SPEAK layer compresses prose output (caveman/classical modes) for maximum token efficiency. Use it when brevity is explicitly requested or when disciplined, high-precision code generation is required.

This skill enforces a high standard for all generated code, prioritizing correctness, clarity, and idiomatic patterns across all languages. It helps minimize code bloat by removing unnecessary abstractions and verbose patterns, while also optimizing the agent's output by using targeted diffs and eliminating excessive conversational overhead. Use this for all code generation, refactoring, or review tasks.

This skill outlines a systematic, multi-phase workflow for diagnosing hard bugs and performance regressions in complex codebases. It emphasizes the critical necessity of building a tight, deterministic feedback loop (Phase 1) before moving to hypothesis generation. The process guides users through reproducing the failure, minimizing the scope of the issue, and forming actionable, ranked hypotheses.

A systematic, non-mutating investigation designed for complex software failures, including bugs, regressions, crashes, and flaky behavior. This skill launches four specialized, read-only sub-agents in parallel to perform deep root-cause analysis, trace code paths, pinpoint the smallest failing seam, and predict the quickest path to confirming or fixing the issue. It is designed purely for diagnosis and hypothesis generation.

This guide details best practices for implementing robust, type-safe GraphQL queries and mutations. It covers using separate .gql files, running code generation tools, and implementing mandatory error handling (onError) and loading states. Use this when building complex, reliable data fetching layers with Apollo Client.

This skill acts as a critical reality-check layer before code generation. It ensures that every function call, import, method, and variable the agent uses is provably available in the user's specific installed environment and version. It prevents runtime bugs caused by hallucinated or improperly assumed APIs, making the generated code robust and reliable.

WGM is a robust, agentic methodology designed to transform vague or rough requirements into working, validated software. It enforces a disciplined workflow across six stages: deep alignment (Grill), structured planning, deterministic iterative building (Loop), mandatory holdout-scenario judging, and final documentation audits. It ensures that the resulting code converges against rigorously tested acceptance criteria rather than relying on single-pass generation.

Generate and maintain technical documentation automatically using MCP workers and cron scheduling. This skill detects drift between code and docs, supports scoped generation for APIs or full projects, and stores patterns for consistency. Ideal for keeping documentation up-to-date without manual effort.