6 Myths About Fixing One Flaky Engineering Annoyance a Month

6 Myths About Fixing One Flaky Engineering Annoyance a Month

Engineering teams tolerate a surprising amount of friction: the flaky test that passes on retry, the deploy step someone runs by hand, the alert that fires every Tuesday. A sensible countermeasure is to select one such recurring annoyance each month and remove its cause. The practice is simple, yet it is surrounded by myths that stop teams from starting. What follows takes six of them in turn and holds each up to ordinary day-to-day delivery.

Myth 1: “Small annoyances are not worth engineering time”

The cost of a minor irritation is paid repeatedly. A test that fails intermittently and takes two reruns costs a few minutes per developer per day, and the loss compounds across a team and across months. There is a second cost that rarely appears on a spreadsheet: people learn to distrust the signal. When a failing build is routinely dismissed as noise, the one genuine failure is dismissed as well.

Reality: recurring friction is often more expensive in aggregate than the occasional large defect, precisely because nobody budgets for it.

Myth 2: “We should wait for a big refactor”

Teams postpone fixes because a larger rewrite is planned. The rewrite then slips by a quarter, then another, and the annoyance is carried the whole time. Most recurring irritations have a narrow cause, such as a missing timeout, a shared fixture, an unpinned dependency or a manual copy step, that can be corrected in a single sitting without touching the architecture.

Reality: fix what repeats now, and let the refactor inherit a cleaner baseline.

Myth 3: “Retrying is a fix”

Automatic retries are a workaround. They hide the failure from the pipeline and leave the cause intact, often adding build minutes. A retry is acceptable as a temporary measure with an expiry date, and it should be recorded as such. Without that discipline, retry counts creep upward and the suite becomes slower without anyone deciding it should.

Reality: a fix removes the condition that produces the failure. If the same job still needs the retry afterwards, the cause remains.

Myth 4: “The team must agree on priorities before anything starts”

A long planning discussion can consume more time than the fix. The monthly practice uses a lightweight rule instead: a shared list, a count of occurrences and a vote at month start. The highest count wins unless a safety or security concern overrides it. That removes the debate about taste and replaces it with a number the team can observe.

Where a team is working through formal scoping of a web build, a long-form deep dive into laying out what a web project must do shows one way requirements get organised; the monthly fix list simply sits beside that work as a small, separate stream.

Reality: a visible count settles priority more quickly than a meeting does.

Myth 5: “Fixing one thing a month is too slow”

Twelve root-cause fixes in a year is not slow when each removes a recurring cost for good. Consider a pipeline whose manual approval step wastes ten minutes per release across forty releases a month. Removing it recovers more than six hours monthly, indefinitely. By contrast, ten simultaneous half-finished fixes recover nothing until they land, and they usually do not land.

The limit of one is deliberate. It keeps work-in-progress low, forces a clean finish and ensures the team can verify the result before choosing again.

Reality: steady, finished fixes accumulate; scattered attempts evaporate.

Myth 6: “We need a new product to solve it”

Many recurring problems are solved by a configuration change, a script of ten lines, a clearer ownership rule or a deleted step. Buying something is occasionally right, but it should follow an honest check that the cause is not simply a setting or a habit. Teams that look at outside material for vocabulary may find it in places such as a site that presents sample-data listings of software and technology offerings, sorted by what they are and which problem they address. It is useful for naming a category of problem, not for deciding what to adopt.

Before any purchase, a guide that lists what to ask prior to commissioning a bespoke web app is a reminder to test whether the need is real. The same discipline applies to tooling choices made to cure a nagging annoyance.

Reality: start with the cause. The solution is frequently smaller than the problem’s reputation suggests.

A year of fixes in a typical team

To see how the myths fall away in practice, imagine a platform team that keeps a plain list. In the first month it removes a flaky integration test by isolating shared test data. The second month it deletes a hand-run database migration step by adding it to the release job. The third month it adds a missing timeout to a service call that periodically hung the nightly build. None of these needed a rewrite, a purchase or a committee. By month six the weekly complaints in standup had shifted from the same three items to new ones, which is the clearest sign that the list is doing its job.

The pattern here is worth stating plainly. Each fix targeted an event that had a measurable repeat count, each had an identifiable cause that one person could change, and each ended with something deleted: a retry, a manual step, a workaround note. Teams that finish a fix by adding a new layer of process tend to relive the annoyance in another form. Subtraction is the more reliable sign of a real repair, and it is also the cheapest to maintain.

What a good monthly fix looks like

  • It names one recurring event, with an occurrence count from logs or tickets.
  • It identifies the cause, not just the symptom, and states it in one sentence.
  • It changes the system so the event cannot recur, rather than asking people to be careful.
  • It deletes the old workaround, including any document that describes it.
  • It is verified a month later by repeating the count.

Starting without ceremony

No special tooling is needed. A shared document, a calendar slot and a rule that one item is chosen per month are enough. Begin by listing the annoyances your team mentioned in the last two weeks of standups, count each, and choose the highest. When that fix is verified, move to the next. After a few cycles, the list becomes shorter, the pipeline becomes more trustworthy and developers stop pre-emptively expecting failure. That change in expectation is the most durable result of all.