Models and levels, in full.Modelsandlevels,infull.

A fixed-capacity cache is dropping the wrong keys: under some access patterns it discards entries that should have survived and holds on to ones a true LRU would have evicted first. Dig into how it tracks usage over time and get its eviction order back in line with least-recently-used.

Bring an empty bounded FIFO queue to life: Push and Pop over a fixed capacity that stay correct when many goroutines hammer it at once. The signatures and public tests ship in the kit — the blocking and safety semantics are yours to pin down.

An existing Express app needs sliding-window rate limiting wired in as middleware: cap how often a given client may call, and turn away the overflow the way an HTTP API should. Grading is deterministic, so drive timing through the kit's injectable clock instead of real wall-clock — the exact limits and response shape live in the tests.

An async web crawler can't keep a straight story about which URLs it has already handled — some get visited twice, others slip through. Track down the concurrency flaw behind the inconsistency and make its bookkeeping hold up when tasks run in parallel. The bug reproduces the same way on every run, not as a flake.

One route in a small orders service gets dramatically chattier with the database as its result set grows, while its neighbors stay lean. Work out what makes that endpoint's data access blow up with size and bring it back down to a flat, predictable cost.

A Raft-style cluster occasionally crowns two leaders in the same term when messages arrive in an awkward order — exactly the safety property it is meant to guarantee. The cluster, transport, and role transitions are all provided and mostly correct; find what lets the second leader slip through and close the gap so a term can only ever have one.

Build a vector clock from empty stubs against a fixed API — Tick, Merge, and Compare. The signatures ship in the kit; the causality semantics each one has to honor are yours to work out and get exactly right.

An RGA text CRDT breaks its core promise: feed two replicas the same edits in different orders and they end up with different documents. Track down what lets them drift apart and restore convergence, so the order edits arrive in stops changing the final result.

A worker-pool orchestrator wedges itself under the right pattern of resource contention — tasks stop finishing and the whole thing hangs. Audit how it coordinates its goroutines, find what deadlocks it, and get every submitted task through to completion. The hang reproduces deterministically, not as a flake.

When callers cancel their context, this service never fully cleans up after itself — goroutines and connections accumulate instead of winding down. Set its lifecycle straight so a cancellation actually releases everything the work started.

A secure-envelope library sometimes accepts forged or tampered messages it should reject, and the way it checks them hands an attacker a timing signal. The cipher and framing underneath are sound — make its verification both strict and constant-time so neither the false accept nor the side channel survives.

Implement swap and its mulDiv helper for a constant-product (x·y=k) AMM against a fixed API. The straightforward version is a few lines; the real work is the arithmetic edge cases the tests lean on, where fees, rounding, and integer limits all collide.

Implement schnorr_verify and merkle_verify from scratch on top of the provided elliptic-curve primitive. The kit pins the serialization convention and ships one worked example; your job is to turn the verification math into code that agrees with the standard test vectors.

An Express API ships with two live vulnerabilities — one lets a crafted request read data it never should, the other lets a malicious payload quietly poison objects across the whole app. Find where untrusted input reaches something dangerous in each case and shut both down, without breaking any legitimate request path.

A bit-packed analytics toolkit is written top to bottom in dense, branchless bit-twiddling — and one of its routines quietly returns the wrong answer on certain inputs. Work through the obfuscation to the function that is off, pin down exactly which inputs break it, and correct it without disturbing the rest.

A tiled attention kernel is fully built except for its heart: the block-update step that folds each new tile of scores into a running softmax. Implement that one function so the streaming result matches a dense reference to tight tolerances — including the inputs crafted to wreck a naive approach.

Write the constant-folding optimization pass for a small bytecode IR, on top of the provided parser and evaluator. The catch is doing it safely — collapsing what is genuinely constant while leaving the program's observable behavior exactly as it was. Dead-code elimination is an optional, separately-scored bonus.

Fill in the broad-phase stage of a small 2D physics engine — the pass that decides which bodies are even worth a precise collision check. The body, world, and narrow phase are already built for you. Correctness alone won't cut it: it has to stay fast as the world grows, or brute force would have done the job just as well.

A small MLP training run blows up to NaN within a handful of steps. More than one thing is destabilizing it — read the way it diverges, reason out what is compounding the blow-up, and fix each cause until the network trains cleanly to its target loss with every step along the way finite.

A cooperative task runtime grinds to a halt under a particular ordering of wakes and schedules — forward progress simply stops. Its lock discipline is spelled out right there in the code; somewhere a path breaks the rules it lays down. Find that violation and restore liveness so the runtime keeps moving no matter the ordering. The stall reproduces deterministically.