FlexFingers · alpha

Catch the bug before your agent ships it.

Five short reviews of agent-written code. One line is wrong, or none is. Then a warmup for the prompts and commands you still type by hand.

Time on this item: 0:00

Spot the bug, try one: Build a request URL

The task given to the agent

Join base and path with one slash, then add params: skip None, repeat keys for lists, booleans as true/false.

The code it wrote

One of these lines is wrong.

Line 1: QueryValue = str | int | bool | list[str] | None
Line 2, blank:
Line 3, blank:
Line 4: def build_url(base: str, path: str, params: dict[str, QueryValue]) -> str:
Line 5: root = base if base.endswith("/") else base + "/"
Line 6: relative = path[1:] if path.endswith("/") else path
Line 7: url = root + relative
Line 8: pairs: list[tuple[str, str]] = []
Line 9: for key, value in params.items():
Line 10: if value is None:
Line 11: continue
Line 12: if isinstance(value, bool):
Line 13: pairs.append((key, "true" if value else "false"))
Line 14: elif isinstance(value, list):
Line 15: pairs.extend((key, item) for item in value)
Line 16: else:
Line 17: pairs.append((key, str(value)))
Line 18: return f"{url}?{urlencode(pairs)}" if pairs else url

Spot the bug

Every bug proven, every find timed

Every bug has a failing case

Each bug is one small mutation of correct TypeScript, Python or Go. It passes the language's own compile or type check, and it fails a real test case, which you see after you answer. No model writes or grades anything while you play.

Three levels

Easy: one line is wrong, or none is. Medium and Hard: up to two lines are wrong, and Hard is code that takes more reading. The page tells you the most there can be, never how many there are.

Timed while you look

The clock runs only while the tab is visible and the window is in front. Time to find counts finds only, so a fast guess never passes for a fast review.

Blind spots by kind

Every round ends with what you found by kind of bug, each bug counted on its own, so you know what to read for next.

  • Off by one
  • Logic
  • Null handling
  • Async
  • Arithmetic
  • Wrong variable
  • Collections
  • Comparison
  • Error handling
  • HTTP contract
  • Concurrency
  • Shared state
Then warm up

For the prompts and commands you still type

The agent writes the code, but the prompt and the terminal are still yours. A warmup is 30, 60, or 90 seconds of exactly that, scored for speed and accuracy.

Warmups need a real keyboard, so they open on a laptop or desktop.

How it works

Review first, then warm up

  1. 1
    Spot the bug
    Five short reviews of TypeScript, Python or Go code at Easy, Medium or Hard. Flag the wrong lines or call the code correct. Where there was a bug, see the fix, what was wrong, and the failing case.
  2. 2
    Warm up
    30, 60, or 90 seconds of typing on agent prompts or shell commands. Code, prose, and markdown are there too.
  3. 3
    Open Improve
    Signed in, see which keys, key pairs, and fingers are slowing you down, with a finger map of your keyboard, and drill them.