@skills · Owner

Agent skills by pproenca

217 skills indexed from github.com/pproenca. Reference any of them in AdaL, Claude Code, Cursor or any coding agent — nothing to install.

• .agents · Collection · 192 stars
• .curated · Collection · 192 stars
• .experimental · Collection · 192 stars
• 12-factor-app · Skill · 192 stars

  The Twelve-Factor App methodology for building scalable, maintainable cloud-native applications. Use when designing backend services, APIs, microservices,

• 37signals-rails · Skill · 192 stars

  37signals Rails coding principles and conventions from DHH, Jorge Manrubia, and the Fizzy/Basecamp/HEY codebase. This skill should be used when writing, re

• acceptance-pipeline-catalog · Skill · 192 stars

  Use when implementing, reviewing, or debugging a Gherkin acceptance-test pipeline with mutation testing. Covers parser, JSON IR, generator, runtime, step h

• acceptance-pipeline-feature-design · Skill · 192 stars

  Designs new features, extensions, or modifications to Uncle Bob's Acceptance Pipeline Specification — new mutation strategies, Gherkin syntax support, repo

• adversarial-beam · Skill · 192 stars

  Use this skill to gate Elixir/OTP systems on BEAM runtime architecture with a pass/fail adversarial review — a single blind reviewer subagent judges a diff

• adversarial-ddd · Skill · 192 stars

  Use this skill to gate DDD and ubiquitous-language quality with a pass/fail adversarial review — a single blind reviewer subagent judges a diff, a module/b

• adversarial-elixir · Skill · 192 stars

  Use this skill to gate Elixir, OTP, Ecto, and Phoenix code with a pass/fail adversarial review — a single blind reviewer subagent judges a diff or file set

• adversarial-ios-design · Skill · 192 stars

  Use this skill to gate iOS SwiftUI design and UX with a pass/fail adversarial review — a single blind reviewer subagent judges screens, diffs, or features

• adversarial-phoenix-liveview · Skill · 192 stars

  Use this skill to gate Phoenix LiveView realtime UIs with a pass/fail adversarial review — a single blind reviewer subagent judges a diff or file set again

• adversarial-python · Skill · 192 stars

  Use this skill to gate Python code (floors 3.10+, rules verified through 3.14) with a pass/fail adversarial review — a single blind reviewer subagent judge

• adversarial-reactor · Skill · 192 stars

  Use this skill to gate Elixir code built on the Reactor orchestration library (~> 1.0) with a pass/fail adversarial review — a single blind reviewer subage

• adversarial-rust · Skill · 192 stars

  Use this skill when reviewing or refactoring existing Rust code that carries an alien mental model — OO/enterprise ceremony from Java/C#, garbage-collected

• adversarial-swift · Skill · 192 stars

  Use this skill to gate Swift language code with a pass/fail adversarial review — a single blind reviewer subagent judges a diff or file set against 36 deci

• adversarial-swift-ui · Skill · 192 stars

  Use this skill to gate SwiftUI code with a pass/fail adversarial review — a single blind reviewer subagent judges a diff or file set against 31 decidable r

• adversarial-tanstack · Skill · 192 stars

  Use this skill to gate TanStack Start plus TypeScript web-app changes with a pass/fail adversarial review — a single blind reviewer subagent judges a diff

• adversarial-ts-patterns · Skill · 192 stars

  Use this skill to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent

• adversarial-zod · Skill · 192 stars

  Use this skill to gate Zod 4 schema code in TypeScript and TanStack Start apps with a pass/fail adversarial review — a single blind reviewer subagent judge

• algorithmic-complexity-review · Skill · 192 stars

  Algorithmic complexity (Big-O) review — finding nested loops, N+1 queries, exponential recursion, quadratic string builds, and other accidental complexity

• app-planner · Skill · 192 stars

  Produces a design-plan (living document like an exec-plan) that maps an app domain to feature groups using Apple Design DNA patterns. Each feature group be

• ast-grep · Skill · 192 stars

  ast-grep rule writing and usage best practices. This skill should be used when writing, reviewing, or debugging ast-grep rules for code search, linting, an

• ast-grep-typescript-react · Skill · 192 stars

  Use this skill when writing, debugging, or reviewing ast-grep patterns, YAML rules, or codemods against TypeScript or React (.ts/.tsx) code — searching for

• audio-voice-recovery · Skill · 192 stars

  Audio forensics and voice recovery guidelines for CSI-level audio analysis. This skill should be used when recovering voice from low-quality or low-volume

• base-ui-migrator · Skill · 192 stars

  Migrates React UI code to Base UI (`@base-ui/react`) — replacing bespoke modals, custom dropdowns, raw `<dialog>`/`<select>` elements, ad-hoc popovers/menu

• better-auth · Skill · 192 stars

  Better Auth in TypeScript — setting up the auth instance, picking adapters, wiring framework route handlers, configuring sessions and cookies, adding plugi

• better-auth-scaffold · Skill · 192 stars

  Scaffolds a Better Auth setup in a Next.js (App Router) + Drizzle project — lib/auth.ts, lib/auth-client.ts, the /api/auth/[...all] route handler, middlewa

• bug-review · Skill · 192 stars

  Use this skill when a user asks to review a pull request for bugs, wants AI code review focused on correctness issues, or runs /bug-review. Trigger on PR r

• bug-review · Skill · 192 stars

  Multi-pass PR bug review — 5 parallel passes, majority voting, independent Opus validation, and resolution rate tracking. Trigger on PR review, bug finding

• build-mcp-server · Skill · 192 stars

  Entry point for MCP server development — interrogates the user about their use case, determines the right deployment model (remote HTTP, MCPB, local stdio)

• chat-apps-ui-sdk · Skill · 192 stars

  Interactive UI rendered inside ChatGPT or Claude — OpenAI Apps SDK apps, MCP Apps (the @modelcontextprotocol/ext-apps standard), or MCP-UI components, with

• chrome-extension · Skill · 192 stars

  Chrome Extensions (Manifest V3) performance and code quality guidelines. Use when writing, reviewing, or refactoring Chrome extension code including servic

• chrome-extension-ui · Skill · 192 stars

  Chrome Extensions UX/UI design and implementation guidelines for popups, side panels, content scripts, and options pages. Triggers on tasks involving brows

• clean-architecture · Skill · 192 stars

  Clean Architecture principles and best practices from Robert C. Martin's book. This skill should be used when designing software systems, reviewing code st

• clean-code · Skill · 192 stars

  Use when writing, reviewing, or refactoring code for maintainability and readability. Triggers on code reviews, naming discussions, function design, error

• clean-code-ts-react · Skill · 192 stars

  Use when writing, reviewing, or refactoring TypeScript or React code for craftsmanship — naming, function and component shape, error handling, data modelin

• cli-for-agents · Skill · 192 stars

  Designing CLIs that AI agents will invoke — non-interactive flags, layered --help with examples, stdin/pipeline composition, actionable errors, idempotency

• cli-review-runner · Skill · 192 stars

  Black-box CLI grading harness — runs a test suite against a target CLI and reports per-rule pass/fail from the cli-for-agents 45-rule catalog. Use when rev

• code-distill · Skill · 192 stars

  On-demand pattern extraction from a specific GitHub codebase, given a focused query — "how does shadcn/ui implement the design system", "how does opencode

• code-map-visualization · Skill · 192 stars

  Rendering and perception layer for codebase-as-geohash-map visualisations — choosing what to encode on colour/size/position, picking perceptually honest co

• code-simplifier · Skill · 192 stars

  Code simplification skill for improving clarity, consistency, and maintainability while preserving exact behavior. Use when simplifying code, reducing comp

• codebase-comprehension-algorithms · Skill · 192 stars

  Mapping an unfamiliar codebase into feature/business domains — answering "what is this about", "which files implement feature X", "where is the architectur

• codemod · Skill · 192 stars

  Codemod (JSSG, ast-grep, workflows) best practices for writing efficient, safe, and maintainable code transformations. This skill should be used when writi

• codemod-react-pipeline · Skill · 192 stars

  Guided, scripted pipeline for running JSX/TSX/React codemods safely across large legacy codebases. Use when you need to scaffold a codemod, dry-run it, val

• codex-goals · Skill · 192 stars

  Patterns and anti-patterns for using OpenAI Codex Goals — the persistent objectives feature introduced in Codex 0.128.0. Use this skill whenever writing, r

• complexity-optimizer · Skill · 192 stars

  Analyze a software codebase for algorithmic complexity and performance hotspots, then propose or implement safe optimizations without breaking behavior. Us

• computer-science-algorithms · Skill · 192 stars

  Choosing or implementing an algorithm or data structure — asymptotic complexity, data-structure selection, sorting & searching, dynamic programming, graph

• datadog-dashboards · Skill · 192 stars

  Corrects the wrong defaults a model has when building Datadog dashboards, verified against Datadog's docs in July 2026. Use when creating, editing, or revi

• debug · Skill · 192 stars

  Comprehensive debugging methodology for finding and fixing bugs (formerly debugging). This skill should be used when debugging code, investigating errors,

• design-review · Skill · 192 stars

  Structured UI design review — existing code (React/JSX, CSS, Tailwind) and, when behaviour matters, the running app in a real browser — reported as a prior

• design-to-react-algorithms · Skill · 192 stars

  Reverse-engineering a Sketch file (or Figma export with similar shape) into pixel-perfect React + CSS — the iteration mental model, tree reconstruction, la

• deterministic-metric-design · Skill · 192 stars

  Inventing deterministic metrics — turning a fuzzy property like 'maintainability', 'risk', or 'how reducible this code is' into a deterministic, computable

• dev-rfc · Skill · 192 stars

  Create well-structured RFCs and technical proposals for software projects. Use this skill whenever the user wants to write an RFC, technical proposal, desi

• diagram-quality · Skill · 192 stars

  PlantUML diagram quality on the agent-uml collaborative canvas — three tiers: rendering safety (syntax that prevents HTTP 400 blank canvas), conversation m

• diataxis · Skill · 192 stars

  Use whenever writing, editing, restructuring, or reviewing technical documentation — READMEs, API docs, guides, tutorials, reference, onboarding, or develo

• django-recommender-search-backend-patterns · Skill · 192 stars

  Django backend patterns for recommendation services (AWS Personalize, Databricks Model Serving, internal microservices) and OpenSearch-backed search/feed e

• dockerfile-optimise · Skill · 192 stars

  Dockerfile optimization guidelines from official Docker documentation. This skill should be used when writing, reviewing, or refactoring Dockerfiles to ens

• docs-search · Skill · 192 stars

  Library-documentation lookup methodology — API behavior, version-specific changes, idiomatic usage, or why production diverges from docs — independent of w

• domain-architect · Skill · 192 stars

  Discovers business domains in a Swift codebase by tracing what users can DO — not by reading folder names or architecture docs. Maps each domain's vertical

• dot-skills · Collection · 192 stars
• drizzle-nextjs-postgres · Skill · 192 stars

  Drizzle ORM against PostgreSQL inside a Next.js App Router app. Covers client construction (globalThis singleton across HMR, serverless pool sizing, `prepa

• drizzle-sqlite · Skill · 192 stars

  Drizzle ORM targeting SQLite (better-sqlite3, libsql/Turso, bun:sqlite, Cloudflare D1, expo-sqlite, op-sqlite). Covers schema definition (column modes, pri

• drizzle-sqlite-scaffold · Skill · 192 stars

  Scaffolds Drizzle ORM + SQLite boilerplate — a new `drizzle.config.ts`, a singleton client with the right pragmas, per-table schema files with explicit pri

• dx-harness · Skill · 192 stars

  Developer-experience friction auditing and fixing — slow onboarding, repeated manual setup steps, missing bootstrap/reset/seed scripts, undiscoverable conv

• effect-ts · Skill · 192 stars

  Effect-TS library usage in TypeScript — Effect.gen generators, Schema.Struct/Schema.Class definitions, Layer/Context.Tag/Service patterns, Effect.pipe pipe

• elixir-meta-programming · Skill · 192 stars

  Use this skill when building an Elixir macro or a declarative DSL — a schema/spec/route/workflow language in the shape of Ecto.Schema, Absinthe, Plug.Route

• emilkowal-animations · Skill · 192 stars

  Emil Kowalski's animation best practices for web interfaces. Use when writing, reviewing, or implementing animations in React, CSS, or Framer Motion. Trigg

• eval-mcp · Skill · 192 stars

  Measures whether Claude uses an MCP server's tools correctly — tests tool selection accuracy, analyzes schema quality, and iteratively optimizes descriptio

• exec-plan · Skill · 192 stars

  Manage the lifecycle of ExecPlans — self-contained, living specifications for multi-step work. Creates plans in the correct format, enforces living section

• expo · Skill · 192 stars

  Expo React Native performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring Expo React Native code to ensure o

• expo-design-system · Skill · 192 stars

  Airbnb-DLS-aligned design system engineering for Expo / React Native apps targeting both web and native iOS, built on Unistyles v3, Reanimated, Skia, and F

• expo-design-system-scaffolder · Skill · 192 stars

  Scaffolds Expo / React Native design system components that obey the expo-design-system rules by construction — a variant-driven pressable primitive, a slo

• expo-ios-hig · Skill · 192 stars

  Expo / React Native iOS interface conforming to Apple Human Interface Guidelines (iOS 26) — native navigation (Expo Router native stack and tabs), platform

• expo-ios-hig-verify · Skill · 192 stars

  Static scan of an Expo / React Native iOS app for non-native patterns — Material component kits, JS navigators instead of native stack/tabs, PanResponder,

• expo-ios-screen-scaffolder · Skill · 192 stars

  Scaffolds Expo (React Native) iOS screens that follow Apple Human Interface Guidelines by construction — list, detail, form, modal sheet, native tabs layou

• expo-react-native-coder · Skill · 192 stars

  Comprehensive Expo React Native feature development guide. This skill should be used when building mobile app screens, navigation, data fetching, authentic

• expo-react-native-performance · Skill · 192 stars

  Expo React Native performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring Expo React Native code to ensure o

• expo-ui · Skill · 192 stars

  Library reference for @expo/ui SwiftUI components on iOS — covers Host boundaries, modifier composition, iOS 26 Liquid Glass and Human Interface Guidelines

• feature-arch · Skill · 192 stars

  React feature-based architecture guidelines for scalable applications. This skill should be used when writing, reviewing, or refactoring React code to ensu

• feature-arch-gate · Skill · 192 stars

  Adversarial pass/fail review gate that enforces the feature-arch skill's React feature-based architecture rules. Use when a diff, branch, PR, or src/ tree

• feature-spec · Skill · 192 stars

  Feature specification and planning guidelines for software engineers. This skill should be used when writing PRDs, defining requirements, managing scope, p

• fog-of-war-js-ts · Skill · 192 stars

  Fog of war, field of view, line of sight, and tile visibility in JavaScript or TypeScript games — roguelikes, RTS, top-down, or strategy maps. Covers effic

• framer-motion · Skill · 192 stars

  Framer Motion performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring React animations with Framer Motion to

• geohash-spatial-code-maps · Skill · 192 stars

  Geohash encoding/decoding in TypeScript or Rust — bit interleaving, the base32 alphabet, precision and cell geometry, neighbour/adjacency computation, prox

• go-process-cli · Skill · 192 stars

  Write Go CLIs that manage processes and workloads — daemons, supervisors, job runners, deploy tools, anything that spawns or controls other processes. Use

• graph-schema · Skill · 192 stars

  Graph database schema design and data modeling expert. Use when designing, reviewing, or refactoring graph database schemas (Neo4j, Memgraph, Neptune, etc.

• harness-engineering · Skill · 192 stars

  Set up or update the agent-first engineering harness for any repository. Implements the complete scaffolding that makes AI coding agents effective: knowled

• human-copywrite · Skill · 192 stars

  User-facing copy — UI strings, documentation, marketing, release notes, error messages, onboarding flows, blog posts, or anything that a person will read.

• humanize · Skill · 192 stars

  Remove signs of AI-generated writing from text (formerly human-writing). Use when editing or reviewing text to make it sound more natural and human-written

• implementation-design-patterns · Skill · 192 stars

  Implementation guide for the 22 Gang of Four design patterns in TypeScript, distilled from refactoring.guru. Use this skill when writing, refactoring, or r

• implementation-design-patterns-python · Skill · 192 stars

  Implementation guide for the 22 Gang of Four design patterns in idiomatic modern Python (3.10+), distilled from refactoring.guru. Use when writing, refacto

• implementation-functional-patterns · Skill · 192 stars

  TypeScript's functional answers to the 22 Gang of Four classes — factory functions (Factory Method, Abstract Factory, Prototype, Memento), module-scope sin

• inngest-nextjs-patterns · Skill · 192 stars

  Inngest event-driven functions in a Next.js (App Router) project — creating the client, the /api/inngest route handler, typed events with Zod schemas, dura

• io-bound-data-processing · Skill · 192 stars

  Processing, transforming, or moving datasets that may exceed RAM on a single low-compute box — covers memory discipline (streaming, generators, dtype shrin

• ios-animations · Skill · 192 stars

  Clinic-architecture-aligned iOS animation craft guidelines for SwiftUI (iOS 26 / Swift 6.2) covering motion tokens, spring physics, gesture continuity, spa

• ios-chaos-monkey · Skill · 192 stars

  Crash-hunter skill for iOS 26 / Swift 6.2 clinic-architecture codebases that finds and fixes concurrency, memory, and I/O bugs using TDD. Covers data races

• ios-design · Skill · 192 stars

  SwiftUI interface implementation patterns aligned with the iOS 26 / Swift 6.2 clinic modular MVVM-C architecture, grounded in Creative Selection and Design

• ios-design-system · Skill · 192 stars

  Clinic-architecture-aligned iOS design system engineering for SwiftUI (iOS 26 / Swift 6.2) covering token architecture, color/typography/spacing systems, c

• ios-hig · Skill · 192 stars

  Apple Human Interface Guidelines for iOS 26 / Swift 6.2 clinic-architecture apps. Covers navigation, interaction design, accessibility, feedback states, UX

• ios-navigation · Skill · 192 stars

  Opinionated SwiftUI navigation enforcement for iOS 26 / Swift 6.2 clinic modular MVVM-C apps. Enforces Domain coordinator protocols, App-target `Dependency

• ios-storyboard · Skill · 192 stars

  Legacy interoperability skill for Storyboard and Interface Builder maintenance in iOS 26 / Swift 6.2 clinic codebases. Use only for migration or maintenanc

• ios-taste · Skill · 192 stars

  Designs iOS 18+ SwiftUI experiences with real taste — starting from user goals, not pixels. Use this skill whenever the user asks you to build SwiftUI view

• ios-testing · Skill · 192 stars

  Testing practices for iOS 26 / Swift 6.2 clinic modular MVVM-C applications. Covers unit/UI/snapshot testing, protocol-based mocks, async actor isolation,

• ios-ui-refactor · Skill · 192 stars

  Principal-level SwiftUI UI review and refactoring patterns for iOS 26 / Swift 6.2 clinic-architecture apps, grounded in Rams, Segall, and Edson principles.

• ios-xcode · Skill · 192 stars

  Xcode setup and tooling guidance for iOS 26 / Swift 6.2 clinic modular MVVM-C projects covering project configuration, SwiftData container wiring, testing,

• js-google · Skill · 192 stars

  JavaScript style and best practices based on Google's official JavaScript Style Guide. This skill should be used when writing, reviewing, or refactoring Ja

• jscodeshift · Skill · 192 stars

  jscodeshift codemod development best practices from Facebook/Meta. This skill should be used when writing, reviewing, or debugging jscodeshift codemods. Tr

• knip-deadcode · Skill · 192 stars

  Knip dead code detection best practices for JavaScript and TypeScript projects. Use when configuring Knip, analyzing unused code, setting up CI integration

• language-spec-author · Skill · 192 stars

  Turn a rough idea for a language into a complete, implementable specification — a DSL, query, config/data, template, or protocol language — by interviewing

• library-reference-distillation · Skill · 192 stars

  Methodology for starting a new library-reference distillation skill — one that turns an external library (nuqs, zod, framer-motion, msw, react-hook-form, e

• linguistic-semantic-algorithms · Skill · 192 stars

  Mapping out an unfamiliar codebase via NLP and graph algorithms — 40 algorithms across topic modelling, semantic embeddings, code graphs, repository mining

• marketplace-personalisation · Skill · 192 stars

  Personalisation and recommendation systems for a two-sided trust marketplace built on AWS Personalize — event tracking, dataset and schema design, two-side

• marketplace-pre-member-personalisation · Skill · 192 stars

  Pre-member journey of a two-sided trust marketplace — from anonymous landing through onboarding, registration, and the paid-membership paywall. Covers anon

• marketplace-recsys-feature-engineering · Skill · 192 stars

  Feature engineering for marketplace recommenders — what to extract from raw marketplace assets (listing photos, owner-entered listing metadata, sitter wiza

• marketplace-search-recsys-planning · Skill · 192 stars

  Search and recommendation system planning for a two-sided trust marketplace built on OpenSearch — user-intent framing, product-surface architecture, index

• metric-validation-harness · Skill · 192 stars

  Empirically validates a software metric before trusting or optimizing it — point it at any candidate metric (a command that takes a path and prints one num

• migrate-js-to-modern-typescript · Skill · 192 stars

  Migrating a JavaScript codebase to TypeScript — converting .js files to .ts, adding types to existing JS, or tightening a loosely-typed TS project toward s

• msw · Skill · 192 stars

  MSW (Mock Service Worker) best practices for API mocking in tests (formerly test-msw). This skill should be used when setting up MSW, writing request handl

• mui-base · Skill · 192 stars

  MUI Base UI style guidelines for building headless React component libraries (formerly headless-ui-style). This skill should be used when creating unstyled

• nextjs · Skill · 192 stars

  Next.js 16 App Router performance, caching, server components, server actions, routing, and codebase-hygiene best practices — plus a category-major review/

• nextjs-bundle-optimizer · Skill · 192 stars

  Next.js 16 bundle-size and build-time optimization — runs a data-driven iteration loop: measure baseline → analyze top offenders → apply ONE recipe → re-me

• nextjs-ppr-patterns · Skill · 192 stars

  Next.js 16 App Router pages mixing static and dynamic content — Partial Prerendering (PPR) under the Cache Components model. Covers enabling it with cacheC

• nginx-c-module-debug · Skill · 192 stars

  nginx C module debugging guidelines based on the official nginx development guide. This skill should be used when debugging nginx C module crashes, memory

• nginx-c-module-design · Skill · 192 stars

  nginx C module directive design guidelines for creating admin-friendly configuration interfaces. This skill should be used when designing nginx module dire

• nginx-c-module-perf · Skill · 192 stars

  nginx C module performance optimization and reliability guidelines based on the official nginx development guide. This skill should be used when optimizing

• nginx-c-modules · Skill · 192 stars

  nginx C module development guidelines based on the official nginx development guide. This skill should be used when writing, reviewing, or refactoring ngin

• nuqs · Skill · 192 stars

  nuqs (type-safe URL query state) best practices for Next.js and other React frameworks. This skill should be used when writing, reviewing, or refactoring c

• nuqs-codemod-runner · Skill · 192 stars

  Migrates a nuqs codebase off pre-v2.5 patterns — deprecated `throttleMs`, hand-rolled setTimeout/useState debounce around `useQueryState`, unchecked `parse

• nuqs-scaffolder · Skill · 192 stars

  Scaffolds URL-state filters for a Next.js page — typed `searchParams.ts` parser map and a `<Filters />` client component backed by `useQueryStates`. From a

• openai-codex-rust-patterns · Skill · 192 stars

  OpenAI Codex Rust coding patterns distilled from the codex-rs workspace. Use this skill whenever writing, reviewing, or refactoring Rust code — especially

• opencode-ts · Skill · 192 stars

  Write and refactor TypeScript code in repos that use Effect-TS services, Effect Schema, event-sourced persistence, and barrel-module architecture. Use this

• opensearch-function-scoring-algorithms · Skill · 192 stars

  Search relevance and ranking on OpenSearch/Elasticsearch for a two-sided marketplace — candidate retrieval (hybrid BM25 + kNN, RRF, two-tower EBR), base re

• opensearch-personalize-caching-strategies · Skill · 192 stars

  Caching strategies in front of AWS OpenSearch (Elasticsearch) or AWS Personalize — search, recommenders, multi-recommender pages, anon vs logged-in traffic

• opinionated-nextjs-patterns · Skill · 192 stars

  Opinionated, backend-agnostic Next.js 16 (App Router) architecture — authorization at the data layer, server-side loading with cache()+Promise.all, mutatio

• orval · Skill · 192 stars

  Orval OpenAPI TypeScript client generation best practices. This skill should be used when configuring Orval, generating TypeScript clients from OpenAPI spe

• playwright · Skill · 192 stars

  Playwright testing best practices for Next.js applications (formerly test-playwright). This skill should be used when writing, reviewing, or debugging E2E

• pt-irs-runbook · Skill · 192 stars

  Portuguese personal income tax (IRS / Código do IRS) and Modelo 3 filing — determining tax residency (Art. 16), classifying income by category (rental/Anex

• pulumi · Skill · 192 stars

  Pulumi infrastructure as code performance and reliability guidelines. This skill should be used when writing, reviewing, or refactoring Pulumi code to ensu

• python · Skill · 192 stars

  Python 3.11+ performance optimization guidelines (formerly python-311). This skill should be used when writing, reviewing, or refactoring Python code to en

• python-pep-author · Skill · 192 stars

  Drafting Python Enhancement Proposals (PEPs) — proposing a Python language feature, a standard library change, an interoperability standard, or an informat

• radical-simplification · Skill · 192 stars

  Cognitive moves for collapsing complexity — reframe, clarify, reduce, decompose, invert, constrain, transfer, generalize, audit — distilled from the workin

• radical-simplification · Skill · 192 stars

  Cognitive moves for collapsing complexity — reframe, clarify, reduce, decompose, invert, constrain, transfer, generalize, audit — distilled from the workin

• rails-application-ui-blocks · Skill · 192 stars

  Compose new Rails backend pages and refactor existing Rails UI to use premium blocks from templates/application-ui. Use when requests mention ERB views, Ra

• rails-design-system · Skill · 192 stars

  Ruby on Rails design system guidelines for building consistent, maintainable UI with minimal abstraction. This skill should be used when creating or refact

• rails-dev · Skill · 192 stars

  Ruby on Rails performance and maintainability optimization guidelines for building backend APIs and frontend web applications. This skill should be used wh

• rails-hotwire · Skill · 192 stars

  Ruby on Rails Hotwire best practices for building interactive applications with Turbo Drive, Turbo Frames, Turbo Streams, Turbo 8 morphing, and Stimulus co

• rails-testing · Skill · 192 stars

  Ruby on Rails testing best practices for writing effective, maintainable test suites with RSpec. This skill should be used when writing, reviewing, or refa

• react · Skill · 192 stars

  React 19/19.2 modern patterns for concurrent rendering, Server Components, actions, ref-as-prop, document metadata, resource hints, hooks, and memoization

• react-19-component-scaffolder · Skill · 192 stars

  Scaffolds React 19 / React 19.2 code in TypeScript — components, Server Component pages, client islands, form actions with useActionState, context provider

• react-fetch-cache-patterns · Skill · 192 stars

  React data-fetching patterns at scale — recommender carousels, infinite feeds, pages with many parallel fetches, dashboards. Covers request orchestration (

• react-hook-form · Skill · 192 stars

  React Hook Form performance optimization for client-side form validation using useForm, useWatch, useController, useFieldArray, the subscribe() API, and th

• react-hook-form-audit · Skill · 192 stars

  Audits a Next.js (App Router, 14/15+) codebase for React Hook Form anti-patterns — watch() at form root, Controller inlined in parent, async submit without

• react-native-elements · Skill · 192 stars

  React Native Elements UI component library best practices for performance, theming, and proper component usage. Use when building React Native apps with RN

• react-optimise · Skill · 192 stars

  Application-level React performance optimization covering React Compiler mastery, bundle optimization, rendering performance, data fetching, Core Web Vital

• react-refactor · Skill · 192 stars

  Architectural refactoring guide for React applications covering component architecture, state architecture, hook patterns, component decomposition, couplin

• react-testing-library · Skill · 192 stars

  React Testing Library best practices for writing maintainable, user-centric tests. Use when writing, reviewing, or refactoring RTL tests. Triggers on test

• refactor · Skill · 192 stars

  Code refactoring best practices based on Martin Fowler's catalog and Clean Code principles (formerly refactoring). This skill should be used when refactori

• relational-data-modeling · Skill · 192 stars

  Corrects the wrong defaults a model has when designing a relational schema — the DDL decisions an experienced engineer makes differently. Use when creating

• relational-database-design · Skill · 192 stars

  Distills a logical relational-database design methodology into rules an agent applies while designing or reviewing a schema. Covers the design sequence (mi

• restful-hateoas · Skill · 192 stars

  RESTful API design guidelines following the Richardson Maturity Model through to Level 3 (HATEOAS) for Ruby on Rails. This skill should be used when design

• ruby-optimise · Skill · 192 stars

  Ruby performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring Ruby code to ensure optimal performance pattern

• ruby-refactor · Skill · 192 stars

  Ruby refactoring guidelines from community best practices. This skill should be used when refactoring, reviewing, or restructuring Ruby code to improve des

• rust-implement · Skill · 192 stars

  Write production-grade Rust code using a multi-pass approach. Design types first, then implement, then simplify, then verify with automated lint. Use this

• rust-refactor · Skill · 192 stars

  Decision frameworks for Rust refactoring, simplification, module decomposition, and incremental migration. Use this skill when simplifying Rust code, split

• rust-write-tests · Skill · 192 stars

  Expert-level Rust testing — the "What Could Break?" framework, five transformations from superficial to expert tests, flake hunting protocol, intent-based

• same-results-less-code · Skill · 192 stars

  Same behaviour in fewer, clearer lines — covers the judgment gaps that linters cannot catch (reinvention, wrong frame, hidden duplication, derived state, p

• search-ios26-docs · Skill · 192 stars

  Search and inspect local iOS 26 SDK documentation and Swift interfaces, especially SwiftUI and SwiftUICore. Use when Codex needs current iOS 26 SwiftUI API

• search-macos26-docs · Skill · 192 stars

  Search and inspect local macOS 26 SDK documentation and Swift interfaces, especially SwiftUI, SwiftUICore, and AppKit. Use when Codex needs current macOS 2

• shadcn · Skill · 192 stars

  shadcn/ui component library best practices and patterns (formerly shadcn-ui). This skill should be used when writing, reviewing, or refactoring shadcn/ui c

• shell · Skill · 192 stars

  Shell scripting best practices for writing safe, portable, and maintainable bash/sh scripts. Use when writing, reviewing, or refactoring shell scripts, Doc

• skill-authoring · Skill · 192 stars

  Design and development best practices for Claude Code skills, MCP tools, and AI agent capabilities. Use when creating skills, writing SKILL.md files, desig

• skills · Collection · 192 stars
• skills · Collection · 192 stars
• sonarqube-ai-slop-gate · Skill · 192 stars

  Corrects the wrong defaults a model has when standing up self-hosted SonarQube Server as a continuous gate on AI-generated code, verified against docs.sona

• staff-level-elixir · Skill · 192 stars

  Use this skill when writing, reviewing, or refactoring Elixir, OTP, Ecto, or Phoenix/LiveView code. It corrects the staff-level judgment calls a capable mo

• storybook · Skill · 192 stars

  Use whenever creating, configuring, or extending Storybook for a TS/React component library — covers main.ts/preview.ts setup, CSF3 story authoring, args/a

• stripe-inspired-api-design-rules · Skill · 192 stars

  JSON HTTP API design rules distilled from Stripe — resource modeling, identifier schemes, URL structure, request/response wire format, pagination, errors,

• swift-data · Skill · 192 stars

  SwiftData persistence and data-layer architecture for iOS 26 / Swift 6.2 clinic modular MVVM-C apps. Use when writing, reviewing, or refactoring @Model ent

• swift-optimise · Skill · 192 stars

  Swift 6.2 and SwiftUI performance optimization for iOS 26 clinic architecture codebases. Covers async/await concurrency patterns, Sendable/actor isolation,

• swift-refactor · Skill · 192 stars

  Swift and SwiftUI refactoring patterns aligned with the iOS 26 / Swift 6.2 clinic modular MVVM-C architecture (Airbnb + OLX SPM layout). Enforces @Observab

• swift-ui-architect · Skill · 192 stars

  Opinionated SwiftUI architecture enforcement for iOS 26 / Swift 6.2 clinic modular MVVM-C apps using local SPM package boundaries. Enforces App-target `Dep

• tailwind · Skill · 192 stars

  Tailwind CSS v4 performance optimization and best practices guidelines (formerly tailwindcss-v4-style). This skill should be used when writing, reviewing,

• tailwind-refactor · Skill · 192 stars

  Tailwind CSS code refactoring patterns for v4 migration and anti-pattern cleanup. This skill should be used when refactoring Tailwind utility classes, migr

• tailwind-responsive-ui · Skill · 192 stars

  Responsive UI transformation patterns for Tailwind CSS applications. This skill should be used when making interfaces responsive, refactoring layouts for m

• tailwind-ui-refactor · Skill · 192 stars

  Refactoring UI design patterns for Tailwind CSS applications. This skill should be used when writing, reviewing, or refactoring HTML with Tailwind utility

• tanstack-query · Skill · 192 stars

  TanStack Query v5 performance optimization for data fetching, caching, mutations, and query patterns. This skill should be used when using useQuery, useMut

• tdd · Skill · 192 stars

  Test-Driven Development methodology and red-green-refactor workflow (formerly test-tdd). This skill should be used when practicing TDD, writing tests first

• terminal-ui · Skill · 192 stars

  Terminal User Interface (TUI) performance and UX guidelines for TypeScript applications using Ink and Clack. This skill should be used when building CLI to

• theory-of-constraints · Skill · 192 stars

  Apply the Theory of Constraints (Goldratt's Five Focusing Steps) to find and fix the single bottleneck that caps a process, workflow, pipeline, or Agent Sk

• think · Skill · 192 stars

  Deep strategic thinking mode that finds the single highest-leverage, most innovative action by blending concepts across domains. Use this skill whenever th

• threat-model · Skill · 192 stars

  Security threat modeling, attack surface mapping, and trust boundary analysis on a codebase. Triggers on 'threat model', 'security review', 'attack surface

• threat-patch · Skill · 192 stars

  Remediate security findings by producing minimal, surgical code patches. Triggers on 'patch security findings', 'fix vulnerabilities', 'remediate findings'

• trpc · Skill · 192 stars

  Corrects the wrong defaults a model has for tRPC v11 (verified against 11.18.0). Use when code imports initTRPC, createTRPCContext, createTRPCOptionsProxy,

• ts-google · Skill · 192 stars

  Google TypeScript style guide for writing clean, consistent, type-safe code. This skill should be used when writing, reviewing, or refactoring TypeScript c

• typescript · Skill · 192 stars

  TypeScript performance, tsconfig, type errors, async patterns — triggered when the user asks to "optimize TypeScript performance", "speed up tsc compilatio

• typescript-advanced-patterns · Skill · 192 stars

  Advanced TypeScript — type-level programming, library/DSL APIs, declaration merging, modern language features at depth (decorators, using, const T, NoInfer

• typescript-refactor · Skill · 192 stars

  TypeScript and TSX refactoring and modernization guidelines from a principal specialist perspective, current to TypeScript 6.0 and React 19. This skill sho

• ui-design · Skill · 192 stars

  UI/UX and frontend design best practices guidelines (formerly frontend-design). This skill should be used when writing, reviewing, or designing frontend co

• uniwind · Skill · 192 stars

  Uniwind best practices for React Native styling with Tailwind CSS. This skill should be used when writing, reviewing, or refactoring React Native code usin

• unix-cli · Skill · 192 stars

  UNIX command-line interface guidelines for building tools that follow POSIX conventions, proper exit codes, stream handling, and the UNIX philosophy. This

• vhs · Skill · 192 stars

  VHS terminal recording best practices from Charmbracelet (formerly charmbracelet-vhs). This skill should be used when writing, reviewing, or editing VHS ta

• vite · Skill · 192 stars

  Vite performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring Vite configuration and projects to ensure optim

• vitest · Skill · 192 stars

  Vitest testing framework patterns for test setup, async testing, mocking with vi.*, snapshots, and test performance (formerly test-vitest). This skill shou

• web-rules · Skill · 192 stars

  Strict design and UX rules for React 19 + Next.js 16 (App Router) + Tailwind CSS 4. Covers navigation, interaction design, accessibility, user feedback, UX

• web-taste · Skill · 192 stars

  Designs React 19 + Next.js 16 + Tailwind CSS experiences with real taste — starting from user goals, not pixels. Use this skill whenever the user asks you

• webpack-plugin-authoring · Skill · 192 stars

  Writing webpack 5 plugins — hook selection (compiler vs compilation, tap vs tapAsync, processAssets stages), the asset pipeline (emitAsset, source classes,

• webpack-plugin-recipes · Skill · 192 stars

  Use whenever you face a webpack-build problem that ends with needing to write a plugin — 26 production-shaped recipes covering bundle-size budgets, forbidd

• write-design-docs · Skill · 192 stars

  Write, revise, or review software design documents using Malte Ubl's "Design Docs at Google" guidance. Use when Codex needs to draft a design doc, technica

• wxt-browser-extensions · Skill · 192 stars

  WXT browser extension performance optimization guidelines. This skill should be used when writing, reviewing, or refactoring WXT browser extension code to

• yjs-nextjs · Skill · 192 stars

  Corrects the wrong defaults a capable model has when building Yjs collaborative editing into a Next.js 16 App Router app with tRPC v11 and shadcn/ui — pinn

• zod · Skill · 192 stars

  Zod schema validation best practices for type safety, parsing, and error handling. This skill should be used when defining z.object schemas, using z.string

• zustand · Skill · 192 stars

  Zustand state management best practices for React applications. Use when writing, reviewing, or refactoring Zustand stores to ensure optimal performance an

• mlflow-3 · Skill

  MLflow 3 (open-source, pinned to 3.15) for classic-ML MLOps — logging and registering models, promoting versions across dev/staging/prod, standing up a tra

• mlflow-mlops-migration · Skill

  Guided workflow for taking any ML codebase — including one with no experiment tracking at all, or one full of MLflow 2-era idioms — to a production-grade o

• ray · Skill

  Production Ray (open-source, pinned to 2.57) for classic-ML workloads from training to serving — Ray Train, Tune, Data, Serve, Core, and cluster deployment

• ray-llm · Skill

  LLM workloads on open-source Ray (pinned to 2.57) — OpenAI-compatible serving with ray.serve.llm (vLLM-backed LLMConfig + build_openai_app) and batch infer

Browse the @skills marketplace