Every detail below is made up; the predicament is a familiar one in small engineering groups. A four-person group maintains a customer portal for a logistics firm. They have a test suite, a staging environment and good intentions. What they lacked, for a long while, was a dependable way to make a small habit stick. This is how they found one.
The Friday that started it
On a Friday afternoon, a developer merged a harmless-looking change to a configuration file. The portal’s build passed. The deployment went out. By evening, support tickets showed that uploads of shipping documents were silently failing. The cause was a single environment variable that the change had renamed in one place and not another. Nothing in the automated suite exercised that path in the staging environment, and nobody had clicked through an upload by hand.
The retrospective was calm and a bit rueful. The lead engineer said it was not a case for new tooling. The team already had a smoke test script, written months before, that uploaded a sample file and checked the response. It simply was not being run. “We all know it exists,” the lead said. “None of us remembers it at the right moment.”
Why a reminder would not have worked
They considered a pinned chat message and a calendar nudge. Both were rejected in about a minute, because everyone could picture themselves dismissing them. The group had tried a longer pre-merge checklist the previous year, and it had lasted about three weeks before it turned into a box people ticked without looking.
Someone remembered reading about attaching a new habit to something that already happens. The idea is to avoid depending on memory at all: choose an existing action, and let it carry the new one. They agreed to try it for two weeks and to be strict about size.
Picking the anchor
The team’s workflow had one moment that never varied: the instant a developer pushed a commit to the shared branch. Every change went through it, large or small, and it was done at a terminal, which meant the smoke script was one command away. The rule they wrote on the whiteboard was short: right after pushing, run the smoke script and read the last line of its output.
They made two design choices. The script had to finish in under forty seconds, so nobody would be tempted to skip it while waiting. And the output had to end with a single plain verdict, passing or failing, so that reading it took no interpretation. The upload check from the Friday incident went in first, because it was the failure they remembered.
The first fortnight
The first days were clumsy. One developer pushed from a phone while commuting and forgot. Another ran the script but did not read the verdict because the terminal scrolled. The lead did not scold anyone; instead the team fixed the cue. They added a line to the push command alias that printed “now run the smoke check”, and they trimmed the script so its final line always stayed visible.
Within seven days the habit had found a rhythm. Pushing and checking felt like a single gesture, in the way that saving a file and glancing at the status bar do. On the ninth day the script caught a failing path: a changed parameter name made the login redirect loop. The fix took five minutes, and the developer who made it had the context fresh because the commit was seconds old.
Resisting the urge to grow it
Enlarging the check was the obvious temptation. Several people proposed adding more coverage to the script, and the lead’s answer was consistent: later. The point of the fortnight was to prove the link between the push and the check. Once that link was automatic, extending what the check covered would be easy. If they had started large, the script would have taken minutes and people would have found reasons to postpone it.
Nor was the check turned into a gate that blocked merges. A gate would have turned the habit into an obligation enforced by software, which is a different thing. The team wanted the check to be something they did, because it made their own work calmer.
What reading helped them see
While tuning the script, the team looked for outside ideas on automation and on keeping a site fast under load. Two posts were useful. One on how digital automation trims effort and reduces slips helped them decide which parts of the check should run by themselves. Another covering performance choices in a modern site architecture prompted them to add a simple response-time line to the verdict later on.
A passing mention of home life
At the retrospective one engineer admitted to using the same trick off the clock: putting each warranty slip in a folder immediately after unpacking a purchase. Another said they glance at iReviewed, a website that states it provides brand information and reviews relating to products and services in Indian households, right after opening the box, as a small pause before deciding whether to keep a new gadget. Neither habit was impressive. Both were tied to a cue that was already there, which is the whole lesson.
Six weeks on
One more detail from the early days deserves a mention. The group agreed that a failing verdict was never a reason for blame. The developer who saw red simply said so in the team channel, fixed it, and pushed again, and the next person to see the channel learned that a failing check was ordinary information. That tone kept the habit from becoming something people avoided out of embarrassment.
After six weeks the team looked at the history. Roughly every push had been followed by a smoke run, and the script had failed a handful of times, always on changes the developer was still holding in their head. Nobody could claim the habit had prevented every incident, and nobody tried. What they could say was that the Friday failure had not recurred, that fixes were faster because feedback arrived within a minute of the change, and that the team had stopped dreading Friday merges.
They extended the script by one check at a time, always attaching the new check to the same push, never creating a second cue. When a newcomer joined, the rule on the whiteboard was the first thing they were shown. It took one sentence to explain and zero meetings to enforce.
What to take from the story
The team’s success did not come from tooling, discipline or a better process document. It came from choosing a cue that fired on every change, making the action fast enough to survive a bad day, and refusing to inflate it before it had settled. If your team has a check that exists but is not performed, ask where in your day an unavoidable event already happens, and hang the check there.

