Sets up Prometheus scrape jobs targeting the Supabase metrics endpoint and configures log drain pipelines. Establishes monitoring dashboards and alerting baselines. Use when configuring Supabase monitoring, setting up Prometheus metrics, implementing log drains, or establishing observability for production Supabase deployments.

Workflow for a ticket that touches real source code (anything that is not purely documentation). Use when a ticket changes code, or when you cannot tell whether it is docs or code (default to this). Covers tests-first gating, implementation, running the full suite, PR, Copilot review, and merge-on-clean-review.

Workflow for a documentation-only ticket — one that changes only the README, files under docs/, any .md file, or a plain text/typo fix, with no source-code changes. Covers the branch, commit, push, PR, human-review, and merge steps.

Demo skill two used to verify global vs project install behavior across agents

Register a new Docker Compose project on UGOS Pro (NASync) when the compose file lives in the nanoclaw repo. Plumbs the `/volume1/docker/PROJECT_NAME` directory symlink, the in-repo `.env` symlink, and the UGOS Pro SQLite registration row so the project appears in the Projects UI without UGOS rewriting the tracked compose file. Use when adding a new sidecar that needs UGOS Pro UI Start/Stop visibility, when wiring a repo-tracked compose project onto the NASync for the first time, when migrating an existing service to the symlinked-compose topology, or when asked to "register a UGOS project" / "add a sidecar to UGOS Pro".

List pending skills and rules on the NAS staging area. Shows what the agent has created or updated that hasn't been promoted to plugins yet. Use before running promote, or when the user asks what's on staging.

Sequential workflow for migrating an admin-plugin skill, rule, or script set into a per-chat overlay plugin. Audits cadence frontmatter, state-plane couplings, and cross-skill imports; moves files across two plugin repos; updates per-group additionalTiles config; ships each side through the publish pipeline; verifies live materialisation. Use when extracting an admin skill to an overlay, refactoring admin content into per-chat plugins, splitting capabilities out of nanoclaw-admin, or wiring additionalTiles for a freshly extracted overlay.

Demo skill one used to verify global vs project install behavior across agents

Reference material for writing Rego/OPA policies in a specific domain — Kubernetes admission control, Terraform/CloudFormation infrastructure-as-code validation, HTTP API authorization (request body validation, rate limiting), RBAC/ABAC access control models, metadata annotations, or Regal linter compliance by rule category. Load this when rules.md's general Rego style rules aren't enough and you need worked examples or domain-specific patterns for one of these areas.

Creates Drizzle ORM schema definitions and generated SQL migrations for PostgreSQL from the entity model. Use when the user asks to "create a migration", "generate SQL", "set up database tables", "update the schema", or mentions Drizzle, drizzle-kit, pg-core, schema.ts, or database versioning for a NestJS project.

Implements use cases across a NestJS backend with Drizzle ORM over PostgreSQL and a Next.js App Router frontend wired to that API. Use when the user asks to "implement a use case", "build the API", "create a REST endpoint", "write the data access layer", "build the page", or mentions NestJS modules, controllers, providers, Drizzle queries, repositories, or a Next.js frontend calling a NestJS backend.

Creates NestJS backend tests with Vitest — unit specs with stubbed repositories, and Supertest end-to-end specs that boot the application against a real PostgreSQL database in Testcontainers. Use when the user asks to "write backend tests", "test the API", "write an e2e test", "test the endpoint", or mentions Supertest, Testcontainers, NestJS testing, or Vitest for a NestJS project.

Scan a project for practice gaps — missing domains, weak implementations, and new technology areas. Use when starting a new project, joining an existing codebase, beginning a major feature (3+ new files), or when the PreToolUse gate hook blocks a write. Produces a structured gap report that drives skill-search and downstream skills.

Generate project-level quality standards in CLAUDE.md from installed proactive skills. The quality block is the single biggest lever for code quality (4x improvement in experiments). Use after skill-classifier runs, when the skill set changes, or when the user asks "update my quality standards", "what standards should I follow".

Compare your code against installed proactive skill checklists and fix gaps. Use after committing, after completing a feature, before submitting a PR, or whenever you want to verify your code meets quality standards. Can be triggered by a post-commit hook, a periodic check, or a direct request like "review your code", "check quality", "did you follow the skills".

Review the surface of a Kotlin API you're designing or exposing — a function, a class, a module, or a published library — against the concerns that govern good API design: simplicity, readability, consistency, predictability, debuggability, testability, and (for published surfaces) backward compatibility, multiplatform, and documentation. Use when the user is designing or reviewing an API — phrases like "review this API," "is this API idiomatic," "design this interface," "review my public API," "will this break binary compatibility," "API design check," or when changing a type that other modules or external consumers depend on. This is the design-and-review counterpart to the always-on idiom rules: those govern how to write a line of Kotlin, this governs how to shape and expose an API.

Convert JUnit-style test classes (`@Test` methods, `assertEquals`, `assertThrows`) to idiomatic Kotest specs (`DescribeSpec` / `BehaviorSpec`, `shouldBe`, `shouldThrow`). Maps assertions, rewrites imports, preserves test intent, then verifies the conversion by delegating to `scripts/verify-no-junit-assertions.sh`. Use when the user wants to migrate a JUnit test file to Kotest, when a test file mixes JUnit and Kotest assertions, or when a new contributor writes JUnit-style assertions in a Kotest project.

Replace java.util.Optional usage (Optional.of, Optional.empty, Optional.ofNullable, orElse, ifPresent, etc.) with idiomatic Kotlin nullable types using the question-mark suffix and the safe-call, elvis, and let operators. Strips Java's Optional workaround out of Kotlin code where the language has a better answer. Use when the user asks to "remove Optional," "kotlinify nullables," "strip Optional wrappers," or shows code that wraps nullable values in Optional for no benefit.

Open and warm up a JavaCV OpenCVFrameGrabber reliably on macOS, probe for real (non-black) frames before starting the main loop, and skip virtual cameras (Insta360 Link, Snap, OBS, Continuity Camera) that hijack low indices. Use when an OpenCVFrameGrabber call succeeds but returns black/stale frames, when switching between built-in and USB webcams, or when the first ~5 seconds of a pipeline produce zero face detections.

Run expensive per-frame inference (face recognition, emotion classification, ViT) at a fraction of the capture rate so the producer loop stays at 30 fps. Includes the 4× downscale pattern for Haar face detection, persisted-overlay technique for skipped frames, and Flow.sample() vs manual modulo approaches. Use when designing a vision pipeline that combines high-rate capture (30 fps+) with heavy per-frame work and you don't need every frame to be inferred.

Tail a Hubitat hub's live log or event websocket, filtered, and interpret it against the code to diagnose an app or driver. Use when the user wants to debug, watch logs, tail the log stream, see live events, or figure out why a Hubitat app/driver misbehaves.

Deploy a Hubitat app or driver's Groovy source to a hub and confirm it saved and runs by watching the log stream. Use when the user wants to deploy, push, upload, or install app/driver code onto a Hubitat hub, or iterate the edit-deploy-check loop.

Run a command on a Hubitat device over HTTP and confirm it landed — turn a switch or plug on/off, set a dimmer level, refresh a sensor, start an irrigation zone, or run a driver's custom command. Use when the user wants to command, control, operate, or exercise a device, test that a device responds, or run a device command and verify it took effect. Not for deleting a device (that is device-removal).

Registra en docs/bitacora-ia.md cada tarea hecha con un agente de código (Claude Code, Codex u otro), con lo que se le pidió, lo que hizo, lo que revisó o corrigió la persona, las propuestas descartadas y su motivo, y el tiempo que tomó. Úsala al terminar una tarea hecha por el agente, cuando la persona corrige o descarta una propuesta del agente, al cerrar un entregable, o para reconstruir la bitácora desde el historial de git antes de escribir el README.

Crea la rama de un entregable, abre el pull request y lo integra en la rama de integración (por ejemplo ProductionEnv) con merge commit y etiqueta, sin borrar la rama, para que cada entregable se vea claro en el historial de git. Úsala al empezar o terminar un entregable, al integrar una rama, al preparar la entrega final hacia main, o cuando pregunten cómo dejar el historial de git listo para una revisión.

Escribe o revisa el README.md de entrega de una prueba técnica hecha con agentes de código, con los 12 puntos obligatorios (funcionalidades, tecnologías y versiones, estructura, cumplimiento de requisitos, instalación, base de datos, procedimiento almacenado, tiempo, herramientas de IA, uso del agente, decisiones técnicas y consideraciones). Toma los datos del código, del historial de git, de la bitácora de IA y del glosario. Úsala al preparar la entrega, al cerrar un entregable o cuando pidan revisar si el README cumple.

Use when the user asks to log work, record what was done, or save task progress. Creates a structured markdown task log in `agent-logs/` with validation, waivers, and a final gates summary.

Use when the user asks you to implement a feature, fix a bug, or complete a repository task end-to-end (from scoping through code changes, validation, and final gate summary).

Use when `.tf` or `.tfvars` files have been edited, added, or removed and you need to verify that the code changes produce the intended Terraform plan before the task is considered complete. Runs `terraform plan` in `examples/test_app` and cross-checks the result against the change set you expected your edits to cause. This is a gate: do not declare a Terraform task done without passing it.

Format code using the projects formatter

Use when the user asks to write unit tests, generate a test suite, or migrate/convert Jest or Vitest tests to Themis in Node.js/TypeScript repos. Produces Themis-native tests, runs validation commands, and applies Themis migration workflows.

Create or update a CONSTITUTION.md that defines project governance — establishes coding standards, quality gates, TDD policy, review requirements, and non-negotiable development principles with versioned amendment tracking. Use when defining project rules, setting up coding standards, establishing quality gates, configuring TDD requirements, or creating non-negotiable development principles.

Create a feature specification from a natural language description — generates user stories with Given/When/Then scenarios, functional requirements (FR-XXX), success criteria, and a quality checklist. Use when starting a new feature, writing a PRD, defining user stories, capturing acceptance criteria, or documenting requirements for a product idea.

Generate a technical design document from a feature spec — selects frameworks, defines data models, produces API contracts, and creates a dependency-ordered implementation strategy. Use when planning how to build a feature, writing a technical design doc, choosing libraries, defining database schemas, or setting up Tessl tiles for runtime library knowledge.

Interview stakeholders to clarify ambiguous or underspecified requirements before writing code. Use when receiving a new task, feature request, or bug report that lacks clear acceptance criteria. Produces clarified requirements ready for spec authoring. Common triggers: "new feature", "build me", "implement", "add support for", or any task where requirements are vague or incomplete.

Verify that implementation and tests remain synchronized with specs after code changes. Use when code has been generated or modified from specs, after implementation is complete, or when reviewing a PR that touches spec-covered code. Reports mismatched targets, broken test links, and undocumented behavioral changes. Common triggers: "verify the spec", "check spec alignment", "are specs up to date", or after completing implementation work.

Create or update .spec.md files from clarified requirements. Use when requirements have been gathered and confirmed, and specs need to be written or updated before implementation begins. Produces well-structured spec files with frontmatter, requirements, and test links. Common triggers: "write the spec", "update the spec", "create a spec for", or after requirement-gathering completes.

One-coroutine-per-device debounce controller for rate-limited IoT APIs in Kotlin. Min-interval throttle, 2-tick stability filter, send-latest semantics. Min-interval is 0.2s for LAN devices, 1.2s for cloud APIs. Dispatches on Dispatchers.IO. Use when a real-time producer (camera loop, sensor feed, Flow<T>) drives a cloud or LAN IoT device that can't keep up with per-frame updates, or when you see flicker / HTTP 429 errors from hammering an actuator.

Render a segmented LED progress bar that fills bottom-up with red/yellow/green gradient — thermometer pattern, not falling-bar. Handles top-indexed hardware (where segment[0] is physically at the top) and bottom-indexed hardware. Use when wiring a quantised level (0..N) into an LED bar, especially Govee H6056, Hue Lightstrip, or similar segmented devices where fill direction and gradient matter.

Discretise continuous producer signals (Float, Double) into Int targets so the debounce controller's stability filter can actually commit. Without quantization, a noisy 0.42-vs-0.43-vs-0.42 signal blocks every commit and the actuator stays dark. Use when wiring a continuous producer (confidence score, sensor reading, audio level) into a debounce controller, or debugging "I call submit() but onApply() never fires".

Open and warm up a cv2.VideoCapture reliably, probe for real (non-black) frames before starting the main loop, and handle macOS index enumeration quirks. Use when a VideoCapture call succeeds but returns black/stale frames, when switching between built-in and USB webcams, or when the first ~5 seconds of a pipeline produce zero face detections.

Run expensive per-frame inference (face recognition, emotion classification, ViT embeddings) at a fraction of the capture rate so the camera loop stays responsive. Use when designing a vision pipeline that combines high-rate capture (30fps+) with heavy per-frame work (dlib, ViT, DeepFace) and you don't need every frame to be inferred.

Generates bUnit component unit and integration tests for Blazor components (.razor). Use when the user asks to "write bUnit tests", "test Blazor component", "create UI test for Blazor", or mentions bUnit, Blazor component testing, or xUnit rendering tests.

Generates C# backend unit and integration tests for EF Core DbContext repositories, domain services, and vertical slice handlers using xUnit / NUnit. Use when the user asks to "write unit tests for C#", "test ef core context", "write integration tests for dotnet", or mentions xUnit backend tests.

Generates Entity Framework Core (EF Core) database migrations for C# / .NET projects based on the entity model specification in docs/entity_model.md. Use when the user asks to "create database migration", "add ef migration", "update schema with ef core", "generate db migration for .net", or mentions EF Core, DbContext, or database migrations in C#.