dtgbao/fullstack-dev

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

Reviews completed changes across correctness, clarity, architecture, security, and performance. Use when a change is ready for pre-merge or pre-release review.

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

Curates task-specific agent context. Use at session start, when switching tasks, when output drifts from project conventions, or when creating project rules.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

TypeScript implementations of the 22 Gang of Four design patterns. Use when writing, reviewing, or refactoring object-oriented TypeScript code that needs creational, structural, or behavioral patterns, or when comparing closely related patterns and their tradeoffs.

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

Source-verified Python 3.11+ and FastAPI practices for production APIs. Use when writing, reviewing, debugging, or refactoring FastAPI code involving application structure, typing, dependency injection, errors, security, async execution, databases, API contracts, or deployment.

Builds production-quality, accessible, responsive user-facing UIs. Use when building or modifying interfaces and pages, creating components, implementing layouts, meeting WCAG accessibility requirements, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Structures Git and release history. Use when explicitly asked to branch, commit, resolve conflicts, coordinate parallel work, choose a version, tag a release, or write a changelog.

Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

Primary entrypoint for the Fullstack Development plugin. Use when Fullstack Development is explicitly invoked or the user's main goal is full-stack engineering work spanning definition, design, implementation, verification, operations, or delivery. Routes the request to the appropriate focused skills.

NestJS best practices and architecture patterns for building production-ready applications. This skill should be used when writing, reviewing, or refactoring NestJS code to ensure proper patterns for modules, dependency injection, security, and performance.

Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.

Optimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.

Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.

Source-verified Python testing practices for pytest, mocks, retries, controlled state, property tests, database integration, and FastAPI applications. Use when writing, reviewing, configuring, or stabilizing Python test suites.

React architecture reference. Use when implementing, refactoring, or reviewing React TypeScript code that touches component composition, focused custom hooks, feature/shared boundaries, scoped state/providers, effect-driven state synchronization, API/data hooks, React 19 refs/context.

Behavior-preserving refactoring workflow with a catalog of 23 code smells and 66 language-neutral techniques. Use when diagnosing maintainability problems, selecting a named refactoring, restructuring existing code without changing observable behavior, planning incremental technical-debt cleanup, or reviewing refactoring safety.

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

Verifies version-sensitive implementation against authoritative sources. Use when framework or library APIs may have changed, installed types or source are insufficient, or the user requests source-cited code.

Specifies non-trivial changes before coding. Use when a new project, feature, or significant change has understood requirements but no approved specification.

Postgres performance optimization and best practices from Supabase. Use this skill when writing, reviewing, or optimizing Postgres queries, schema designs, or database configurations.

Drives behavior changes test-first. Use when adding or changing logic, or fixing a bug where a failing test can prove the requirement or regression.

Vitest fast unit testing framework powered by Vite with Jest-compatible API. Use when writing tests, mocking, configuring coverage, or working with test filtering and fixtures.

Vitest testing reference for reliable unit, component, and integration tests. Use when configuring or upgrading Vitest, writing or reviewing tests for React, Vue, Svelte, or framework-neutral TypeScript and JavaScript, using Testing Library-style queries, mocking modules, timers, environments, or network requests, defining coverage or snapshot policy, or diagnosing flaky test isolation.