• No LLM by default
  • No API key
  • Zero dependencies
  • MIT

AI yaps, we cut

Pull requests written like the good old days

Your agent writes the code. buzzcut makes the commits and PRs it writes say what changed and why, in plain words, so reviewers read the PR itself instead of asking another AI to explain it.

npm i -g buzzcut && buzzcut setup

Claude Code · Cursor · Windsurf · Antigravity · VS Code · Codex · any terminal

01 Try it

See your PRs the way reviewers do

Paste a public pull request. buzzcut checks that it says what changed and why, and marks everything a reviewer would skim past. Paste a repo to rank its last merged PRs. It all runs in your browser.

Or pick one of three made-up PRs

    02 The problem

    Nobody should need an AI to read a pull request

    Senior engineers keep saying it: AI-written PRs are hard to read. Headers on a nine-line fix, a bold label on every bullet, a tour of files the diff already shows. So reviewers paste them into another chatbot to find out what changed. A PR should just say it, the way good ones always did.

    0 words
    acme/api · PR #482 · 9 changed lines

    What we found in 1,275 real PRs opened by coding agents this year

    • 20%Never say why
    • 16%More bullets than the change deserves
    • 16%A bold label on every line
    • 6%A tour of files the diff already shows
    • 4%A full template on a small diff

    PRs from Claude Code, Copilot, Cursor, Devin, Jules, Amp and Codex. The data and the script are in bench/.

    03 How it works

    Install once, then just say push it

    Whatever agent you use keeps writing the code, the commit and the PR. buzzcut reads each one before it runs and sends back anything a reviewer would struggle with, with the exact fix. You don't do anything.

    your editor · agent chat
      1. 1

        It writes it right the first time

        Before writing, the agent asks buzzcut what changed: which files, how big the change is, how long the description should be, and how this repo writes its commits.

      2. 2

        It checks before anything runs

        Every git commit, gh pr create and GitHub tool call is read against the diff before it runs. A form on a tiny change, a subject that says nothing, or tests claimed that never ran goes back with the fix. A name, file or number it can't find comes back as a note.

      3. 3

        It cuts yap, never facts

        A rewrite that drops numbers, error messages, issue links or file:line pointers is sent back with the list of what went missing. Short means no padding, not fewer facts.

      Sent back to the agent

      • Subjects that say nothing: "fix bug", "wip", "Update webhook.js"
      • A full Summary / Changes / Testing form on a small diff
      • A commit body that lists every change as bullets
      • Tests claimed that were never added or run, or a test count that isn't what the run printed
      • A rewrite that quietly dropped facts

      A note, never a block

      • A bit long, a few extra bullets, a buzzword
      • No reason given on a larger change
      • A name, file or number it can't find in the diff, the repo or the session
      • "Added" instead of "Add", and it follows your repo's tense
      • Anything a person writes. People only ever get a warning.

      04 For teams

      Put it on every repo your team reviews

      Readable PRs matter most to the people reviewing them. Start with your own machine, commit it to a repo, or check every pull request in your org, including ones from people and agents that never installed anything.

      Your machine

      Every repo, every agent

      Git hooks for every repo and the skill for every coding agent it finds. buzzcut setup --uninstall puts it all back.

      npm i -g buzzcut && buzzcut setup

      One repo

      The whole team, the same rules

      Writes the hooks and the skill into the repo. Commit them and every teammate's agent follows the same rules. Nobody gets locked out if they don't have it.

      npx buzzcut init

      Every PR in your org

      The GitHub Action

      Checks each PR description and its commits, keeps one comment up to date, and fails the check only when something is sent back on a coding agent's PR. A person's PR gets the comment and a warning. Full workflow

      uses: Shiva-Xs/buzzcut@v0

      Works with Claude Code · Cursor · Windsurf · Antigravity · VS Code + Copilot · Codex · Gemini CLI · any terminal

      05 Proof

      Tested on real pull requests, from before AI and after

      Two tests. buzzcut's checks ran on every PR and commit we downloaded, including work merged between 2018 and May 2021 in 75 projects, from kubernetes and rust to cpython and the Linux kernel: anything flagged there counts as a false alarm. Then a model wrote descriptions for real PRs with and without buzzcut's rules, and a blind grader compared them.

      3,366real PRs and commits buzzcut's checks ran on, 1,275 of them opened by coding agents
      0 of 167commits from before AI were sent back
      49 of 64descriptions where buzzcut's 0.3 tool ranked above a good plain prompt, blind-graded, on PRs from repos it was never tuned on
      30 of 30times a blind judge preferred buzzcut's version of a real agent PR over the agent's original (the original skill, 0.1)

      Data, scripts and every judged pair: bench/ and bench/eval/corpus/

      06 FAQ

      Questions teams ask first

      Something else? Open an issue and ask.

      Is this an AI detector?

      No. It flags patterns, not authors. A person who writes "leverage" gets the same note as a model that does, and no roast ever names who wrote it.

      Does it use an LLM or send my code anywhere?

      Not by default. The checks are deterministic and run on your machine in tens of milliseconds per hook call. The only network calls go to GitHub, when you roast a PR or run the Action. The Action has an optional AI check you turn on with your own API key; it is off by default and only advises.

      What does it check against the diff?

      The files that changed, the changed lines, the repo as it stood and what your agent ran. That sizes the description, catches a file-by-file tour or a feat: on a docs-only change, and looks up the names, files and test counts a description cites; one it can't find is shown as a note. It can't tell whether what you say the code does is true.

      Will it block my team?

      Coding agents get sent back with the fix. People only ever get a warning, unless you set "block": "always", and a teammate without buzzcut can always commit.

      Does it make agents write "What" and "Why" headings?

      No. It asks for the PR a good engineer writes: an opening that says what changed and why in plain words, a few bullets for the changes a reviewer would ask about, and what you ran if you ran something. On a small change, headings like "## Summary / ## Changes / ## Notes" count as a form; on a big one, a few short plain headers are fine.

      How do I undo it?

      buzzcut setup --uninstall puts every hook, skill and setting back exactly as it was.

      Keep the agent,
      lose the yap

      npm i -g buzzcut && buzzcut setup

      No API key, zero dependencies, MIT.