Common Continuity Errors (and How to Catch Them Before Readers Do)

Character errors

The most common kind: an age, status, name, or piece of knowledge that contradicts an earlier establishment. A character knows a secret they were never told; someone's eye color changes; a minor character's name shifts between appearances; a character grieves a death they should not yet know about; a person introduced as an only child mentions a brother twelve chapters later.

These dominate the count because characters are the part of the world that changes most. A location mostly sits still; a character is alive, then dead; ignorant, then informed; loyal, then turned. Every one of those transitions is a fact with a before and an after, and the error is almost always using the wrong side of a transition — writing a character as knowing something in a scene set before they learned it.

Catch them by tracking each character's status as a set of dated facts — alive or dead, where, and what they know, as of each point in the story — and checking new scenes against the state that was true at that moment, not the latest state. The question to ask of every scene is not "is this true about the character?" but "is this true about the character right now, here, in this part of the timeline?"

Timeline errors

Events in an impossible order, or ages and dates that do not add up. A child born after a parent dies; a character too young to have witnessed something they describe; a war that lasted three years in one reference and a decade in another; a flashback that does not fit the established sequence.

Timeline errors are insidious because the arithmetic is almost never done. A reader — or the author — accepts "twenty years ago," "she was a child then," and "she is thirty now" as three separate, reasonable statements, and never adds them up to notice the child would have to be ten years old today. Each fact is fine; the sum is impossible.

Catch them with a real timeline — events placed in order with years attached — rather than a paragraph of backstory prose. When the events sit on an actual sequence, the impossible order is visible at a glance and the ages do the arithmetic for you. Sequence and age errors are obvious on a timeline and effectively invisible in a wall of text, which is why backstory written only as prose is where they breed.

World-rule errors

The mechanics of your world drift. The classic case is power creep: an ability that costs a memory in the first arc and nothing by the climax, or a power level that quietly inflates because each fight has to top the last. Technology drifts the same way — a communication device that takes days to cross the world early on and works instantly when the plot needs it to — and so do economics, politics, and the rules of who can do what.

The pressure behind world-rule drift is almost always dramatic convenience. The rule was set when it was cheap; later a scene needs the rule to bend so the hero can win, the message can arrive, the cost can be paid in something other than the thing established. Each bend feels justified in its own scene, and collectively they dissolve the rule until the world no longer has reliable physics — which is the moment a reader stops trusting it.

Catch them by writing rules with their costs and limits as explicit facts, then checking the scenes that invoke them against the rule as written. "Magic always costs a memory" is checkable — you can find every scene that spends magic and confirm a memory was paid. An unwritten, vibes-based rule is not checkable at all, because there is no fixed version to check against, only the impression of one that quietly changes.

Plot-thread errors

A thread is dropped and never resolved, resolved twice, or its payoff contradicts a clue planted earlier. The introduced-and-forgotten subplot, the mystery whose solution ignores a clue you carefully seeded, the prophecy that pays off in a way its setup ruled out — these are the plot-thread family.

They are the hardest to catch because they unfold across the most pages and the most time. A character error sits in one scene; a plot thread spans the whole work, sometimes years of real-world publishing time, and the setup and the payoff can be a thousand pages apart. By the time you reach the payoff, the setup is a half-remembered detail, and it is genuinely easy to resolve a thread in a way that contradicts a promise you made and forgot.

Catch them by tracking each open thread as its own object — its current state, the clues planted, and where it was last touched — so nothing silently falls off the board and no resolution contradicts its setup. A thread you can see the state of is a thread you will not drop; a thread that lives only in your memory of "I think I set something up about that" is one you will.

Why a final read-through misses all four

The instinctive defense against all of this is a careful read-through before you publish. It does not work, and the reason is structural rather than a matter of effort. A read-through is linear: you encounter the contradicting facts one at a time, pages or chapters apart, and the human brain does not hold a fact from chapter two live enough to clash against its contradiction in chapter forty. You read each as locally fine, because locally each is fine.

Catching contradictions requires the opposite of reading: holding the whole world at once and comparing facts that are far apart in the text but adjacent in meaning. That is not a reading task, it is a checking task, and it is exactly the task no single pass of human attention can do at scale — which is why even meticulous authors of beloved series ship continuity errors their fans then catalog with glee.

Where CanonBoard fits

All four families fall to the same underlying tool: a structured record of the world's facts that something can read all at once and check against itself. Character status over time, a real timeline, rules with explicit costs, threads with tracked state — these are not four separate systems but four kinds of card in one canon.

CanonBoard holds exactly that, and runs the check the read-through cannot. It scans the whole board on demand and surfaces each kind of break with both sides quoted and the conflict named — the character who knows too soon, the age that does not add up, the rule a scene ignores, the thread about to be dropped — before any of it reaches a reader. Name the four errors, build the world so each is checkable, then let the check find them while they are still cheap to fix.

There is a limit to what any record can do for you, and it is worth naming. A record answers what the world has already decided; it cannot tell you what the world has never decided at all. Surfacing that second category takes a deliberate practice — the zero drafting method — and the full taxonomy of which failures it catches, and which two it never will, is in continuity failure modes.

Frequently asked questions

What are the most common continuity errors?

Character errors (age, status, name, or knowledge that contradicts an earlier establishment), timeline errors (impossible order or ages), world-rule errors (power or technology drifting), and plot-thread errors (dropped or double-resolved threads).

How do you catch continuity errors before publishing?

Keep a structured record of your world's facts and run a consistency pass over the whole thing before each installment — checking new material against established canon rather than relying on a final read-through.