typescript
javascript
python
go
rust
javaPopular Rules
30+ community-ranked rules
Prefer small, focused functions under 30 lines. Extract helpers when logic grows.
Saving the agent time by explicitly stating a specific function length preference (under 30 lines) that requires inferring from code patterns otherwise.
Use TypeScript strict mode with `strict: true` in `tsconfig.json` — enables `strictNullChecks`, `noImplicitAny`, and other safety checks.
This belongs in tsconfig.json (`strict: true`), not in agent instructions.
Use `readonly` for arrays and properties that should not be mutated.
Saving the agent time on consistently applying TypeScript immutability best practices without needing to infer from scattered code examples.
Use discriminated unions for state management over boolean flags.
Saving the agent time by explicitly enforcing a TypeScript best practice for state management that requires code pattern recognition across files.
Use Google-style JSDoc docstrings for every public module, class, function, and method.
Documentation formatting should be enforced by static analysis tools like eslint-plugin-jsdoc rather than relying on AI instructions.
In tests, start only the components under test using `component/system-using` to limit startup overhead and isolate the system under test.
Saves time by recommending component/system-using to limit component startup in tests to only the components under test.
Follow PSR-12 coding style. Use `camelCase` for methods, `PascalCase` for classes, `UPPER_CASE` for constants.
This belongs in a php-cs-fixer config with 'PSR-12' ruleset or PHP_CodeSniffer with PSR12 standard, not in agent instructions.
Provide `mytype_create()` and `mytype_destroy()` functions for allocation and cleanup — callers never call `malloc`/`free` on opaque types.
Saving the agent from reading multiple header and source files to infer the required create/destroy pattern for opaque types.
If you're unsure whether to use `interface` or `type`, prefer `interface` for object shapes (extendable) and `type` for unions, intersections, and computed types.
Saves the agent time from scanning multiple code files to infer the conditional preference for interface vs type in TypeScript.
Use plan mode for verification steps, not just building
Adds minimal value over the 0922494eee667d5d rule as it restates plan mode use without distinct actionable guidance.
Use `satisfies` operator for type validation without widening: `const config = { ... } satisfies Config`.
Saves the agent time by directly specifying the `satisfies` operator pattern for TypeScript type validation without widening, which it could learn from docs but benefits from explicit guidance.
Validate all external inputs at system boundaries. Trust nothing from users, APIs, or files.
Saves time by specifying all three untrusted input sources (users, APIs, files) as requiring validation at system boundaries.
Declare opaque types as `typedef struct MyType MyType;` in public headers — define the struct only in the `.c` implementation file.
Saving the agent from reading multiple header and .c files to infer the exact opaque type declaration pattern.
Use template literal types for string pattern validation: `type Route = \`/${string}\``.
Saving the agent time by specifying the exact preferred TypeScript template literal type pattern for string validation like routes, which it could infer from codebase examples but not standard configs.
Follow Ruby community conventions: `snake_case` for methods and variables, `PascalCase` for classes and modules.
For TypeScript: Only write Vitest tests when resolving a specific user issue or upon explicit request.
Design a minimal, intuitive public API. Every exported symbol is a commitment — keep the surface area small.
Avoid N+1 query patterns — use batch loading, JOINs, or DataLoader patterns.
Prefer `Array.from()`, `.map()`, `.filter()`, `.reduce()` over manual loops for data transformation.
Preference for functional array methods over manual loops is standard modern JavaScript practice an agent applies automatically.
Prefer `unknown` over `any` — it forces type narrowing before use and catches bugs at compile time.
Enforce preferring `unknown` over `any` with a linter rule like ESLint `@typescript-eslint/no-explicit-any` or Biome `noExplicitAny`, not in agent instructions.
Use `WeakMap`/`WeakSet` for caching references that should not prevent garbage collection.
Saves the agent time by directly specifying the precise WeakMap/WeakSet pattern for memory-safe caching instead of reasoning through alternatives like Map/Set.
If a type is used across more than 2 files, move it to a shared `types/` directory. If it's only used locally, co-locate it.
Saving the agent from analyzing type usage across files to infer the exact threshold of more than 2 files for shared types directory placement.
Keep schema definitions close to the domain — one schema file per module or feature.
Recommends domain-colocation of Drizzle schema files, encoding a project organization decision that prevents agents from defaulting to a single monolithic schema file.
Write rules for yourself that prevent the same mistake
This belongs in automated testing or linting pipelines, not in agent instructions.
Use `interface` for object shapes that may be extended and `type` for unions, intersections, and mapped types.
Saving the agent from having to discover the preferred TypeScript interface vs type convention from the handbook or existing code patterns.
Use strict types: declare `declare(strict_types=1)` at the top of every PHP file — it prevents silent type coercion in function arguments.
Avoid `any` — use `unknown` with type guards when the type is truly unknown.
Avoiding `any` belongs in an ESLint (@typescript-eslint/no-explicit-any) or Biome (typescript/noExplicitAny) rule instead.
If a function can fail, return a discriminated union (`{ ok: true; data: T } | { ok: false; error: E }`) instead of throwing — callers are forced to handle both cases.
The agent cannot infer the non-standard convention of using specific discriminated unions instead of throwing exceptions, which contradicts common TypeScript/JavaScript defaults.
Prefer `var` when type is apparent from context.
Enforce `var` usage via `.editorconfig` (`csharp_style_var_when_type_is_apparent = true`) rather than relying on an agent rule.
Use PHP 8.2+ features: readonly classes, enums, named arguments, fibers, union/intersection types.
Saves the agent time by explicitly directing use of specific PHP 8.2+ features rather than defaulting to older compatible syntax after detecting the version from composer.json.
Have a rule that helps your AI coding agent? Share it with the community.
Suggest a Rule