Development Claude Skills
8 676 development skills from 759 authors. They write and change code. Half of them fit into 1 830 tokens or less — that is what one costs your context window when the agent loads it. 1 213 ship runnable scripts rather than instructions alone. 42 of them cannot work without an MCP server, most often rube. We also found 1 172 copies of these same skills sitting in other people's repositories — counted once here, not 1 172 times.
8 676 unique 759 authors 5 252 updated this month 1 369 from vendors
Python asyncio - Modern concurrent programming with async/await, event loops, tasks, coroutines, primitives, aiohttp, and FastAPI async patterns
Django full-featured Python web framework with batteries included (ORM, admin, auth)
Python code-quality anti-patterns and review checks: exception-hierarchy correctness, singleton identity comparison, narrow exception handling, wildcard-import avoidance, magic-number naming, and dead-local removal. Use when reviewing or self-reviewing Python code for correctness and readability defects that linters and reviewers should catch.
Flask - Lightweight Python web framework for microservices, REST APIs, and flexible web applications with extensive extension ecosystem
mypy - Static type checker for Python with gradual typing, strict mode, Protocol support, and framework integration
Pyright fast Python type checker from Microsoft with VS Code integration and strict type checking modes
Python data validation using type hints and runtime type checking with Pydantic v2's Rust-powered core for high-performance validation in FastAPI, Django, and configuration management.
Build production Rust CLIs with Clap: subcommands, config layering, validation, exit codes, shell completions, and testable command surfaces
Axum (Rust) web framework patterns for production APIs: routers/extractors, state, middleware, error handling, tracing, graceful shutdown, and testing
Build cross-platform desktop applications with Rust using Tauri framework and native GUI alternatives
ONNX Runtime in Rust via the `ort` crate (2.x): loading sessions, configuring CPU/CoreML/CUDA execution providers, tensor I/O with ndarray, async-safe spawn_blocking wrapping, global thread-pool init, and debugging provider/opset issues
PM-invocable protocol for running and interpreting Rust quality gates in the trusty-tools monorepo: fmt, clippy, and test in strict sequence before any merge
PM-invocable protocol for Cargo publish and release operations in the trusty-tools Rust monorepo: semver rules, 10-step release sequence, macOS codesign safety, and cross-crate dependency ordering
tRPC end-to-end type-safe APIs for TypeScript with React Query integration and full-stack type safety
Type-safe SQL ORM for TypeScript with zero runtime overhead
Production Fastify (TypeScript) patterns: schema validation, plugins, typed routes, error handling, security hardening, logging, testing with inject, and graceful shutdown
Node.js backend development with TypeScript, Express/Fastify servers, routing, middleware, and database integration
TanStack Query (React Query) for asynchronous server-state management with automatic caching, background refetching, optimistic updates, and pagination in React applications.
Minimal, unopinionated state management library for React with simple hook-based API, no providers, and minimal boilerplate for global state without Redux complexity.
Jest with TypeScript - Industry standard testing framework with 70% market share, mature ecosystem, React Testing Library integration
Advanced TypeScript patterns and best practices for 2025
TypeScript-first schema validation library with static type inference for form validation, API validation, and runtime type checking with compile-time types.
Headless UI - Unstyled, fully accessible UI components for React and Vue with built-in ARIA patterns
shadcn/ui component library for React with Tailwind CSS - copy-paste accessible components with full code ownership
Dependency audit and cleanup workflow for maintaining healthy project dependencies. Use for regular maintenance, security updates, and removing unused packages.
Homebrew formula maintenance workflows for Python CLIs and taps, including version bumps, SHA/resource updates, testing, audits, and releases.
API security checklist for reviewing endpoints before deployment. Use when creating or modifying API routes to ensure proper authentication, authorization, and input validation.
Compare tradeoffs and recommend architectural patterns — dependency injection, service-oriented architecture, repository, domain events, circuit breaker, and anti-corruption layer. Use when choosing between design patterns, planning microservices boundaries, evaluating system design alternatives, or asking 'which pattern should I use' for a specific coupling or resilience problem.
Reliably drive the GitHub gh CLI for issue, PR, and label operations in automation and subagent environments, with pre-flight verification so you never fabricate a success or a fake issue URL.
Essential Git patterns for effective version control, eliminating redundant Git guidance per agent.
Use git worktrees for parallel development on multiple branches simultaneously
Create detailed implementation plans with bite-sized tasks for engineers with zero codebase context
Environment variable validation, security scanning, and management for Next.js, Vite, React, and Node.js applications
Six-stage quality-gate pipeline for any code implementation task
Comprehensive API design patterns covering REST, GraphQL, gRPC, versioning, authentication, and modern API best practices
Best practices for documenting APIs and code interfaces, eliminating redundant documentation guidance per agent.
> layering, separation of concerns, domain modeling, and module boundaries. Use when reviewing architecture, designing package layout, evaluating dependency graphs, or refactoring monoliths into modules. "dependency direction", "clean architecture Go", "module boundaries". Do NOT use for code-level style (use go-coding-standards) or API endpoint design (use go-api-design).
> discipline, exit codes, signal handling, and when Cobra/Viper earn their weight over the standard library. "handle Ctrl+C", "cobra command", "read from stdin", "CLI UX". in general (use go-project-layout), or configuration of services (use go-architecture-review).
> REST and gRPC API design patterns for Go services. Covers HTTP handlers, middleware, routing, request/response patterns, versioning, pagination, graceful shutdown, and OpenAPI documentation. Use when designing APIs, writing HTTP handlers, implementing middleware, structuring REST endpoints, or setting up gRPC services. "middleware pattern", "graceful shutdown", "gRPC service", "API versioning". Do NOT use for general architecture (use go-architecture-review) or concurrency in handlers (use go-concurrency-review).
> interface compliance verification, composition, the accept-interfaces-return-structs principle, and common pitfalls. Use when designing interfaces, decoupling packages, defining contracts, reviewing interface usage, or refactoring for testability. "interface compliance", "consumer-side interface", "interface composition". Do NOT use for HTTP handler patterns (use go-api-design) or general code review (use go-code-review).
> global state, and when frameworks (wire, fx, dig) earn their complexity. "remove global state", "singleton in Go", "use google/wire", "uber fx", "make this testable". project directory structure (use go-project-layout), or test doubles and mocks (use go-test-quality).
> Example functions, deprecation notices, and doc links. "add examples to docs", "deprecate a function", "package documentation", "improve the docs". guides (plain writing task), or code style rules (use go-coding-standards).
> Modernize Go code to use current language features and standard library additions. Covers generics, log/slog, errors.Join, slices/maps packages, range-over-func, and iterators introduced in Go 1.21-1.23+. "upgrade Go version", "slog", "errors.Join", "range over func", "iterators". error handling philosophy (use go-error-handling), or logging architecture (use go-observability).
> sync primitives, context propagation, and goroutine lifecycle management. Use when writing concurrent code, reviewing async patterns, checking thread safety, debugging race conditions, or designing producer/consumer pipelines. "channel patterns", "sync.Mutex", "context cancellation", "goroutine leak". Do NOT use for general code style (use go-coding-standards) or HTTP handler patterns (use go-api-design).
> Structured git commit messages following Conventional Commits format for Go projects. Generates well-scoped, atomic commits with clear descriptions. Use when committing changes, writing commit messages, preparing PRs, or reviewing commit history quality. "prepare PR", "squash commits". Do NOT use for changelog generation (use changelog-generator) or code review (use go-code-review).
> vulnerabilities, review go.mod hygiene, identify unused or redundant deps, and evaluate dependency quality. Use when auditing dependencies, checking for CVEs, cleaning up go.mod, upgrading modules, or evaluating third-party packages. "update modules", "vulnerability scan", "govulncheck". Do NOT use for code-level security issues (use go-security-audit) or architecture review (use go-architecture-review).
> renames, extracting packages, breaking circular dependencies, and strangler migrations — always behind green tests. "break this circular dependency", "split this god package", "migrate callers", "clean up without changing behavior". adopting new language features (use go-modernize), or performance rewrites (use go-performance-review).
> Navigate and analyze Go codebases semantically with the toolchain instead of go list for the dependency graph, and go doc for APIs. used", "trace the dependency graph", "explore this codebase", "find usages before changing", "map the module". judging the architecture found (use go-architecture-review), or documentation writing (use go-documentation).