Hunter

@sks24git

github.com/sks24githunting since August 2026

128species caught
128discoveries
2132stories

Collection

Stories

@sks24git2026-11-07beat 2 review rounds
A watcher looked up a commit's build runs on one page, but its own scheduled runs pile up on that same commit. After two quiet days the real build falls off the page, and a stale site goes unreported.
Filter a list query to what you look for, not just the first page. Your own noise can push the answer off it.
@sks24git2026-11-07beat 1 review round
A new alert for a bad API answer sat after an older parser that crashes on that same answer, in a script that stops at the first error. The script dies first, so the new alert never fires and nothing reports.
Check what runs before your new line. Under stop-on-error, an earlier crash makes the later check dead code.
Turn a bad answer into an alert, not a throw.
@sks24git2026-11-07
A watcher picked the deploy runs of a release by their creation time, but a re-run keeps its old creation time. The re-run that ships the release is left out, and a cancelled run reads as a failed deploy.
Time a run by when it started, not when it was created. A re-run reuses its first creation time.
Pick runs by branch too, not by commit alone.
@sks24git2026-11-07beat 2 review rounds
A note promised a figure stays the same on every read, but the figure is read live and a late charge moves it. A client trusts the first zero it saw and books a paid item as free.
Fix a false sentence by deleting it. A truer claim in its place adds a new one to prove.
Never promise a live read is stable. Late writes break the promise silently.
@sks24git2026-11-07beat 1 review round
A reply had two exits, and the explaining note was added to only one of them. The exit taken most often still showed a bare zero, the very reading the change set out to stop.
Build the reply once, spread it on every exit. An early return skips what you add below it.
Label a total as a total. A per-item sum beside a per-call figure gets added up twice.
@sks24git2026-11-07
A test asserted inside a fake dependency whose caller catches every error and treats it as a failed call. A broken assertion turns into a quiet fallback, and the test stays green either way.
Record inside fakes, assert after the call returns. A swallowing caller eats the assertion's throw.
@sks24git2026-11-07beat 2 review rounds
A freshness watch checks that the release step did not fail and that the site names some build. A release that never starts trips neither check, so the site sits a day behind and every check stays green.
Check the outcome, not only each step. A step that never runs has no failure to report.
Write the state table before the watcher. Each missing row comes back as one more finding.
@sks24git2026-11-07
A receipt explained why a charge was zero, but several different causes all read as zero, and it named only one of them. A client trusting the note would act on a reason that was false for its own case.
State what you saw, not why. One zero has many causes; a guessed reason misleads.
Test the fallback, not just the happy read. An untested catch can't be told from a missing one.
@sks24git2026-11-06
A layout test switched on a side panel but cut off the data feed that keeps it mounted. The panel mounts and unmounts in a race, so the overlap check measures a button in one of two spots and flakes.
Turn on only what the test can feed. A widget whose data is cut off races its own removal.
Measure the layout users get, not a half-built one.
@sks24git2026-11-06beat 1 review round
A lag alert starts its clock at the commit date, not at when the change landed. Merge work that was written a day ago and the alert fires at once, while the release is still running on time.
Judge a pipeline by its own run results, not by clocks. Commit dates say when code was written, not when it shipped.
Stop patching a design that yields one bug per fix. Change the design.
@sks24git2026-11-06
A staleness alert waits one grace period, counted from the newest change rather than the oldest one still not live. Each new change resets the clock, so a release step that keeps failing stays silent all day.
Count lag from the oldest pending change. The newest one resets with every merge.
Parse what a probe reads in tested code. A shell one-liner fails quietly and alerts falsely.
@sks24git2026-11-06
A fix made a page hide its optional widgets when the settings call fails, but it parsed any a message body as a real answer. A server error reply carries no settings, so every widget the owner switched off draws again.
Check the status before you parse the body. An error page in a message reads like an answer with every field missing.
Fail closed on a missing field, not only on a failed call.
@sks24git2026-11-06beat 2 review rounds
A check scrolled a link into view, then read its position on the next line. The page asked for smooth scrolling, so nothing had moved yet and the check measured the old spot.
Pass instant scroll before you measure. Smooth scroll is a promise, not a move.
Treat an unread value as a fault. A fallback that passes hides the case you cannot see.
@sks24git2026-11-06beat 1 review round
A pre-flight check probed only the first of several job kinds, so a dead service behind another kind passed it. Each success of the first kind reset the outage counter, and the failing kind spent the budget.
Probe every path the run will use, not the first one. A check that covers one path proves nothing about the rest.
@sks24git2026-11-06
A new judge path got tests only on clean text, never on text the scanner flags as risky. Drop the flagged pieces from its prompt and every test stays green while the comparison quietly skews.
Test a new branch on every input class the old ones were tested on. A clean-input test proves the happy path only.
@sks24git2026-11-06beat 1 review round
A browser check asked what sits under each corner of a link, but never scrolled the link into view first. Off screen the answer is nothing, so the check fails a page that works the day the layout moves down.
Scroll before you hit-test. A point off screen hits nothing and looks like a bug.
Keep pass rules out of the browser loop. A pure function can be graded; inline code cannot.
@sks24git2026-11-06beat 1 review round
A deploy job runs its checks from its own checkout but builds the newest commit, which can be newer than that checkout. The old checks then judge the new release, so a correct release fails or a broken one passes.
Check a build with the checks from the same tree. Checks and the code they judge change together.
Pin what a queued job sees at start. A queued job wakes up in a newer world.
@sks24git2026-11-06
A deploy queue keeps one waiting run, and a later trigger for an older commit replaces it. The older run then sees it is not the newest commit and exits clean, so the newest commit never goes live.
Let any deploy run target the current head. Then queue order cannot drop the release that matters.
Read your queue rules before trusting a skip. A green no-op can hide a lost run.
@sks24git2026-11-06beat 2 review rounds
A small link was lifted above a card-wide click layer, but the card was a column flex box. The link stretched to the full row, so clicks on empty space beside it went to the wrong page.
Measure the box, not the words. In a flex column a link grows to the full width unless you stop it.
Hit-test the empty space too. The bug lives where nothing is drawn.
@sks24git2026-11-06beat 1 review round
A card went from one big link to a plain box, kept clickable by a link stretched over it from its top line. The bars inside were positioned too and painted above that layer, so a click on them did nothing.
Hit-test every region after a stretched link. A positioned child painted later sits on top and eats the click.
Give the overlay a z-index. Paint order, not markup, decides who gets the tap.
@sks24git2026-11-06beat 1 review round
A sign-in path stopped redeeming a stored code but kept the code stored, so a dead code was never cleared. Every later sign-in got pulled to a form that could not use it, for a month.
When a path stops consuming a value, decide who clears it. The old consumer was its only cleaner.
Move a value with the user, don't leave a copy. Carry it in the link and drop the stored one.
@sks24git2026-11-06
A fix moved a stored code from auto-apply to a manual form, but only the old path ever cleared it. Once the form applies it, the stale code stays stored and blocks newer ones for a month.
Move the cleanup with the action. A new path that does the work must drop what the old one dropped.
Keep the caller's destination. A detour that replaces it loses what the link was for.
@sks24git2026-11-06beat 2 review rounds
A guard banned "sends only" wording but matched only when the qualifier came after the verb. A page saying "Only listed files leave" kept the banned claim, and the test stayed green.
Search for the qualifier, then read each hit. Word order beats a verb-first pattern every time.
@sks24git2026-11-06beat 1 review round
A stop flag was checked before each item, but one item makes two slow model calls in a row. Stopping during the first call still let the second one start, so the stopped worker held its lock long past its exit window.
Check a stop flag before every slow step, not only before every item. One item can hold several long waits.
@sks24git2026-11-06beat 2 review rounds
A check read where a click came from, but real clicks pass through a hop whose headers tell the browser to drop that detail. Tests sent the detail straight to the end, so they passed while the feature never fired.
Test through every hop a real request takes. A shortcut in the test skips the hop that breaks it.
A header your redirect sends changes what the next request carries.
@sks24git2026-11-06
A new branch fires only on requests carrying one header, and the test for the signed-in case never sends it. Reorder the checks and every test stays green while signed-in users fall into the new path.
Send the header your real users send. A test without it never reaches the branch it claims to guard.
Pin the order of checks that guard each other.
@sks24git2026-11-06beat 1 review round
A status page copied the setting names and default values that the real readers use, instead of sharing them. Rename a setting or change a default and the page shows a state nothing runs, while every test stays green.
Share one name and one default per setting. A status view with its own copy reports the past.
Put shared constants in a leaf module. A new import cycle can leave a value undefined at load.
@sks24git2026-11-06
A page count was cached in one shared slot for the whole process, keyed by nothing. A second data source in the same process then reads the first one's number, so tests pass or fail by their order.
Key a cache by all its value depends on. A missing key part serves one source's answer to another.
Delete the tests with the feature. A test of removed output fails the build, not the code.
@sks24git2026-11-06
A status line had a branch for a broken saved config, but the loader had already dropped broken configs. So the page says nothing is set, and the operator never learns the saved one is ignored.
Show state from the raw row, not the cleaned one. A loader that drops bad input hides it.
Test the page, not the helper. A helper fed raw input passes while the page never sees it.
@sks24git2026-11-06beat 1 review round
A test drove a copy button through a fake element that returned a fixed string, never the value the page renders. Swap in another product's commands and every test stays green while users copy the wrong lines.
Assert what the user gets, not what your stub returns. A fake that answers for the page hides the page.
Pin each variant's output. One branch tested says nothing of the other.
@sks24git2026-11-06
A page gained a copy button driven by an inline script, but the page's security policy allows no script at all. The tests only searched the page text, so they passed while every click did nothing.
Test a page script under the policy the page really sends. A text search passes for code the browser blocks.
Hash each inline script into the policy. Otherwise it never runs.
@sks24git2026-11-06beat 2 review rounds
A shutdown was taught to wait for background work, but with no limit on the wait. One hung task would keep the process up until the platform killed it, past the window set aside to hand work back.
Cap every wait you add to a shutdown, and count it in the kill budget. An unbounded wait swaps a race for a hang.
@sks24git2026-11-06beat 1 review round
A worker's stop cleared its timers but never waited for a pass a timer had already started. That pass kept its lock and took work queued after stop returned, so the next test's own run found the lock busy.
Make stop wait for the work its timers started. Clearing a timer stops the next run, not the one in flight.
@sks24git2026-11-06beat 2 review rounds
A test for a priority window planted only rows inside the window, so the window's size never changed the outcome. Shrink the window to minutes and every test stays green while retries fall behind the backlog.
Put a row on both sides of every boundary you test. One side alone proves nothing about the line.
Mutate each constant once and watch a test fail.
@sks24git2026-11-06beat 1 review round
A queue moved its priority into a computed sort key ahead of the time column. The index could no longer stop at the limit, so every worker scanned and sorted the whole backlog once a minute.
Express priority as separate index-ordered selects, not a computed sort key. The limit stays cheap.
Plant test rows out of order. An in-memory store hides a missing sort.
@sks24git2026-11-06
An offline measuring tool copied the live checker's decision steps, and then the live checker changed how it treats soft hits. The copy kept holding those stories, so every result on them measured an old rule.
Call the live code from a measurement, never a copy of it. A copy drifts quietly, and the numbers keep coming out as if nothing changed.
@sks24git2026-11-06beat 2 review rounds
A guard that compares two record versions was tested only on hand-built rows, never on rows read back from storage. Swap the stored version for the reader's constant and every test stays green.
Test a guard on the data path it guards. A hand-built row skips the read that fills the field.
@sks24git2026-11-06beat 1 review round
A replay paired a stored model score with a scan by checking the score's version against the reader's own constant. During a rollout a newer scan sits beside an older score, and the pair passes on pieces never judged.
Compare two records with each other, not each with your own build. Old and new code run side by side mid-deploy.
@sks24git2026-11-06
A race test fired its delete right after the first read, but the code under test read the same table again before its own guard. The earlier read caught the delete, so removing the guard kept the test green.
Fire the race inside the window the guard closes. Remove the guard once and watch the test fail before you trust it.
@sks24git2026-11-06beat 6 review rounds
A checker is told that every word on a team's list is a private name, and teams often name things with plain words. A lesson that uses such a word in its plain sense gets cut or held as a leak.
Tell a model what a hint is for, not just what it is. A list labeled as names turns plain words on it into names too.
@sks24git2026-11-06beat 5 review rounds
A page check asserted that the live incident file was empty, though posting an incident means editing that file. The first real incident would turn every build red, right when the team needs to ship fast.
Never pin live data in a test; feed the test its own fixture. Real data changes the day you need it.
Check that the shipped file parses, not what it holds. Content is the operator's job.
@sks24git2026-11-06beat 6 review rounds
A replay report trusted a check for every piece of a kind it had shown the model once. A newer scan found a fresh piece of the same kind in the text, and the old pass still counted it as clean.
Tie a stored verdict to the exact input it judged. A label on the kind of input covers pieces it never read.
@sks24git2026-11-06beat 3 review rounds
One capped list held words from two sources, and each fix moved the other source to the back. Whichever came first could fill the cap, so a big input pushed the other words out of the list.
Give each source its own quota. Reordering a shared cap only changes who loses.
Test the cap with a large input from each side. One small fixture hides the squeeze.
@sks24git2026-11-06beat 3 review rounds
A batch reader appends each chunk by spreading every row into one push call. Once a chunk holds about a hundred thousand rows, the call overflows the stack and the whole read fails.
Never spread a query result into a call. Argument count has a hard engine limit; append in a loop.
Test batch code at its real chunk size. Small fixtures never reach the limit.
@sks24git2026-11-06beat 5 review rounds
A replay report skipped any score that lacked a new answer, even when an older answer already failed the bar. It also let one answer stand for pieces found later that it never saw, so the tally drifted both ways.
Record what each answer covered, not just that it exists. A later scan can find more than the check read.
Apply a failing score before asking for more. An extra question can only fail harder.
@sks24git2026-11-06beat 4 review rounds
A new question was added to a model check, but the replay report still trusted old scores that never asked it. Stories the live check would doubt were counted as passed, so the tuning looked safer than it was.
Version every replayed score by the questions it answered. An old answer to a smaller test proves nothing about a new one.
@sks24git2026-11-06beat 1 review round
A report began to skip scores from an older version of its questions, but the job that refills scores still counted those stories as done. After the release the report went empty, with nothing left to score again.
Drop old data only where it gets rebuilt. A filter with no refill empties the view it guards.
Keep side quests out of the change. Bookkeeping added mid-review grew its own bugs.
@sks24git2026-11-06
Each scored check was tagged with its question version, but the report that tunes the threshold never read the tag. Scores from the old and new questions went into one sweep, so the cut-off it picked fit neither.
Read the tag where it matters. A version written but never filtered on changes nothing.
Pin a version to what it names. A hand-kept number drifts on the next edit.
@sks24git2026-11-06
A per-user query lost its row limit when it was folded into one batch read, with the cap moved into code after the fetch. One user with a huge history now pulls every row into memory on each lookup.
Keep the row cap in the query when you batch it. A cap applied after the fetch bounds nothing you read.
Test the single-item path after a batch refactor. It now runs the batch code too.
@sks24git2026-11-06
A check stopped holding on one kind of finding, but its report still counted that kind as a hold reason. The report people read to tune the check showed holds that no longer happen.
Change the report in the same commit as the rule. A report that mirrors an old rule misleads the tuning.
Grep every place that restates a decision rule.