Conventions
Coding standards and style guides for a language or framework, usually rules.
Download all 68
- HTTP API design rules
Rules for HTTP APIs covering resource naming, status codes, problem+json errors, cursor pagination, idempotency keys and versioning. Load when designing or changing HTTP endpoints.
- C# style rules
Standing rules for C# an assistant writes, covering nullable reference types, async all the way with cancellation tokens, records and pattern matching, dependency injection and xUnit tests.
- Go style rules
Standing rules for Go an assistant writes, covering wrapped errors, context propagation, small consumer-side interfaces, table-driven tests and no goroutines without an owner.
- Java style rules
Standing rules for Java an assistant writes, covering modern language features, immutability, Optional and null handling, exceptions, restrained streams, records and JUnit 5 tests.
- Python style rules
Standing rules for Python an assistant writes, covering type hints, pathlib, logging over print, explicit exceptions, safe subprocess calls, project layout and the project's own tooling.
- React component rules
Standing rules for React code an assistant writes, covering function components, the rules of hooks, colocated state, stable list keys, accessible markup and no effect-driven derived state.
- Rust style rules
Standing rules for Rust an assistant writes, covering ownership-first APIs, Result over panic, clippy-clean code, typed errors, async hygiene and minimal, justified unsafe.
- SQL style rules
Standing rules for SQL an assistant writes, covering formatting, naming, explicit column lists, parameterised queries, NULL handling, data types and safe migrations.
- Angular rules
Standing rules for Angular code covering standalone components, signals, OnPush change detection, typed reactive forms, RxJS without leaks, inject over constructor bloat, and lazy-loaded routes.
- Ansible rules
Standing rules for Ansible playbooks and roles covering idempotent modules over shell, FQCN names, variable precedence, vault for secrets, handlers, check mode and safe rollouts.
- ASP.NET Core rules
Standing rules for ASP.NET Core services covering thin endpoints, the options pattern, DI lifetimes, EF Core usage, ProblemDetails errors, validation, cancellation tokens and logging.
- Astro rules
Standing rules for Astro sites covering zero JavaScript by default, islands with the right client directive, content collections with schemas, images, routing and static versus server output.
- Audit a project's lint and formatter setup
Audits an existing lint and formatter setup for conflicting tools, disabled rules, inline suppressions, version drift and missing high-value rules, with a ranked cleanup plan.
- Set up a linter and formatter for a project
Sets up a linter and formatter for a project's stack with a sane rule set, editor integration, a CI check and a one-time format commit hidden from git blame.
- C++ style rules
Standing rules for modern C++ an assistant writes, covering RAII, no raw new or delete, const by default, value semantics, span and string_view at boundaries, and sanitizer-clean code.
- CSS and SCSS rules
Standing rules for hand-written CSS and SCSS covering design tokens as custom properties, low specificity, no !important, flex and grid layout, logical properties and shallow nesting.
- dbt rules
Standing rules for dbt projects covering staging, intermediate and mart layers, ref and source only, one grain per model, naming, tests and docs per model, and safe incremental models.
- Django rules
Standing rules for Django code covering app layout, where business logic lives, querysets without N+1, safe migrations, forms and validation, settings per environment and security defaults.
- Dockerfile rules
Standing rules for writing Dockerfiles covering pinned base images, multi-stage builds, cache-friendly layer order, non-root users, no secrets in layers, small images and signal handling.
- Electron rules
Standing rules for Electron apps covering context isolation, sandboxed renderers, a typed preload bridge, validated IPC, navigation limits, secure updates and main-process hygiene.
- Elixir style rules
Standing rules for Elixir an assistant writes, covering tagged tuples and with, pattern matching, supervised processes, no atoms from user input, Credo, Dialyzer and ExUnit tests.
- Embedded C rules
Standing rules for embedded C an assistant writes, covering fixed-width types, no heap after init, volatile registers, short interrupt handlers, checked errors and MISRA-style restraint.
- Error handling rules
Standing rules for error handling in code an assistant writes, covering no swallowed errors, added context, failing fast on bugs, retryable versus fatal, safe user messages and logging once.
- Express rules
Standing rules for Express APIs covering a router per resource, input validation at the edge, async error handling, one error middleware, security middleware, config and graceful shutdown.
- FastAPI rules
Standing rules for FastAPI services covering typed request and response models, dependency injection, async correctness, error responses, settings, background work and tests.
- Find inconsistent code patterns in a codebase
Finds places where a codebase solves the same problem several ways (errors, HTTP calls, config, dates, logging), proposes the house pattern for each and lists the outliers to migrate.
- Flask rules
Standing rules for Flask apps covering the app factory, blueprints, config per environment, no global state, SQLAlchemy session scope, input validation, CSRF and error handlers.
- Flutter rules
Standing rules for Flutter code covering widget composition, const constructors, a single state management approach, async and BuildContext safety, theming, accessibility and widget tests.
- GDScript rules
Standing rules for Godot 4 GDScript an assistant writes, covering static typing, signals over hard references, scene composition, physics in the physics step and exported tuning values.
- GitHub Actions rules
Standing rules for GitHub Actions workflows covering least-privilege permissions, actions pinned to SHAs, no untrusted input in run steps, safe triggers, concurrency, caching and timeouts.
- GraphQL schema rules
Standing rules for GraphQL schemas and resolvers covering naming, nullability, Relay connections, input and payload types, errors, deprecation, DataLoader against N+1 and query limits.
- HTML rules
Standing rules for the HTML an assistant writes, covering document basics, semantic elements, headings, forms and button types, images, links, tables and valid nesting.
- Infrastructure as code style rules
Standing rules for Terraform, OpenTofu and similar IaC, covering pinned providers and modules, no hard-coded secrets or IDs, tags on every resource, validated variables, small state and plan review.
- JavaScript style rules
Standing rules for plain modern JavaScript without TypeScript covering ES modules, const by default, strict equality, async error handling, JSDoc types and safe built-in use.
- Jetpack Compose rules
Standing rules for Jetpack Compose UI covering state hoisting, stable parameters, remember and effect APIs, modifier conventions, ViewModel boundaries, lazy lists and previews.
- Jupyter notebook rules
Standing rules for Jupyter notebooks covering top-to-bottom runs, a parameters cell, no hidden state, relative paths, logic moved to modules, pinned environments and clean commits.
- Kotlin style rules
Standing rules for Kotlin an assistant writes, covering null safety, immutability, coroutines with structured concurrency, and data and sealed classes.
- Kubernetes manifest rules
Standing rules for Kubernetes YAML covering requests and limits, probes, non-root securityContext, standard labels, pinned images, config and secrets, disruption budgets and rollouts.
- Laravel rules
Standing rules for Laravel code covering thin controllers, form requests, policies, Eloquent relations and eager loading, queues, config caching and feature tests.
- NestJS rules
Standing rules for NestJS services covering module boundaries, DTO validation, thin controllers, typed config, exception filters, guards for auth, safe database transactions and testing modules.
- Next.js rules
Standing rules for Next.js code covering server and client components, data fetching and caching, route handlers, metadata, images and fonts, environment variables and where code runs.
- pandas rules
Standing rules for pandas code covering vectorised operations, no chained assignment, explicit dtypes on load, method chaining, copy semantics, validated merges and missing data.
- Phoenix and LiveView rules
Standing rules for Phoenix and LiveView covering contexts as boundaries, thin LiveViews, mount and handle_params, streams for lists, assigns discipline, Ecto changesets and PubSub.
- PHP style rules
Standing rules for modern PHP an assistant writes, covering strict types, typed properties and returns, PSR-12 and PSR-4, exceptions over error codes, prepared statements and Composer hygiene.
- PowerShell style rules
Standing rules for PowerShell scripts and modules covering approved verbs, advanced functions, parameter validation, objects not text, ShouldProcess, error handling and portability.
- Prisma rules
Standing rules for Prisma code covering schema conventions, the migrate workflow, select over include, N+1 queries, transactions, raw SQL safety, error codes and one client per process.
- PySpark rules
Standing rules for PySpark jobs covering explicit schemas, the DataFrame API over Python UDFs, no collect on large data, partitioning, skew, broadcast joins, caching and idempotent writes.
- PyTorch rules
Standing rules for PyTorch code covering device-agnostic tensors, seeded runs, train and eval modes, no_grad inference, DataLoader settings, full checkpoints, shape comments and mixed precision.
- Ruby on Rails rules
Standing rules for Rails code covering conventions, strong parameters, restraint with callbacks, eager loading, deploy-safe migrations, background jobs and request specs.
- React Native rules
Standing rules for React Native code covering platform-specific files, list performance, navigation, native module boundaries, permissions, secure storage and testing on real devices.
- Ruby style rules
Standing rules for plain Ruby an assistant writes, covering RuboCop-clean code, small objects, explicit errors, frozen string literals, safe metaprogramming limits and RSpec or Minitest tests.
- Scala style rules
Standing rules for Scala an assistant writes, covering immutability, Option and Either over null and exceptions, exhaustive ADTs, restrained implicits, one effect system and scalafmt.
- Settle a coding convention dispute
Settles a recurring team argument about a coding convention by laying out each option's real costs, recommending one, and writing the decision record, the enforcement and the migration plan.
- Shell script rules
Standing rules for Bash and POSIX shell an assistant writes, covering strict mode, quoting every expansion, no parsing of ls, mktemp with trap cleanup, ShellCheck-clean code and a usage message.
- Solidity rules
Standing rules for Solidity smart contracts covering checks-effects-interactions, reentrancy guards, access control, custom errors, pinned compiler, events, safe token calls and upgrade safety.
- Spring Boot rules
Standing rules for Spring Boot services covering package structure, constructor injection, typed configuration, transaction boundaries, error responses, actuator and slice tests.
- Supabase rules
Standing rules for Supabase apps covering RLS on every table, tested policies, keys kept out of clients, typed generated clients, migrations in the repo, storage policies and edge function secrets.
- Svelte and SvelteKit rules
Standing rules for Svelte and SvelteKit code covering runes or stores consistently, load functions, form actions, server-only code and secrets, progressive enhancement and accessible components.
- Swift style rules
Standing rules for Swift an assistant writes, covering value types, optionals without force unwraps, structured concurrency, access control and API Design Guidelines naming.
- SwiftUI rules
Standing rules for SwiftUI code covering small views, clear state ownership, no work in body, NavigationStack routing, lists and identity, previews and accessibility.
- Symfony rules
Standing rules for Symfony apps covering autowired services, thin controllers, Doctrine repositories and migrations, forms and validator constraints, Messenger, voters and config.
- Tailwind CSS rules
Standing rules for Tailwind CSS covering design tokens in the theme, class ordering, extracting components instead of repeated class strings, responsive and dark variants and visible focus states.
- Tauri rules
Standing rules for Tauri 2 apps covering minimal capabilities and permissions, typed commands, async Rust handlers, errors across IPC, state, secrets and signed updates.
- TypeScript strict rules
Keeps TypeScript code fully type-safe under strict mode, with no any, no unchecked casts, validated external data and exhaustive unions. Use in any TypeScript project.
- Unity C# rules
Standing rules for Unity C# scripts covering serialized private fields, lifecycle order, no per-frame allocations or Find calls, ScriptableObjects for data, physics timing and null checks.
- Vue and Nuxt rules
Standing rules for Vue and Nuxt code covering the Composition API, typed props and emits, reactivity pitfalls, composables, stores and server versus client rendering in Nuxt.
- Write a custom lint rule for a team convention
Writes a custom lint rule (ESLint, Semgrep, Roslyn, golangci-lint, RuboCop and similar) that enforces a team convention, with a safe autofix where possible and passing and failing tests.
- Write a team coding standards document
Drafts a team's coding standards from its actual code, lint config and review comments, splitting what tools enforce from what needs judgement, with a reason and example for every rule.
Rules with a single subject go to that subject (commit rules go to git).