What's the difference between a regression and a new bug?

A regression is a bug that breaks something that previously worked, usually introduced by a change, while a new bug is a defect in something newly added (like a freshly-implemented feature). A regression undoes existing functionality; a new bug is a flaw in new functionality that never worked correctly. The distinction matters because a regression points at what changed, traceable via version tracking, while a new bug points at the new feature.

How do I find what caused a regression?

Use version tracking. A regression broke something that previously worked, so it started in a specific version, the one where the change that caused it shipped. Tagging issues by version makes a regression show up as a problem new on a particular build, pointing you at that update's changes (the diff between the last good version and the first bad one), which is where the cause lives. Without version tracking, a regression is a blind search.

Why are regressions especially worth catching?

Because they erode stability over time, each regression undoes a feature that was working, often in an area unrelated to what you intended to change, and if they accumulate unfixed, your game gets less stable with each update. They're also frustrating to players who had working functionality taken away. Catching regressions (via per-version tracking and regression testing) before or shortly after they ship keeps stability trending up rather than degrading.

Regression vs New Bug: What's the Difference?

Quick answer: A regression is a bug that breaks something that previously worked, usually introduced by a change; a new bug is a defect in something new. A regression points at what changed; version tracking reveals which update caused it.

Not all bugs are alike: a regression broke something that used to work, while a new bug is a flaw in something new. The distinction shapes how you diagnose and prevent them. Here's the difference between a regression and a new bug.

What a Regression Is

A regression is a bug that breaks functionality that previously worked. Something was fine, you made a change, and now it's broken, the change caused a regression. Regressions are insidious because they undo working features, often in areas unrelated to what you intended to change, and they erode stability over time if not caught.

Because a regression is tied to a change, it's traceable: it started in a specific version. Bugnet tags issues by version, so a regression shows up as a problem new on a particular build, pointing you at the update, and the changes, that caused it.

What a New Bug Is

A new bug is a defect in something newly added, a freshly-implemented feature that has a flaw, or a new piece of content that doesn't work right. It's not breaking something that worked before; it's something that never worked correctly because it's new. New bugs are expected when adding features.

New bugs are part of building, any new code can have defects. Bugnet captures these alongside regressions, but the key difference is that a new bug is in new functionality, while a regression broke existing functionality. The diagnosis differs accordingly.

Why the Distinction Matters

The distinction guides diagnosis and prevention. A regression points you at what changed, the diff in the version that introduced it likely contains the cause, so version tracking makes regressions far easier to trace. A new bug points you at the new feature itself. Regressions also signal a need for better regression testing to catch them before shipping.

Bugnet's per-version tracking is what lets you tell a regression (new on a build, breaking old functionality) from a new bug (a flaw in new functionality). So treat regressions as traceable to a change, use version tracking to find which update caused them, and recognize new bugs as defects in new work, each with its own diagnostic path.

A regression breaks something that previously worked (usually from a change); a new bug is a flaw in newly-added functionality. A regression points at what changed, version tracking reveals which update caused it.