ajyadav013

api-integration

Wire the app to a backend API — data fetching, caching, error handling, loading states. Use when connecting to an endpoint, adding a fetch layer, or fixing API error and loading behaviour. React-query detail lives in tanstack-react-query-patterns.

component-design

Create or restructure a UI component — architecture, component patterns, accessibility, design-system rules. Use when adding a new component, splitting a large one, or making one reusable. App-level work belongs to frontend-ui-engineering.

decision

Record an architecture decision as an ADR. Use when making significant technology choices, pattern adoptions, or convention changes.

deploy

Deploy-and-verify loop — commit, trigger the deployment, watch the pipeline, verify the running instances, test, fix, repeat until clean. Interviews you once for your delivery setup. Use when asked to deploy, ship, or run the ship loop.

archive-sprint

Archive a completed sprint's planning docs and update the backlog status.

backlog

Add a new feature idea to the product backlog. Use when the user wants to log a new idea, feature request, or improvement.

execute

Takes raw text/requirement, optimizes it into a precise prompt, then executes it immediately. Use when you have a rough idea and want Claude to refine and act on it in one step.

accessibility-review

UI accessibility (WCAG) review — keyboard operability, focus, ARIA semantics, color contrast, touch targets. Returns prioritized fixes. Distinct from performance/visual review.

alembic-migrations

Alembic migration setup and patterns for async SQLAlchemy — async engine + run_sync in env.py, autogenerate, RLS/multi-tenant migrations. Use for alembic init, writing migrations, or debugging migration errors.

anthropic-vertex-integration

Claude on Vertex AI via the AnthropicVertex SDK — lazy ADC client init, env-based project/region resolution, async helpers, backoff retry. Use when calling Claude via GCP Vertex AI (not direct Anthropic API).

api-and-interface-design

Stable API and interface design patterns. Use when designing REST/GraphQL endpoints, module boundaries, type contracts between modules or frontend/backend, or changing public interfaces.

api-pagination-filtering-sorting

HTTP query parameter conventions for pagination, filtering, sorting, and search with standardized response metadata. Use when designing list endpoints or building repositories that turn query params into SQL.

async-python-patterns

Async Python for high-performance services. Use when implementing FastAPI/Temporal/Kafka async handlers, AsyncSession database access, asyncio.gather concurrency, or diagnosing event loop blocking.

auth-and-rbac

FastAPI auth patterns — session/JWT chains, argon2id hashing, pyotp TOTP/Email OTP, role-based access control, x-user-data gateway forwarding. Use when building auth dependencies, MFA, or role hierarchies.

backend-repo-architecture

Canonical backend repository structure for Python/FastAPI — multi-mode entrypoint, app factory, ConnectionManager, BaseDao, flat vs versioned layout. Use when scaffolding or reorganizing a FastAPI service.

Testing & QA Listed

browser-testing-with-devtools

Real browser testing via Chrome DevTools MCP — DOM inspection, console analysis, network requests, performance profiling. Use when debugging anything browser-rendered. Requires the chrome-devtools MCP server.

bug-hunt

Proactively hunt latent defects across a feature/module by reading source and tracing data flow. Use to find bugs before they ship. Distinct from debugging a known failure or reviewing a diff.

ci-cd-and-automation

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.

code-review-and-quality

Multi-axis code review (correctness, security, performance, design) before merging any change. Use to assess quality; not to refactor (use code-simplification) or hunt complexity only (use over-engineering-review).

code-simplification

Simplifies/refactors working code for clarity without changing behavior. Use when code is harder to read or maintain than it should be. Distinct from code-review-and-quality (assesses only) and over-engineering-review (delete-list only).

Data & Documents Listed

configargparse-yaml-env-layering

Three-layer service config — YAML defaults, configargparse CLI/env override, Pydantic BaseSettings singleton. Use for Python services with multiple runtime modes and precedence-ordered config sources.

consolidate-learnings

Merge duplicate and overlapping .claude/agent-memory/ learnings into one canonical entry per rule and rebuild the index. Use when the SessionStart hook nudges or user says consolidate/clean up learnings.

containerization-and-deployment

End-to-end containerization overview for Python/FastAPI services — entrypoint MODE dispatch, cert and keytab bootstrap, Cloud Run and k8s deploy, Makefile dev workflow. Start here for the whole picture; the dockerfile-* skills cover focused work.

context-engineering

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

cron-and-scheduled-jobs

Scheduled jobs across two mechanisms — Kubernetes CronJobs (schedule in Helm values, MODE=cron) and Temporal Schedules. Use when adding periodic jobs or choosing between k8s and Temporal.

Data & Documents Listed

data-engineering-bigquery-gcs

BigQuery medallion architecture (bronze/silver/gold), parameterized queries, MERGE upserts, partitioning, CDC dedup, Temporal orchestration. Use when building batch ETL pipelines or BigQuery schemas.

debugging-and-error-recovery

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.

dependency-verification

Pre-install check that a package NAME exists and isn't a typosquat, plus intake vetting for third-party agent config (skills, MCP entries, hooks). NOT for judging worth (library-review) or CVE audits (dependency-scanner).

deprecation-and-migration

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.

design-patterns-and-conventions

Cross-cutting design patterns, naming, folder layout, and anti-patterns for production Python/FastAPI backends. Use when architecting services, refactoring, reviewing structure, or debugging session leaks.

design-system-ops

Operate a design system over time — drift detection, token architecture, adoption, governance, AI-readiness. Use for system-wide health audits. Do NOT use to build/style components (use component-design).

distributed-systems-patterns

Distributed data placement and replication — consistent hashing/vnodes, sharding, N/W/R quorums, KV-store and cache anatomy, gossip failure detection, B-tree vs LSM engines. Use when designing a sharded, replicated, or cached data tier.

doc-consolidation

Harvest ephemeral agent-run reports (REPORT/ANALYSIS/AUDIT/SUMMARY, scratch notes) into canonical committed docs, then delete sources. Do NOT use to author new docs or judge prose (use documentation-and-adrs).

docker-compose

Docker Compose for local dev and multi-service orchestration. Use when setting up local infrastructure (postgres/redis/kafka/temporal), one-image-many-roles containers, or env-specific compose files.

docker-shared

Shared Docker building blocks — base images for private registries, .dockerignore conventions, compose fragment reuse with YAML anchors. Use when creating base images shared across multiple services.

dockerfile-backend

Multi-stage Dockerfiles for Python/FastAPI backends — builder vs runtime, slim vs alpine, system deps, layer caching, non-root users. Use when containerizing or optimizing Python backend images.

dockerfile-frontend

Multi-stage Dockerfile patterns for React/Vite/TypeScript frontends — node:alpine build, lockfile caching, build-time VITE_* vars, nginx SPA fallback, envsubst config. Use when containerizing static frontends.

documentation-and-adrs

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.

doubt-driven-development

Subject every non-trivial decision to fresh-context adversarial review before it stands. Use when correctness beats speed or stakes are high. Do NOT use as primary loop — layer on spec/test/source-driven.

edge-to-service-trust-boundary

Cryptographic trust contract between API gateway/edge and backend — edge HMAC-signs forwarded identity headers, services verify and FAIL CLOSED. Do NOT use for general app hardening or RBAC (use auth-and-rbac).

fastapi-service-patterns

Production FastAPI conventions — app factory, lifespan hooks, custom request routing, dependency injection, middleware, ResponseData envelope. Use when building a FastAPI service or adding routes/middleware.

Data & Documents Listed

file-export-and-reporting

Excel/CSV generation and download endpoints in FastAPI — pandas to_excel, multi-sheet workbooks, CSV streaming, presigned GCS URLs, UploadFile parsing. Use when building report exports or file downloads.

frontend-repo-architecture

Frontend repo structure for React + Vite + TypeScript — three organizational models, API layer patterns, hand-written types, state split. Use when setting up a React frontend or architecting state/API layers.

frontend-ui-engineering

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

gcp-cloud-run-github-actions

GitHub Actions workflows for deploying containerized services to Google Cloud Run — auth, image caching, multi-job pipelines, VPC/Cloud SQL, post-deploy checks. Use when building CI/CD pipelines for Cloud Run.

gcs-file-storage-patterns

Google Cloud Storage patterns — credential refresh, single/bulk uploads, signed URLs, CSV/Excel reads, gs URI parsing. Use when implementing file upload/download endpoints. Distinct from batch ETL.

git-workflow-and-versioning

Structures git workflow practices for any codebase. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.

grafana-dashboards-and-alerts

Production Grafana dashboards and unified alerting. Use when editing dashboard JSON or PromQL, building RED dashboards, authoring alert rules and contact-point routing, or provisioning dashboards as code.

graphql-patterns

Tactical Strawberry GraphQL (backend) + Apollo Client (frontend) — filter/dropdown endpoints alongside REST, JWT auth, hand-typed gql queries. NOTE — limited-footprint pattern (~2 apps), not the org default.

idea-refine

Refines raw ideas into sharp, actionable concepts via divergent-then-convergent thinking. Use when an idea is vague or to stress-test assumptions. Triggers on ideate, refine this idea, stress-test my plan.