
Writing infrastructure code is one skill. Reading it critically, especially your own, is another, and it is the one that quietly separates a junior engineer from a senior one. Newspaper sub-editors have practised this second skill under deadline for more than a century. They receive a draft from a writer, tighten it, check it for sense and hand it on, usually within minutes. Here is a walkthrough of their routine, adapted to reviewing your own DevOps work: Terraform files, pipeline definitions, shell scripts or configuration. No special tools are needed, only a notebook and about twenty minutes.
Why a sub-editor and not another engineer?
Because the sub-editor’s situation resembles yours more than you might expect. They work alone on a deadline, they did not write the first draft (or have forgotten it), and mistakes that slip through are public. They cannot rely on a colleague noticing. So they developed a layered method that catches different kinds of error on separate passes, rather than hoping to catch everything in one read.
That layering is the useful part. Most self-review fails because it is one vague pass: you glance through the file, see what you meant to write instead of what you wrote, and approve it. The steps below force you to look at the same change several times, each time for one thing only.
Step 1: Let the draft go cold
Editors rarely edit immediately after writing. They leave a gap, even a short one. Do the same: finish your change, then do something else for ten minutes. Make tea, answer a message, walk to the window. After a gap you read your own code more like a stranger would, which is exactly the effect you need.
Step 2: Restate every change as a plain sentence
The first editorial pass is for sense. Read the diff slowly and describe each change in plain English in a text note: “this opens port 8080 to the load balancer” or “this deletes the old storage bucket after copying.” If you cannot describe a line simply, you probably do not understand it well enough to ship it. Where your description surprises you, stop and investigate.
Step 3: Check the facts
Editors verify names, figures and dates against the source. In infrastructure terms, check every concrete value: region names, resource identifiers, version numbers, environment names. A staging value pasted into a production file is the equivalent of the wrong name under a photograph. Keep a short list of the five values that would hurt most if wrong and check those first.
Step 4: Cut what is not needed
Sub-editors trim ruthlessly. Their rule is that every sentence must earn its place. Look at your change and ask what you could remove without losing the behaviour you want. Commented-out blocks, leftover debugging lines and settings that merely repeat the defaults all add noise for the next reader. Taking them out shrinks the change, which makes it quicker to grasp and simpler to undo.
Step 5: Check the headline, which here is the commit message
The headline is what most people read. For your change, the equivalent is the title and description. Does the commit message say what changed and why, in a sentence that a person on call at night could grasp? “Fix config” fails this test. “Raise queue worker memory limit to stop nightly restarts” passes it. Rewrite until the message would still make sense in six months.
Step 6: Look for the libel risk, in other words the dangerous change
Newspapers train editors to spot the sentence that could cause real harm. Do the same hunt in your diff. What is the one line that, if wrong, would cause an outage or expose data? Open permissions, a deletion command, a change to a shared network rule. Read that line three times and write down what you believe it will do. If the plan includes a way back, note it next to the line. For an introduction to how engineers grow into this kind of judgement over time, the article on the climb from entry level to seniority in DevOps is worth a read.
Step 7: Sign off with a short note
A finished sub-edited piece goes on with a short note for whoever handles it next. End your review the same way. Write two or three lines: what you checked, what you did not check, and anything the next person should watch after the change goes live. It takes a minute, and it turns a private review into something a teammate can build on.
What this looks like on a real morning
Imagine a pipeline definition that adds a deploy step to a small service. In the cold-read gap, you fetch coffee. On the plain-English pass, you realise the step runs on every branch, not only the main one, which you did not intend. On the facts pass, you find the target environment name is a leftover from a test. On the cut pass, you delete a commented-out block from an earlier experiment. The headline pass turns “update pipeline” into something precise. The risk pass flags the deploy command itself and prompts you to add a manual approval before production. Total time: about twenty minutes. Total number of problems that reached your colleagues: none.
The slips this routine tends to catch
After a few weeks of keeping notes, most engineers notice that their own errors cluster. Yours might be copy-pasted values, forgotten cleanup or changes that quietly touch more than intended. Keep a running tally in the back of your notebook, and give each recurring slip its own line on the checklist. A sub-editor keeps a personal list of pet errors for the same reason: the writers they work with repeat the same ones, and so do they.
- Scope creep inside a single change. You meant to adjust one setting and also tidied two unrelated files. Split them.
- Environment mix-ups. Names that differ by a single word are easy to confuse. Search the diff for every environment name and confirm each one.
- Silent defaults. A new resource that takes a default value you never looked at. Read the documentation for at least the settings that affect access or cost.
Over time the list becomes a short, personal quality gate. Colleagues rarely see it, but they notice the result: fewer corrections requested on your changes and faster approvals.
Making the habit stick for your career
Engineers who review their own work this way build a reputation for dependable changes, and that reputation tends to open doors. Those who move from system administration into DevOps will find it a useful bridge, since sysadmins already have the instinct to distrust surprises; this write-up on changing course from sysadmin and support into DevOps shows what that transition can involve. For a wider view of the options available to developers who pick up operations skills, see what new career paths DevOps opens for software developers.
If you want other ideas outside your own field, browse widely. Gyan School is one stop to try: a single landing page for engineering study, whose menu leads on to articles, discussion and an LMS, and whose tracks include application development, machine learning and operations. Combine reading like that with chats with friends in other professions, and you will keep finding routines worth adapting.
A quick recap you can print
- Let the draft go cold for ten minutes.
- Describe each change in plain English.
- Check the concrete values.
- Cut anything unnecessary.
- Rewrite the commit message.
- Study the most dangerous line.
- Leave a short sign-off note.
Try the full routine on your next change, then drop the steps that do not catch anything for you. The method is a starting point, and the sub-editor would be the first to say that good practice is the practice that works.