Developers often maintain separate Node.js tools, scripts, and configuration for common workflows. This skill maps those workflows to Bun and explains Bun APIs for faster application development.

Lint issues can slow development and leave code quality problems unresolved. This skill runs the project lint workflow, applies small fixes, and checks the result again.

Complex code and documentation can be difficult to understand quickly. This skill turns inspected relationships, flows, and structures into focused Mermaid diagrams.

Teams often lose time choosing the right workflow for a software task. This skill maps task context to focused agent skills and a practical development sequence.

Framework guidance becomes outdated as APIs and recommended patterns change. This skill verifies versions, follows current official documentation, and cites sources for each decision.

Large changes are difficult to test, review, and recover when problems appear late. This skill breaks work into complete increments with explicit tests, verification, and rollback points.

Long sessions can turn assumptions into accepted facts and hide costly failure modes. This skill applies bounded, fresh-context adversarial review before non-trivial decisions stand.

Debugging failures by guesswork wastes time and can hide the real cause. This skill provides a repeatable process for reproducing, isolating, fixing, and verifying problems.

Teams often lack measurable quality standards, allowing checks and thresholds to drift during development. This skill defines a shared contract and connects each constraint to practical enforcement.

Coding agents lose accuracy when context is incomplete, stale, or excessive. This skill provides practical structures for focused sessions, durable rules, and reliable handoffs.

Complex code slows reviews, maintenance, and debugging. This skill guides focused refactoring that improves clarity while preserving behavior, errors, side effects, and tests.

Unclear contracts, inconsistent errors, and unsafe retries make APIs difficult to use and evolve. This skill provides practical patterns for typed interfaces, validation boundaries, compatibility, pagination, and idempotency.

Browser bugs can hide behind static code and incomplete unit tests. This skill uses Chrome DevTools MCP to inspect live behavior and verify fixes with runtime evidence.

Code reviews often miss risks when they focus only on tests or style. This skill guides a consistent review of correctness, readability, architecture, security, and performance.

Substantial feature work can become ambiguous when product intent, technical decisions, and implementation drift apart. This skill guides agents through practical product and technical specifications that stay aligned with shipped work.

Vague requests waste engineering time and cause rework. This skill turns them into structured execution plans with clear gates, mandatory steps, and acceptance checks.

Execution plans often pass review while still missing acceptance criteria, deltas, or verification steps, which causes rework during implementation. This skill routes each plan to the correct review lane and checklist, then returns graded blockers so a plan is only marked implementation-ready when it is truly executable.

Large coding plans often fail when an agent edits too much at once. This skill implements one approved plan step at a time, keeps edits scoped, and reports a clear status when the step is done.

ai-gates documentation can be difficult to apply when project files, plugin files, and hooks have separate roles. This skill explains the workflow boundaries so users can start work, upgrade safely, and avoid duplicate setup.

Manual test design and fragmented tools slow reliable releases. This skill plans, writes, runs, and reports automated, API, performance, and CI tests.