Use when setting up or configuring Storybook for a project. Covers main configuration, addons, builders, and framework-specific setup.

Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.

Core BDD concepts, philosophy, and the Three Amigos practice

Use when creating or modifying CocoaPods podspec files. Covers required attributes, file patterns, dependencies, and platform specifications for iOS, macOS, tvOS, watchOS, and visionOS projects.

Use when publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best practices for successful library distribution.

Cucumber best practices, patterns, and anti-patterns

Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.

Use when configuring Fnox secrets management with fnox.toml. Covers file structure, secrets definition, profiles, and hierarchical configurations.

Use when building iOS apps with UIKit, implementing MVVM/MVC/Coordinator patterns, or integrating UIKit with SwiftUI.

Use when working with Ruby gems, Bundler for dependency management, creating gemspecs, and publishing gems to RubyGems.

Use when formatting shell scripts with shfmt. Covers consistent formatting patterns, shell dialect support, common issues, and editor integration.

Use during implementation when designing modules, functions, and components requiring SOLID principles for maintainable, flexible architecture.

Use when biome configuration including biome.json setup, schema versions, VCS integration, and project organization.

Use when bundling JavaScript/TypeScript code with Bun's fast bundler. Covers building for different targets, tree-shaking, code splitting, and optimization strategies.

This skill should be used when the user asks about "bun:ffi", "foreign function interface", "calling C from Bun", "native libraries", "dlopen", "shared libraries", "calling native code", or integrating C/C++ libraries with Bun.

Use when implementing hot reloading with Bun (--hot, --watch), HMR, or automatic code reloading during development. Covers watch mode, hot mode, and HTTP server reload.

Evaluate JavaScript at bundle time and inline results. Use when optimizing compile-time code generation, embedding files, inlining environment variables, or executing code during the bundling process.

Use for bun:sqlite, SQLite operations, prepared statements, transactions, and queries.

This skill should be used when the user asks about "WebSocket in Bun", "real-time communication", "Bun.serve websocket", "ws server", "socket connections", "pub/sub", "broadcasting messages", "WebSocket upgrade", or building real-time applications with Bun.

Use when working with Crystal language development including WebSocket communication, TLS/SSL configuration, HTTP frameworks, ORM operations, and high-performance concurrent systems.

Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.

Explain code, concepts, or technical decisions in clear, understandable terms

Use when managing environment variables and project settings with Mise. Covers env configuration, direnv replacement, and per-directory settings.

Use automatically during development workflows when making claims about tests, builds, verification, or code quality requiring concrete evidence to ensure trust through transparency.

Use when working with Ruby blocks, procs, lambdas, and functional programming patterns including closures and higher-order functions.

Use when configuring shfmt for shell script formatting including .shfmt.toml setup, EditorConfig integration, and project-specific settings.

Use for Bun file I/O: Bun.file, Bun.write, streams, directories, glob patterns, metadata.

Use when building APIs with Hono framework on Bun, including routing, middleware, REST APIs, context handling, or web framework features.

Use when managing dependencies with Bun's package manager. Covers installing packages, workspaces, lockfiles, and migrating from npm/yarn/pnpm to Bun.

Use when working with Bun's runtime APIs including file I/O, HTTP servers, and native APIs. Covers modern JavaScript/TypeScript execution in Bun's fast runtime environment.

Bun shell scripting with Bun.$, Bun.spawn, subprocess management. Use for shell commands, template literals, or command execution.

Use when building or running SvelteKit apps on Bun, including SSR, adapters, and Bun-specific APIs

Use for Web Workers in Bun, worker_threads, parallel processing, and background tasks.

Use when configuring Credo static analysis for Elixir projects requiring customized code quality rules and settings.

Use when managing development tool versions with Mise. Covers installing tools, version pinning, and replacing language-specific version managers.

Use when working with Ruby's object-oriented programming features including classes, modules, inheritance, mixins, and method visibility.

Use when managing blueprints directory structure and avoiding duplication. Always search existing blueprints before creating to prevent duplicate documentation. Handles naming conventions and cross-references.

Use when integrating Drizzle ORM with Bun's SQLite driver for type-safe schema definitions and migrations.

Use when building HTTP servers with Bun.serve, handling requests/responses, implementing routing, creating REST APIs, or configuring fetch handlers.

Use when creating terminal layouts with Ink using Flexbox-based positioning and styling for CLI applications.

Use when responding to production incidents following SRE principles and best practices.

Use when building reliable and scalable distributed systems.

Use when defining version policies, banning dependencies, pinning versions, or creating partitioned version groups in syncpack. Covers advanced version management patterns.

Use when defining and working with Ecto schemas including field types, associations, and embedded schemas. Use when modeling database entities in Elixir.

Use when responding to questions or providing information requiring professional honesty and directness over excessive agreeableness.

Use when implementing error handling, cleanup routines, or debugging in shell scripts. Covers traps, exit codes, and robust error patterns.

Use when setting up or configuring syncpack for a monorepo. Covers configuration files, workspace detection, and custom rule definitions for dependency version management.

Run verification commands and confirm output before claiming success. Use when about to claim work is complete, fixed, or passing, before committing or creating PRs.

Modern TypeScript/JavaScript testing with Vitest. Fast unit and integration tests, native ESM support, Vite-powered HMR, and comprehensive mocking. Use for testing TS/JS projects.

Use when facilitating BDD collaboration between developers, testers, and business stakeholders. Use when running discovery workshops and example mapping sessions.

Use when modifying existing files, refactoring, improving code quality, or touching legacy code by applying the Boy Scout Rule to leave code better than you found it.

Core Cucumber concepts, Gherkin syntax, and feature file structure

Validate at every layer data passes through to make bugs impossible. Use when invalid data causes failures deep in execution, requiring validation at multiple system layers.

Use when creating or modifying Han plugins. Covers plugin structure, configuration, hooks, skills, and best practices.

Progressive Web Apps with service workers, web manifest, offline support, installation prompts. Use for installable web apps, offline functionality, push notifications, or encountering service worker registration, cache strategy, manifest configuration errors.

Systematically trace bugs backward through call stack to find original trigger. Use when errors occur deep in execution and you need to trace back to find the original trigger.

Use when configuring Sentry alerts, managing issues, or setting up notifications. Covers alert rules, issue triage, and integrations.

Use when setting up performance monitoring, distributed tracing, or profiling with Sentry. Covers transactions, spans, and performance insights.

Use when building comprehensive monitoring and observability systems.

Use when analyzing and fixing Dialyzer warnings and type discrepancies in Erlang/Elixir code.

Run custom queries on Sentry events and issues with advanced filtering

Use when configuring Dialyzer for Erlang/Elixir type checking and static analysis.

Manage git worktrees - list active worktrees, prune stale ones, and merge work back into the main branch.

Run tests, linting, and quality checks for WooCommerce development. Use when running tests, fixing code style, or following the development workflow in WooCommerce projects.

Use when understanding and fixing common Credo check issues for Elixir code quality and consistency.

Use when creating custom Credo checks for project-specific code quality rules and standards in Elixir.

Prefer explicit configuration over framework defaults to prevent environment-dependent failures

Reduce token waste by batching tool calls and avoiding narration between sequential operations

Use when working with SIP messages, methods, call flows, and protocol fundamentals for VoIP applications.

Minimize token consumption through efficient tool usage patterns

Update an existing SOP to reflect changes in tools, processes, or best practices

Deeply research all systems and create or update blueprints/ documentation for the entire codebase

Analyze performance metrics and identify slow transactions in Sentry

Check release health and compare error rates across deployments

Research a specific system and create or update its blueprints/ documentation

Create a new Standard Operating Procedure (SOP) file with proper structure

Investigate recent errors and exceptions in your Sentry projects

Create a new issue in a GitHub repository

Create a new merge request in a GitLab project

Create a new pull request in a GitHub repository

Search for code across GitHub repositories

Get detailed information about a specific Linear issue

Show all Linear issues assigned to you

Show all ClickUp tasks assigned to you

Search for ClickUp tasks

Get detailed information about a specific Jira ticket

Show all Jira tickets assigned to you

Load, validate, and populate templates consistently across frameworks

Launch multiple agents concurrently, collect their results, and handle timeouts for fan-out orchestration patterns

Generate or complete intake forms (project-intake, solution-profile, option-matrix) with interactive questioning and optional guidance. INTENDED FOR SUBSTANTIAL NEW WORK — new addons, new frameworks, new tracks, refactors crossing module boundaries — not every feature request. Apply the `sdlc-right-sizing` rule first to determine whether intake is appropriate; most day-to-day features need only an issue and possibly an ADR.

Orchestrate Construction→Transition phase transition with IOC validation, production deployment, and operational handover

Orchestrate Elaboration→Construction phase transition with iteration planning, team scaling, and full-scale development kickoff

Scan existing codebase and generate intake documents by analyzing code, dependencies, and infrastructure. Accepts optional guidance text to tailor analysis.

Orchestrate Discovery Track flow to prepare validated requirements and designs one iteration ahead of delivery

Orchestrate Inception→Elaboration phase transition with architecture baselining and risk retirement

Orchestrate Knowledge Transfer flow with assessment, documentation, shadowing, validation, and handover