How to Proofread GitHub Comments and PR Descriptions Without Changing Code

GitHub comment boxes contain Markdown source, not formatted prose. That makes them one of the riskier places to run an automatic correction — and one of the places where a typo costs the most credibility.

By Raheel Ashraf10 min read

Tested October 2026 on Chrome, Edge and Firefox (Windows 11)

Add to Chrome

Free · works in Chrome, Edge and Firefox

On this page

The short answer

GitHub issue comments, PR descriptions and review comments are all plain textarea fields, so you can correct them with a browser extension. The catch is that those fields contain Markdown source, including code you do not want touched.

The reliable workflow is to keep prose and code separate. Write the prose part in the textarea, run the correction, read the popup line by line for anything that changed inside a code fence or an inline identifier, and only then Apply. If the description is code-heavy, draft the prose in a scratch tab instead and paste the final Markdown into GitHub.

Which GitHub editors work

GitHub has several different editors, and they are not all the same kind of field. We tested each separately in October 2026 on current stable Chrome, Edge and Firefox under Windows 11.

Field-by-field results on github.com
EditorWorksNotes
Issue comment boxYesPlain textarea containing Markdown source.
New issue bodyYesTextarea. Issue forms may also render separate input fields, which work individually.
PR description ('Add a description')YesTextarea. The same field is used when editing an existing description.
PR review comment (single-line and multi-line)YesTextarea. Multi-line comments attach to a diff range, which the extension does not see or affect.
Commit message box on the web editorYesTextarea. Worth correcting — commit messages are permanent.
github.dev web editor code paneNoA Monaco editor instance, not a form field. Do not try to grammar-check source code.
Wiki page editorYesTextarea in Markdown mode. The rich-text WYSIWYG mode behaves differently and is not worth relying on.
GitHub Desktop / CLI / IDE integrationsNoNot a browser. Nothing an extension can reach.

Tested October 2026 on current stable Chrome, Edge and Firefox, Windows 11.

The safe workflow for a PR description

  1. Write the prose sections first, without code

    Get 'What changed', 'Why' and 'How to test' written in plain sentences. Leave placeholders where the code blocks will go.

  2. Click the One Shot Fix toolbar icon

    The extension is invoked from the browser toolbar only. In Chrome and Edge, pin it from the puzzle-piece menu if it is hidden. In Firefox, use Customize Toolbar.

    There is no keyboard shortcut and no GitHub-specific right-click item, so you cannot trigger it from inside the editor.

  3. Read the popup output line by line

    The popup shows corrected plain text with no diff highlighting. Scan for three things: anything inside backticks that changed, any hyphen or dash at the start of a line that changed, and any URL that changed.

  4. Click Apply

    The corrected Markdown replaces the textarea contents. Nothing is submitted — you still click 'Create pull request' or 'Comment' yourself.

  5. Paste your code blocks in last

    Adding code after the correction pass means the code never went through it. This is the single most effective habit for avoiding corrupted snippets.

  6. Use GitHub's Preview tab

    Before submitting, switch to Preview. A correction that quietly ate a backtick or a list dash shows up immediately as broken rendering.

What a good correction looks like

PR description prose

Before

This PR fixes the race condition in the cache layer where two request could write to the same key simultaniously. I have added a mutex around the write path and a test that reproduce the failure on the old code.

After

This PR fixes the race condition in the cache layer where two requests could write to the same key simultaneously. I have added a mutex around the write path and a test that reproduces the failure on the old code.

What changed. Pluralised 'requests', fixed the spelling of 'simultaneously', and corrected the subject-verb agreement in 'a test that reproduces'. No technical term was altered. This is the whole job.

Issue comment with an inline identifier

Before

I can reproduce this on 3.2.1. The error only happen when `enableStreaming` is true and the response have no content-length header.

After

I can reproduce this on 3.2.1. The error only happens when `enableStreaming` is true and the response has no content-length header.

What changed. Two verb-agreement fixes. The version number, the camelCase identifier inside backticks and the kebab-case HTTP header name are all unchanged. If any of those three had moved, the comment would have been useless.

Review comment

Before

nit: this function does two thing — parsing and validation. Could we split it so the caller can validate without re-parsing?

After

nit: this function does two things — parsing and validation. Could we split it so the caller can validate without re-parsing?

What changed. One plural. The 'nit:' prefix, the em dash and the lowercase register were left alone, which is correct for a review comment.

A failure example you should expect

Here is what goes wrong when you run a correction over a description that already contains code. This is a real class of failure, not a hypothetical one.

PR description before correction (Markdown source)
## What changed

Moved the retry logic out of `fetchUser()` and into a seperate
`withRetry()` helper.

```ts
const result = await withRetry(() => fetchUser(id), { attempts: 3 });
```

Run `npm test -- --grep retry` to verify

What a careless Apply produces

Before

Run `npm test -- --grep retry` to verify

After

Run `npm test --grep retry` to verify

What changed. The doubled dash is not a typo. In npm, `--` separates npm's own flags from the arguments passed through to the test runner. Removing it makes the command silently filter nothing, and the reviewer who copies it gets a green run that proved nothing. This is exactly why you read the popup before Apply.

Even with a protected-words list, treat fenced code blocks as off-limits. The correct habit is to add them after the correction pass, as in step 5 above.

Markdown details worth checking by hand

These are the Markdown constructs a prose-oriented correction is most likely to disturb. None of them is a grammar error, and none of them should change.

Markdown constructs to verify after Apply
ConstructWhy it is at riskWhat to check
Fenced code blocks (```)The fence characters and the language tag look like stray punctuationBoth fences present, language tag intact
Inline code (`x`)A single backtick pair can be read as a stray quoteBackticks still balanced around each identifier
Task lists (- [ ])The brackets look like an incomplete sentenceCheckbox syntax unchanged, or your list renders as text
Links [text](url)URLs contain characters no sentence hasThe URL is byte-identical, especially query strings
Tables (| a | b |)Pipe characters look like typosHeader separator row still present
Nested list indentationWhitespace changes are invisible in plain textPreview tab renders the nesting you intended

The Preview tab catches nearly all of these in one glance. Make it a habit rather than an afterthought.

Where this breaks down

Where this breaks down

  • It cannot correct code, and it should not. A tool that rewrites `useEffect` or reformats a shell pipeline is a tool that breaks your snippet.

    Workaround: Use a linter and a formatter for code. Reserve the grammar pass for prose.

  • It has no structural understanding of Markdown. It cannot tell a fenced code block from a paragraph, so protection depends on you reading the output and on the protected-words list.

    Workaround: Add code blocks after correcting, or draft prose in a scratch tab and assemble the Markdown manually.

  • The github.dev and Codespaces code editors are Monaco instances, not form fields. Nothing can correct them, and no browser extension reaches inside them.

    Workaround: Write commit messages and PR descriptions in the normal github.com UI if you want a correction pass.

  • Whole-field correction only. A long PR description with six sections cannot have one section corrected in isolation.

    Workaround: Draft long descriptions in a scratch tab section by section, correcting each before you assemble.

  • English only. Multilingual repos and teams writing in more than one language will not get consistent results.

    Workaround: Correct the English portions only, and leave other languages untouched.

  • Text is sent to our backend API for correction. For private repositories under an NDA or a strict compliance regime, that may not be acceptable.

    Workaround: Check your organisation's policy on sending source-adjacent text to third-party services before enabling this on internal repos.

Before you open your next PR

Frequently asked questions

Does GitHub have a built-in grammar checker?

GitHub offers Copilot writing assistance in some editors for paid accounts, but it rewrites rather than corrects and is not available on every field. The baseline is your browser's spell check, which catches misspellings only.

Will a grammar checker break my code blocks?

It can, because GitHub comment boxes hold raw Markdown and a correction tool has no structural view of what is code. Read the corrected output for changes inside fences and backticks before you Apply, and add code blocks after the correction pass.

Can I protect specific identifiers from being changed?

Yes. One Shot Fix has a protected-words list. Add function names, CLI commands, package names and internal codenames so they are not treated as errors.

Does it work on github.dev or in Codespaces?

No. Those use the Monaco editor, which is not a form field. It works on the standard github.com comment boxes, PR descriptions, issue forms and commit message fields.

Can I correct only part of a long PR description?

No. Correction applies to the whole field. Draft long descriptions in a scratch tab and correct them section by section.

Can I undo a correction after applying it?

No. Copy the original Markdown before you Apply if the description matters, or paste the corrected text into a scratch tab first and review it there.

Related guides

GitHubpull requestsMarkdowndeveloper writingproofreading

Written by Raheel Ashraf, builds and maintains one shot fix. Tested October 2026 on Chrome, Edge and Firefox (Windows 11). Last updated 7 October 2026.

Write naturally. Send clean.

Correct prompts, emails and messages in the browser field you are already typing in. Free to install.

Add to Chrome