Review completed implementation against approved specs to ensure all requirements are satisfied. Use after finishing implementation work, before marking a task as done, or when a stakeholder asks to verify deliverables against requirements. Produces a review summary with pass/fail per requirement. Common triggers: "review my work", "check against spec", "did I miss anything", "is implementation complete".

Classify installed skills as proactive (apply to all code, review at every commit) or reactive (domain-specific, use only when working in that domain). Use after installing new skills via skill-search. The classification drives which skills quality-standards includes in CLAUDE.md and which skills self-review checks against.

Orchestrates practice gap discovery and quality improvement. Coordinates gap-analysis, skill-search, skill-classifier, quality-standards, and self-review skills. Use when starting a new project, joining an existing codebase, beginning a major feature, or when the user asks "what skills do I need", "find best practices", "audit this project".

Search the Tessl registry for skills that fill practice gaps identified by gap-analysis. Uses a two-pass strategy: first find language-agnostic best practice skills, then find technology-specific skills for the project's stack. Use after gap-analysis identifies gaps, when entering a new technology domain, or when the user asks "find skills for X", "what best practices exist for Y".

Set up self-verification before building features — test runner, type checking, linting, and feedback loops that let the agent confirm its own work. Use when starting a new project, setting up a codebase for the first time, or when the user asks "how will you test this", "set up testing", "make sure this works", or "verify your work". Run this BEFORE writing feature code.

Generate quality checklists that validate requirements completeness, clarity, and consistency — produces scored checklist items linked to specific spec sections (FR-XXX, SC-XXX). Use when reviewing a spec for gaps, doing a requirements review, verifying PRD quality, auditing user stories and acceptance criteria, or gating before implementation.

Generate Gherkin .feature files from requirements before implementation — produces executable BDD scenarios with traceability tags, computes assertion integrity hashes, and locks acceptance criteria for test-driven development. Use when writing tests first, doing TDD, creating test cases from a spec, locking acceptance criteria, or setting up red-green-refactor with hash-verified assertions.

Generate dependency-ordered task breakdown from plan and specification. Use when breaking features into implementable tasks, planning sprints, or creating work items with parallel markers.

Validate cross-artifact consistency — checks that every spec requirement traces to tasks, plan tech stack matches task file paths, and constitution principles are satisfied across all artifacts. Use when running a consistency check, verifying requirements traceability, detecting conflicts between design docs, or auditing alignment before implementation begins.

Execute the implementation plan by coding each task from tasks.md — writes source files, runs tests, verifies assertion integrity, and validates output against constitutional principles. Use when ready to build a feature from a tasks.md plan, start coding against an Intent Integrity Kit implementation plan, develop from the task list, resume a partially completed implementation, or run the implement phase of the iikit workflow.

Convert tasks from tasks.md into GitHub Issues with labels and dependencies. Use when exporting work items to GitHub, setting up project boards, or assigning tasks to team members.

Report a bug against an existing feature — creates a structured bugs.md record, generates fix tasks in tasks.md, and optionally imports from or creates GitHub issues. Use when fixing a bug, reporting a defect, importing a GitHub issue into the workflow, or triaging an error without running the full specification process.

Resolve ambiguities in any project artifact — auto-detects the most recent artifact (spec, plan, checklist, testify, tasks, or constitution), asks targeted questions with option tables, and writes answers back into the artifact's Clarifications section. Use when requirements are unclear, a plan has trade-off gaps, checklist thresholds feel wrong, test scenarios are imprecise, task dependencies seem off, or constitution principles are vague.

Initialize an IIKit (Intent Integrity Kit) project, uninit (remove IIKit scaffolding before `tessl uninstall`), check IIKit feature progress, select the active IIKit feature, and display the IIKit workflow command reference. Use when starting a new IIKit project, running IIKit init or setup, uninstalling/removing/uninit-ing IIKit before running `tessl uninstall`, checking IIKit status, switching between IIKit features, looking up IIKit available commands and phases, or asking for help with the IIKit workflow.

Creates tests for Hilla use cases on both sides of the browser boundary: Vitest + React Testing Library tests for the React/TypeScript view (with the generated endpoint clients mocked) and Spring Boot integration tests for the @BrowserCallable service behind it. Use when the user asks to "test a Hilla view", "write Hilla tests", "test a React view for Vaadin", "test a @BrowserCallable service", "write Vitest tests for a Hilla app", or mentions Hilla testing, React Testing Library for Vaadin, endpoint mocking, or testing TSX views.

Implements use cases by creating Hilla views — React/TypeScript views with file-based routing calling @BrowserCallable Java services — and jOOQ queries for the data access layer. Use when the user asks to "implement with Hilla", "create a Hilla view", "build a React view for Vaadin", "create a @BrowserCallable endpoint", or mentions Hilla, client-side Vaadin views, file-based routing, TSX views, or React + jOOQ.

Implements use cases by creating Vaadin Flow views, forms, and grids — server-side Java UI — and jOOQ queries for the data access layer. Use when the user asks to "implement a use case", "build the UI", "create a Vaadin view", "write the data access layer", or mentions Vaadin Flow, server-side Java views, jOOQ queries, Java web app, or database-backed UI. For Hilla (React/TypeScript) views use the implement-hilla skill instead.

Creates Karibu server-side unit tests for Vaadin views covering navigation, component interactions, form validation, grid operations, and notifications. Use when the user asks to "write Karibu tests", "unit test a Vaadin view", "test the UI server-side", "create view tests", or mentions Karibu testing, Vaadin unit tests, or server-side UI testing.

Creates Playwright browser-based tests for Vaadin views using the Drama Finder library for type-safe element wrappers with accessibility-first APIs. Covers two test types: integration tests for a single use case (UC-*) and end-to-end journey tests for a test case (TC-*) spanning multiple use cases. Use when the user asks to "write Playwright tests", "create e2e tests", "write integration tests", "test in the browser", "write IT tests", "automate a test case", "test a user journey", or mentions end-to-end testing, browser tests, UI integration tests, Playwright for Vaadin, or Drama Finder. Also trigger when the user references a use case (UC-*) or a test case (TC-*) and asks for Playwright or E2E tests.

Creates Spring Boot tests for REST controllers and Spring Data JPA repositories. Defaults to MockMvcTester and RestTestClient + Testcontainers for new projects (asking the user to confirm on the very first backend test), but detects and follows whichever convention a project already uses — including legacy MockMvc or RestAssured + Testcontainers — rather than migrating it. Use when the user asks to "write backend tests", "test the REST API", "test the controller", "write a Spring Boot test", "test the JPA repository", or mentions MockMvc, MockMvcTester, RestAssured, RestTestClient, Testcontainers, @SpringBootTest, or server-side Java testing for this stack.

Creates Vitest component tests for Angular views using Angular's own testing idioms — TestBed, ComponentFixture, and HttpTestingController — not React Testing Library patterns. Use when the user asks to "write frontend tests", "test the Angular component", "write a Vitest test", "unit test an Angular page", or mentions TestBed, HttpTestingController, or component testing for this stack.

Implements use cases for C# and Blazor (.NET 10) applications using a Vertical Slice Architecture. Takes a UC-XXX.md specification and generates feature-folder components, C# Commands/Queries, EF Core entities/configurations, and Blazor pages/components. Use when the user asks to "implement a use case in C#", "build a Blazor page", "create a Vertical Slice", or mentions Blazor, .NET 10, or C# implementation.

Generates native C# Playwright end-to-end (E2E) browser tests for user journeys (UC-* / TC-*) using Microsoft.Playwright.Xunit. Use when the user asks to "write e2e test", "create playwright test for dotnet", "write browser test in C#", or mentions Playwright with .NET.

Generates a structured, human-readable reviewer packet summarising what changed in a pull request, why it matters, what was verified, and where human attention is most needed. Use when the user asks for a PR review summary, a code review packet, a human-readable change report, or wants to hand off review findings to a human reviewer. Produces a scannable document: quick approvals (low-risk PRs) can be assessed in under 30 seconds; detailed reviews (high-risk PRs) in under 2 minutes. Outputs a formatted markdown packet with risk rating, verification status, ranked findings, unresolved questions, and a recommended review focus — making human review faster without replacing human judgment.

Build a compact, trustworthy evidence pack before deeper PR review starts. Use this skill when a pull request needs review — it is always the first step. Triggered by requests to review code, check a PR, review my changes, review a merge request, or any similar code review or pull request review request. Collects PR context, runs deterministic verifiers, classifies risk, maps hotspots, and checks for missing artifacts. Produces the evidence pack that all downstream review skills consume.

Evaluates which code review comments (review tiles) actually produced changes after a pull request is merged or closed, by passively collecting outcome data from the GitHub API and git history — zero developer friction. Use when analyzing post-merge pull request outcomes, assessing code review effectiveness, measuring review feedback impact, or answering questions like "how did PR #6 go?", "which review comments were accepted?", or "did any escaped defects appear after this pull request merged?" Produces a structured per-finding outcome record (accepted / rejected / ignored / superseded), merge time delta, escaped defect count, and AI authorship correlation for each PR.

Creates Playwright browser-based end-to-end tests for a Next.js frontend running against a live NestJS API, using accessibility-first locators. Use when the user asks to "write Playwright tests", "create e2e tests", "test in the browser", or mentions end-to-end testing, browser tests, or a test case (TC-*) to automate.

Creates Vitest component tests for Next.js App Router pages and React components using React Testing Library and accessible queries. Use when the user asks to "write frontend tests", "test the page", "test the component", "write an RTL test", or mentions React Testing Library, jsdom, or component testing for a Next.js project.

Archive a completed change in the experimental workflow. Use when the user wants to finalize and archive a change after implementation is complete.

Enter explore mode - a thinking partner for exploring ideas, investigating problems, and clarifying requirements. Use when the user wants to think through something before or during a change.

Propose a new change with all artifacts generated in one step. Use when the user wants to quickly describe what they want to build and get a complete proposal with design, specs, and tasks ready for implementation.

Sync delta specs from a change to main specs. Use when the user wants to update main specs with changes from a delta spec, without archiving the change.

Reviews the entire PLAN.md of a new project through fixed, file-only provider rounds. Triggered by plan-mode when every plan entry is draft; Round 1 alternates Codex and Claude, then returns control to a human checkpoint.

Builds and maintains openspec/PLAN.md, the human-approved plan that sequences OpenSpec changes toward a stated goal — the tier above tasks.md. Explore read-only, draft entries, then stop and ask for approval; a change cannot start until its entry is approved. Trigger — make a plan, what should we build first, plan the work, roadmap, add this to the plan, approve the plan, why is the plan gate failing, NO-ENTRY, HASH-MISMATCH.

Refines an incoming prompt through a bounded score → interview → lock → rewrite loop until it is mechanically good enough (rubric score ≥ 9/10) to feed the SDD workflow. Trigger — automatically before openspec-propose when the request is non-trivial development work; explicitly on: refine this prompt, prompt loop, score my prompt, is this prompt ready.

Structured interview process that turns a vague stakeholder request into clear, actionable requirements before any spec or code is written. Trigger — new feature request, unclear requirements, vague task, clarify scope, before proposing a change.

Single entry point to the spec-as-source workflow: given a request, decides which of the plugin's skills to activate — excluding trivial work first, deriving the current phase from the state of the repo second, and matching descriptions last — then runs the chosen skill inline or in a subagent. Use when you do not know which skill applies, or want the workflow driven for you. Trigger — which skill should I use, what do I do next, route this, start working on X, implement X, propose a change, continue the implementation, I want to build X, help me with this project, non so da dove partire.

Installs the spec-as-source OpenSpec schema, enforcement scripts, CI workflow, and pre-commit hooks into a project. Trigger — setup spec enforcement, add spec checks, configure spec-as-source, install spec scripts, add spec CI, install openspec schema.

Syncs .github/workflows/spec-verification.yml with the test runner and test files declared in specs. Trigger — update CI workflow, sync spec CI, regenerate workflow, CI out of sync with specs, add spec test to CI.

Runs an autonomous Ralph-style loop over the tasks of an active OpenSpec change: one task per fresh-context agent invocation, mechanically gated by scripts/verify.sh, with runaway guardrails. Trigger — run the loop, ralph loop, autonomous apply, loop the tasks, implement the change unattended.

Deletes all files declared as targets in openspec/specs/**/spec.md and rebuilds them from the specs to verify spec-as-source integrity. Trigger — clean rebuild, verify source of truth, spec drift check, regenerate from specifications, rebuild from spec.

Runs all spec consistency checks (link integrity, target ownership, manifest build), the test suite, and a semantic drift spot-check, then reports results. Trigger — verify specs, spec check, run spec suite, check spec consistency, validate spec links, spec integrity, spec drift.

Creates and maintains capability spec.md files under openspec/specs/: requirements, scenarios, targets frontmatter, and Verified by test links. Trigger — write a spec, update a spec, document requirements, create capability spec, spec drift in frontmatter or links.

Reviews completed implementation requirement-by-requirement against its capability spec, with file:line evidence, before declaring work done. Trigger — review my work, is this done, verify completeness, check against spec before merging, final review.

Bootstrap a new TamboUI Toolkit DSL application — generates a `ToolkitApp` subclass with a working `render()` and a `main` entry point, plus the right Maven/Gradle/JBang dependencies. Use when the user says "create a TamboUI app", "scaffold a TUI", "new tamboui app", "hello world TamboUI", or asks to start a TUI project from scratch.

Add a Toolkit `Element` wrapping an existing TamboUI widget so it gains CSS support, styled sub-components, focus integration, and a Toolkit factory method. Use when the user says "wrap a widget", "add an element for X widget", "make widget Y CSS-aware", "expose widget Z in the DSL", or asks to integrate a custom widget into the Toolkit.

Move every app reference from an old Hubitat device onto a new one — via Settings → Swap Device where possible, a virtual-device bridge or parking slot where the swap list blocks it, and a guided manual re-select where neither works. Use when the user wants to swap, migrate, replace, or move a device's references to a different device, re-home a device to a different hub over Hub Mesh, or asks why a device does not appear in the Swap Device list.

Safely remove a Hubitat device — enumerate where it's used, warn about the blast radius before deleting, verify references cleared after, and re-wire them onto a replacement device. Use when the user wants to remove, delete, retire, or replace a device, or asks what a device is used by before deleting it.

Fire an ordered list of Hubitat devices with a timed hold on each, so you can walk the property and bind each observation to a device id — which lamp is `Kitchen 3`, which shade is `Office Left`, which valve is irrigation zone 7. Use when the user wants to map which physical thing a device controls, identify which zone/lamp/shade/valve is which, run a set of devices one at a time in sequence, or fire devices on a timer for field verification.

Update Z-Wave device firmware on a Hubitat hub via the native zwaveJS updater — discover installed versions, find vendor-latest firmware, stage it, and batch-flash safely with a radio-hang watchdog. Use when the user wants to update/flash device firmware, check which devices are behind on firmware, or fix a device whose issue a firmware update addresses.

Manage the hubs.json config that records how to reach each Hubitat hub by IP for code operations. Actions — init a config, add a hub, set the default hub, remove a hub, list hubs. Use when the user wants to configure, register, add, or list Hubitat hubs for deploy/pull/debug.

Run the Hubitat sandbox linter on app or driver Groovy and judge each finding — real defect vs. false positive — before the code goes near a hub. Use when the user wants to lint, check, or validate Hubitat code, or automatically before deploying.

Use the hub's first-party AI (MCP) Connector Integration to read hub state and drive devices over its local MCP endpoint — connect with the bearer token, discover the live tool surface, prefer read-only tools, gate sensitive actions, and verify the mutation. Use when the user wants to control or query a Hubitat hub through its MCP server / AI connector, or asks whether an operation should go through MCP or the hub_* scripts.

Diagnose Hubitat Z-Wave and Zigbee network problems — ghost/failed nodes, packet errors, weak routes, dead or unjoined Zigbee devices, devices that stopped responding to commands, a broken hub-mesh link, an unhealthy mesh. Use when the user wants to check mesh health, find ghost nodes, debug a flaky/slow/dead Z-Wave or Zigbee device, or figure out why the radio network misbehaves.

Generate a correct Hubitat app or driver skeleton from declared capabilities, with the required lifecycle callbacks, subscription/schedule idioms, and logging conventions wired in. Use when starting a new Hubitat app or driver, or when the user asks to create/scaffold/bootstrap Hubitat Groovy code.

Onboard one or more Hubitat sensors with verification at each step — pair, confirm the built-in driver auto-selected, name by function and position, raise event retention, read the real adjustable preferences, share to the mesh and confirm the mirror, add to inactivity monitoring, acceptance-test, and reconcile the inventory. Use when the user wants to onboard, install, add, or set up sensors (soil probes, contact/motion/temperature/energy sensors) on a hub, or roll out a sensor fleet.

Set up and run offline unit tests for a Hubitat app or driver — load the script under biocomp/hubitat_ci, mock the platform executor, and assert on sendEvent/log/parse output off-hub. Use when the user wants to test, unit-test, mock, or add CI for Hubitat Groovy code.

Runs all spec consistency checks (link integrity, target ownership, manifest build) and the test suite, then reports results. Trigger — verify specs, spec check, run spec suite, check spec consistency, validate spec links, spec integrity.