Skill UI

This catalog provides comprehensive infrastructure abstractions and hooks for the Webiny ecosystem. It includes standardized lifecycle hooks (Before/After Build/Deploy/Watch) and specialized services (Logger, UI, AWS interactions) for various modules (Admin, API, Core). Use these standardized interfaces to seamlessly integrate custom logic into your build and deployment pipelines, ensuring modularity and consistency.

Use this skill to prompt the agent to zoom out from a specific code section, providing a broader, higher-level perspective. It helps map out the overall system architecture, identifying relevant modules, calling relationships, and how the current code snippet fits into the larger picture. Ideal when you are unfamiliar with a specific area or need system-level understanding.

This skill guides the end-to-end development, implementation, and validation of production-ready Python modules for Azure IoT Edge. It covers critical aspects including telemetry processing, protocol adaptation (Modbus, OPC-UA), local inference, and ensuring robust, secure edge-to-cloud messaging under variable network conditions.

A comprehensive playbook for defeating anti-debugging mechanisms in protected binaries. Covers advanced techniques across both Linux (ptrace, /proc/self/status, timing checks) and Windows (PEB flags, NtQueryInformationProcess). Provides detailed detection methods and corresponding bypass strategies (e.g., patching, hooking, kernel modules) essential for advanced binary reverse engineering.

This deployment skill is designed to be integrated into the Playwright testing workflow. Its primary function is to validate the loading process of shared skills across the entire environment during the startup phase. It ensures that all necessary components and modules are correctly registered and available for reliable End-to-End (E2E) testing execution.

This guide outlines a systematic workflow to eliminate copy-paste duplication (code clones) detected by tools like jscpd. It teaches developers how to refactor repeated code into shared functions, modules, constants, or base classes. Use this process when your codebase exhibits significant redundancy to improve maintainability, reduce technical debt, and enhance overall code quality.

This meta-skill scans a target codebase path to extract modules, dependencies, and hotspots. It then intelligently classifies the most appropriate architectural diagram type (class, sequence, component, etc.) and renders the diagram simultaneously as both PlantUML source code and editable draw.io XML. Finally, it composes a structured Word document containing both deliverables for comprehensive documentation.

A utility for managing and installing specialized AI skills into the Codex environment. It supports fetching curated skills from predefined sources (like openai/skills) or installing custom capabilities directly from any GitHub repository, including private ones. It handles listing available skills, installing specific modules, and provides robust fallback methods (download/git sparse checkout).

A comprehensive guide and shared vocabulary for designing and structuring complex software modules. Use this when you need to refine an existing module's interface, identify opportunities for deepening its capabilities, determine optimal internal seams, or improve code testability and AI-navigability. It establishes clear principles for Module, Interface, Depth, and Seam.

A comprehensive tool for exploring Go/Golang packages and modules using the pkg.go.dev API via the `godig` client. It provides read-only access to essential information, including detailed API signatures, comprehensive documentation, version history, dependency graphs, known vulnerabilities (CVEs), and import usage. Ideal for researching external Go libraries, verifying API usage, or understanding module structure.

This critical protocol is the ultimate measure for dealing with deeply corrupted, unmaintainable, or structurally rotten code modules. Instead of risky patching, it mandates a controlled, multi-phase process to completely delete the target and rebuild it from scratch. It ensures precise identification of all public interfaces, implicit contracts, and working behaviors (the Preservation List) before any removal occurs, guaranteeing the new implementation matches the original functionality while resolving deep architectural debt.

This skill provides comprehensive pull request (PR) code reviews that go beyond simple syntax checks. It aggressively surfaces deep-rooted decay risks, architectural design smells, and maintainability issues. Findings are reported using a structured Symptom → Source → Consequence → Remedy framework, drawing insights from classic engineering principles. Ideal for reviewing complex or crucial code modules.