Pager

• 

  Pager landing: practice the judgment that comes after AI writes the code, with a real incident card showing context, decision, and proof.

• 

  The incident room: live signals on the left, real Python code in the center, and three AI Pair repairs from GPT-5.6 on the right.

• 

  Reviewing an AI repair side by side. This one only trims the identifier, so it treats formatting, not the invariant. Reject it.

• 

  A second AI fix that just sorts the queue on read. It changes presentation, not membership, so the duplicate still slips through.

• 

  The safe repair: guard duplicate pending work by checking membership first, so a retry joins existing work instead of doubling it.

• 

  The execution-verified credential: 5 of 5 checks passed, incorrect AI recommendation rejected, and a plain debrief of what proved it.

• 

  The learning loop in three steps, investigate, judge, verify, with the reminder that execution, not an LLM, decides the outcome.

• 

  Why Pager is different: it makes the invisible part of AI-assisted work visible, the judgment between a generated patch and a safe ship.

• 

  The practice path: five execution-verified incidents from easy to advanced across Python and TypeScript, each with a real test suite.

• 

  The roadmap: scale the evidence loop, not just the catalog, adding languages and cases only when each has a real runner and tests.

Inspiration

AI writes code fast now. It does not tell you when that code is wrong.

During Build Week we kept hitting the same moment: an AI assistant hands you a fix in seconds, it looks reasonable, it even makes the error go away, and it still breaks the one rule that mattered in production. The scarce skill is no longer writing the patch. It is knowing whether to trust it. Today there is no safe place to practice that judgment, so developers learn it the hard way, from a bad 2 AM deploy. We built Pager to be that safe place.

What it does

Pager is an execution-verified incident simulator for developers working next to AI coding tools. It drops you into a realistic production incident and makes you do the part that actually protects customers.

1. Read the incident. A brief, live signals, a real codebase, and stakeholder pressure from product, engineering, SRE, finance, and support.
2. Judge the AI repairs. An AI teammate, the AI Pair powered by GPT-5.6, proposes several plausible fixes. You inspect the exact before and after diff and decide: apply or reject.
3. Prove it by execution. The browser runs the incident's real acceptance suite. That run, not a model's opinion, decides whether the incident is contained.
4. Earn a credential only when you both pass the suite and reject the unsafe proposals. No badge collecting: the credential is backed by a decision trail plus execution evidence.

Five execution-verified labs ship today, easy to advanced, across Python and TypeScript: an invoice-queue retry, an inventory reservation, a settlement replay, a webhook replay, and a concurrent-checkout race. Each is tagged with its fault class (idempotency, concurrency, replay safety) so the lesson transfers to real work.

How we built it

Next.js App Router, strict TypeScript, the Monaco editor, real in-browser execution, and a manifest-driven content model.

• Real execution, not a fake green check. TypeScript labs boot an isolated WebContainer in the browser and run the fixture's own test command. Python labs load Pyodide and run the real unittest suite. Cross-origin isolation headers make the sandbox work.
• Manifest-owned incidents. Every lab is one JSON manifest plus a runnable fixture: source, tests, alert, telemetry, stakeholders, repair candidates, and an executable success condition. The UI and engine stay generic.
• Deterministic grading. A model never marks a repair correct. Candidate verification scripts and a Playwright end-to-end test prove the safe repair passes and the unsafe ones fail, every time.
• Codex and GPT-5.6, both load-bearing. GPT-5.6 (gpt-5.6-sol) generated the incident codebases and their planted invariant violations. GPT-5.6 (gpt-5.6-terra) drafts the fallible repair proposals and stakeholder replies at runtime. Codex built the platform around them: the runner architecture, the Pyodide and WebContainer boundaries, the workspace, verification, and the browser tests. We made the product calls: education first, repair options authored and neutral before the learner decides, execution as the only grading authority, and no language marketed until it has a trusted runner.
• Optional Live Coach. A bounded GPT-5.6 assistant answers investigation questions in an Observation, Question, Next step format. It cannot name the answer, supply a patch, or grade you, and a response filter strips code and direct recommendations. The whole product runs without it.
• Private by default. No account. Drafts and progress live in local browser storage. The OpenAI key stays server-only.

Challenges we ran into

• Making the browser truly execute code safely. WebContainers need cross-origin isolation, and Pyodide needs its module cache cleared between runs or a later verification silently uses stale code. Both took care so the first click always tests the code you see.
• Keeping AI in its lane. The hardest rule was that the model helps you think but never decides. We separated authored repair options from live rendering and made execution the single source of truth.
• Honesty over surface area. It was tempting to show a Java or C++ tab. We refused to list any language without a real runner behind it, because a fake capability would betray the whole point of the product.
• Polish under the hood. A failing suite is the default first state of every lab, so we fixed a case where the Python runner surfaced an uncaught error on every failing run, and added clear progress while the runtime loads so nothing ever looks frozen.

Accomplishments that we're proud of

• It is real. No hardcoded green check anywhere. Every pass comes from an actual test run in the browser.
• The credential means something. It requires proving the fix and catching the unsafe advice, so it reflects judgment, not luck.
• It runs for anyone in seconds. No account, no key, no setup, and a full evidence loop in about fifteen minutes on the live URL.
• We found the unclaimed category. SWE-bench measures whether AI can write the fix. Pager measures whether a human can tell when it cannot.

What we learned

• Verification is now a distinct discipline, and the industry is starting to say so. Research shows AI patches routinely pass a visible symptom while breaking a hidden invariant, which is exactly the failure mode each lab is built around.
• Guardrails are a feature. Writing the prompts and filters that make an AI coach useful without letting it give away the answer taught us as much as the runners did.
• Determinism builds trust faster than intelligence. People trust a green suite far more than a confident model, so we let execution have the final word.

What's next for Pager

• Bring your own agent. Paste a real Codex or Claude patch and have Pager verify it against the hidden invariant suite. This bridges agent benchmarks, which grade the AI, and Pager, which grades your trust in the AI.
• More incident packs across authentication, data migrations, caching, and distributed systems, each with a real acceptance suite.
• More languages, but only after each has a verified isolated runner. Java and C++ are on the roadmap, not the marketing.
• Teams and classrooms: accounts, cohorts, a quantified judgment score, and a post-incident debrief, with heavier execution moving to server-side sandboxes.

Built With

• codex
• css
• eslint
• gpt-5.6
• monaco-editor
• next.js
• node.js
• openai
• playwright
• pyodide
• python
• react
• responses-api
• typescript
• vercel
• vitest
• webassembly
• webcontainer-api