Prism

Prism uses parallel GPT‑5.6 engineering investigators to turn Git diffs, CI logs, and source context into an evidence-backed root cause and proposal-only patch.

Comment

Inspiration

When a build fails after a code change, engineers must manually connect several scattered artifacts: the Git diff, CI output, failing tests and relevant source code. That investigation is slow, especially when the logs are noisy and the failure is far removed from the line that caused it.

AI can summarize these artifacts, but a confident answer is not enough if an engineer cannot verify where the conclusion came from. Prism was inspired by a simple question:

What if an AI investigation had to support every major claim with exact evidence from the incident?

Prism focuses on evidence traceability rather than producing the longest possible explanation.

What it does

Prism is an AI engineering investigation dashboard for software engineers diagnosing failed builds after a code change.

A user provides:

  • A Git diff
  • CI and test-failure logs
  • Optional relevant source context

Prism analyzes that evidence through four specialized GPT-5.6 investigators:

  1. Test Investigator examines assertions, failure mechanics and the relationship between the change and the failing test.
  2. Performance Investigator looks for repeated work, latency, resource pressure and scale effects.
  3. Security Investigator examines validation, trust boundaries, exposure and possible abuse paths.
  4. Architecture Investigator evaluates contracts, coupling, ownership and system-level consequences.

The investigators run concurrently. Each returns a structured hypothesis, confidence score, recommended checks and exact evidence citations.

After the specialists finish, a Lead Investigator compares their validated reports and produces:

  • A probable root cause
  • A confidence score
  • Confirmed evidence
  • Inferences
  • Unresolved uncertainty
  • Competing hypotheses
  • A recommended fix
  • A proposal-only unified diff
  • Patch risks
  • Verification steps

Prism never executes submitted code and never automatically applies a generated patch.

How we built it

Prism uses:

  • Next.js, React, and TypeScript for the visual investigation dashboard
  • OpenAI's official JavaScript SDK
  • GPT-5.6 through the Responses API
  • Zod for structured-output validation
  • NDJSON streaming for live progress updates
  • Vitest and Testing Library for automated tests
  • OpenAI Sites for the public deployment
  • Bundled synthetic fixtures for a reliable demonstration
  • In-memory state, with no database in the MVP

The four specialist calls start concurrently. Lead synthesis begins only after the specialists settle, and only validated reports are passed forward.

Every evidence citation includes a source type, exact excerpt, line reference, and explanation of relevance. After schema validation, Prism checks those citations against the original submitted evidence. A structurally valid response is still rejected if its excerpts or line references cannot be verified.

Sample mode sends the bundled synthetic N+1 incident through the hosted GPT-5.6 pipeline. It also retains validated fixture results as a transparent reliability fallback if a live response is unavailable or fails evidence validation.

Codex contributed substantially throughout development. It helped scaffold the application, define schemas and prompts, implement concurrent orchestration, integrate the Responses API, build citation validation, create the synthetic incident, develop the dashboard and patch viewer, write tests, improve documentation and deploy the application.

I supplied and approved the target audience, product direction, specialist roles, evidence-first requirements, visual-dashboard experience, technical boundaries and phased implementation decisions.

Challenges we ran into

Verifying model evidence

Structured JSON did not guarantee that a model's evidence was real. A response could satisfy the schema while quoting an excerpt that did not exist or pointing to the wrong lines.

We addressed this with a second validation layer that compares every citation against the original diff, logs, or source context before accepting the report.

Coordinating parallel investigators

The specialists needed to run concurrently, while the Lead had to wait for their results. The pipeline also needed to handle an individual specialist failure without confusing the user or inventing missing evidence.

We implemented explicit orchestration around concurrent promises, validated reports, partial failures and streamed progress events.

Keeping the demonstration reliable

Live model requests can experience timeouts, rate limits, or invalid responses. At the same time, the application needed to remain consistently demonstrable.

Prism's sample path prefers the real GPT-5.6 investigation pipeline while retaining validated synthetic results as a clearly disclosed fallback.

Making patch generation safe

A proposed code change is useful, but automatically modifying an arbitrary repository would be unsafe for this MVP.

Prism renders the result as an inert unified diff with an explanation, risks, copy and download actions, and unexecuted verification steps. It never applies the patch.

Accomplishments that we're proud of

We are especially proud that Prism is a complete, working developer tool rather than a collection of disconnected AI responses.

The MVP includes:

  • Four genuinely distinct GPT-5.6 engineering perspectives
  • Concurrent specialist execution
  • Structured Responses API output
  • Exact evidence and line-reference validation
  • Lead synthesis based only on accepted reports
  • Clear separation of confirmed evidence, inference, and uncertainty
  • A proposal-only unified diff with risks and verification steps
  • Graceful timeout, retry, and partial-failure handling
  • A synthetic N+1 incident with diff, logs, test output, source, and expected result
  • A public, judge-accessible deployment
  • 28 passing automated tests in the latest recorded verification
  • A public MIT-licensed repository

A hosted strict-live smoke test invoked all four GPT-5.6 investigators and completed Lead synthesis. Three specialist reports passed citation validation, while one was rejected for unverifiable evidence, demonstrating that Prism's validation boundary works on real model output.

What we learned

The biggest lesson was that trustworthy AI developer tools need more than strong prompts.

They also need:

  • Explicit schemas
  • Strict evidence boundaries
  • Citation verification
  • Separation between facts and inference
  • Predictable partial-failure behavior
  • Transparent fallback behavior
  • Human control over generated changes

We also learned that multiple AI perspectives are only valuable when their responsibilities are meaningfully different. Simply asking the same model for four reviews creates repetition. Giving each investigator a distinct engineering objective and requiring a Lead to compare their validated evidence produced a much more useful workflow.

Finally, building Prism with Codex demonstrated how an AI coding agent can contribute across the engineering lifecycle: specification, architecture, implementation, testing, debugging, documentation, compliance review and deployment.

What's next for Prism

The current submission is a focused MVP. The next work would concentrate on improving reliability and evaluation rather than expanding its claims prematurely.

Potential next steps include:

  • Adding more synthetic incidents covering different failure categories
  • Building a broader evaluation set for citation accuracy and root-cause quality
  • Improving visibility when an individual investigator response is rejected
  • Adding full browser-level end-to-end coverage
  • Refining patch-diff rendering for more complex unified diffs
  • Evaluating confidence calibration across repeated investigations

Any future repository or workflow integrations would require explicit authentication, permission boundaries and a separate safety review. They are not part of the current Prism MVP.

Built With

Share this project:

Updates