How to Rename a Character in Your Novel: Why Find and Replace Isn’t Enough

At some point in a long draft, there is a good chance you will decide that someone has the wrong name.

Maybe the name was only meant to be a placeholder. Maybe you discover a spelling you prefer after using the original for twenty chapters. Maybe two characters have names that are too similar, or the name no longer fits the setting, culture, or person you eventually developed.

For a short manuscript, changing it may be easy. Open Find and Replace, enter the old name, enter the new one, and replace every result.

The trouble is that a character’s identity is rarely contained in one exact string of text.

A character may be called by a first name in narration, a surname in dialogue, a title by subordinates, a nickname by family, and an alias while concealing their identity. Their name may also appear in scene notes, character sheets, timelines, relationship notes, outlines, and worldbuilding documents.

Once a manuscript becomes large enough, renaming a character stops being a simple text-editing problem. It becomes a continuity problem.

How I Ran Into the Problem

An author and editor I spoke with mentioned character renaming as a writing frustration that Scriptri might eventually help address. The comment stayed in the back of my mind, but I did not fully understand the scope of it until I ran into the same problem in my own fiction.

I had been using placeholder names and eventually decided that one of them needed to change.

My manuscript was still short, so the immediate process was simple:

1. Open Find and Replace, or Project Replace in Scrivener.
2. Search for the old name.
3. Enter the new name.
4. Replace the results.
5. Read through the affected text to make sure nothing strange happened.

That worked. But while thinking through how Scriptri might support the same operation, I started imagining the manuscript at 20,000, 50,000, or 100,000 words.

What if the character had several aliases?

What if another character shared the same first name?

What if the old name appeared in notes that were not part of the manuscript?

What if some uses of the name referred to a place, family, organization, or historical figure instead?

At that point, “replace every occurrence of Henry” is no longer a particularly safe simple workflow.

Where Find and Replace Works

Find and Replace is still a useful tool. If a name is distinctive and consistently spelled, it can handle most visible manuscript references quickly.

It is especially effective when:

• The character has one name.
• No other person or place shares that name.
• The manuscript is relatively short.
• Planning notes are stored in the same searchable project.
• The writer is comfortable reviewing every replacement afterward.

For plenty of manuscripts, that may be enough.

As a blunt instrument, find and replace gets the job done. But the problem is that it only understands text, not the identity of what is being replaced.

It knows that the letters Henryappear in a sentence. It does not know which Henry the sentence refers to, whether “Mr. Vale” is the same person, or whether “the captain” should also be considered part of the rename.

A Character Is More Than One Name

Consider a character named Henry Vale.

Across a manuscript, he might appear as:

• Henry
• Henry Vale
• Mr. Vale
• Captain Vale
• Vale
• Hen
• the captain
• the Archivist
• an assumed name used in one section of the story
• one-off references like “sir” or “he”

Those phrases may all refer to the same person, but ordinary search treats them as unrelated strings.

The reverse problem can happen too. Two different characters may both be named Henry. A global replacement cannot know that one Henry should become Elias while the other should remain unchanged.

Possessives and variants introduce smaller problems:

• Henry
• Henry’s
• HENRY, in a script or heading
• a misspelled variant that survived several drafts
• a plural family name derived from the character’s surname

A careful writer can search for each form separately, but every additional variation increases the chance that something will be missed or incorrectly changed. For a practical example, if you want to see this just how messy this problem can get first-hand, name one of your characters “Will” sometime and see the chaos that ensues when you try to rename him later.

The Manuscript Is Only Part of the Project

A name can also exist outside the prose itself.

It might appear in:

• Scene summaries
• Revision notes
• Character descriptions
• Relationship notes
• Timelines
• Location histories
• Mystery clue lists
• Worldbuilding documents
• Comments left during revision
• External spreadsheets or story bibles

Changing the manuscript without changing those supporting records can leave the project in an awkward state. The prose uses the new name, while the notes still refer to the old one.

That may not create an immediate continuity error, but it creates confusion later. A search for the new name will not find the older notes, and someone reviewing the project may wonder whether the two names refer to different characters.

This was the part of the problem that made me rethink how text should work inside Scriptri.

Text References Versus Entity References

Most writing software stores a character name as ordinary text. The word “Henry” is simply five letters at a particular location in a document.

Entity-aware text adds another layer. The visible word is connected to a stable record representing the underlying character.

The text might display:

Captain Vale entered the room.

But the phrase “Captain Vale” can be linked internally to the same character entity as “Henry,” “Mr. Vale,” and “the Archivist.”

That link changes what the software knows.

Instead of asking:

Where does the word “Henry” appear?

the software can ask:

Which passages, notes, and records refer to this particular character?

That distinction is especially useful when names overlap. If two characters are named Henry, their visible names may be identical while their underlying entity references remain separate.

It also means an alias can be renamed without changing every other reference to the character. A writer might replace “the Archivist” with “the Curator” while leaving “Henry Vale” untouched.

How Scriptri Handles Renaming

Scriptri now uses entity-aware text throughout much of the project. Writers can associate manuscript references and notes with characters, places, objects, factions, clues, or other story entities.

When renaming an entity, Scriptri can identify references that are explicitly linked to that entity rather than relying only on a text search.

A writer can choose whether to:

• Rename the entity itself.
• Rename one particular alias.
• Update every linked reference.
• Update only selected references.
• Leave some uses unchanged when the context requires it.

Because the references are linked to an entity, Scriptri can distinguish between two characters who happen to share the same visible name.

This does not mean the process requires no review. Scriptri cannot reliably change a reference that was never tagged, and indirect phrases such as “her father” or “the man by the window” may still require human judgment.

The goal is not to eliminate the writer from the process. It is to reduce uncertainty about which references belong to the thing being renamed.

What Happens With Scrivener Projects

Scriptri is designed to work alongside Scrivener rather than silently edit a writer’s source project.

When a manuscript has been imported from Scrivener, Scriptri does not write the renamed text directly back into the Scrivener file. That would create too much risk for a tool that is meant to remain conservative with a writer’s manuscript at this point in Scriptri’s development.

Instead, Scriptri creates a checklist of references that need to be updated in the source document.

The writer can make those changes in Scrivener using its own editing tools. When the project is refreshed in Scriptri, completed changes are recognized and checked off.

This creates a slightly more manual workflow than directly rewriting the source file, but it keeps control where it belongs. The writer can see every proposed change and decide how each reference should be handled.

Why Tagging Hygiene Matters

Entity-aware renaming only works when the project contains meaningful links.

That makes a few habits important:

Keep one entity for one character

Do not create separate character records for “Henry,” “Captain Vale,” and “the Archivist” if they are all the same person. Store those names as aliases attached to one entity.

Tag important references consistently

Not every pronoun or indirect mention needs to be tagged. But names, aliases, titles, and references that matter to continuity should be connected to the correct entity.

Review untagged occurrences

Before considering a rename complete, search for the old name normally as well. This catches passages that were never tagged or variations that were entered inconsistently.

Check notes as well as prose

A manuscript may be correct while the surrounding project remains stale. Review scene notes, descriptions, timelines, and other supporting material.

Keep a backup

Any manuscript-wide replacement deserves a backup, regardless of which tool performs it.

Semantic links make the operation safer, but they should support careful revision rather than replace it.

A Practical Character-Renaming Checklist

Whether or not you use Scriptri, a character rename can be approached in stages:

1. List the character’s current name, surname, titles, nicknames, aliases, and common misspellings.
2. Check whether any of those names are shared by another character, place, or organization.
3. Search the manuscript for each variation.
4. Review possessives, dialogue references, headings, and capitalization variants.
5. Update character sheets, scene notes, outlines, timelines, and relationship records.
6. Check whether the old name influenced family names, place names, jokes, initials, or clues.
7. Read every changed passage in context rather than trusting a global replacement blindly.
8. Search for the old variations again after the rename is complete.
9. Keep a backup until the revised manuscript has been reviewed.

As you can see, the longer and more inter-connected a manuscript gets, the more time-consuming these tasks necessarily become; even with good manuscript hygiene.

Renaming Is an Identity Problem

I originally thought character renaming would be a relatively small feature.

Instead, it exposed a larger architectural question: should references inside Scriptri merely contain text, or should they know which story entity that text represents?

Supporting renames safely required stronger entity links throughout the application. That work has affected far more than character names. The same system can help distinguish locations with similar names, track objects across aliases or descriptions, and preserve connections between manuscript text and project notes.

The side benefit is that, with the work done in Scriptri to make nearly all text Entity Aware, I should be able to pull together some interesting features in the future that go far beyond consistent renaming for entities. Which is pretty exciting. In the mean-time, Scriptri can now, hopefully, meaningfully address this classic pain-point for authors.