Proofreading Your Own Work

In the previous post I mentioned various proofreading methods I considered for my short story collection, The Year of the Elm (TYOTE). While the objective in all cases was the same — eliminating nagging typos and errors — each method had different strengths and weaknesses.

Because I knew TYOTE would be read by almost no one, and would bring in almost no revenue, I decided to pursue the option that promised to teach me the most about the proofreading process, and about my own ability to spot mistakes. Against all advice, and despite knowing in advance that I could not be one hundred percent successful, I decided to proofread the final draft of the collection myself. (Full disclosure: one other person gave the stories a proofreading pass early in the process.)
Having written professionally in a number of mediums I know I have a decent eye. Not great, but good enough to catch a lot of common errors. Still, like every writer, I have my nemeses. For example, I am constantly transposing ‘from’ and ‘form’, and no spell checker can save me from that fate. Even when I consciously watch for that mistake, slowing my eye to a letter-by-letter crawl, I invariably miss an instance. (Case in point, when I originally wrote ‘from’ and ‘form’ above, I wrote it as ‘from’ and ‘from’ — and didn’t catch the mistake until re-reading the sentence for the umpteenth time.)
Too, it’s worth noting that much of my professional writing has been script work, both in the motion picture and interactive industries. While I certainly don’t want typos in my milestone drafts, a typo in a script feels like less of a crime simply because a script is a blueprint, not a finished work. When I really came to terms with the fact that I would be producing a finished product with my name on it, my level of concern (and vanity) about typos markedly increased. Where I previously felt that typos in a script were unprofessional, I suddenly felt as if typos in my short story collection would be a personal criticism of me.  
Given this heightened sense of responsibility, it probably seems incongruous that I decided to trust myself to find all the mistakes I’d made. I grant the point. The missing factor — beyond my desire to learn as much as I could about proofreading my own work — was my competitive desire to defy conventional wisdom. If I failed miserably, and I almost hoped I would, I would forever relieve myself of any obligation to track down mistakes on my own. On the other hand, if I succeeded, I might improve my craft as well as demonstrate the kind of attention to detail that authors and publishers look for in a freelance editor.
Step 1: Read and Repeat
The process I followed was pretty primitive: start at the beginning and read through the whole draft, fixing mistakes as I found them. When I was done I started in again, lather-rinse-repeat style. My goal was a full pass which revealed no new errors, although I knew that would hardly be a guarantee of success. Rather, it would simply signal the point at which I had become blind to my own work despite all efforts to the contrary.
How many times did I go through the whole book? I can’t tell you. It was easily four times (and here I mean four times during the final proofreading process), and probably six or seven. While that may seem like a lot (or not), what amazed me most is that I kept learning new things about the collection. Sometimes I found a subtle error between different stories (something an editor of almost any pay grade might miss), while other times I suddenly discovered obvious, in-your-face mistakes that made me wonder if I could proofread my own name.
What did I learn along the way? One thing I continually demonstrated to myself was that rewriting even a single sentence during the proofing process almost necessarily introduced new mistakes — either in the newly-written text, or when taken in context with the rest of the work. Because I kept finding sentences I wanted to tweak I made sure I revisited the changed text multiple times, over and above each full proofreading pass. (All word processors include highlighting, underlining or other marking functions that allow an author to easily identify changed sections of text, to say nothing of more complex revision/editing features which track changes in real time. If you make any revisions during the proofreading process, mark that text for review the next day. You’ll be amazed at how many mistakes you find.)
Step 2: Learn As You Go
The most useful thing I learned while proofreading TYOTE was to keep track of discovered mistakes, consistency concerns and usage issues in a separate list. As the final step in the proofreading process I worked through the list, item by item, using the ‘find’ function in my word processor to locate as many instances of the (potential) problem as possible. For example, once I realized that I had written ‘Mom’ as ‘mom’ in several places, I wrote ‘Mom/mom’ down to remind me to check all uses of the word for appropriate capitalization.
For TYOTE, here’s the list I ended up with:
  • Mom/mom
  • any more = 2 words
  • ‘em only in dialogue
  • start/ed/ing
  • very
  • really
  • just
  • too – no rule/see blog post
  • even
  • it’s/its
  • possessives
Many of these are obvious and would apply to any work. Because TYOTE was written from the point of view of a child, however, usage that might be improper for an older or more educated character was proper, but still required judgment on a case-by-case basis. The words ‘very’, ‘just’ and ‘really’ were checked not only for usage in each sentence, but relative to the overall work. The goal was to allow the main character to talk the way kids talk without turning the work into a colloquial swamp. Checking the use of such words in a dedicated pass allowed me to make those judgments in a way that would have otherwise been impossible.
The Stopping Point(s)
The best part about this two-step process is that it simply runs its course. You read and re-read the text until you can’t find any more mistakes. Along the way, you compile a list of words/issues to check across the breadth of the entire text. When you can’t find any more mistakes in your read-throughs you turn to the list, and when you’re done with the list you’re done.
Again, the fact that I ran out of things to find doesn’t mean there aren’t fifty (or five hundred) obvious mistakes in The Year of the Elm. It simply means I will never be the one who spots them. Having said that, the fact that I kept drilling down and finding more issues actually made me fell like I did a decent job. Had I made one pass, fixed some obvious errors, then found nothing to fix on my second pass, I would have had little confidence in the outcome.
In that sense I think any author can use this two-step process both to improve their proofreading skills and to gauge their own ability to proofread content. If you find almost nothing that needs fixing, chances are that your eye may simply not be up to the task. On the other hand, if you keep finding mistakes, and your knowledge of the work grows as you comb through the copy, the odds are that you’ll do a fairly good job of cleaning up the text. (Or at least a better job than you might have otherwise.)
For me, the best and most surprising thing about this process was that my authorial knowledge of TYOTE continued to grow even after I thought the creative process had effectively concluded. Not only didn’t I expect that, but having seen the benefits firsthand I can’t imagine not following the same process with subsequent works — even as I will certainly involve others in the proofreading process. (Again, my goal with TYOTE was to learn as much as I could about proofreading, and about myself in that role. In that respect the process I followed paid incredible dividends, and improved the collection in ways I could not have replicated using other approaches.)
Results So Far
The punchline is that no one has pointed out a typo or other mistake in TYOTE. While it’s tempting to believe that I really did perform some sort of miracle edit, the truth is more banal.
First, the number of readers is but a handful, so I can’t lay claim to any sort of crowd-sourcing or broad-based sample. Second — and I know this from having written online for years — readers almost never report mistakes. And why should they? Not only isn’t it their job to spend time fixing things I should have gotten right in the first place, but it’s a risky thing to do emotionally. Will the author be thankful, indignant, or simply ignore the message? I tend to think most writers are appreciative when notified of a mistake, but I’m sure there are irascible exceptions.
The final takeaway from this process, for me, is that editing your own work may or may not be viable, but in order to know – to have some measure of certainty that you’re not simply deluding yourself — you’re inevitably going to have to run your work by others. They may not find anything either, but that’s the only way to know for sure whether your text is clean.
I’m now convinced that my job is to give my text to others only when I’m sure it’s as clean as it can possibly be. It’s not my job to let others find and fix my mistakes because some of the changes I made to TYOTE during the proofing process could not have been conceived of by anyone else. My job is to work on the text exhaustively, until I literally have nothing left to give.
And then get help.


This is a reprint from Mark Barrett‘s Ditchwalk.

Comments are closed.