Durable, general engineering knowledge, written to be read by an AI coding agent and by a human.
Working with LLM coding agents: prompts, skills, harnesses.
What gets read back is the constraint, so the index line matters more than the entry body.
Small models emit the call as plain text; the server reports no call and finish_reason "stop", and the agent silently stops.
"Restart it" brings the old code back; with the client deployed by CI, new requests hit the old backend and the feature just shows nothing. Say "pull, then restart"; check the process's cwd and HEAD first.
Scheduler and webhook input classifies as non-human, so the opt-in is silently skipped; enable the mode in settings the run reads.
Language-level behavior, semantics, idioms.
Reserved-for-future-use identifiers are compile errors, and half is the natural name for a Blinn-Phong halfway vector.
Object.is separates them, so a -0 out of a sign flip or any multiply or divide that lands on zero fails a check that === would pass — deepEqual included.
Since Python 3.12 it blocks until every handler ends, so awaiting it before telling clients to leave deadlocks.
Math.max(1, NaN) is NaN, so the loop runs zero times while the !== 0 liveness test keeps reporting the entity as moving.
Invisible line terminators: a regex literal fails with "missing /" on a line that looks whole, and the rest of a // comment silently runs as code.
The compiler then reports the imported class's own methods as missing, and only the classes implementing that interface are affected.
A "have all the pieces arrived?" check with every(p => p !== undefined) says yes after the first piece; use includes(undefined) or a count.
Testing, review, design, process.
Doc themes inject an anchor into every heading after load, so copying innerHTML doubles the links and swallows the click; clone and strip first.
Browsers prune the cells; the DOM still has every aria-label, so it reads as missing labels rather than invalid structure.
Presentation attributes enter the cascade at zero specificity, so a script-set colour is ignored on exactly the elements a stylesheet already styles.
[hidden] is only a UA stylesheet rule, so any class setting display keeps the element painted while el.hidden reads true.
The second step is either another listener or a default action such as implicit form submission; stopPropagation fixes one and preventDefault the other, and only the latter is reachable by a dispatched event.
A hidden tab stops delivering frames, so a life-- counter stalls and the overlay freezes on screen; end effects on wall-clock time, except ones that must be seen, which a late frame would retire undrawn.
A visibilitychange handler that pauses and shows its panel from the frame loop never paints it; the model reads paused while the DOM still says playing.
A hidden or backgrounded surface never delivers one, so the page shows its static placeholders while every handler silently takes its if (!built) return branch.
The guard is tested when the callback is scheduled, not when it runs, so a deep link applied in the gap is silently replaced by the queued default.
English text is read by the system-locale voice unless you set lang and pick a voice, and getVoices() is empty until voiceschanged.
Blocked audio fires no start, end or error at all, so a promise awaiting onend deadlocks while both health probes look healthy.
Engines read 🎉 as "party popper", and U+2212 hides in the symbol range you sweep, so "2 − 4" is spoken "2 4".
try/catch around localStorage hides the failure, not the consequence; re-reading the key returns the old value and the session contradicts itself.
A label and its unit span land on separate rows and item counts are off by one; yet adjacent text nodes merge into one item, so gap never separates two appended strings.
The item gets a real box, but an inline wrapper inside it stays inline and collapses to 0x0, taking its absolutely positioned children with it.
The covered node keeps its box, its selectors and its events, so only a human eye or a bbox sweep notices.
A viewBox ratio blows up 1fr grid tracks and beats position:absolute insets, so the graphic overflows and the next row paints over it.
Observing fires once immediately, and assigning canvas.width clears the bitmap even when the value is unchanged; only a surface with no next frame shows it.
Typically a custom property set in one callback sizing a sibling; the change waits a frame and Chrome tells only window error listeners, so Puppeteer's pageerror misses it. Observe deeper, or use an IntersectionObserver rooted at the box.
opacity, filter, clip-path or a clipping overflow collapse 3D children into one plane while getComputedStyle still reports preserve-3d.
findNext: false on the first request is dropped silently and found-in-page never fires; omitting the option starts a session.
flex: 0 1 190px renders at the text's width; use width for a fixed preferred size.
One path fills the union at a flat alpha; a fill per shape stacks at every overlap, and winding is not what causes it.
stroke() outlines every subpath, including the ones buried inside the union, so a rim added to a flat-filled blob reinstates its internal edges.
A collapsed pane returns a 0x0 box; clamp to a floor and regenerate disposable state instead of scaling noise back up.
vw/vh measure a box the stage does not occupy, so a phone-sized HUD swallows a fixed-aspect canvas.
The track's automatic minimum is the whole un-shrunk row, so the items are never asked to shrink; cap it with minmax(0, 1fr).
place-items: center aligns inside the track, and an auto track is max-content, so the item sits flush left instead; flex centres it correctly.
flex-grow resolves the main size and stretch the cross size, so the declared ratio is inert and a canvas renders stretched.
imageSmoothingEnabled = false is nearest-neighbour, not exact; a fractional camera offset drops a row at every tile edge, and only while it moves.
Each run clones the previous run's clones; they finish transparent, so it surfaces as a leak and as element counts that no longer match reality.
Each replay is cut short by the next render, so elements sit permanently in the animation's opening frames and it reads as a CSS bug.
Tabs redrawn by the same render the fetched data triggers are swapped under a tap; nothing runs, and automation fails intermittently with a detached node. Build controls once, update their state.
The padding already satisfies the length test, so later items are silently dropped and it reads as a data bug upstream.
A cond ? el : null child, harmless in element helpers that skip nulls, shows a stray "null" when passed straight to a DOM method; filter first.
beforeunload fires for the demo world under the title card, so a first-time visitor is offered "Continue" for a session they never began.
Shrinking the font wraps the text into fewer, longer lines, so the single-variable loop bottoms out still overflowing.
Hangul wraps like Chinese characters, so words split mid-word on narrow screens; keep-all plus overflow-wrap: break-word wraps at spaces, but never apply it to Chinese or Japanese.
Emoji break like CJK ideographs, so ☀️🌧️ stacks in a squeezed flex item and doubles the row's height; nowrap plus flex: none, since a declared width does not stop a flex item shrinking.
Chunked work stalls off-screen while a microbenchmark of the yield reports 0 ms; MessageChannel is not budgeted.
The DOM and scroll position look right, so it reads as a broken observer config rather than a hidden page; sweep on visibilitychange.
:root[data-theme] a beats .btn.primary, painting a link-button's label the colour of its own background, in one theme only.
Gradients throw on any non-finite argument (a NaN centre too) and arc on a negative radius, while NaN shapes are skipped silently; the page stays alive while the surface stops being painted.
A var() in ctx.font, an incomplete shorthand or a negative lineWidth all no-op without throwing, so the drawing uses whatever the last successful call set.
Visuals driven from it run outputLatency ahead of the sound; the offset is per-device, so it never shows on the machine it was built on.
It keeps a plausible non-zero value instead of erroring, so everything draws while nothing moves; anchor to a wall clock or gate on state === 'running'.
The sizes stay put while the areas move under them, and any row the list does not cover falls to grid-auto-rows; it breaks at one breakpoint only.
Indices in, symbols back out: the rejected attempt looks fine and the control only breaks the next time it is built from state, persisted corruption included.
Two overlapping ducks make zero the value to restore, so the bus is muted for the rest of the session with nothing left to undo it.
The last handed-out value is as stale as its last caller, so the handover rewinds the clock by however long the app sat idle.
The apply looked fine; the damage lands one click later as a confident sentence about the target, so the user blames the target and not the mode.
120cqw on the container itself silently measures the viewport; a custom property holding one resolves where it is used, so half the geometry can be right.
The wrappers are flat boxes at the camera plane, so they win the hit test against the very children they position; painting still looks right.
flex: 1 1 150px is 150px wide in a row and 150px tall in a column, so stacking cards in a media query gives every one a fixed height.
overflow:auto one level below a grid item does not stop the item's auto minimum from blowing the track out; min-width:0 on the item does.
stretch subtracts the item's margins and width: 100% does not, so one indented item alone breaks out of the track.
Listening for pointerup on window and then testing e.target discards every real click while drag keeps working, so it reads as a dead action.
A second finger making a pinch, blur or a hidden page end it too; flagging it as a drag or nulling it stops the tap but leaves hold-to-repeat firing ("pinching also builds"). Also: no press while 2+ fingers are down, and a fresh drag origin after a pinch.
complete and naturalWidth say the image is there and the promise stays pending for ever, so an await returns nothing and throws nothing.
Random arguments for each centre turn soft blotches into fans that look like lighting or shadow artifacts on a textured 3D surface; use one centre.
lighter adds a region into one channel and multiply by rgb(0,255,255) subtracts it from red alone; blurred fills make the edges feather.
It centres block children too, and stops at a table, so implementing either half alone mis-renders every page wrapped in one.
A 401/404/500 sets readyState to CLOSED with the same bare error event as a blip; check readyState in onerror or a page with a stale token spins "reconnecting" forever.
Like transform and filter, so a phone tab bar fixed to bottom:0 inside a frosted sticky header lands at the top of the screen; drop the blur at that breakpoint.
Keyboard-only and Safari tests pass; after one click on a stepper or hint toggle, Enter runs that control again. preventDefault() on its mousedown keeps focus put.
A camera that "will not start" can be waiting behind a stuck microphone request (for example Chrome's fake audio device on macOS); no error, only a reload resets it.
An empty strip along the bottom; display-mode: standalone does not match, 100vh is shorter, grown fixed layers stay clipped; grow html by the measured top inset (navigator.standalone), never fixed layers too.
WebKit's own swipe recognizer sits on the full screen view in every iPad browser, so preventDefault and touch-action do nothing; send drag-driven games to the Home Screen instead, and detect the iPad by MacIntel plus touch points.
The usual standalone || fullscreen "installed?" check turns true when the user presses a full screen button, and a toggle hidden on it vanishes just when it is needed to exit; ask document.fullscreenElement first.
Once anything wraps the box takes its whole max-width, fit-content included, so an overlay's empty strip beside the shorter lines catches taps meant for the scene; pointer-events: none on the container.
Modifiers win by source order alone and a breakpoint adds no specificity, so a base class resized for phones overrides its modifiers on phones only, while the custom property they size from still holds the old value.
body:not(.touch) .x scores above .x, so later breakpoints stop applying on mouse (or touch) devices only and get patched with !important; :where(body:not(.touch)) .x ties .x and lets source order decide.
Both are inclusive, so max-aspect-ratio: 3/4 and min-aspect-ratio: 3/4 both apply at exactly 3:4, which most iPads in portrait are; make one side strict with range syntax, or with a leading not, which negates the whole query, so nest anything else inside it.
A bare .touch button rule also matches <body class="touch">: the body shrinks to the button's box, the whole page fades by its opacity and inherited text grows, only on the devices that set the flag. Qualify the rule or name the flag apart.
The clamp only shortens the box; later lines still paint and overflow clips at the padding edge, so a long text hangs a sliver under the ellipsis. Use a transparent border.
Shrink is weighted by base size, so "give way first" still costs a short label its last character; use flex: 1000 1 0; max-width: max-content instead.
The usual truncation check passes on text ending in "…"; compare a Range's width with the box's.
An open() that just overwrites the stored onClose drops the old dialog's cleanup (a camera, a mode, a drawn canvas); a see-through dialog leaves the other openers clickable, so it is an ordinary click. Run it before building the new one.
Waiting for canvas.width > 0 passes at once, and the pixel read after it is blank whenever the first draw is late; wait for a size or pixel the draw sets.
Its available width is what lies right of left, so a bar between half the screen and its max-content wraps or scrolls with room to spare; width: max-content or left: 0; right: 0; margin-inline: auto fixes it, fit-content alone does not.
Hit testing uses the whole border box, painted or not; where two groups overlap the later one takes the other's taps, so an overlap check on the buttons alone passes while a button's edge is dead. Compare the groups' boxes, or make groups pointer-events: none.
Embedded webviews reject writeText with "Write permission denied" inside a real click; a selected textarea plus execCommand('copy') still succeeds in the same gesture. Script clicks fail both.
👨👩👧 needs U+200D and Scotland's flag needs tag characters, both category Cf; exempt them with /(?![\u200d\u{e0020}-\u{e007f}])\p{C}/gu.
The clone is loaded as an SVG image, where scripting is off, so "needs JavaScript" fallback text appears in the screenshot; filter NOSCRIPT out.
Without preserveDrawingBuffer, read back in the same task as the render; screenshot libraries copy canvases later and get nothing, so composite the 3D view under a DOM snapshot yourself.
The input looks focused but nothing typed appears, in tests too; give on* properties a block body or use addEventListener.
A streaming page can play muted locally while viewers hear full sound, and a local volume control does nothing for them; route through Web Audio to change what they hear.
On a busy device the timer fires mid-typing and the rest lands in the first box (a password in the username); focus only if nothing in the dialog has it.
Ordinary complexions span 0.33-0.78 luma, so a fixed face-luma target lightens dark faces and darkens pale ones; meter light on the frame and keep only variation on skin.
There is no draw order to lean on; the part is added, lit and drawn, just behind an opaque surface, so it reads as a missing mesh.
One value driving both halves of a symmetric rig moves them apart; the rig looks right at rest and breaks on the first animated frame.
Aim is a ray, so a sphere around the cursor only works at the cursor's depth; test angular distance, and resolve to one best-aimed candidate.
A centre ray falls into the gaps of spiky, curly or leafy tops and reads low; sample a footprint-sized disc, and test stored attachment heights against the mesh headlessly.
A flower or grass sprite's entry distance always beats what stands in it, so an animal in a flower can never be clicked and it reads as a rare flake; let sprites lose to an entity at the same depth.
Zero value and zero slope at the rim means primitives add with no crease and no impulse, which is what lets a body stay glued to the surface.
Consecutive samples step by a constant, so "random" speckle rules itself into diagonals as density rises; use an R2 low-discrepancy sequence.
Back-face culling discards it silently, so a missing highlight reads as a state bug rather than a geometry one; assert winding where meshes are built.
N·L fixes the lit radius by geometry, so more power only clips the centre; move the light off the surface and wrap the diffuse term.
Metals have no diffuse term, so adding or brightening lamps cannot fill them; a prefiltered environment is the missing term.
Flat fills are final values; as albedo they get multiplied down by ambient, N·L and fog, and the dark end vanishes first.
The whole gradient renders several stops too dark, which reads as a badly picked palette or a bad light rig rather than a missing encode.
Asymmetry breaks the reverse traversal, leaving a hairline gap that looks like a placement bug.
A sphere fit is orientation-blind and empties a portrait frame; projecting extents instead clips the near corners.
Projected area peaks looking down a planar subject's normal, so the fill objective is what flattens the picture; clamp the angle range.
The translation is f·d·tan(fov/2), about the subject's height at portrait range; a view offset (shift lens) slides the picture instead, and three.js's setViewOffset overwrites aspect.
Rounded ends poke through their neighbours and a curve renders ribbed; chain the segments into polylines first.
Off-axis parts are correctly oriented while pointing inward, so the heuristic buries the one real inversion in 70% false positives.
A narrow viewport's nearest visible ground collapses, so one huge near polygon fills a third of the screen and reads as a culling bug.
The cut has to be given back within the blend, so the bank is about 1.4x the face's own slope whatever the window shape.
At a hairpin the two legs hold different values, leaving a step down the middle of the corridor; average over every sample in range instead.
Two independent functions agree only by accident; heading G/g into the fall line gives grade G by construction.
Smooth geometry and smooth normals with teeth in the shaded render means the fault is in the colour; low-pass the slope before any threshold.
The runway is transformed, clipped, projected and queued correctly, and is simply not there; cut it into strips and bias coplanar layers.
The gap is half a coarse cell wide, and the background showing through it reads as water or cloud rather than as missing geometry.
Both conventions are one angle called yaw, they agree at 0 and pi, and off-axis the mesh is drawn ninety degrees from the collider of the same object.
Pitch picked by eye is wrong at every other window size, and sizing a 3D canvas to the subject's 2D footprint wastes the frame; clamp so it never solves to straight down.
Clicking and looking passes near top-down and fails once the camera is orbited; keep the projection maths out of the GPU so the sweep runs headlessly.
No single pixel sigma is round in cells, so the blob starves along one axis and the low count reads as a bad threshold.
Gustafsson's falloff is non-monotonic below ~0.55r and creases each handle; one flat at the rim holds to 2r/3.
The same blur erases a distant face and barely touches a near one, which reads as a badly tuned slider; derive it from a measured feature.
Rotation stretches the runs by up to √2, so blur fails the real pattern and a data-area look-alike wins; match the 5x5 template in the symbol's own module grid.
The homography's denominator is affine and size is about 1/depth, so weighting positions by 1/size extrapolates foreshortening that B + C - A ignores.
Centre-based spacing passes on horizontal and vertical bisectors and overlaps the arc on diagonals; the distance needed grows as 1/sin(half-angle), so fit the figure with the label in it.
The wings of a deep notch come out sharper than the tip (38° against 49°), so a correct arrow reads tail-first at map size; keep the tip sharpest, or draw a teardrop.
Mipmaps average alpha and the cutoff tests the average, so a card under half opaque is discarded far away; paint more than the cutoff opaque, or keep coverage per mip.
The agent acts on the first tick of acquiring the thing, so the interval paces nothing; symptoms land in physics, not in the timer.
"The seed changes nothing" points at the generator; the repetition is in the reset upstream of it.
Keep a random board only if a deliberately weak solver clears it; cheap enough to draw on demand, but acceptance collapses as density rises.
Constant gain-vs-drain rates make skill decide the length, not the outcome; escalate the drain instead of adding a timer.
Peak target speed above the controlled variable's slew rate makes a pursuit task unreachable; it reads as brutal tuning, so assert the ratio.
Per-game variance buries a ~0.1 effect under a ~1.2 standard error; swapping arms across seats on the same seed cut it 30x.
A per-tick miss chance is an 8ms jitter, not a handicap; survival stays flat and a punishing game reads as trivial.
Perfect and good play pay within 12% of each other, so run length stops reporting skill; a streak multiplier doubled the gap.
Euclidean ranking never leaves a spiral's outer arm; rank on a flood-filled distance field, and check reachability and completability separately.
A perfectly positioned stationary body returns less than it received, and the rally is lost three touches later, so the symptom points away from the movement policy.
Collision resolution pushes a body straight through the wall the clamp just enforced; both pieces of code are correct and the order is not.
Every individual resolution is correct; sweep release positions across the whole world to find the shelf.
A resting contact is re-resolved every substep, so flat damping compounds; cap the tangential impulse by the normal one.
Clipping can give both manifold points the same originating edge; the error is signed, so it integrates into a slow lean and more solver iterations do not help.
Stable alone and in a chain; in a cloth grid it reaches a thousand times the mesh's own weight. Model "rigid" as a very stiff implicit spring instead.
The body accelerates over the overshoot and the position pass hands that depth back as height, so an elastic ball climbs; halving the timestep only halves the gain.
A Galton board goes bimodal against both outer walls, and no amount of restitution, friction or ball-size tuning moves it.
c*dt/I_red < 2 is the threshold; the same coupling is fine in a 3:1 gear and diverges in ten steps at 13.5:1, and it reads as a friction or contact bug.
Expired decals and particles persist for the whole idle period, which is when they are being looked at; retire before the early return.
Under sustained fire a hit-flash branch is permanently on, so the artwork underneath is never seen and the cue stops carrying information.
Assign pieces at removal time and the deal is solvable by construction, with a certificate to replay in the tests; no solver needed.
The floor is the gap between standing and ducking hitboxes; the ceiling is every chained verb, so a barrier above a single jump is still beaten by a double one.
an inert tuning knob is a fact about the model; attribute the resource by cause before changing the number again.
A ceiling above the target makes full power always score; the tell is a scoring window whose upper edge equals the input cap.
Collision uses the whole footprint but the action uses one ray, so a straddling entity drills at the empty tile beside the one holding it up.
A trip that costs more than it earns reads as a stuck agent, not as a price; measure yield along the path travelled, not map density.
Sequential pair collisions on an exact lattice act as a Newton's cradle: one body leaves fast, the rest sit still, and every collision is individually correct.
Effective opening scales with the entry angle's sine, so the widest-window trajectory is also the tallest; measure apexes, not just makes.
Median scoring window went 0.04° to 0.58° by re-ranking the same candidates; a pass/fail verdict cannot tell a robust shot from a fluke.
A controller with zero injected error still making the game's own mistakes is a policy bug, and its cost gets charged to the level design.
Buffer M, top-up k, length L: survivable while pace stays under k + M/L of optimal, so the whole curve is one monotone sequence.
Brute-force the aim/power space from real positions: near-zero solution density is a physics fault no amount of search or aim assist can fix.
A perfect controller shuts out every tier, so difficulty has to be read from rally length; win rates need a fallible controller.
An error smaller than half the paddle plus the ball radius yields a zero miss rate, so the difficulty dial reads as tuned while rallies never end.
A uniform random field alone reads 1/sqrt(mean), so the metric starts wrong and appears to depend on resolution.
The narration and the readout disagree on one screen, both computed correctly, and only once someone moves a control off the default.
The underlying power law sets the pacing, so the animation is correct and still spends most of itself on one unchanging image.
Nothing was ever freed, so entities sit somewhere they could not have travelled to and it reads as a movement bug.
Chatter at the switching point averages the two rates, so a hold-at-a-value loop ends up pinned at one extreme.
A flawless controller dying as often as a noisy one means the injected error never reaches the outcome; the usual blind spot is a filter that drops the hazard already overlapping the agent.
Still choosing where to be on the approach makes it unavoidable rather than hard, and halving its speed halves the warning too; lock the final track at a handover distance.
Greedy placement converges on 1/gap wherever candidates are dense, so the gap replaces the source's own shape; add a rolling-window budget alongside it.
It commits to gaps it cannot reach, and raising the avoidance penalty pushes harder toward the unreachable one.
Placement and movement are both correct; the constraint has no authority over the interval between them.
Applying puzzle.answer proves the lock accepts its own key; parse the answer back out of the rendered clue or an unsolvable room passes every test.
The run neither wins nor loses, so win rate reports nothing; floor the rate and count stalled episodes.
Each one wakes while the other is cooling, so a pair meeting every precondition never acts; it survives a single-seed test.
A windfall gated on a lagging indicator floats a dead system above its floor for ever, and only shows up as a code path never entered.
A per-frame share under one unit rounds to 0 every frame, so a smoother update loop is what breaks it; carry the remainder.
Tiers pinned to a grid collapse into each other wherever the content already sits on it; define each as a share of the full set.
The jump is already in clock() - epoch; applying it fires every event in the skipped span at once, which reads as a logic bug downstream.
A fallback or an unconstrained distractor can make the answer a single click, and a seed sweep that only asks "is it solvable" says yes fastest of all.
Rolling and pitching moments are unaffected and yaw damping is sign-invariant, so a half-converted table looks consistent and diverges a minute into the flight.
The gate refuses for a position the operator cannot see or hold, so the mode can be selected and never used; make the rest position depend on whether the interlock is armed.
The call returns normally having done part of the work, so a fast-forward that stops early reads as a model that stopped responding.
Both lags are individually correct and the steady state is right; only the transient inverts, and it is blamed on whatever it shows up in.
Peak demand and the failure condition move the same signal, so the cutoff trips at full throttle on a healthy system; separate them in frequency, not by value.
The action under test is counted alongside the ones the entity took by itself, so an exact-count assertion fails and a lower-bound one passes for the wrong reason.
The score does not change as units are placed, so coverage read 43% instead of 99% and the level got blamed; weight each threat point by how well it is already covered.
A level that trades health for a new threat reads as a dip and the invariant fails on exactly the content worth protecting; compare across the design's own cycle length.
f(mean error) is not the mean of f; under a decaying curve random answers averaged 5x the score at their mean distance, and a constant midpoint answer more. Monte Carlo the curve and measure no-skill baselines.
Eased steps and clipped corners land in unsampled columns, and a side entry under a crown is air until the height rule pulls the agent up through it; gate each step on its destination's top; a ground keep-out check at one point ahead cuts corners the same way, so test the footprint's corners.
A ring's corner is r√2 away and its edges r, and ring r+1 beats ring r's corners from r = 3; keep the best by true distance and stop once the ring passes it.
Every later draw shifts, so seeded tests of untouched entities move and the new feature gets blamed; give each subsystem its own stream and assert the old traces stay identical.
Re-picking when stuck just draws another unreachable target; sweep the footprint along the straight way at pick time, allowing the hop up at a step.
A new draw or a new reject check in an earlier loop shifts everything after it, so seed-pinned tests start testing different content; edit the finished result instead.
An onGround tolerance band catches ~40% of falls a substep early, so impact events never fire and a held jump takes the standing-jump path; key impacts on the contact speed, and drop callers' was-airborne-last-frame guards.
Small swimmers sit too deep and never get their head out, so climbing out onto a bank never fires; make the probe per body, under the float line.
Keeping its gap behind a walking leader never closes it, so "lost" teleports become routine; time no-progress only while the leader stands still.
Every level before is a walkover and every one after impossible for every strategy; size polynomial growth to the smallest map's fully built capacity.
It stands inside its steering radius below the height the check wants, never counts as stuck, and waits out a per-step give-up timer; derive both from one predicate and measure progress on every axis.
Your avatar is drawn now and the enemy in the past, so contact lands with it ~speed × delay off and its recoil shows a snapshot late; extrapolate interactive entities, fade corrections, kick locally on hit.
Holding forward stalls the car on the far side of a loop; ease the camera behind the heading or read input along the track, and test a whole lap through the real input path.
Path shoulders, eased platforms, tree crowns, railings, walls on a slope and drops all make a way round; check gates with a step-aware flood fill over many seeds, one seed hides the leaks.
Per-axis collision lets a glancing dash slide along the wall at full speed, so a total-speed "stuck" test never bonks it; test the velocity component along the dash for a moment, with an angled wall.
*/5 on hours wraps to a 4-hour gap at midnight; use an interval timer or a self-rescheduling one-shot instead.
A build timestamp in the generated file makes every scheduled run commit, burying the one run that changed something.
isatty says "not a terminal", not "has data"; a pipe with no writer never reaches EOF.
A reader opened per prompt drops type-ahead and every line of a paste after the first.
On DNS64 networks (hotspots, carriers) every IPv4-only host resolves into 64:ff9b::/96; a range check that does not decode it flags every site as private, or lets 127.0.0.1 through.
The head buffer holds the new protocol's first frames; ignore it and a server's greeting vanishes on loopback.
Upgraded sockets leave HTTP tracking but still hold the net.Server open; track sockets on connection and destroy them, or teardown and simulated outages silently fail.
The stack unwinds past every undo, leaving the shared position as deep as the search reached; it only shows up once the object is reused.
The peer sees ECONNRESET instead of the error you wrote; half-close and drain before closing.
Chunking text for a size limit mangles emoji only when one straddles a boundary; send() and TextEncoder replace lone halves silently. Back the cut off a high surrogate.
The server receives an innocent path, so the test passes vacuously or blames the guard; send raw paths with http.request or curl --path-as-is.
Usage events report activities, not apps; closing the session on the first pause silently under-counts foreground time.
The permission does not exist pre-33, so the obvious guard mutes every notification on Android 10-12.
The subsystem writes to an object nobody reads; a test that wires up after the reset picks up the new one and passes.
Dividing by one vector component, or comparing against an expected zero, fails correct code and invites loosening the tolerance until it tests nothing.
A write that stores the value already there leaves no trace, so the output is one element short and still looks like a valid sequence.
target/ for Maven output also ignores a Java package named target; the commit succeeds and CI is the first to notice.
node_modules/ ignores the folder but not a node_modules link into another checkout or worktree, which git add -A then commits.
no matches found means the program never ran; docs tested in bash or Oh My Zsh break for plain zsh, and & splits the command in every shell. Quote URLs in examples.
POSIX shells ignore SIGINT for cmd & when job control is off, and Python keeps it ignored; test Ctrl+C with set -m (bash) or SIG_DFL restored.
Returning finishes a chunked body normally, so a streamed ZIP cut short is saved as a complete download; only the panic drops the connection.
A case failing two checks is caught by whichever runs first; give each guard a case only it rejects and mutation-check by deleting guards.
createServer ignores the handler's promise, so an uncaught throw, often in the response write itself, is an unhandled rejection that ends the process. Catch around the write, or set events.captureRejections.
A path starting with // parses as an authority, so //[x throws, and fetch and http.request send it; uncaught in an upgrade listener it ends the process. Use URL.parse and answer null with 400.
Both replay a spent token and get the session revoked; allow a short grace for the just-replaced token and serialize refreshes across tabs with Web Locks.
echo ===== dies with zsh: ==== not found (the EQUALS option) while bash prints it; quote such words.
A rollback restores a value that was never empty, or setting a value the fixture already holds changes nothing and fires no event; it reads as a slow-CI flake. Capture the start, derive a value that differs.
An old frame or a freeze effect still shows the start, so the wait passes and the next step meets the change; wait for the change first.
A failing cell or position fingerprints the random layout; run the bare generator with the test's placement logic over thousands of seeds, pin a match, and prove the fix on it instead of looping for a 1% event.
Same-patch copies are skipped, amended ones conflict in code you never wrote; git rebase --onto origin/main <your-base> replays only your own commits.
The scratch repo's init re-initialises the shared one as bare (every checkout then fails "must be run in a work tree") and its git config writes a test author there; strip GIT_* before a hook runs tests.
prog $LIST gets one argument in zsh (SH_WORD_SPLIT is off) and several in bash; the program fails far from the cause, with no shell error. Use arrays, or ${=VAR}.
Defaults stamped now() beat every real edit, so the first sync resets the user's data on all devices; stamp 0, bump only on user edits, merge counters and earned items monotonically.
"é" and Hangul syllables have composed and decomposed encodings; hash password.normalize('NFC') both when setting and checking (RFC 8265), never NFKC or case folding.
Full-width letters and zero-width or bidi characters make different strings that look the same; key by normalize('NFKC').toLowerCase(), reject \p{C}, rate-limit per key.
kern.memorystatus_vm_pressure_level (1 normal, 2 warning, 4 critical) says when starting another job would swap; free memory is always low on macOS. High load with idle CPU means page-in waits.
It finds the strongest period in the whole signal: the bass or a ringing note; measure each candidate note's energy from the note's start, in the melody's own range, to verify a synthesized tune.
Build tools, version control, CLIs, editors.
LightShadow rebuilds the view matrix every frame but never the projection, so the box stays 10x10 and a normalBias sized for the real one paints spurious shadow.
setFromCamera reads matrixWorld, which only render or updateMatrixWorld refreshes, so a tap right after a view opens picks nothing (from the origin down -z); call camera.updateMatrixWorld() first.
Non-raw ShaderMaterials are already GLSL ES 3.00; GLSL3 only drops the pc_fragColor declaration, so colorspace_fragment fails to compile and the mesh silently vanishes.
A top-down profile is wound inside out: a closed one still looks solid (you see the far wall), an open one like a sleeve vanishes.
GTAO/SSAO/SAO/Bokeh/Outline prepasses skip custom shaders: no normal attribute gives NaN (a voxel terrain went black under GTAO), shader-placed instances sit at the raw position, alpha cards turn solid; feed AO the main pass's depth.
The renderer overwrites the uniform with scene.environmentIntensity on every draw, so glossy and matte parts reflect alike; give each material its own envMap, and dim them together through a shared uniform.
Both ping-pong buffers become MSAA (about 250 MB each at 2880×1800 with 4× half-float), though only the scene render gains; draw the scene into one MSAA target and run the passes between plain ones.
The standalone kotlin.android plugin is now a hard build failure, and android.kotlinOptions is gone with it.
The push then fails with a misleading "access rights" error; check git remote -v first.
Enumerate sites by has_pages and derive the URL from the repo name; filtering on homepage drops most of them with no error.
Exit status 0 and no rows, indistinguishable from "not started yet", so a CI wait loop spins forever; expand with git rev-parse first.
A run pins github.sha at creation, so a queued run still checks out the base its sibling pushed past; the retry belongs in the push step.
Not even within one run, so "highest ID is newest" picks an older artifact, as @actions/artifact's getArtifact and latest do after a re-run; sort by created_at or pass the uploaded artifact-id.
The re-run sits queued with no jobs, cannot be cancelled or deleted, and every new deploy fails naming it; wait, then POST /pages/builds instead. Deleting the github-pages environment clears a stuck one.
Intermittent "No artifacts named github-pages" despite matching versions, and re-running then fails on two artifacts; upload in an earlier job and deploy from a needs: job.
gh has no pages command, the nested source needs bracketed -f keys, and the .status a script waits on is never written for a workflow-built site.
The browser serves the other project's file at the same URL, so an import fails naming an export the file on disk plainly has.
The vendored file returns 200 and the error names it, while the 404 is a sibling filename that appears nowhere in your source.
Dev static servers send no Cache-Control, so an edit that "did not apply" is a stale subresource, not a bad edit.
It is a same-document navigation: nothing is fetched and no script re-runs, so an edit-then-navigate loop verifies the previous build and cache headers cannot fix it.
Its default plugins page bare .md, index the README and rewrite .md links, so a Markdown repo becomes a site with one _config.yml; a bare local Jekyll does none of it.
kramdown rewrites $$…$$ to \[…\] but leaves inline $…$ as text; MathJax closes both once $ is an inline delimiter.
its "already has an index" test is case-insensitive, so the site root silently 404s; claim / with a permalink instead.
no delimiter row needed, so prose with |a| or P(A|B) is silently rebuilt as a table on Pages; markdown: CommonMarkGhPages matches GitHub.
Braces vanish, cases rows merge and thin spaces print as commas, with no error; write \lbrace, \rbrace, \cr, \thinspace.
**"사과"**를 keeps its asterisks on GitHub because a particle, kana or hanzi is not whitespace or punctuation; keep punctuation outside the bold, or use <strong>.
One blocked domain returns 400 and zero results; an errored search is not an empty search.
Tool results share the user role; filter on origin.kind == "human" or overcount prompts ~20x.
Subagent turns go to <session-id>/subagents/**/agent-*.jsonl; parsing only the session file silently drops most of the run.
An idle timer quits the app; restored sessions lose Remote Control and can fall back to the previous Claude Code build. disableAutoUpdates in managed preferences is the sole off switch.
remoteControlAtStartup is read from policy/flag/user scope only, and arms a fresh start but not a resume — an app auto-update drops it.
A repair pass decodes it in every tool's input unless something path-like shares the string, and Edit's fallback can then escape all non-ASCII in new_string; build such characters at run time, use a placeholder for escape text, and check the bytes.
Usage lives in SQLite session_message rows, not JSONL; the four buckets are disjoint, so bill output + reasoning as output and skip aborted rows with no tokens.
Heredocs writing outside it, cd out, computed operands and xargs are refused before running; write a script with the file tool and run it with one plain command.
The existing-file check maps the download name to the finished one through final_ext; without it every run re-downloads and re-encodes, silently.
Section downloads probe PATH only and abort with "ffmpeg is not installed" despite a correct flag; put the directory on PATH.
Every dependency is behind an extra: opus/ogg/flac cover art fails the whole download, and Deno alone cannot solve the JS challenge. Depend on yt-dlp[default].
ExtractAudio replaces the codec's own ffmpeg options when re-encoding, dropping -acodec alac; silent, .m4a either way. Re-pass it via --ppa.
The hook gets the pre-step info copy, so ExtractAudio's "finished" still names the .webm; read outputs, and raise DownloadCancelled, at the next "started".
The existing-file check then hands a 15-second clip back as the full track, or the reverse; put the range in the file name.
The native vorbis encoder masks it in -encoders; tools asking for libvorbis die after downloading, and installing ffmpeg-full changes nothing on PATH.
The field accepts text while the focus handler never ran, so automation passes against state the app never set.
Hidden and backgrounded surfaces may not paint, so the image shows the pre-change style; assert against getComputedStyle instead.
A synthetic drag survives only when the id collides with the real mouse pointer's; the throw lands inside the app's handler, half-initialising the gesture.
Untrusted events run no default action and injected ones may arrive with an empty e.key; check isTrusted before blaming the app.
page.touchscreen.touchStart() per finger, then move()/end() for that finger alone, as trusted touch pointer events without hasTouch. Raw CDP: a touchMove that omits a finger keeps it down, and touchEnd lifts only the points it lists, despite the protocol text.
Touch moves reach the page with the next frame; with frames held back (software GPU in CI) a read straight after move() can be one move behind, so a gesture test passes locally and fails in CI. Wait for the end state; end() flushes the queued move.
The DOM is already correct; a cross-fade caught mid-flight shows both states at once and reads as a broken toggle.
The loop never runs while screenshots still return images; expose a deterministic step instead of waiting on frames.
the buffer is only readable inside the drawing task; readPixels there separates "never rendered" from "never presented".
Sync reads stay fast, so one code path looks tens of times slower than a heavier sibling; a duration that ignores input size is measurement, not compute.
One install carries several renderers; a grep hit is a hypothesis, and what the user sees on screen outranks it.
Resetting one without the other, or feeding a backwards timestamp, drives the accumulator negative and the simulation silently stops while rendering continues.
A step hook plus code still calling performance.now() gives two timelines; the clamp hides it, pinning progress at 0 or snapping it to 1.
Absolute timestamps stop firing the moment anything drives the clock instead of observing it; the continuous state still moves, so it reads as broken event logic.
Late ticks slow only the fixed-dt loop, so loops sharing a world drift apart under load; step by capped elapsed time, and reproduce by busy-waiting in an interval.
Completing an attempt and preparing the next are one transition, so a late-sampled probe returns a flattering, plausible number.
Camera smoothing and other per-render integrators advance once per batch, and wall-clock interpolation not at all, so the picture shows a state the app would never reach.
The image goes arbitrarily stale while the DOM and canvas hold the new state; freeze the simulation's rates instead of the frame loop.
node --test tests/ dies in the module loader on Node 26 and a quoted glob fails on Node 20; bare node --test is the portable form.
The default timeout is Infinity, and a timed-out test still leaves a listening server holding the process open; add --test-force-exit. Timeouts count as cancelled, not failed.
The child takes itself for the runner's child and reports to nobody, so a test-gate under test passes everything; drop the variable from the child's env in the production code.
No per-test retry option exists; a state file makes a second identical run skip what passed. Wrapper call sites are numbered, before hooks rerun, and the rerun's counts cover the whole file.
Node 22 and older piped TAP (not ok, # fail N); 23+ prints ✖ and ℹ fail N there too, so a grep finds nothing and reads as no failures. Judge by the exit code, or pin --test-reporter.
The failure diff grows with the square of the data (66 GB for 8×16k floats) and ignores --max-old-space-size, so one failing equal on three.js nodes hangs the run until the OS kills it; compare identity with assert.ok(a === b).
It never hit-tests, so a suite driving a covered or pointer-events-disabled control passes while the feature is dead for everyone.
A HUD or banner that lets taps through is never returned, so a paint-order check gets the canvas below either way; switch both layers to auto for one hit test where they meet.
Items scrolled out of a sideways scroller report rects past its edge, over the buttons beside it, so a box-overlap sweep fails once a wrapping row starts scrolling; intersect with the container's clip rect first.
-this-escape is JDK 21+, so one hard-coded lint string kills every older-JDK job in the matrix before a line of source is read.
Apple's Tk 8.5.9 composites nothing and never returns from update(), so a working paint path looks like a drawing bug; check the patchlevel first.
_metadata/generated_indexed_rulesets/ appears on every unpacked load; ignore it in git and exclude it by name from packages.
Postinstall downloads (Puppeteer's Chrome) silently don't happen; approvals are version-pinned by default.
HSTS preload and HTTPS upgrades send real domains to TLS, so "blocked" assertions pass vacuously; sniff TLS on one port. With --ignore-certificate-errors pages stay secure contexts, so Web Crypto apps run under a real-looking hostname.
CDP keys skip editing shortcuts: keyboard.press('KeyV', { commands: ['Paste'] }) (also Copy, Cut, SelectAll); ControlOrMeta is Playwright-only and throws.
It awaits an IntersectionObserver that a hidden page never fires; bringToFront() first.
Override getUserMedia to resolve canvas.captureStream() for the camera and an oscillator's MediaStreamDestination for the microphone; no flags, device or prompt, and it exercises the real media path.
UTF-8 names come out as ?????? or fail with "write error (disk full?)" while unzip -t, Python and Archive Utility are fine; write made-by Unix plus mode bits.
curl -T f "https://host/?x=1" sends PUT /?x=1 and the server never sees the name; pass options as headers.
Same id and token while the old socket lingers: signaling works but peer.open stays false forever; use fresh tokens, verify the socket after reconnect(), replace disposable peers.
The offer and every ICE candidate expire separately, so one failed dial raises peer-unavailable several times and the echoes kill the next attempt.
send() returns normally and only the sender's connection emits message-too-big, so a large state snapshot silently never arrives; use raw and chunk.
The AbortError looks like an autoplay refusal, so a muted fallback and a needless "tap for sound" show every time; skip a repeated stream and treat AbortError as superseded.
peer.call(id, new MediaStream(), { constraints: { offerToReceiveAudio, offerToReceiveVideo } }) watches a one-way stream with no getUserMedia prompt or fake tracks.
Browsers hide host addresses behind mDNS and do not always signal a srflx candidate, so parsing candidates intermittently records nothing; read getSelectedCandidatePair() once connected, skipping relays.
The WebSocket URL, heartbeat and the OFFER/ANSWER/CANDIDATE payload shapes, both ways; no PeerJS client, browser, open port or compiler, and Chrome's mDNS candidates still connect.
ws closes on an unmasked, oversized or invalid-UTF-8 frame and also emits error; unhandled, that is an uncaught exception, so any client can stop the server. Attach ws.on('error', …) to every connection.
Its default dotfiles: 'ignore' checks every segment it is given, so ~/.myapp/file and Express's res.sendFile of it 404; pass the folder as root and only the file name as the path.
While the real peer is offline a squatter gets every dial, encrypted to them; pin a public key and require a signature over a fresh nonce (WebCrypto ECDSA, same raw format in browsers and Node).
A ::ffff:0:0/96 rule in a private-address list matches every IPv4 address checked as 'ipv4', so everything reads as private; leave it out, IPv4 rules already cover mapped forms.
Browser-code tests that stub navigator die at the assignment under ESM or silently test Node's own object under CommonJS; install the stub with Object.defineProperty and restore the descriptor.
Mid-test it silently resets the app to its start screen; before the first goto it re-runs init scripts on about:blank, where localStorage throws a SecurityError pageerror. Sweep sizes with those two flags fixed.
Both run at the next rendering update (observers after its rAF callbacks), so code evaluated at once, or after one awaited rAF, sees a stale camera aspect, canvas size or observer-kept custom property; wait for the app's own updated state.
The box is read, then the mouse events are sent; a slow frame between them (a dialog's scale pop-in under software rendering, or a centred dialog growing as data arrives) presses a neighbour. Wait for getAnimations() to empty; anchor dialogs that fill in late at the top.
A laptop has a fine pointer and a CI runner has none, so touch-only UI shows in CI and never locally; setEmulatedMedia ignores these features and only hasTouch moves them, towards touch.
A test hook that steps and draws N frames returns at once; with SwiftShader (CI) the GPU process then works for seconds, no rAF runs, and rAF-polled waits or wall-clock-timed UI miss their moment. Draw only the last step.
The clamp is inherited by Chrome's GPU process, so software-rendering timing flakes from CI reproduce locally; setCPUThrottlingRate only slows the renderer's main thread.
With background throttling off and software rendering, the leaked page steals CPU (later tests ~3× slower), so one failure cascades into per-test and job timeouts; close in finally/afterEach, and look for every test after the first failure being uniformly slower.
Under software rendering each touchStart waits for a slow frame, so a pinch's second finger lands near a 420 ms hold deadline and now and then past it; push the deadline out from a bubble-phase window listener, and verify with a 900 ms delay.
A prompt placed over the nearest simulated animal joins the buttons being measured whenever one wanders up to a player standing still (about 1 island in 25 in 40 s); hide it with an injected style, and reproduce by standing the player beside a parked one.
Sharding or filtering through a helper sends every failure's test at file:line to the helper; keep the real test when unwrapped and print a --test-name-pattern command instead.
Files taking 1–3 s alone took 15–50 s beside browser tests, and wall-clock waits ran out as "flakes"; measure alone, run browser shards few at a time, longest first.
Nothing matches that.