The right knowledge,
at the right moment.

Perform a WCAG-flavored accessibility review of UI code or markup. Use when the user asks for an a11y review, accessibility audit, WCAG check, or wants to make a component/page usable for assistive tech.

Write an Architecture Decision Record - capture the context, options considered, decision, and consequences so future readers understand why, not just what. Use when the user makes a significant technical choice, asks to document a decision, asks "why did we choose X", or wants to set up ADRs in a project.

Design consistent HTTP/REST endpoints with sensible naming, status codes, pagination, error formats, and versioning. Use when the user asks to design, review, or extend an HTTP API, or wants feedback on endpoint shape.

Evaluate a system or component design against non-functional requirements - scalability, reliability, maintainability, security, cost. Use when the user asks for an architecture review, design critique, system review, or wants to evaluate a proposed design or ADR before commit.

Design a caching strategy - decide what to cache, where, with what TTL and invalidation, and how to avoid the classic foot-guns (stampede, stale data, key collisions). Use when the user asks about caching, cache invalidation, Redis/Memcached design, HTTP caching, or fixing cache-related bugs.

Maintain a CHANGELOG.md following the Keep a Changelog format with semver. Use when the user asks to update the changelog, add release notes, prepare a release, or generate changelog entries from commits or merged PRs.

Design or review a CI/CD pipeline - stage ordering, quality gates, caching, secrets handling, and deploy strategy. Use when the user asks to set up CI, fix a slow or flaky pipeline, review GitHub Actions/GitLab CI config, add quality gates, or design a deployment workflow.

Perform a structured code review with severity-tagged feedback. Use when the user asks for a code review, PR feedback, evaluating a diff before merge, or wants a second opinion on a change.

Establish, document, and enforce a code style guide for a codebase - naming, structure, formatting, lints. Use when the user asks to set up a style guide, define coding conventions, configure linters/formatters, or enforce consistency across a team.

Systematically explore and understand an unfamiliar codebase - entry points, architecture, data flow, conventions, and hotspots - before changing anything. Use when the user asks how a project works, asks to onboard onto a codebase, asks "where is X handled", or before implementing in a project you haven't mapped yet.

Write and maintain agent context files (AGENTS.md, CLAUDE.md, .cursorrules) that actually steer coding agents - commands, conventions, architecture, and boundaries, without bloat. Use when the user wants to set up or improve agent instructions for a project, asks why an agent keeps making the same mistake, or wants to make a codebase agent-friendly.

Generate Conventional Commits messages from staged changes. Use when the user asks to write a commit message, follow Conventional Commits, summarize staged changes, or prepare a commit.

Review cloud/infrastructure spend and propose specific cost reductions without sacrificing reliability - sized instances, storage tiers, idle resources, data egress, observability spend. Use when the user asks for cost review, FinOps audit, cloud bill investigation, or wants to reduce infra spend.

Audit code and systems for GDPR/CCPA-style data privacy compliance - data minimization, consent, subject rights, retention, transfers, and breach readiness. Use when the user asks for a privacy review, GDPR check, data protection audit, or handling personal data correctly.

Plan and write safe database schema migrations using the expand/contract pattern with zero-downtime in mind, lock awareness, and rollback plans. Use when the user asks to add a migration, change schema, alter a table, or migrate data.

Systematically debug a problem - reproduce, isolate, fix, verify, prevent regression. Use when the user reports a bug, an unexpected error, a failing test, or asks to investigate why something is broken.

Safely update project dependencies - assess risk, batch by risk level, verify with tests, and produce a clean changelog. Use when the user asks to update dependencies, bump packages, audit outdated deps, or handle a security advisory.

Retire an API, library, field, or pattern safely - parallel-run old and new, migrate consumers with warnings and deadlines, then remove the old path completely. Use when the user wants to deprecate an endpoint or feature, replace a library or framework, rename/remove a schema field, or asks how to migrate consumers without breaking them.

Design a coherent error-handling strategy across a codebase - what to throw vs return, where to catch, how to log, how errors surface to users and to operators. Use when the user asks about error handling, exception design, Result types, error boundaries, or wants to review how errors flow through the code.

Plan and execute a safe feature rollout using flags - design the flag, ramp gradually, monitor, and clean up. Use when the user asks about feature flags, gradual rollout, dark launches, kill switches, canary releases, or A/B test plumbing.

Build Filament admin panels that stay fast and maintainable - resource vs custom page decisions, table and form design, actions, authorization via policies, and query performance in tables. Use when creating or reviewing Filament resources, deciding how to structure an admin panel, adding actions or widgets, or when a Filament table is slow or an admin panel has grown chaotic.

Build TALL stack UIs with Flux UI the intended way - pick the right component, compose forms and tables, theme with CSS variables, and avoid fighting the library with custom CSS. Use when building or reviewing Blade views in a project using Flux, converting custom Tailwind markup to Flux components, or deciding between Flux and hand-rolled UI.

Work git like a professional - branching discipline, rebase vs merge, history hygiene, interactive rebase, bisect, and recovering from mistakes with reflog. Use when the user asks about branching strategy, fixing a messy history, undoing a git mistake, resolving conflicts, splitting commits, or any non-trivial git operation.

Audit code and UI for internationalization correctness - string extraction, pluralization, dates/numbers/currencies, RTL support, and locale-aware sorting. Use when the user asks for an i18n review, localization audit, or wants to make an app translation-ready.

Sharpen a vague idea into a buildable concept by interviewing the user - probe the problem, users, constraints, and success criteria before any spec or code. Use when the user pitches a rough idea, says "I want to build something like…", asks for help thinking through a concept, or when a request is too fuzzy to spec.

Work through a production incident calmly - triage severity, mitigate first, communicate clearly, then root-cause and document. Use when the user reports prod is down, an outage is in progress, a degraded service, or asks for help during/after an incident.

Implement a plan one small, verified, committed step at a time - never leave the codebase broken between steps. Use when implementing a planned feature, executing a task list, doing a large change that must stay reviewable, or when the user asks to build something step by step.

Build VILT apps with Inertia.js the intended way - controller-to-page data flow, form handling, partial reloads, shared data, and type sync between Laravel and Vue. Use when building or reviewing Inertia pages and controllers, deciding what data a page receives, handling forms and validation errors, or when an Inertia app over-fetches or drifts out of type sync.

Build AI features in Laravel with the laravel/ai SDK - agent and tool design, structured output, conversation storage, queued AI work, testing with fakes, and cost control. Use when adding AI functionality to a Laravel app, designing agents or tools with laravel/ai, reviewing AI integration code, or wiring LLM calls into jobs and Livewire components.

Find and fix Eloquent performance problems - N+1 queries, eager loading strategy, chunking, indexes, and query review for Laravel apps. Use when a Laravel page or job is slow, when reviewing Eloquent code for query efficiency, when the user mentions N+1 problems, or before shipping list views and reports that touch large tables.

Design Laravel queue jobs that survive production - idempotency, retries and backoff, failure handling, batching, chaining, and Horizon tuning. Use when the user creates or reviews queued jobs, debugs stuck or duplicated jobs, asks about retries or failed_jobs, or moves slow work out of the request cycle.

Test Laravel applications effectively with Pest or PHPUnit - feature vs unit boundaries, factories, database strategy, what to fake, and HTTP/Livewire assertions. Use when writing tests for Laravel code, reviewing a Laravel test suite, deciding how to test a controller, job, or command, or when tests are slow or brittle.

Design Livewire components with clear boundaries - state ownership, props vs events, performance (network round-trips, lazy, computed), forms, and Alpine handoff. Use when creating or reviewing Livewire components, deciding how to split a page into components, debugging re-render or state-sync issues, or when a Livewire page feels slow.

Design LLM-powered features that survive production - model choice, prompt structure, structured output, fallbacks, cost control, evals, and guardrails. Use when the user wants to add AI/LLM functionality to a product, asks about prompt design, RAG, agent features, handling model failures, or evaluating LLM output quality.

Decide what to instrument with logs, metrics, and traces so a system is debuggable in production. Use when the user asks about observability, monitoring, logging, metrics, tracing, alerts, or how to make a service debuggable.

Write or audit onboarding documentation so a new engineer can get productive without ambient knowledge - setup, architecture, conventions, who to ask. Use when the user asks to write onboarding docs, improve dev setup instructions, create a getting-started guide, or audit new-hire experience.

Define and enforce performance budgets for web apps - bundle size, Core Web Vitals, render time, API latency. Use when the user asks to set perf budgets, review performance, investigate slowness, or set up performance gates in CI.

Write a clear, scannable pull request description from a diff or branch. Use when the user asks to draft a PR description, summarize a branch, prepare a change for review, or fill out a PR template.

Use PrimeVue 4 effectively - theme with design tokens instead of CSS overrides, configure DataTables for server-side data, build validated forms, and keep bundle size in check. Use when building or reviewing Vue UIs with PrimeVue components, customizing the theme, wiring DataTable to a Laravel/API backend, or when PrimeVue styling is being fought with !important.

Refactor code safely with characterization tests first, small reversible steps, and verification after each step. Use when the user asks to refactor, restructure, clean up, simplify, extract, or rename existing code.

Run through a structured pre-release, release, and post-release checklist to ship safely. Use when the user asks to prepare a release, cut a version, deploy to production, or wants a checklist for shipping software.

Make calls to dependencies survive failure - timeouts, retries with backoff and jitter, idempotency, circuit breakers, bulkheads, and graceful degradation. Use when the user integrates an external service or API, asks about retries or timeouts, debugs cascading failures, or wants a resilience review of service-to-service calls.

Write a runbook for on-call so the next person can resolve an alert without paging the author - symptoms, diagnostics, mitigation, escalation. Use when the user asks to write a runbook, document an alert, create an incident playbook, or improve on-call ergonomics.

Perform an OWASP-flavored security review focused on input handling, authentication, authorization, secrets, and dependencies. Use when the user asks for a security audit, threat review, vulnerability check, or wants to harden code before release.

Write a focused spec before building - problem statement, scope, acceptance criteria, edge cases, and open questions. Use when the user describes a feature to build, asks for a spec or PRD, or starts a task that is too vague to implement directly.

Break a feature or spec into small, atomic, independently verifiable tasks with explicit ordering and dependencies. Use when the user asks to plan implementation, create a task list, estimate work, or when a spec is ready and needs to become an executable plan.

Inventory technical debt and prioritize it by interest paid, not by annoyance - quantify cost, classify, and produce a ranked paydown plan that survives contact with a roadmap. Use when the user asks what to refactor first, wants a tech debt audit, needs to justify cleanup work to stakeholders, or asks whether to fix or live with a known problem.

Decide what to test, structure tests with arrange/act/assert, and avoid common pitfalls. Use when the user asks to write, add, or improve tests for existing code, or wants test coverage for a new feature.

Model threats before building - map assets, trust boundaries, and attack surfaces, walk STRIDE categories, and rank risks with concrete mitigations. Use when the user designs a new feature or system that handles sensitive data or auth, asks "how could this be abused", or wants a threat model or security design review before implementation.

Navigate the elyra-skills registry - pick the right skill for the task, chain skills across the development lifecycle, and combine them without conflicts. Use when unsure which skill applies, when a task spans multiple skills, when the user asks what skills exist or how they fit together, or at the start of a large multi-phase task.

Design Vue 3 components with Composition API discipline - props/emits contracts, composables for shared logic, state placement (local vs Pinia), and render performance. Use when creating or reviewing Vue components, deciding where state lives, extracting reusable logic, debugging reactivity issues, or when a Vue app's components have grown tangled.