Development skills

Use this skill when concurrent work may write to the same file, branch, key, or state object. It helps identify shared mutable state, split independent outputs, and serialize writes only when a single shared target is truly required.

• Planning parallel work that may touch shared files
• Separating worker outputs before integration
• Choosing when a shared write needs a lock or sequential phase

Organize validation and error handling at system boundaries such as command inputs, configuration, networks, and external APIs. Keep internal business logic focused on typed data and pure functions, making it easier to test without framework wiring.

• Deciding where input validation belongs
• Separating business logic from framework code
• Reviewing how external data becomes typed state

Use this skill to check whether a measured speedup, regression, throughput, latency, or evaluation result reflects the work you intended to measure. Identify the limiting resource, rule out other explanations with evidence, and keep run counts and variation with the result.

• Checking a benchmark before reporting its speedup
• Investigating a surprising latency or throughput result
• Reviewing whether an evaluation gap holds across trials

Scaffold extensions for Super Agent Party as either a static HTML interface or a Node.js app with an Express backend. The guide covers package metadata, chat UI integration, optional MCP tools for AI agents, themes, localization, and responsive behavior.

• Scaffolding a static interface extension
• Creating an extension with a Node.js backend
• Adding tools an AI agent can call

Use this skill to structure Next.js App Router applications, fetch data in Server Components, and manage caching and revalidation. It also covers middleware, Server Actions, route organization, and patterns for handling loading and error states.

• Planning an App Router structure for a dashboard
• Fetching and caching data in Server Components
• Validating form input in Server Actions

Guides Django project organization, database query optimization, Django REST Framework serializers, signals, and middleware. It helps structure business logic, reduce unnecessary database queries, validate API input, and spot common design pitfalls in a Django application.

• Organizing Django apps and project settings
• Reducing unnecessary ORM database queries
• Validating Django REST Framework API input

Turn coding-session outcomes into reusable notes. Record corrections, successful approaches, and anti-patterns, then organize them by topic and track confidence and frequency so future work can apply established lessons appropriately.

• Recording a correction made during code review
• Keeping track of approaches that worked well
• Organizing recurring lessons by development topic

Learn practical Redis patterns for caching, rate limiting, messaging, event processing, and atomic operations. The examples show how to choose between Pub/Sub and durable Streams, manage cache lifetimes, and avoid common production pitfalls.

• Designing a cache with expiration and invalidation
• Adding sliding-window rate limiting
• Choosing messaging patterns for events

Use this skill to improve frontend loading and responsiveness. It offers patterns for React Server Components, streaming, code splitting, image and font handling, Core Web Vitals targets, and measuring real user performance.

• Reducing client-side JavaScript on a page
• Improving image loading and layout stability
• Reviewing Core Web Vitals and real user measurements

Use this skill to investigate PostgreSQL performance with query plans and statistics, then consider indexes, partitioning, JSONB operations, and connection pooling. It provides examples for diagnosing slow queries and matching database structures to query patterns.

• Investigating a slow PostgreSQL query
• Choosing indexes for common filters and joins
• Working with JSONB fields and arrays

Design GraphQL schemas, resolvers, cursor-based pagination, typed mutation errors, and subscriptions. Use DataLoader—a batching tool that reduces repeated database lookups—to handle related fields efficiently, with guidance on modular schemas and query limits.

• Designing a GraphQL schema for a new API
• Adding cursor-based pagination to list queries
• Reducing repeated database lookups for nested fields

Plan and implement real-time messaging with WebSocket, Socket.io, or Server-Sent Events (SSE), a one-way server-to-client stream. Covers connection authentication, reconnection, rooms, and scaling Socket.io across servers.

• Building a chat feature with rooms
• Choosing between WebSocket and SSE
• Adding reconnection after dropped connections

Apply common Rust systems programming patterns for ownership and borrowing, traits, async work, error handling, and configuration builders. The skill also highlights safer concurrency, reduced cloning, and documented invariants for any unsafe code.

• Choosing borrowing or ownership in Rust
• Designing reusable traits and error types
• Reviewing async concurrency and unsafe code

Use this skill to write and organize Python projects with modern type hints, dataclasses, async code, packaging, and pytest. It offers concrete conventions for structuring data, handling errors, managing dependencies, and testing behavior.

• Choosing between dataclasses and Pydantic for data models
• Writing async HTTP code with concurrency limits
• Setting up a typed Python project with pyproject.toml

Use these patterns to build mobile interfaces with React Native or Flutter. Examples cover navigation, reusable components, scrollable lists, layouts for different screen sizes, and platform-specific behavior, with guidance on common implementation pitfalls.

• Planning navigation between app screens
• Building performant scrollable product lists
• Adapting layouts for phones and tablets

Provides implementation patterns for MCP servers, including tools, resource endpoints, prompt templates, and transport setup. It covers input validation, user-friendly error responses, secret redaction, and client configuration so developers can build composable server capabilities for AI clients.

• Designing tools for an MCP server
• Exposing application data as MCP resources
• Creating reusable MCP prompt templates

Use this skill to plan or implement web authentication and access control. It covers JWT access and refresh tokens, OAuth2 with PKCE, sessions, and role-based permissions, with code examples and a checklist of common security practices.

• Adding JWT access and refresh tokens to a web app
• Setting up an OAuth2 login flow with PKCE
• Restricting routes by user role

Plan REST APIs with consistent resource URLs, HTTP methods, error responses, pagination, filtering, and versioning. It also covers writing an OpenAPI specification, a machine-readable API contract that can guide implementation and validation.

• Choose resource URLs and HTTP methods for an API
• Plan pagination and filtering for list endpoints
• Draft an OpenAPI specification before implementation

Use this skill to handle advanced Git tasks such as working on branches in separate worktrees, finding a bug-introducing commit with bisect, cleaning up history, and recovering lost work. It also explains hooks and safer collaboration practices.

• Working on two branches at the same time
• Finding which commit introduced a regression
• Cleaning up commits before merging

Use this skill to write and maintain Go code with common idioms. It provides examples for contextual error handling, small interfaces, cancellable goroutines, table-driven tests, useful zero values, structured logging, and Go module maintenance.

• Handling errors with useful context
• Designing small interfaces for services
• Managing worker pools and goroutine lifecycles

Use this skill when building React 19 interfaces. It provides implementation patterns for Server Components, Actions, Suspense, hooks, and compound components, along with guidance on state placement and performance choices.

• Choosing between Server and Client Components
• Building forms with Actions and pending states
• Structuring shared hooks or compound components

Use this skill to identify and address common web performance issues. It covers bundle analysis and code splitting, lazy loading and image handling, caching headers, virtual lists for large datasets, and monitoring Core Web Vitals such as LCP, INP, and CLS.

• Finding large JavaScript bundles and splitting code
• Loading images and routes only when needed
• Choosing cache headers for assets and API responses

Use this skill to investigate slow PostgreSQL or MySQL workloads. It explains how to read execution plans, choose indexes, detect repeated queries, and consider connection pools, replicas, and partitioning when tuning database performance.

• Investigating a slow SQL query with an execution plan
• Choosing indexes for filters, sorting, or text search
• Finding repeated database queries in an endpoint

Structure Spring Boot applications with thin REST controllers, service-layer business logic, and JPA repositories. The patterns also cover DTOs, transaction boundaries, validation, exception handling, and fetching related data without common query inefficiencies.

• Organize a Spring Boot application into layers
• Design REST endpoints with DTOs and validation
• Review JPA fetching and transaction patterns