Lion Cipher Lab

Map the jagged frontier: build a paired-task eval where a stub model aces a hard security task and fails its trivially easy twin, count the capability inversions, and prove the overall accuracy hid them

• AI Security
• Advanced
• ~90 min
• Free · no account required

Why it matters

Every team that puts an AI model on a security job wants one number for it: an accuracy, a score, a single figure that says good enough or not. That number is a trap, and this lab builds the trap in miniature so you can watch it spring. The 'jagged frontier' is the finding, documented by Dell'Acqua and colleagues in a large field study of knowledge workers using AI, that a model's capability is not a smooth hill where everything below a line is hard and everything above it is easy - it is a jagged edge, where a genuinely difficult task sits inside the frontier (the model nails it) right next…

What you'll learn

• building a PAIRED-TASK eval suite - 60 matched (hard, easy-twin) security cases where the twin is the SAME case reformatted and simplified, so the twin is genuinely EASIER for a human (mean true difficulty 0.162 vs the hard item's 0.763) while carrying surface changes a model is sensitive to
• writing a DETERMINISTIC stub classifier whose competence is driven by SURFACE features - familiar format, canonical phrasing, token length against a sweet-spot band - and almost not at all by true difficulty, with every verdict decided by a SHA-256 coin so the whole study is reproducible to the digit and free
• seeing a single overall accuracy of 0.7667 (92/120) and then watching it SPLIT into hard-item accuracy 0.9333 and easy-twin accuracy 0.6000 - a +0.3333 gap the average silently absorbs, which is the precise sense in which one number hides the jaggedness
• counting CAPABILITY INVERSIONS (hard right, easy-twin wrong): 23 of 60 pairs (rate 0.3833) against only 3 in the expected direction, proving the model-aces-hard-fails-easy pattern is the dominant behaviour here and not a rounding artefact
• reading the surface cause of each inversion - the 23 broke down as chat-paraphrase 10, terse-note 7, sms-style 5, one-liner 1, every one an unfamiliar or terse reformat - and inspecting one pair end to end (hard json-alert surface 0.9041 RIGHT; easy terse-note twin surface 0.4504 WRONG, same correct answer)
• keeping the honest negative this lab exists to teach: you cannot patch the frontier smooth - promoting terse-note to a familiar format moved its inversions only 7 -> 4 (survivors sunk by length instead), total inversions just 23 -> 20, because jaggedness is multi-dimensional and patching one surface axis leaves it open on the next
• drawing the operational conclusion - because jaggedness is not predictable from a global score you can only find failing neighbours by testing the specific twins, so you keep a live paired-twin suite rather than trusting a leaderboard number

Steps in this lab

1. The words first: the jagged frontier, a paired task and its easy twin, surface features versus true difficulty, a capability inversion - and the fact that the classifier is a stub
2. Open a terminal and check Python (all three operating systems)
3. Build the paired corpus: 60 matched (hard, easy-twin) security cases whose correct verdict you already know
4. The classifier is a DETERMINISTIC STUB wired to SURFACE features - and here is the entire model in writing
5. The single overall number - and the split it hides
6. Count the capability inversions - the jag made into a number
7. Look at one inversion up close
8. The honest negative: 'fix' the loudest spot and watch the frontier MOVE, not close
9. Reading the result - and when this lens is the right one to reach for
10. The way a pro does it
11. OPTIONAL appendix: point the identical interface at a real local model

Open the full interactive lab →