Inspiration
Code review is one of the most important parts of software development, but many bugs are difficult to catch from a diff alone. Developers often receive vague comments such as “this may fail in production” without a reliable reproduction, test case, or safe fix.
Bug Court was inspired by the idea of turning code review into a transparent hearing. Instead of simply generating comments, Codex builds a case file: it identifies likely bugs, explains why they matter, creates reproduction steps, runs tests, and lets the developer accept fixes one at a time.
What Bug Court Does
Bug Court reviews a pull request and organizes its findings into an evidence-backed case file.
For every finding, it shows:
- Severity and confidence
- Exact file and line location
- Plain-language explanation
- Reproduction steps
- Test results
- Suggested fix
- Developer decision state
The developer stays in control. Fixes are never applied blindly. Each proposed patch must be reviewed and accepted individually.
How We Built It
The project was built with Codex as a coding partner. The interface was designed as a focused developer workbench with a pull request queue, annotated diff viewer, AI case file, test evidence panel, and transparent activity timeline.
The architecture is designed around three cooperating agents:
- A diff and history agent that understands the pull request.
- A reproduction agent that creates and runs targeted test cases.
- A judge agent that ranks findings and prepares the case file.
The current demo uses deterministic fixture data so the experience is reliable during judging. The production integration is designed around GitHub pull requests, the OpenAI Responses API, the Agents SDK, and a sandboxed test runner.
What We Learned
We learned that useful AI code review is not just about finding more issues. Trust comes from showing the evidence behind each issue.
A strong review needs:
- Precise code locations
- Reproducible failures
- Clear confidence levels
- A visible chain of actions
- Human approval before changes are applied
We also learned that the best developer tools make model behavior inspectable instead of hiding it behind a single “Generate fix” button.
Challenges
The biggest challenge was designing an experience that felt intelligent without becoming overwhelming. Developers need detailed evidence, but they also need to scan findings quickly.
Another challenge was balancing automation with control. Bug Court automates the tedious work of investigation while keeping the final decision with the developer.
We also designed the demo to work without credentials, so judges can experience the complete review flow immediately while still seeing how the live GitHub and agent integrations would connect.
What's Next
The next version will connect directly to GitHub, run generated tests in isolated containers, create patch branches, and allow developers to open reviewed pull requests directly from the case file.
Log in or sign up for Devpost to join the conversation.