Skill UI

A powerful pre-action hook designed to enforce rigorous checks before AI agents modify code, create files, or execute destructive commands. Instead of relying on superficial self-evaluation, GateGuard forces the LLM to gather concrete facts (like dependencies, data schemas, and impacted modules), significantly improving code reliability and architectural depth. It provides multiple gates for edits, writes, and destructive bash commands.

This skill provides the core mechanism for integrating Hex into external data pipelines. It enables triggering, monitoring, and managing Hex projects (e.g., via Airflow or Dagster) programmatically. Users can implement parameterized runs, execute multi-step ETL workflows sequentially, and handle status polling and error management, making it ideal for production data orchestration.

Learn how to build complex, multi-step AI agents using Cohere's Chat API v2. This skill demonstrates defining external tools (like weather APIs or database searches) and implementing the full agent loop: model calls tool -> execute tool -> feed result back -> final answer. Ideal for creating autonomous, tool-using workflows that interact with external systems.

This guide details how to set up and execute large-scale, distributed GPU training jobs on the CoreWeave platform. It covers both single-node multi-GPU setups and multi-node training utilizing PyTorch DDP and Kubernetes resources (A100/H100). This workflow is ideal for fine-tuning large language models (LLMs) or running complex deep learning models that require high-performance, shared-storage compute clusters.

This skill provides expert guidance on building and maintaining applications using Amazon Aurora DSQL, a serverless, PostgreSQL-compatible distributed SQL database. It covers critical areas including schema management, multi-tenant architecture, IAM authentication, and safe data migrations (e.g., MySQL to DSQL). Users can execute direct queries, analyze performance bottlenecks using query plan explainability, and adhere to industry best practices for robust, scalable database design.

This guide provides techniques to optimize Grammarly API interactions, focusing on reducing latency and improving throughput. Learn how to implement efficient caching strategies (like LRU cache) for repeated score checks and how to execute multiple API calls in parallel using Promise.all. Use this when experiencing slow response times or needing cost/performance improvements in Grammarly integrations.

This tool allows users to execute complex, multi-agent workflows defined in YAML format directly within the AI environment. It functions as an orchestration engine, sequentially invoking various specialized roles (agents) without requiring manual API key configuration. Ideal for structured tasks requiring collaboration between multiple personas.

A comprehensive playbook for identifying and exploiting clickjacking vulnerabilities (UI redress). Learn how to test if target pages can be framed, bypass security headers like X-Frame-Options and CSP frame-ancestors, and execute high-impact actions through invisible iframes. This guide covers single-click, multi-step, and drag-and-drop attack vectors, applicable to sensitive endpoints like account deletion or admin panels.

HTTP Parameter Pollution (HPP) occurs when a single request contains multiple instances of the same parameter key. Different components in the request path (e.g., WAFs, proxies, application frameworks) may parse these duplicate keys using different rules (first value, last value, array join). This skill teaches how to exploit these discrepancies to bypass security checks, execute SSRF, or manipulate business logic.

A comprehensive meta-skill for generating auditable compliance reports, suitable for frameworks like GDPR or SOC2 self-assessments. This bundle executes a multi-step process: deep research with citations, generating a signable .docx report, archiving a read-only .pdf version, and saving the evidence chain to memory for future retrieval. It ensures a complete, traceable audit trail.

A comprehensive, adaptive framework for developing and implementing features, adhering to a strict, multi-phase workflow: Specify, Design, Tasks, and Execute. This skill ensures feature quality through granular task breakdown, atomic Git commits, requirement traceability, and mandatory, independent verification. It automatically adjusts its depth based on feature complexity (Small to Complex), providing a robust mechanism for managing technical debt and capturing project lessons.

This skill enforces a rigorous, multi-phase coding workflow (Discuss -> Map -> Decompose -> Execute -> Verify) to ensure code is structurally grounded, complete, and free from invented APIs or assumptions. It is designed for high-stakes, complex, or multi-file engineering tasks, acting as a senior, disciplined coding partner that plans meticulously before writing code.