One line changed on a Friday afternoon. The tests passed. The page broke anyway, because the new code never met an empty list.

The fix was not hard. The check was missing. That is the whole subject of this article: the step between knowing something is wrong and changing it. Most of the damage in software does not come from fixes that were too small. It comes from changes nobody checked.

The fix that broke the fix

Here is the shape of the bug, stripped down to nothing:

def average(items): return sum(items) / len(items) average([]) # ZeroDivisionError: division by zero 

Total divided by count, and count was zero. The code was correct for every list except the empty one, and the empty one was the case nobody tested. In Python this raises an error. In JavaScript the same expression quietly becomes NaN, and the wrong value ships without a sound. Neither outcome is a mystery after the fact. Both were preventable before it, with one question: what happens when there is nothing here?

That question is the check. It costs seconds and it catches the class of bug that tests miss, because tests usually cover the cases the author already thought of. The empty list, the single item, the missing field, the user with no history: these are the cases that break in production, because production is where the cases nobody imagined show up first.

A fix that introduces a bug is not a rare event. It is the normal result of changing code you have not fully understood, and shipping it on the strength of tests that never met the edge case. The remedy is not more caution in general. It is a specific habit: check the change against the cases it will actually meet, before it ships.

Understand it before you edit it

The same habit applies upstream, before the fix exists at all. You inherit code. You open a library you never touched. You meet your own code from six months ago. You can read every line and still not know what it does, because reading lines is not the same as understanding behavior.

So ask first, in plain words. Paste the code and ask what it does, line by line: what it does, why it does it, and the parts worth a second look. The explanation is the diagnosis. Once you can say what the code does and why, the edit writes itself, and the check at the end has something to check against.

Editing code you do not understand is guessing with a keyboard. The edit might work. It might also quietly break the empty-list case, and you will find out on Friday afternoon, from a user, instead of from your own check ten minutes earlier.

This is also why "verify before you edit" is not a slogan. It is the order of operations. Understand, then change, then check. Skip the first step and the third step has nothing to stand on.

Check the answer before you quote it

Research has the same shape, in a different form. Six tabs open, three notes, and still no answer. The research is scattered across tools, so the answer never lands in one place, and when it finally does, you have no idea whether any of it holds.

The fix is the same habit. Ask the question once, in one workspace, and get the answer back with its sources attached. Then check the sources instead of trusting the summary. A citation is a check you can run: open it, read it, confirm the claim. An answer with no sources is a claim you cannot verify, which means the checking still has to happen later, at the worst possible time, usually in front of somebody else.

Notice the pattern across all three cases. The code fix, the code you do not understand, the research answer: each one fails the same way, by skipping the check and paying for it later. And in each case the check is cheap at the start and expensive at the end. Read the sources now, or defend the quote later. Understand the function now, or debug the breakage later. Test the empty list now, or explain the outage later.

Know the deal before you sign up

The habit applies to tools, too. Most free tiers are a demo with a paywall behind it: the real workspace shows up only after you pay. So before you sign up for anything, check what free actually gets you.

SpyCore's free tier is the workspace itself: chat, research, code, reasoning, and images, in one place, no card. The limit is honest: 500 credits a week, and when they run out you wait for the refill. Nothing is locked behind a higher plan. Paid plans only add more room to work. You pick, or let it route for you. Both ways are in the free tier.

That matters for the same reason the empty list matters. A tool that hides its limits is a tool that breaks on you later, in the middle of real work. A limit stated up front is a limit you can plan around. The check is the same: know what you are getting before you commit to it.

What a real check looks like

So what does "check it" actually mean, in practice? Four moves, and none of them is exotic.

  1. Reproduce it first. Before you fix anything, make the failure happen where you can see it. A fix for a bug you cannot reproduce is a guess, and you will not know whether it worked.
  2. Test the edges, not just the middle. Empty, one item, missing, huge. The middle is where the author already looked. The edges are where production lives.
  3. Confirm nothing else changed. Run the behavior you already had and confirm it still does exactly what it did before. A fix that breaks something else is not a fix. It is a trade, and usually a bad one.
  4. Read the fix and the reason together. A fix without a reason is a change nobody can review, maintain, or trust next month. The reason is part of the fix.

None of this needs a new tool. It needs one place where the work stays put: the failing code, the explanation, the fix, the sources, all together, so nothing gets re-explained and nothing gets lost between tools. The check lives next to the change it checks.

A first task for this week

Here is the whole method as one task, small enough to do today.

  1. Pick one function you changed this week.
  2. Ask what it does, line by line, before you touch it again.
  3. Ask what it breaks: empty input, one item, missing field.
  4. Fix what you find, then confirm the old behavior is unchanged.
  5. End with one finished thing, checked, not just changed.

Try it on real work. SpyCore has a free tier, no card, and the whole workflow above runs in one workspace: chat, research, code, and images together. One subscription, one weekly credit pool, no overage, so a check run first is not a guess burned on the wrong direction.

Check before you change it. Understand it, test the edges, confirm nothing else moved. Then ship it, and pick up the next one.