5 exercises on the precise English verbs used when finding, exposing, and recreating software defects.
Key discovery collocations
reproduce a bug → recreate the exact conditions (standard QA term)
uncover a regression → reveal a hidden failure (automated or exploratory)
spot an edge case → notice something in review or manual testing
trigger a scenario → cause specific conditions to occur
introduce a defect → accidentally create a bug with a code change
0 / 5 completed
1 / 5
A QA engineer says: "Our automated smoke tests ___ a regression in the payment flow after the latest deploy."
Which verb is correct?
"Uncover a regression" — the precise collocation for revealing a hidden failure:
Uncover implies that the regression was lurking beneath the surface and has now been exposed. It is especially natural when automated tests or monitoring do the discovering.
Bug-discovery verb family:
uncover a regression / a defect → reveal something previously hidden
detect an anomaly → automated systems often detect
spot a bug → informal, human observation: "I spotted a typo in the error message"
surface a defect → bring a hidden issue to visibility: "The load test surfaced a race condition"
catch a bug (in review) → intercept before it reaches production
Why not "found"? "Found a regression" is grammatically fine and widely used, but "uncovered" specifically implies the regression was hidden — which is the typical meaning when smoke tests run post-deploy. Both are acceptable; "uncover" is more precise and professional.
2 / 5
During code review, a senior developer says: "Good catch — you ___ an edge case that could have caused a null pointer exception in production."
Which verb completes the sentence?
"Spot an edge case" — the natural collocation for noticing something in review:
Spot means to notice or identify, typically by a human (as opposed to automated tools which "detect" or "catch"). It is commonly used for things found during code review, manual testing, or visual inspection.
Discovery verbs by context:
spot → human observation, often during review or testing: "spot a bug", "spot a regression", "spot an edge case"
trigger → to cause something to happen, not discover it: "trigger an edge case" = make it occur, not find it
catch → intercept before it escapes: "catch a bug in review", "catch an error early"
surface → bring to light: "surface a latent defect"
Edge case vocabulary: "Edge case" refers to input or state at the extreme boundary of expected values. Related: corner case (intersection of two edge conditions), boundary case (exactly at the limit). Always say "handle an edge case" or "test for edge cases", not "do edge cases".
3 / 5
A developer writes in a Slack message: "I was able to ___ the bug consistently — it happens every time the user has exactly zero items in their cart and clicks checkout."
Which verb is correct?
"Reproduce the bug" — the universal standard for recreating a defect:
Reproduce (verb) / repro (informal noun/verb) means to recreate the exact conditions under which a bug manifests. If you can reproduce a bug, you can investigate and fix it.
Reproducibility vocabulary:
reproduce consistently → happens every time (deterministic): "Can you reproduce it consistently?"
reproduce intermittently → only sometimes (non-deterministic, flaky)
repro steps → short for "reproduction steps" (the sequence of actions)
Cannot Reproduce (CNR) → standard ticket status when the bug cannot be recreated
heisenbug → a bug that disappears when you try to observe or reproduce it (named after Heisenberg)
Key phrase: "Reproduced on Chrome 124, Windows 11 — see repro steps in the ticket description." The word "consistently" strengthens the report, distinguishing a deterministic bug from a flaky one.
4 / 5
A product manager writes a ticket: "Users reported the dashboard loading slowly. After analysis, the team confirmed the recent caching refactor ___ a performance defect."
Which verb is correct?
"Introduce a defect" — the standard collocation for accidentally creating a bug:
When a code change causes a new bug, we say the change introduced a defect or regression. This is the professional way to describe how bugs enter a codebase — without blaming an individual directly, while still being specific about the cause.
Bug-origin vocabulary:
introduce a bug / regression / defect → a change accidentally creates a new problem
uncover a latent defect → the bug was always there, but new code exposed it
trigger a regression → a specific action causes the bug to manifest
surface a defect → bring a hidden issue into visibility
Latent vs introduced defect: A latent defect is a bug already present in the code that hasn't been triggered yet. An introduced defect is caused by a specific change. This distinction matters for root cause analysis: "Did we introduce this regression, or did we uncover a latent defect in the legacy payment module?"
5 / 5
A tester says: "The bug only appears under very specific network conditions — we need to ___ exactly the right scenario in our test environment to see it."
Which verb is correct?
"Trigger a scenario" — the correct collocation for causing conditions to occur:
Trigger is the go-to verb when you want to cause a specific condition, event, or code path to execute. It is used extensively in testing, DevOps, and debugging contexts.
Trigger collocations in testing:
trigger a scenario / edge case / bug / failure → cause it to occur
trigger a deployment / pipeline / build → start an automated process
trigger an alert → cause a monitoring alert to fire
trigger a race condition → create the timing conditions for a concurrency bug
Discovery vs triggering: Note the distinction: you trigger (cause) an edge case to happen, then you spot or catch (discover) the resulting bug. The tester in this question wants to trigger the scenario so they can then observe the bug. Related vocabulary: replicate the conditions, simulate the network failure, stub the external service.