Best Tools to Catch Continuity Errors in Your Novel

The best continuity checker for writers is the one that finds the error you didn’t know to look for. That test sounds obvious, but it quietly disqualifies most of the tools writers reach for first, because nearly all of them only surface a mistake once you already suspect it. Here is an honest look at every practical way to catch continuity errors in a novel, what each one actually finds, and where each one leaves you exposed.

Disclosure up front: StoryGuard, listed near the end, is our product. It exists specifically for this problem, so we have a stake in the answer. We’ve tried to describe every option by what it genuinely does well.

What “catching” an error actually requires

A continuity error is a place where your manuscript contradicts a fact you established somewhere else. To catch one, a tool needs two things:

1. A source of truth: the recorded fact (Elena’s eyes are grey, the ferry runs at dawn, the king dies in chapter 12).
2. A way to compare that fact against the prose, ideally everywhere the fact could be contradicted.

Any tool that gives you the first without the second can store your world beautifully and still never catch a single error. Hold that distinction in mind, because it’s the whole game.

Spreadsheets and series bibles

The classic: a grid of characters and attributes, or a document listing your world’s facts.

Catches: anything you deliberately look up.

Blind spot: everything you don’t think to check. A spreadsheet answers “what color are Elena’s eyes?” only when you ask, and the errors that reach print are precisely the ones you were sure about. Coverage also decays exactly when drafting gets intense, because updating the sheet is the first thing to slip. Useful as a reference, close to useless as a safety net. (We wrote a full system for making this work by hand in how to track continuity in a novel.)

Re-reading and printouts

Reading the whole manuscript to hunt for contradictions.

Catches: errors in the scenes where your attention holds.

Blind spot: attention fades across 100,000 words, and the distance between an established fact and its contradiction is usually dozens of chapters, which is the exact span human memory handles worst. Re-reading is essential for prose and weak for cross-referencing.

Beta readers and editors

Other humans reading for problems.

Catches: the plausibility and logic issues no software can (motivation, pacing, “would she really do that”). Good beta readers are irreplaceable here.

Blind spot: they read once, inconsistently, and late in the process, and they miss mechanical contradictions as easily as you do. A copyeditor may catch a repeated name, but you’re paying by the hour for a machine-shaped task, and the fix arrives when it’s most expensive.

General-purpose tools you already own

Word and Google Docs Find, Scrivener, Notion, Obsidian.

Catches: Find locates exact strings you remember typing. Scrivener organizes a long draft superbly. Notion and Obsidian store richly structured world data.

Blind spot: none of them know your manuscript and your world notes are supposed to agree. Scrivener won’t tell you the eye color changed, and a Notion database has no concept of chapter 31. They are storage and organization, not checking. (For the full comparison of these as worldbuilding homes, see our tools roundup.)

Pasting your manuscript into a general AI chatbot

Tempting, and it half-works.

Catches: some real contradictions, especially in shorter manuscripts.

Blind spot: a general chatbot has no source of truth, so it compares your book to its own fuzzy memory of your book. It misremembers details across long documents, hedges with vague “consider clarifying the timeline” notes, and confidently flags your unreliable narrator’s intentional contradiction as an error. We wrote an honest breakdown of where this holds up and where it fails in can AI catch plot holes and continuity errors?

Purpose-built continuity checkers

Tools designed for this one job, where the source of truth and the manuscript live in the same system and get compared automatically.

This is the category StoryGuard is in, and here is the honest positioning. In StoryGuard you build a world graph (characters, locations, objects, factions, rules, and the relationships between them), and you write chapters in an editor where @mentioning an entity links the prose to the graph. An AI scan then reads the world and the manuscript together and flags contradictions with the offending sentence highlighted: a wrong attribute, a broken world rule, a timeline slip, a character who is dead in chapter 12 speaking in chapter 15.

Catches: the errors you never suspected, because it checks facts you don’t think to check. It also understands state over time, so “true until chapter 12” is a fact the scan can enforce rather than a judgment call you have to remember.

Blind spot: it only checks facts you’ve recorded, it produces the occasional false positive (treat every flag as a question, not a verdict), and it won’t catch deep logic holes that need human judgment. It’s also early: the editor isn’t Scrivener-deep, and there’s no compile-to-EPUB pipeline yet.

How to choose

The pattern is clear: every method except the last requires you to already suspect the error, or to get lucky with a reader’s attention. If your novel is short and your world simple, a bible and good beta readers are plenty. The case for a dedicated checker gets stronger with every character you add, every timeline you complicate, and every book you add to the series.

The bottom line

Storing your world is a solved problem, and a dozen good tools do it. Catching the contradiction between your world and your prose is the part that’s still mostly done by hand, badly, at the worst possible time. If that’s your bottleneck, use a tool built for it. If it isn’t, a well-kept bible and a sharp beta reader will carry you a long way. Just don’t confuse a place to keep facts with a system that checks them.