hermes

Start here 1

The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.

Search and filter in Conventions
  • 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.

Specific 65

One situation, audience, tool or format inside the category. Example: Plan a road trip with children.

  • 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.

  • 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.

  • 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.

  • FastAPI rules

    Standing rules for FastAPI services covering typed request and response models, dependency injection, async correctness, error responses, settings, background work and tests.

  • 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.

  • Kotlin style rules

    Standing rules for Kotlin an assistant writes, covering null safety, immutability, coroutines with structured concurrency, and data and sealed classes.

  • Laravel rules

    Standing rules for Laravel code covering thin controllers, form requests, policies, Eloquent relations and eager loading, queues, config caching and feature tests.

  • 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.

  • 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.

  • Spring Boot rules

    Standing rules for Spring Boot services covering package structure, constructor injection, typed configuration, transaction boundaries, error responses, actuator and slice tests.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

Showing 50 of 65. See them all in search

Advanced 2

Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.

  • 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.

  • 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.

Rules with a single subject go to that subject (commit rules go to git).