Prooflayer

Inspiration

AI coding assistants like Codex can now generate entire diffs in seconds, but a diff alone doesn't tell a release owner why it's safe to ship. We kept seeing the same gap: teams got faster at writing code and no faster at deciding whether to trust it. ProofLayer started from a simple question — what if the AI's output for a release decision looked less like a confident paragraph and more like a court exhibit, where every claim points to evidence a human can actually check?

What it does

ProofLayer turns a code change and its operational context into a structured, evidence-backed release brief. Given a change title, context, and diff (the demo uses a realistic Orders API authentication migration), it generates an impact map, a risk register, a list of open unknowns, a test plan, and a rollout/rollback checklist. Every item in the brief links to an evidence reference a reviewer can inspect in a dedicated drawer — nothing is asserted without a source. Critically, the release approval toggle stays locked until a human explicitly confirms each condition; the tool supports the release decision, it never makes it. The finished brief exports to Markdown for sharing.

How we built it

The app is a Next.js 16 (App Router) project using React 19, TypeScript, and Tailwind CSS 4, kept intentionally client-side and single-page so a judge can run the full flow with npm install && npm run dev — no API keys, no backend, no network calls. Codex handled most of the implementation: scaffolding the product boundary, building out the UI flow (packet → brief → evidence selection → human confirmation → export), and running the lint/build checks. GPT-5.6 shaped the underlying analysis structure — specifically the decision to separate evidence, risk, and unknowns into distinct first-class categories instead of one free-form AI summary, which became the core design principle of the product.

Challenges we ran into

The hardest problem wasn't the UI, it was resisting the urge to make the demo look more autonomous than it should be. It would have been easy to wire up a live model call and call it a day, but that would have hidden exactly the kind of unverified confidence ProofLayer is trying to eliminate. Keeping the judge path deterministic and credential-free — while still making the evidence-linking feel real and interactive — took several passes to get right without it feeling like a static mockup.

Accomplishments that we're proud of

Getting the "no claim without evidence" principle to hold all the way through the product, not just in the copy but in the interaction model itself — evidence buttons only ever reveal a source, they never trigger a side effect or an inference. We're also proud that the release approval gate is a genuine hard block until every human confirmation is checked, which was a deliberate stand against the "AI approves, human rubber-stamps" pattern a lot of these tools slide into.

What we learned

Building this reinforced that the interesting design problem in AI-assisted engineering tools isn't generating the analysis — it's structuring it so a human can trust and verify it quickly. Separating "what changed," "what's risky," and "what we don't know" into distinct, inspectable categories turned out to matter more for trust than the sophistication of the underlying analysis itself.

What's next for ProofLayer

The current build is a deliberately scoped single-user demo. Next would be authenticated repository ingestion (pulling real diffs instead of a sample packet), a live model-backed analysis endpoint replacing the deterministic brief, persisted release history so teams can track decisions over time, role-based approvals for real release workflows, and integrations with issue trackers and deployment tooling so the release contract connects directly to the systems it's governing.

Built With

• codex
• eslint
• gpt-5.6
• nextjs
• node.js
• react
• tailwindcss
• typescript