Latest Agent Skills

Plan backend domains, services, jobs, integrations, and failure handling for a product or major feature. Use when UX and product scope are defined and the team needs a production-minded backend design without defaulting to premature microservices.

Use this skill when designing UI components, choosing color palettes, implementing responsive layouts, or reviewing code for UX issues. For landing pages, dashboards, e-commerce, SaaS, and mobile apps. Provides 50+ design styles, 97 color palettes, 57 font pairings, and stack-specific guidelines for React, Vue, Next.js, Flutter, SwiftUI, and more.

Use this when designing or scaffolding serverless functions for APIs, webhooks, background handlers, or small trusted services across cloud runtimes. Trigger on requests about serverless handlers, event functions, or function-level architecture.

Use this when a project needs a better local development workflow for setup, running services, seeding data, testing integrations, or managing multi-service developer environments.

Use when designing a new system, choosing between architectural patterns, planning how components will connect, evaluating scalability and reliability trade-offs, or reviewing an existing system for structural problems. For system design, service boundaries, database design, API structure, monolith vs microservices decisions, and architecture decision records (ADRs). Activate when user says "how should I structure this", "design the system", "is this architecture right", or "plan the backend".

Use this when reviewing or designing how secrets, API keys, service credentials, signing keys, tokens, and environment-specific credentials are stored, loaded, rotated, and kept out of untrusted runtimes.

Use this when the system needs explicit runtime validation for API inputs, config, queue messages, webhook payloads, file metadata, or external provider responses in TypeScript, JavaScript, Python, or mixed systems.

Use this when the team needs a component breakdown for a screen or feature that may or may not be React-specific. Trigger on requests to plan component responsibilities, composition, states, and boundaries before implementation.

Use this when planning environment variables, config files, secrets, flags, and provider settings across local, CI, staging, production, serverless, or multi-runtime systems.

Use this when designing scripts or small tools for automation, maintenance, CI tasks, file manipulation, config generation, or local workflow support across shell, Python, or mixed environments.

Use when the app is slow, pages take too long to load, API responses exceed 200ms, memory usage is high, or renders are excessive. For profiling, identifying bottlenecks, optimizing React renders, reducing bundle size, improving database query speed, and measuring before/after improvements. Activate when user says "it's slow", "optimize this", "reduce load time", or "too many re-renders".

GSD Execute — Get Shit Done

Use when the team needs a testing plan covering unit, integration, end-to-end, contract, and security-adjacent checks for a product or feature. Trigger on requests to design practical testing strategy before or during implementation.

Use when the team needs to decide how frontend state should be organized across React or Next.js apps. Trigger on requests about local state, global state, server cache, forms, optimistic updates, or choosing between context, stores, and query-based patterns.

Use this when the team needs to decide how responsibilities should be split across services, modules, workers, APIs, or runtimes. Trigger on requests about service boundaries, ownership, modularity, monolith versus separation, or where logic should live.

Use when a web product or component needs responsive layout planning across mobile, tablet, and desktop. Trigger on requests about breakpoints, layout adaptation, content priority, or mobile-first UI behavior.

Use when Codex needs to generate or scaffold a React or Next.js component with clear props, state handling, Tailwind styling direction, accessibility, and file structure. Trigger on requests to create a component, page section, dashboard widget, form, modal, or reusable UI block.

Use this when reviewing database, storage, config, queue, or integration migrations for rollout safety, rollback feasibility, data correctness, and environment-specific deployment risk.

Use when a Firebase app needs Firestore collection design, document shape, subcollection strategy, security rule implications, or query-aware data modeling. Trigger on requests to design Firestore data structures before implementation.

Use when building or planning Firebase Cloud Functions for webhooks, backend APIs, scheduled jobs, claim assignment, or privileged Firestore logic. Trigger on requests to create or review Firebase Functions.

Use this when reviewing how a codebase organizes configuration files, env vars, runtime options, feature flags, and per-environment settings. Trigger on requests to clean up or validate config structure.

Use when designing PostgreSQL tables, enums, relationships, migrations, storage metadata, or tenant-aware schema structures for a Supabase-backed app. Trigger on requests about Supabase schema planning or SQL-first data design.

Use this when the system needs queue-backed processing design, message handling rules, delivery semantics, dead-letter strategy, or throughput planning. Trigger on requests about queues, brokers, message processing, and consumer coordination.

Use this when the project needs Python-specific backend architecture for APIs, services, workers, scripts, or internal tools. Trigger on requests about Python runtime structure, framework fit, module boundaries, or service organization.

Use this when the user gives a broad app, system, service, tool, or feature request and it must be converted into structured implementation requirements, runtime assumptions, security concerns, likely components, and handoff tasks for developer or designer skills.

Design an application database schema from product flows and backend responsibilities. Use when the team needs core entities, relationships, lifecycle fields, indexes, audit needs, tenancy boundaries, and migration-minded schema planning for an MVP or production system.

Use this when the system needs scheduled tasks, cron-style jobs, periodic maintenance, sync loops, cleanup tasks, or non-interactive background automation that is not simply an API request or queue worker.

Use this when the team needs to design or refine a backend service, API-facing domain module, internal service, or runtime-specific server component in Python, Node.js, or another backend environment.

Use this when the system needs clear analysis of trusted versus untrusted execution contexts, external inputs, client/server boundaries, provider callbacks, or admin-level code paths. Trigger on requests about trust boundaries, attack surfaces, or where verification must happen.

Use this when building or planning a Python command-line tool, command surface, argument model, package entrypoint, or automation-oriented CLI workflow.

Use when the team needs a strategy for validation errors, API failures, job retries, user-facing error UX, observability, or recovery behavior. Trigger on requests to design error handling across frontend, backend, and integrations.

Use before any complex or ambiguous task where the path forward is unclear. For breaking down multi-step problems, choosing between approaches, clarifying vague requirements, identifying hidden assumptions, planning before building, and preventing costly mistakes from starting in the wrong direction. Activate when user says "how should I approach this", "what's the best way to", "I'm not sure how to", or presents a problem without a clear solution.

Use this skill when implementing any feature that touches user data, auth, APIs, file uploads, pe...

Use when the team needs sign-in methods, profiles, sessions, invitations, memberships, or auth-related architecture for a Supabase app. Trigger on requests to design authentication and authorization using Supabase Auth.

Use this when a Python worker, consumer, scheduled processor, or background execution service needs design or review. Trigger on requests about Python async jobs, consumers, schedulers, or long-running background processes.

Use when the team needs authentication, identity providers, custom claims, session strategy, or permission design for a Firebase-backed app. Trigger on requests to design or review Firebase Auth architecture.

Use this when a codebase or design effort needs consistency enforcement for tokens, spacing, typography, color usage, component variants, and reusable interaction patterns.

Design authentication and authorization strategy for a product or MVP. Use when the team needs sign-in methods, session model, user/workspace membership, roles, tenant boundaries, invitation flows, or permission enforcement plans.

Use this when frontend or service code needs help integrating with an API, provider, or internal backend contract. Trigger on requests about request flow, response handling, auth propagation, retries, or client-side integration patterns.

Use this when reviewing or designing UI for keyboard access, semantic structure, focus handling, labels, contrast, error communication, motion sensitivity, or screen-reader-friendly behavior.

Use this when the team needs to define permissions, roles, membership rules, resource ownership, or action-level authorization separate from authentication choice. Trigger on requests about access models, RBAC, ABAC, tenancy, or protected operations.

Use when defining a feature's purpose and user value before building it, writing user stories, mapping user flows end-to-end, prioritizing what to build next, evaluating whether a feature solves a real problem, or reviewing scope to prevent over-engineering. Activate when user says "what should I build", "plan the feature", "is this the right approach", "define the requirements", or presents an idea without a clear user need.

Use when the team needs reusable UI component patterns, component responsibilities, states, props, and interaction behavior for React, Next.js, or Tailwind-based interfaces. Trigger on requests to design a component system or define a component before coding it.

Use this when the team needs to improve latency, throughput, render performance, query speed, worker throughput, or resource usage across frontend, backend, database, or background systems.

Use this when the system needs logging, metrics, tracing, alerting, or operator-visible runtime signals for APIs, workers, integrations, serverless functions, or local-to-production supportability.

Use this when designing or refining a Node.js backend service, daemon, worker, integration service, or internal runtime that is not just an Express route layer.

Use this when the team needs detailed interaction behavior for user inputs, transitions, feedback, validation, confirmations, or stateful UI behavior that should be implementation-ready rather than purely visual.

Use this when planning or refining an Express or Express-style Node.js API with route groups, middleware boundaries, validation, auth, error handling, and service layering.

Use this when background workers or job processors need design or review. Trigger on requests about asynchronous processing, job payloads, retries, scheduling, worker ownership, or long-running tasks outside the request path.

Use this when a feature or product needs a clear end-to-end user journey across entry, action, system response, and outcome. Trigger on requests to map the full experience before screens or components are finalized.

Use when a product needs third-party integrations such as payments, email, analytics, AI providers, storage, or internal services. Trigger on requests to plan integration boundaries, provider selection, failure handling, or sync strategies.

Use when implementing login, registration, session handling, protected routes, or role-based access.

Use this when designing or scaffolding a Python API service, endpoint structure, request validation approach, handler layout, or API-specific service patterns in FastAPI, Flask-style, or similar Python backends.

Use when the team needs to understand how data moves through frontend, backend, database, jobs, auth, and external integrations. Trigger on requests to map data flow, event flow, or state transitions across the system.

Use this when reviewing a feature, service, API, auth design, integration, job system, or deployment plan for security weaknesses, unsafe trust assumptions, input risks, or privilege issues.

Use this when the deliverable is a CLI tool, command suite, operator utility, or local developer tool and the team needs command structure, UX, config, packaging, and safety planning across languages.

Use when the team needs a repeatable multi-step workflow, pipeline, or operating sequence that connects multiple skills, systems, or product stages. Trigger on requests to design a workflow from idea to launch, onboarding to retention, or request to execution.

Design user journeys and task flows for a product concept or MVP. Use when the team needs primary flows, branch conditions, edge cases, onboarding paths, and end-to-end user movement before screen planning or UI implementation.

Use when debugging slow SQL queries, designing database indexes, or rewriting queries for better performance. For EXPLAIN analysis, index strategy, N+1 problem resolution, and query optimization patterns.

Use when user flows already exist and the team needs a screen inventory, screen responsibilities, key states, and view hierarchy for a product or feature. Trigger on requests to break a flow into pages, views, or screen-level structure.