agentleFS
learntocloudlearntocloud/learn-to-cloud-app/.github/copilot-instructions.md

learn-to-cloud-app

Copilot instructions1.1k starsChanged 59 days agoMITView on GitHub

Never edit, commit, or stage directly to main. Check the current branch before doing anything. If on main, create a branch using fix/ for bug fixes, feat/ for features, chore/ for maintenance or docs, or refactor/ for restructuring. Commit, push, and open a pull request only when requested. Use the ship-it skill for the delivery workflow. Merging requires explicit authorization. Never force-push to main; report Git errors rather than rewriting history. Keep docstrings short and useful. One line is enough…

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

  • In this repository9 other files it gives its agents.

The file

Show its rules and text

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

19 rules. About 1 is common, 13 are distinctive, and 5 are very specific to this project.

  • ≈1

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈13

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 5

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Never edit, commit, or stage directly to main.

    line 5
  2. Very specific:

    Check the current branch before doing anything.

    line 7
  3. Very specific:

    Commit, push, and open a pull request only when requested.

    line 11
  4. Common:

    Never force-push to main; report Git errors rather than rewriting history.

    line 13
  5. Distinctive:

    Keep docstrings short and useful.

    line 17
  6. Distinctive:

    Don't restate the function name or parameters when they're obvious

    line 19
  7. Distinctive:

    Don't document implementation history ("removed X", "no longer uses Y")

    line 20
  8. Very specific:

    Don't add Args: / Returns: blocks when the types and names are self-explanatory

    line 21
  9. Distinctive:

    Only comment code that needs clarification — skip the obvious

    line 22
  10. Distinctive:

    Don't silence linters, type checkers, or tests just to make a warning go away.

    line 26
  11. Very specific:

    Don't add # noqa, # type: ignore, try/except: pass, or rule exclusions to make CI green.

    line 27
  12. Distinctive:

    If a real fix would require a bigger refactor, don't quietly patch around the symptom instead.

    line 28
  13. Very specific:

    Run targeted checks during development.

    line 32
  14. Distinctive:

    Default to short, plain, direct output.

    line 40
  15. Distinctive:

    No structural padding for short answers: no headers, no bold labels, no scaffolding, no 'in short' or 'to summarize', just answer the …

    line 42
  16. Distinctive:

    Don't teach or give multiple framings unless asked.

    line 44
  17. Distinctive:

    Write PR descriptions in plain language.

    line 48
  18. Distinctive:

    Avoid unexplained jargon. If a technical term is necessary, define it immediately with a concrete explanation.

    line 51
  19. Distinctive:

    If you need to research something that is Azure related always use the azure-skills plugin.

    line 56

≈ “Common” is an estimate: at least 1 in 5 of the 3,779 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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
copilot-instructions.md

Copilot Instructions

Branching

Never edit, commit, or stage directly to main.

Check the current branch before doing anything. If on main, create a branch using fix/ for bug fixes, feat/ for features, chore/ for maintenance or docs, or refactor/ for restructuring.

Commit, push, and open a pull request only when requested. Use the ship-it skill for the delivery workflow. Merging requires explicit authorization. Never force-push to main; report Git errors rather than rewriting history.

Code Comments and Docstrings

Keep docstrings short and useful. One line is enough for most functions.

  • Don't restate the function name or parameters when they're obvious
  • Don't document implementation history ("removed X", "no longer uses Y")
  • Don't add Args: / Returns: blocks when the types and names are self-explanatory
  • Only comment code that needs clarification — skip the obvious

No Hacks or Bandaids

  • Don't silence linters, type checkers, or tests just to make a warning go away. If a rule fires, either the code is wrong (fix the code) or the rule doesn't fit the codebase (have an explicit, justified discussion before excluding it).
  • Don't add # noqa, # type: ignore, try/except: pass, or rule exclusions to make CI green. Same applies to inserting "make the warning happy" code that wouldn't otherwise belong.
  • If a real fix would require a bigger refactor, don't quietly patch around the symptom instead. Tell the user and let them choose.

Quality Gates

Run targeted checks during development. uv run poe check must pass before pushing, no exceptions. Run additional checks when changing their inputs. Task definitions live in pyproject.toml; see Quality Gates for check selection and API smoke testing.

Communication

  • Default to short, plain, direct output. Answer in the fewest words that fully address what was asked.
  • Skip filler, hedging, and pleasantries ("happy to help", "sure!", "let me just...").
  • No structural padding for short answers: no headers, no bold labels, no scaffolding, no 'in short' or 'to summarize', just answer the question directly.
  • Answering a question is not permission to be verbose. Lead with the direct concise answer. Add detail only if asked for additional context or explanation.
  • Don't teach or give multiple framings unless asked.

Pull Request Descriptions

  • Write PR descriptions in plain language.
  • Concisely describe the change, why it is needed, and what effect it has.
  • Lead with what changes, why it is needed, and what effect it has.
  • Avoid unexplained jargon. If a technical term is necessary, define it immediately with a concrete explanation.
  • Describe rollout states plainly. For example, say "the alert is evaluated but sends no notifications" instead of relying on "shadow mode."

Research

If you need to research something that is Azure related always use the azure-skills plugin.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.