How to Check Grammar in a Document, in the Right Order

The short answer

To check grammar in a document, run four passes in this order: content and structure first, then sentence-level grammar, then a mechanical pass for spelling and common grammar errors, then a read-aloud pass. Do it section by section, not once across the whole file. Use your word processor's built-in review for the full document, and a paste-based checker for the body text, because a paste carries only the body.

• Spelling, grammar and style are three different jobs. A machine can do pieces of the first two; the third is always yours.
• Never run a mechanical check on a paragraph you are about to rewrite — checking text you will replace is wasted effort.
• Spellcheck is not grammar checking. Every word in a broken sentence can be a real word.
• Pasting a document into an online checker loses everything outside the body: headers, footers, footnotes, comments, tracked changes and text boxes.
• You cannot proofread your own writing straight after writing it. Distance is a technique, not a luxury.

Spelling, grammar and style are three different jobs

People search for “grammar check” expecting one button, and are disappointed, because the phrase bundles three tasks with three different levels of automatibility.

Spelling asks whether each word, taken alone, is a real word in the language. This is almost fully automatable: the set of valid words is finite and listable, so a checker can compare every token against a dictionary. It cannot tell whether you meant the word — “their” is a real word you may not have intended — but “is this string a word” is a mechanical decision.

Grammar asks whether the words fit together — whether each verb agrees with the subject it actually has and each sentence contains the parts it claims to. Partly automatable: relationships between words can be checked against patterns, and a language model can estimate whether a sentence reads like well-formed English, but every tool checks only a subset of the ways sentences go wrong.

Style asks whether this sentence is the best way to say what you mean to this reader: word choice, register, rhythm, what to cut. Not automatable in any trustworthy way, because it requires knowing your intent, your audience and your organisation's conventions — none of which are in the text. Tools that “check grammar” by rewriting awkward phrasing are doing a style job with a grammar tool's authority, which is exactly when meaning quietly changes.

The practical consequence: stop asking machines for judgement, and stop spending your own judgement on what a machine can decide.

The order to check in

Order matters because every earlier pass can invalidate the later ones. If you check sentence grammar and then restructure, you checked sentences that no longer exist. Run the passes in descending altitude — the biggest problems first, because re-reading a paragraph you are about to rewrite is wasted effort.

Pass 1: content and structure

Read for the document, not the sentences. Does it say what the reader needs, in the order they need it? Is anything missing, duplicated, or in the wrong section? Fix what stays, what goes, and what order the parts sit in before you touch a comma, because moving text breaks connectives like “as noted above” and the cross-references around it.

Pass 2: sentence-level grammar

Now go sentence by sentence. For each one ask four things: does the verb agree with its real subject, not the nearest noun; does every pronoun point at exactly one obvious earlier noun; does the sentence contain the subject and verb it claims to; and does tense stay consistent with the sentences around it. This pass is human work — you are reading structure, not vibes — and it is where the errors that dictionaries cannot see get caught. The machine pass comes after, for what eyes alone miss.

Pass 3: mechanics

Spelling, doubled words, apostrophes, articles, spacing, punctuation. This is the pass to delegate to machines: run your word processor's spell and grammar review across the whole file, and a dedicated grammar checker over the body text. Machine output is leads, not verdicts: accept or reject each flagged change, and everything the tool missed is still yours to find.

Pass 4: read it aloud

The last pass is the only one that approximates how the document will be experienced, because most readers sub-vocalise. Read it out loud, or play it through text-to-speech and listen. Your ear catches what your eye has learned to skip: missing words, run-ons that never end, sentences no human could say in one breath. Stop at each stumble and fix that sentence.

How to check a long document without losing your place

Checking a long document in one pass fails for two reasons. Attention degrades — error detection is clearly worse by page fifteen than on page one, so the back half of a big file gets checked the least well. And the output becomes unmanageable: one continuous stream of flags, and once you have accepted thirty changes you cannot say which sections you have actually finished.

Work section by section instead, where “section” means one heading's worth of text — a bounded block you can finish completely before moving on. Write the list of section names down first, or use the table of contents as your checklist, and tick each one off only when all four passes are done on it. This also lets you order the work: check the sections that are final, and leave anything still being written until it stops changing, so you never check the same text twice.

Keep the passes separated inside each section: one structural read, one sentence read, one machine pass, one read-aloud, then move on. Do not let the first bleed into the third, because that is how you end up fixing a comma in a paragraph you later delete.

Finish with one whole-document pass on the things that only exist across sections: heading numbering, table of contents, cross-references, figure captions, and the consistency of recurring terms. It is mechanical, fast, and the only pass that belongs at document scale.

Why spellcheck is not grammar checking

A spellchecker validates each word in isolation against a dictionary. Grammar lives in the relationships between words, so a sentence can pass every spell flag and still be entirely wrong. These are the classes of error a clean spellcheck report guarantees nothing about.

Real words that are the wrong word. Homophones and confusable pairs are correctly spelled strings, so no spell flag fires: “Their going to approve the budget on Thursday” should be “They’re going to approve the budget on Thursday.” The same blind spot covers “it’s” for “its” and every affect/effect or then/than slip; only a grammar pass — contextual checker or your own eyes — catches them.

Subject-verb agreement across distance. In “The list of overdue accounts are sent out every Monday”, the nearest noun to the verb is plural “accounts”, so the sentence sounds fine to the writer — but the subject is “list”, and it should read “The list of overdue accounts is sent out every Monday.” The longer the clause between subject and verb, the more reliably both eyes and simple checkers miss it; a word-at-a-time spellchecker never looks at the relationship at all.

Punctuation that changes meaning. A missing comma is a grammar error with consequences, not a cosmetic one: write “Let’s eat Grandma” instead of “Let’s eat, Grandma” and the sentence invites the reader to consume the grandmother. Spellcheck sees only correctly spelled words.

Dangling modifiers. In “After reading the draft, several errors were found in Appendix B”, the opening phrase attaches to the nearest candidate, “errors”, which did not read anything. The fix: “After reading the draft, I found several errors in Appendix B.” This requires parsing who did what — pure grammar work.

Tense drift. In long documents written over time, tense wanders: “By the time the auditor arrived, the team finishes the full review” should read “By the time the auditor arrived, the team had finished the full review.” Each verb is a correctly spelled word; only the sequence is wrong.

The reverse gap exists too: a grammar tool may wave through misspellings, rare proper nouns and domain terms, while the spellchecker catches them. The two nets have different holes, which is why you run both — and why a clean report from either one is not a clean document.

Checking grammar in Word and Word Online

The following subsections are general notes on word processors and pasted text — they describe what desktop and web editors typically offer and what a paste can carry, not the checker linked at the bottom of this page.

Desktop Word: the review pane

Desktop word processors run their own spell and grammar pass with a review pane. In Microsoft Word, the Review tab offers Editor, or Spelling and Grammar, and pressing F7 starts the same walk: the pane flags an issue, shows the surrounding text, and offers to change it, ignore it once, or ignore it always. A settings panel switches rule categories on or off — grammar and punctuation, contextual spelling, irregular words. The same engine underlines misspellings and suspected grammar problems as you type. Because the review runs inside the file, it walks text a paste cannot reach: headers, footers, footnotes and text boxes.

The limitation: one engine with one rule set, walking one error at a time, and slow at spotting a sentence that is structurally wrong but breaks no rule. Two independent engines disagreeing on your document is normal; the disagreements are worth reading.

Word for the web and other browser editors

Web editors offer a lighter version of the same job. Word for the web has a spelling and grammar review, but with a smaller settings surface than the desktop app, and some grammar categories are only configurable — or only present — on desktop. Google Docs keeps a spell check dialog that walks spelling and basic grammar with a couple of toggles. If a document matters, treat the web pass as a first filter and do the full review on desktop, because “no errors found” in a lighter checker means only “nothing my smaller rule set recognised”.

Browser-based checkers: a different shape of pass

A browser-based grammar checker works on pasted text rather than on the open file: you paste, and get back a corrected version with your changes listed. That shape has two uses the word processor cannot match: it is a second, independent opinion with different blind spots, and it returns the whole document section at once — corrected text side by side with the original — instead of one modal dialog at a time. Its limitation is structural, and it is the important one: it can only see what you paste.

Why a paste is not a whole-document review

Here is the fact that decides how you schedule your passes: pasting a document into a checker loses everything outside the body. Headers and footers do not come with the selection. Neither do footnotes and endnotes — you get the number in the text, not the note. Comments and tracked changes do not survive as such: a paste carries one frozen snapshot of revisions, and you may not know which version it copied. Text boxes, captions and shapes often vanish or arrive scrambled, because they live on a different layer than the paragraph flow.

The consequence, stated plainly: a checker pass is not a whole-document review. A checker that says “no errors” has checked the body and never saw the words living outside it — including the header that still repeats “DRAFT — DO NOT CITE” on all forty pages. Run the word processor's own review over the whole file for the furniture a paste drops, and keep the paste-based checker for the body.

Two habits make this safe. First, before pasting anything into a checker, accept or reject tracked changes so the text you check is the text you will send, and resolve comments so review notes do not travel into the corrected copy. Second, after moving corrected text back into the document, check that lists and tables survived the round trip — numbered lists in particular arrive as plain text with their original numbering lost.

What automated grammar checking actually catches

There are two engine designs behind every grammar tool you will meet, and each has a fixed, knowable ceiling.

Rule-based checkers match your text against a list of patterns — commonly confused words, article errors, doubled words, a set of agreement patterns, missing spaces after punctuation. They catch exactly what is on the list and nothing else. That makes them predictable and honest: when a rule tool says “no errors”, you know precisely what was never looked for. But its misses are silent, which is the danger.

Language-model checkers work the other way: the model was trained to produce fluent corrected text, so it flags errors the list never contained. But it optimises for sentences that read well, and “reads well” is not the same as “says what you meant”. A model that smooths your sentence does not know your intent and cannot ask — it guesses meaning from the words alone, and can change what you said while fixing how you said it. It can also mistake a rare proper noun for a misspelling and rewrite it into something more common.

Neither engine replaces a human read for judgement, tone or factual accuracy. A sentence can be grammatically flawless and wrong: “The contract expires on 1 June” is perfect English whether or not the date is correct, and no checker has ever read your source. Treat every automated change as a proposal — accept the ones that fixed an error, reject the ones that changed a fact, a number, a name, or a nuance. This is why the diff matters more than the corrected output: a tool that shows exactly which words it changed lets you audit it; one that just hands back polished text hides its edits.

The specific things that go wrong in documents with many authors or many months

A document assembled by several people, or edited by one person over months, fails in ways a single sitting never produces. Expect these and check for them by name.

Terminology drift: three teams called the same thing “client”, “customer” and “user”, and the reader reasonably assumes they are three different things. Decide the canonical term in the consistency pass and search each variant.

Tense and voice seams: the section written for last year's report says “we will launch”, the section written this year says “we launched”, and the reader cannot tell what is future. Pasted sections bring their authors' register too — “utilize” next to “use”.

Stale cross-references: paragraphs moved, numbers renumbered, and “as shown in Table 3” now points at a table that no longer exists or is now Table 4. Re-verify every reference after the final structural change, not the first.

Duplicate and near-duplicate content: two people each wrote the caveat, and the doc now says it twice with slightly different wording — and the differing phrasings read as a deliberate distinction.

Review residue: comments that were resolved but never deleted, tracked changes left pending so each recipient's Word shows a different version, placeholder text like “TBD” or a lorem-ipsum paragraph nobody ever replaced. Before it goes out, search for TBD, @-mentions and square-bracket placeholders — this residue is invisible to spellcheck and grammar checkers alike.

And the master failure: the document has no single reader anymore. Each author reread only their own part, so the seams between parts — the paragraph where section 2 hands off to section 3 — have been read by nobody. Read the seams deliberately.

Proofreading against your own blindness

Your own errors are the hardest to see, and it is not carelessness — it is how reading works. When you look at text you wrote, you are reading your memory of the intended sentence, not the marks on the page; your brain corrects omissions and transpositions toward what you meant before your eyes report them. Every proofreading technique that works exists to break that preview. Four are worth scheduling.

Read backwards for spelling. Start at the last sentence and work up, one sentence at a time, so the story cannot carry you along. Removing narrative flow kills the prediction that hides errors, and a page read backwards shows you dozens of problems the forwards read showed none of. This pass is deliberately blind to structure and meaning; other passes handled those.

Change the look to defamiliarise the text. Swap the font, change the size, push the zoom to 150 percent, switch the page colour, or export to PDF so the layout is someone else's. The point is to stop seeing the draft you remember and start seeing the artifact in front of you; errors only resurface when the page no longer matches the internal image of it.

Print it, or read it on another device. Screen reading skims; paper slows the eye and spatial memory starts working for you — errors get found at “the bottom of the third printed page” in a way they never do when scrolling. Mark the paper up with a pen, then apply the marks.

Read it aloud, and wait before you read it at all. The ear catches missing words and run-ons the eye normalises. And never proofread immediately after writing: your memory of intent is freshest then, which makes it your blindest moment. Overnight if the schedule allows; a few hours and a different task in between if it does not. Distance is not procrastination — it is the cheapest error-detection tool you have.

Where the linked checker fits

The grammar checker linked below is pass 3 for your body text, run section by section. You paste your text into the page, and the English checker sends it to a T5 grammar-correction model that runs inside your browser. It returns the corrected text, a highlighted comparison against your original, and a numbered list of the changes with a short reason beside each one — so you can audit every edit instead of trusting a polished rewrite.

Know what it is not, because that decides where it fits. It is a batch checker, not an underline-as-you-type overlay: it does not sit inside your editor while you draft. It does not rephrase and it does not check style — it is pointed at errors, not at making your prose better, so pass 4 still happens with your own voice. And it checks pasted text, so everything this guide says about what a paste drops applies in full.

There is no word or character limit on the input — the ceiling on a long document is your attention, not the tool, which is why the advice above says paste one section at a time. The model weights are downloaded the first time you use it and your browser reuses them afterwards, so later checks start faster; the page is not network-free and the first check needs a working connection. If the model cannot be fetched — a blocked or failed download — the page falls back to a rule-based checker and says so on screen, so you always know which engine produced the result.

Your text is not uploaded anywhere: the correction runs on your own device. Paste a finished section, read the numbered changes, accept the fixes that are fixes and reject the ones that changed your meaning, and move to the next section.

Frequently asked questions