Tests AWS SQS queue interactions - Standard (at-least-once delivery, near-unlimited throughput) vs FIFO (exactly-once processing, ordered) queue semantics; visibility-timeout interaction model; dead-letter queue (DLQ) for poison-message isolation; message retention period (default 4 days, configurable 60s - 1209600s); test patterns via LocalStack or `aws-sdk-client-mock` (TypeScript) / `moto` (Python). Use when the user works with AWS SQS producers/consumers and needs unit/integration tests for queue interactions.

Authors and runs Sidekiq job tests in Ruby - three Sidekiq::Testing modes (`fake!` jobs accumulate in arrays, `inline!` runs jobs immediately, `disable!` enqueues to Redis as normal); RSpec + Minitest helper patterns; clears jobs between tests via `Sidekiq::Worker.clear_all`; assertion patterns on `MyWorker.jobs.size` and `MyWorker.jobs.first[:args]`. Use when the user works with Sidekiq workers and needs unit / integration tests for job enqueueing, scheduling, retry behavior, or unique-job semantics.

Authors Karate `.feature` files using its Gherkin-flavored DSL for HTTP API tests, leverages the `match` keyword with fuzzy validators (#number / #string / #regex / contains / arrays), runs the suite via JUnit 5 plus Maven Surefire, and produces JUnit XML for CI gating. Use when the project is on the JVM and prefers a feature-file authoring flow over Java-DSL fluent chains; for those fluent chains use restassured-testing, for the same YAML-style flow on a Python/pytest stack use tavern-testing.

Configure and optimize Nx monorepo workspaces with deterministic project-graph structure, boundary enforcement, cache-aware pipelines, and affected-command CI workflows; use when designing workspace architecture, tightening dependency rules, or reducing CI cost through Nx task orchestration.

Integrate Bun runtime into Nx monorepos with deterministic plugin setup, executor configuration, migration from Node.js toolchains, and cache-aware build/test workflows; use when adding the nx-bun plugin, converting projects, or standardizing Bun targets across Nx workspaces.

Translates technical content into plain English for non-technical stakeholders by converting jargon into business language, surfacing decisions and impact early, and producing actionable recommendations with clear ownership and timeline. Use when the user asks to simplify technical content, write an executive summary, explain something in layman's terms, rewrite for non-technical audiences, or translate jargon for management or stakeholders. Applies to document types such as technical reports, architecture decision records, incident summaries, risk assessments, and status updates. Distinct from general writing or documentation skills by its focus on audience identification, decision-first structure, and jargon elimination for non-technical readers.

Configure TripIt→Reclaim travel sync, store selected credentials privately, check optional Google OOO settings and verify a dry-run. Use when asked to set up, connect, link or troubleshoot TripIt/Reclaim credentials or calendar sync.

Run the TripIt→Reclaim travel timezone sync and interpret its JSON output. Handles no-change silence, change summaries, overlap warnings, and errors. Use when the user asks to sync time zones, update Reclaim from TripIt, check travel schedule sync, or run the calendar timezone update.

Use when designing or implementing a programming language, compiler, interpreter, tokenizer, or DSL (domain-specific language). Generates lexer and parser implementations, defines AST node structures using discriminated unions, and builds tree-walk interpreter/evaluator patterns with scoped environments. Use when building a grammar, writing a tokenizer, constructing a syntax tree, or wiring together a full source-to-result pipeline for a custom language.

Use when building TypeScript CLIs. Guides command structure, interactive prompts, and tab completion using citty, `@clack/prompts`, and `@bomb.sh/tab` — and shipping them: CI gates, versioning (Changesets / release-please), and npm or single-binary release.

Generate Atlassian-ready rich text for Jira and Confluence from raw content or context. Use before creating or updating Jira descriptions, comments, environment fields, textarea custom fields, Confluence pages, blog posts, or comments when the endpoint needs ADF JSON, Jira wiki markup, Confluence storage XHTML, or Confluence wiki markup.

Use when authenticating to Atlassian (Jira, Confluence) — opens a local browser for sign-in/MFA and saves a reusable Playwright auth state (session, cookies).

Creates, configures, and debugs `@hapi/hapi` servers — implements routes, plugins, auth schemes, validation, caching, and request lifecycle hooks. Use when building HTTP APIs, setting up stale-while-revalidate caching, registering server methods, configuring views, managing startup sequences, or troubleshooting response marshalling.

Sense-making before action. Classify problem using Cynefin triangulation (3 tests + decomposition) to route to the right skill chain. Use when: frame, what approach, how should I start, which skill, where to begin, unsure what to do. NOT for known tasks — just do them.

Generate L1-L3 business capability maps aligned to customer/guest/patient journey stages for any industry. Use for capability maps, capability models, value chain mapping, capability heat maps, maturity assessments, or operating model design around capabilities. Trigger on "map our capabilities," "capability gap analysis," "business architecture," "where should we invest," "who owns what capability," or "product operating model." Supports PPTX, XLSX, and HTML output. Validates visual output against metis-brand-identity. Do NOT use for: BD capabilities decks or proposals (metis-premier-proposal); general presentations (metis-pptx).

Build email templates with react-email components (v1.0+) and render them server-side for Resend or any email provider. Use this skill whenever creating, editing, debugging, or reviewing React Email templates — even for simple tasks like 'add a button to the welcome email' or 'create a password reset email'. The skill contains critical email client compatibility rules (no flexbox, no rem units, pixelBasedPreset requirement, Outlook conditional comments) that prevent broken rendering in production. Triggers on: React Email components, email templates, react-email component imports, Tailwind in emails, email layout, email styling, Html/Head/Body/Container/Section/Row/Column/Text/Button/Img/Link/Hr/Preview components, render from react-email, PreviewProps, pixelBasedPreset, email client compatibility, Outlook rendering, Gmail rendering.

Ensure Tessl tiles meet all requirements for public registry publication with comprehensive validation. Use when publishing skills to public registry, validating tile.json configuration, creating evaluation scenarios, checking quality thresholds (A-grade ≥108/120), or preparing skills for release. Validates eval scenario coverage, tile.json fields (name, version, private, summary, skills), agent-agnostic compliance, and publication readiness.

Guide for setting up secured VS Code dev containers for coding agents. Use when creating or hardening a DevContainer to sandbox Claude Code or other coding agents, configuring Docker socket proxies, handling VS Code IPC escape vectors, setting up git worktree support, or verifying security controls. Covers threat model, three-layer defence architecture, Node.js/pnpm setup, and verification testing.

Comprehensive React Flow (@xyflow/react) patterns and best practices for building node-based UIs, workflow editors, and interactive diagrams. Use when working with React Flow for (1) building flow editors or node-based interfaces, (2) creating custom nodes and edges, (3) implementing drag-and-drop workflows, (4) optimizing performance for large graphs, (5) managing flow state and interactions, (6) implementing auto-layout or positioning, or (7) TypeScript integration with React Flow.

Implements the UI layer of a use case (UC-XXX) with Hilla: a @BrowserCallable endpoint that delegates to the service layer, and a React/TypeScript view under src/main/frontend/views/ with file-based routing, Vaadin React components, useForm validation from the generated models, and the messages the specification states. The endpoint is Hilla's API and belongs to this layer; it holds no business logic. Use when the user asks to "build the Hilla view for UC-001", "implement the UI layer with Hilla", "create a React view for Vaadin", "create a @BrowserCallable endpoint", or mentions Hilla, TSX views, file-based routing, or useForm in a project that combines layer plugins. Normally run by /use-case-implement after the service layer; it can be run directly. For server-side Java views use /vaadin-flow-ui.

Writes the UI layer tests of a use case (UC-XXX) for Hilla React views with Vitest in browser mode and React Testing Library, with the generated endpoint clients mocked by vi.spyOn — no server, no database. Covers what the actor sees: rendering, form input and useForm validation, the calls the view makes to the endpoint, and the messages the specification states for every outcome and alternative flow. Each suite is UC-XXX-<slug>.test.tsx with describe('UC-XXX: <name>'). Use when the user asks to "test the Hilla view of UC-001", "write Vitest tests for a Hilla view", "test a React view for Vaadin", "test the UI layer", or mentions Hilla testing, endpoint mocking, or TSX view tests in a project that combines layer plugins. Normally run by /use-case-test after the service tests; it can be run directly. Also writes a Java test of the endpoint's access annotation and EndpointException messages. The business rules are tested by the integration layer's test skill.

Writes the end-to-end tests of a Vaadin application (Flow or Hilla) with Playwright for Java and the Drama Finder library's type-safe, accessibility-first element wrappers, against the running application. Two kinds: a use case test (UC-XXX) — one class UC<id><Name>IT with @Nested groups per alternative flow — and a test case journey (TC-XXX) — one class TC<id><Name>IT, annotated @TestCase(id, useCases) with the use cases its Flow links, walking the whole Flow table across views in a single test with a // Step <n>: comment per row. Use when the user asks to "write Playwright tests", "write E2E tests for UC-001", "automate TC-001", "test the user journey in the browser", "write IT tests", or mentions end-to-end, browser tests, Playwright for Vaadin, or Drama Finder in a project that combines layer plugins. Normally run by /use-case-test as the last layer, and the only one /test-case-implement TC-XXX runs; it can be run directly.

Create OpenCode plugins using the opencode-ai/plugin SDK. Use when user wants to build a plugin, extend OpenCode, intercept tool execution, add custom tools, react to events, create a hook, block commands, add custom auth, or add automation to OpenCode. Also use for 'opencode plugin', 'custom tool', 'tool hook', 'plugin hook', 'logging for all tool calls', 'restrict what commands the AI can run', 'lifecycle hooks', 'middleware', 'tool.execute.before', 'tool.execute.after', 'auth hook', 'chat.params', 'intercept bash commands', 'block file writes', 'add audit logging', 'custom model provider auth', 'inject context before LLM call', 'fire-and-forget background task', 'watch session events'.

Build custom tools and plugins using the OpenCode SDK packages. Use when creating custom tools, implementing tool schemas, building plugins, managing OpenCode sessions, using opencode-ai/sdk or opencode-ai/plugin, creating a tool.ts file, writing an execute handler, using tool.schema, ToolContext, createOpencode, plugin hooks, custom auth, automating OpenCode from a script, building a CI tool, or integrating external APIs. Keywords: Zod schema, execute handler, event streaming, session management, abort signal, tool discovery, multiple tools per file, tool factory.

Configure OpenCode via opencode.json and AGENTS.md with deterministic provider setup, model selection, permission policies, formatter behavior, and environment variable handling; use when editing opencode configuration, setting model/provider defaults, tightening agent permissions, or troubleshooting OpenCode config behavior.