dx-toolkit

Full WCAG 2.2 AA accessibility audit procedure. Goes beyond the reference checklist with step-by-step testing methodology, tooling, and remediation guidance.

Design a RESTful API from requirements. Use when creating a new API, adding endpoints, or restructuring an existing API. Produces endpoint specifications, schemas, and implementation guidance.

Assess system architecture, identify risks and bottlenecks, document decisions with ADRs. Covers modular monolith, microservices, event-driven, and serverless patterns.

Shift Left quality gates, feature flag pipelines, and deployment automation. Use when setting up or modifying build and deploy pipelines, or when establishing quality gates for a project.

Perform a thorough code review with structured feedback. Use when reviewing pull requests, code submissions, or when you want a quality check on your code. Covers correctness, security, performance, readability, and maintainability.

Reduce complexity while preserving exact behavior. Use when code works but is harder to read or maintain than it should be. Applies Chesterton's Fence — understand the code before simplifying it.

Generates a codebase overview for onboarding. Use when you need to understand a new project's architecture, conventions, and key files. Produces a structured summary.

Feed agents the right information at the right time — rules files, context packing, MCP integrations. Use when starting a session, switching tasks, or when agent output quality drops due to missing context.

Design a database schema from requirements. Use when creating new tables, planning schema changes, or reviewing database design. Produces table definitions, indexes, constraints, and migration plans.

Five-step triage for failing tests, broken builds, and unexpected behavior: reproduce, localize, reduce, fix, guard. Use when tests fail, builds break, or behavior is unexpected.

Audit dependency health: outdated versions, unmaintained packages, known vulnerabilities, license issues, and bundle size impact.

Pre-deployment verification checklist. Use before deploying to staging or production. Covers code quality, security, performance, database migrations, feature flags, and rollback plans.

Architecture Decision Records, API docs, inline documentation standards — document the why, not just the what. Use when making architectural decisions, changing APIs, or shipping features that others need to understand.

Set up error monitoring and alerting with structured logging. Covers Sentry, Datadog, and custom solutions. Language-agnostic setup procedure.

Techniques for estimating development effort. Covers T-shirt sizing, story points, reference stories, and capacity planning. Helps teams estimate consistently.

Manage feature flag lifecycle: creation, rollout, monitoring, and cleanup. Covers percentage rollouts, user targeting, kill switches, and dead flag removal.

Trunk-based development with atomic commits, Conventional Commits, and semantic versioning. Use when making any code change — this skill applies to every commit, branch, and merge.

Rewrite AI-generated text to sound natural, specific, and human. Use when documentation, PR descriptions, commit messages, or issue comments read like they were written by a language model.

Structured divergent/convergent thinking to turn vague ideas into concrete proposals. Use when you have a rough concept that needs exploration, when starting a greenfield project, or when evaluating multiple approaches to a problem.

Incident management runbook: detection, communication, mitigation, resolution, and post-mortem. Covers severity levels, escalation, and blameless retrospectives.

Build in thin vertical slices — implement, test, verify, commit. Use when implementing any feature or change that touches more than one file, or when a task feels too big to land in one step.

Terraform and Pulumi patterns for managing cloud infrastructure. Covers module design, state management, environment promotion, and drift detection.

Converts a GitHub issue into a structured implementation plan. Use when starting work on a feature request, bug fix, or refactoring task. Produces a step-by-step plan with files to modify, tests to write, and acceptance criteria.

Set up structured logging, distributed tracing, and metrics dashboards. Covers the three pillars of observability for any tech stack.

App Store and Play Store submission process. Covers versioning, build configuration, metadata, screenshots, review guidelines, and OTA updates.

Testing strategy for mobile apps. Covers unit, integration, E2E with Detox/Maestro, screenshot testing, and device farm testing.

Configure a monorepo workspace from scratch or migrate an existing project. Covers tool selection (Turborepo, Nx, pnpm workspaces, Lerna), package structure, dependency boundaries, build caching, and CI change detection.

Measure-first approach to finding and fixing performance problems. Use when performance requirements exist, users report slowness, or you suspect regressions. Covers profiling, Core Web Vitals, bundle analysis, and database query optimization.

Decompose specs into small, verifiable tasks with acceptance criteria and dependency ordering. Use when you have a spec or feature description and need implementable units of work.

Generates a well-structured PR description from the current changes. Use after implementing changes and before creating a pull request. Analyzes the diff and creates a comprehensive description.

Catalog of safe refactoring patterns with before/after examples. Use when code works but structure needs improvement. Each pattern includes safety checklist and test requirements.

Perform a comprehensive security audit of a codebase. Use when conducting security reviews, before major releases, or after security incidents. Covers OWASP Top 10, dependency scanning, configuration review, and remediation guidance.

Pre-launch checklists, feature flag lifecycle, staged rollouts, rollback procedures, and monitoring setup. Use when preparing to deploy to production, especially for major releases or user-facing changes.

Write a specification covering objectives, structure, code style, testing, and boundaries before writing any code. Use when starting a new project, feature, or significant change. The spec becomes the source of truth for all implementation decisions.

Design a testing strategy from requirements. Covers test pyramid, framework selection, coverage targets, fixture management, and CI integration. Language-agnostic.

Manage context window size and optimize token usage. Use when sessions get slow, responses degrade, or costs are too high. Covers when to compact, what to preserve, and how to structure context efficiently.