We split this copilot-instructions.md into the rules it gives an agent

47 rules. About 1 is common, 24 are distinctive, and 22 are very specific to this project.

• ≈1

  Common · estimate

  Many files like this have a rule of this kind.

• ≈24

  Distinctive · estimate

  This author's own choices. Worth a look.

• 22

  Very specific

  Tied to their project's names, files or tools. Probably skip.

• Common
• Distinctive
• Very specific

1. Distinctive:

   Write code that is accessible, performant, type-safe, and maintainable.

   line 21
2. Distinctive:

   Use explicit types for function parameters and return values when they enhance clarity

   line 25
3. Very specific:

   Prefer unknown over any when the type is genuinely unknown

   line 26
4. Very specific:

   Use const assertions (as const) for immutable values and literal types

   line 27
5. Distinctive:

   Use meaningful variable names instead of magic numbers - extract constants with descriptive names

   line 29
6. Distinctive:

   Use arrow functions for callbacks and short functions

   line 33
7. Very specific:

   Prefer for...of loops over .forEach() and indexed for loops

   line 34
8. Very specific:

   Use optional chaining (?.) and nullish coalescing (??) for safer property access

   line 35
9. Distinctive:

   Prefer template literals over string concatenation

   line 36
10. Distinctive:

    Use destructuring for object and array assignments

    line 37
11. Very specific:

    Use const by default, let only when reassignment is needed, never var

    line 38
12. Very specific:

    Always await promises in async functions - don't forget to use the return value

    line 42
13. Very specific:

    Use async/await syntax instead of promise chains for better readability

    line 43
14. Distinctive:

    Don't use async functions as Promise executors

    line 45
15. Distinctive:

    Use function components over class components

    line 49
16. Distinctive:

    Call hooks at the top level only, never conditionally

    line 50
17. Very specific:

    Use the key prop for elements in iterables (prefer unique IDs over array indices)

    line 52
18. Distinctive:

    Don't define components inside other components

    line 54
19. Distinctive:

    Use semantic HTML and ARIA attributes for accessibility:

    line 55
20. Distinctive:

    Use proper heading hierarchy

    line 57
21. Distinctive:

    Add labels for form inputs

    line 58
22. Very specific:

    Use semantic elements (<button>, <nav>, etc.) instead of divs with roles

    line 60
23. Very specific:

    Remove console.log, debugger, and alert statements from production code

    line 64
24. Very specific:

    Use try-catch blocks meaningfully - don't catch errors just to rethrow them

    line 66
25. Common:

    Prefer early returns over nested conditionals for error cases

    line 67
26. Distinctive:

    Keep functions focused and under reasonable cognitive complexity limits

    line 71
27. Distinctive:

    Use early returns to reduce nesting

    line 73
28. Distinctive:

    Prefer simple conditionals over nested ternary operators

    line 74
29. Very specific:

    Add rel="noopener" when using target="_blank" on links

    line 79
30. Very specific:

    Avoid dangerouslySetInnerHTML unless absolutely necessary

    line 80
31. Very specific:

    Don't use eval() or assign directly to document.cookie

    line 81
32. Distinctive:

    Avoid spread syntax in accumulators within loops

    line 86
33. Distinctive:

    Use top-level regex literals instead of creating them in loops

    line 87
34. Distinctive:

    Prefer specific imports over namespace imports

    line 88
35. Distinctive:

    Avoid barrel files (index files that re-export everything)

    line 89
36. Very specific:

    Use proper image components (e.g., Next.js <Image>) over <img> tags

    line 90
37. Very specific:

    Use Next.js <Image> component for images

    line 95
38. Very specific:

    Use next/head or App Router metadata API for head elements

    line 96
39. Distinctive:

    Use Server Components for async data fetching instead of async Client Components

    line 97
40. Very specific:

    Use ref as a prop instead of React.forwardRef

    line 100
41. Very specific:

    Use class and for attributes (not className or htmlFor)

    line 103
42. Very specific:

    Write assertions inside it() or test() blocks

    line 109
43. Distinctive:

    Avoid done callbacks in async tests - use async/await instead

    line 110
44. Very specific:

    Don't use .only or .skip in committed code

    line 111
45. Very specific:

    Keep test suites reasonably flat - avoid excessive describe nesting

    line 112
46. Distinctive:

    Meaningful naming: - Use descriptive names for functions, variables, and types

    line 119
47. Distinctive:

    Documentation: - Add comments for complex logic, but prefer self-documenting code

    line 123

≈ “Common” is an estimate: at least 1 in 5 of the 3,669 Copilot instructions files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

• Where files are headingNew Copilot instructions files have more rules about branches and pull requests, and fewer about code style.

  Of the Copilot instructions files we read, the 2,297 first seen in the last six months, against the older ones: the kind of rule that gained most share, and the kind that lost most. About files like this in general, not this one, and an estimate, since a kind is a pattern in the words.