geremmyas

Create or revise coding-assistant skills that match this repository's structure and conventions. Use when: writing, renaming, or reviewing a skill. Do not use: for general writing or non-skill documentation.

Set up an Android CI/CD pipeline with lint, static analysis, unit tests, dependency review, and build verification. Use when: creating CI for Android, adding Gradle checks. Do not use: for local development setup, non-CI automation.

Run a disciplined bugfix loop with reproduction, hypotheses, regression test, fix, and cleanup. Use when: fixing bugs, debugging regressions, investigating failures. Do not use: for feature implementation, refactoring.

Design or review a ChromaDB-backed RAG workflow. Use when: creating collections, choosing embedding functions, chunking documents, writing retrievers. Do not use: for general LLM integration, non-RAG patterns.

Create, review, or debug a CI/CD workflow. Use when: editing GitHub Actions, fixing CI failures, adding release/deploy automation. Do not use: for general DevOps, infrastructure as code.

Structured code review workflow ensuring context and clarity. Use when: implementation complete, tests verified, before merge request. Do not use: during active implementation, before verification checklist, or for design reviews.

Structure consequential decisions with explicit trade-offs. Use when choosing architecture, tools, or strategy. Do not use for obvious fixes or time-critical emergencies.

Run or prepare a safe Google Cloud CLI operation. Use when: using gcloud, changing GCP resources, deploying to GCP. Do not use: for local CLI exploration, non-GCP operations.

Generate an Architectural Decision Record in MADR 4.0 format. Use when: recording a decision, architecture decision record, documenting why we chose X. Do not use: for full architecture analysis, routine choices.

Extract and formalize domain terminology into a glossary. Use when: defining domain terms, building glossaries, hardening terminology. Do not use: for general documentation, simple dictionaries.

Generate a structured spec from direct input. Use when: you already know what you want and just need the formatted template. Do not use: for exploration and interviews (use spec-writer agent).

Create a safe Git commit with Conventional Commits format. Use when: committing changes, reviewing staged changes. Do not use: for commit history rewriting, interactive rebasing.

Set up a Go CI/CD pipeline with formatting, vetting, static analysis, tests, vulnerability scanning, and container build. Use when: creating CI for Go, adding checks to workflow. Do not use: for local development setup, non-CI automation.

Design or review a LangGraph agent workflow. Use when: creating a graph, choosing state schema, nodes, tools, checkpoints, interrupts. Do not use: for simple chains, non-agent patterns.

Design or review an LLM integration in a service. Use when: adding model calls, tools, structured outputs, retries, rate limits. Do not use: for prompt engineering alone, non-service LLM work.

Zustand v5 recipes for middleware setup, immer mutations, persistence, and XState sync. Use when: zustand middleware, zustand persist, store patterns. Do not use: for state design patterns, non-Zustand stores.

Guide migration from React Router v6 to v7 framework mode. Use when: migrating routes, upgrading react-router, v6 to v7. Do not use: for initial React Router setup, general routing patterns.

XState v5 recipes for React integration, testing with createActor, and actor patterns. Use when: xstate react, testing state machine, actor patterns. Do not use: for simple component state, non-XState management.

Rewrite academic drafts to remove AI writing patterns while preserving claims and citations. Use when editing abstracts or paper sections. Do not use for blog posts or generating new content.

Review a PostgreSQL query, migration, index, or query plan. Use when: optimizing SQL, checking migrations, reading EXPLAIN output. Do not use: for general database design, non-Postgres systems.

Run a premortem on a plan, decision, or launch. Assumes it already failed and works backward to find why. Use when: premortem this, stress test this plan, find blind spots. Do not use: for post-launch postmortems, blame analysis.

Set up a Python CI/CD pipeline with linting, formatting, type checking, tests, security scanning, and publishing. Use when: creating CI for Python, adding checks to workflow. Do not use: for local development setup, non-CI automation.

Explore code and resolve product or technical ambiguity before specification. Use when starting or expanding a feature. Do not use when requirements are already clear.

Set up a CI/CD pipeline for Rust projects. Use when: creating CI for Rust, adding Clippy/fmt/test/audit to CI. Do not use: for local development setup, non-CI automation.

Plan and execute Rust release engineering. Use when: publishing a crate, setting up release automation, cross-compiling binaries. Do not use: for version bumping alone, local build setup.

Design, validate, and report empirical software engineering case studies. Use when: case study protocols, research questions, units of analysis, triangulation. Do not use: for controlled experiments, surveys, benchmarks.

End-to-end workflow for creating, reviewing, and critiquing scientific papers with rigorous methodology. Use when: writing papers, reviewing papers, literature reviews. Do not use: for blog posts, technical documentation.

Plan or review a Supabase database/platform change. Use when: changing schema, migrations, RLS policies, Auth, Storage, Edge Functions. Do not use: for general database design, non-Supabase platforms.

Plan and review a Terraform infrastructure change safely. Use when: editing Terraform, importing resources, moving resource addresses. Do not use: for infrastructure design, non-Terraform IaC.

Rewrite blog drafts to remove AI writing patterns while preserving the author's voice. Use when editing technical posts. Do not use for academic papers or generating new content.

Set up TypeScript CI with type checks, linting, tests, security scans, and builds. Use when creating or extending CI. Do not use for local setup or non-CI automation.

Update project documentation after implementing a feature. Use when: updating docs, documentation, update docs after implementation. Do not use: for doc-first design, specification writing.

Generate Zod validation patterns for common use cases. Use when: validating API responses, form validation, localStorage parsing. Do not use: for type design, non-validation concerns.

HARD GATE: Mandates fresh verification evidence before task completion. Use when: post-implementation, before marking work done. Do not use: before code is written, for planning, or for code review requests.

Implement one behavior at a time with a red-green-refactor loop. Use when: executing tasks.md, doing TDD, implementing a feature from specs. Do not use: for test planning, bulk implementation.