CASEFILE: Every Bug Has a Story. Every Fix Needs Proof.
Debugging should produce evidence, not just guesses.
Every developer has experienced this: a bug appears, a fix is proposed, and everyone hopes the problem is solved.
But can the original bug be reproduced? Did the fix address the actual failure? And is there evidence that the change works as expected?
CASEFILE is an open-source developer tool designed to bring structure, traceability, and evidence to bug investigations.
My goal is to make debugging more systematic by organizing investigations, preparing reproduction-test plans, tracking available results, and generating evidence reports.
What I Built
CASEFILE is designed around four stages:
1. Investigate
Create structured bug investigations instead of leaving debugging notes scattered across terminals, issue trackers, and conversations.
2. Generate
Prepare structured reproduction-test plans to help developers reason about how a bug might be reproduced.
3. Verify
Track execution status and test evidence where supported. Secure isolated code execution and complete original-versus-fixed verification are still under development.
4. Present
Export investigation evidence in JSON and HTML formats, making debugging records easier to share, review, and document.
The principle behind CASEFILE is simple: a proposed fix should be supported by evidence, not just confidence.
The Problem
Debugging often involves switching between issue descriptions, source files, terminal output, test results, and team discussions.
Important details get lost. Reproduction steps may be incomplete. A fix might resolve one issue while introducing another.
CASEFILE aims to bring these pieces into one organized workflow.
The intended users are individual developers, open-source maintainers, and engineering teams that want clearer, more traceable debugging investigations.
Demo
The current application includes an investigation dashboard, investigation management, test-plan previews, execution-status tracking, and JSON/HTML evidence exports.
Screenshots:
Code
GitHub Repository:
CASEFILE
CASEFILE is an evidence-first bug investigation and verification platform for Python projects. It helps teams turn a bug report into a reproducible test, verify the original failure, validate a fix, and keep a record of the evidence.
License
CASEFILE is licensed under the MIT License.
Stack
- Frontend: React + Vite + TypeScript + Tailwind CSS
- Backend: FastAPI + SQLAlchemy + SQLite + Pytest
- Local-only workflow: no external AI APIs or model dependencies
Quick start
Backend
cd backend
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
uvicorn app.main:app --reload --host 127.0.0.1 --port 8000
Frontend
cd frontend
npm install
npm run dev -- --host 127.0.0.1 --port 5173
The API is a local development service, not a multi-user deployment. It binds to localhost by default. Running user-provided tests is disabled until a verified isolated execution runner is configured; CASEFILE does not execute test code on the…
CASEFILE is being developed as an open-source project, with a React frontend, a Python backend, automated tests, and development documentation.
How I Built It
I chose a stack that would let me build a usable developer tool while keeping the architecture straightforward.
Frontend
- React
- Vite
- TypeScript
- Tailwind CSS
Backend
- Python
- FastAPI
- Pydantic
Database
- SQLAlchemy
- SQLite
Testing and development
- pytest
- Vitest
- React Testing Library
- GitHub Actions
- GitHub Copilot
I used GitHub Copilot as an AI pair programmer during development, including assistance with architecture exploration, implementation, debugging, and testing.
I also maintained a development tracker to record implementation progress, test results, security findings, and unfinished work.
One important engineering decision was to keep code execution disabled when a secure, isolated execution environment was unavailable. Executing untrusted code directly on the host machine would introduce unnecessary security risks.
My Use of GitHub Copilot
GitHub Copilot was part of my development workflow, helping me explore implementation approaches, work through frontend and backend changes, investigate errors, and improve tests.
However, generated code is not automatically correct.
I reviewed implementation changes, ran automated checks, investigated issues, and documented remaining limitations. This process helped me distinguish features that were working from those that still needed further engineering.
The biggest lesson was that AI-assisted development is not just about generating code faster. It is about using that assistance responsibly while retaining control over technical decisions, testing, and security.
I want CASEFILE itself to follow the same principle: useful automation backed by verifiable results.
Why Does Open Innovation Matter?
Developer tools frequently operate close to sensitive information, including source code, stack traces, internal logic, and proprietary business rules.
An open-source approach gives developers the freedom to inspect implementations, adapt workflows, build integrations, and contribute improvements.
For CASEFILE, open innovation also creates an opportunity to explore open-weight AI models for understanding bug reports and preparing reproduction-test plans.
In the future, this could allow developers to choose models and deployment options that better fit their privacy, infrastructure, and budget requirements.
My goal is to build a tool that developers can inspect, extend, and improve together rather than treating debugging automation as a closed black box.
The current application does not yet integrate an open-source AI model. Local inference and AI-assisted test generation are future development goals, not completed features.
Testing and Security
A successful build does not prove that every product workflow is complete.
During development, I used automated checks to validate the implemented frontend and backend functionality.
I also identified an important limitation: secure isolated test execution is not yet implemented. Rather than falling back to unsafe host execution, CASEFILE keeps that execution path disabled when the required isolation is unavailable.
This means the project is an early-stage developer-tool MVP, not yet a complete automated debugging and fix-verification platform.
Documenting this distinction is important because reliability and security are central to the problem CASEFILE aims to solve.
What's Next?
My next priorities are:
- Integrate and evaluate an open-weight model for bug-report analysis.
- Generate executable reproduction tests for supported bug patterns.
- Implement and independently verify secure, isolated code execution.
- Compare original and corrected code using reproducible evidence.
- Expand regression testing and investigation management.
- Improve accessibility, documentation, and the overall developer experience.
These improvements will move CASEFILE closer to its long-term goal: a debugging workflow where investigations are structured, results are reproducible, and conclusions are supported by evidence.
My First User
CASEFILE is being developed for developers and open-source maintainers who need a more structured way to investigate bugs and document evidence.
My next step is to gather feedback from developers using the current version and use their experience to identify confusing workflows, missing features, and opportunities to improve the tool.
My Agent Session
GitHub Copilot assisted me throughout the development process, from exploring implementation approaches to debugging and testing.
I used it as a development assistant rather than an unquestionable source of truth. Reviewing changes, validating behavior, and documenting limitations remained important parts of the process.
Prize Categories
Best Use of GitHub Copilot
CASEFILE demonstrates my use of GitHub Copilot as an AI pair programmer during development. It assisted with architecture exploration, implementation, debugging, and testing, while I reviewed changes, validated implemented functionality, and tracked remaining work.
Side Hustle
CASEFILE aims to solve a practical developer problem: organizing bug investigations and making debugging evidence easier to review and share.
The long-term vision is an extensible, open-source debugging workflow that can incorporate open-weight AI models while giving developers greater control over their tools.
I am building toward that vision incrementally, with an emphasis on reliable behavior, transparent limitations, and evidence-based verification.
Final Thoughts
CASEFILE started with a simple observation: fixing a bug and proving that it is fixed are two different things.
I want to make the second part easier.
The project is still evolving, and there is significant engineering work ahead, especially around open-source AI integration and secure test execution. But the foundation is an opportunity to explore a more systematic approach to debugging.
Every bug has a story. Every fix needs proof.
Built with React, FastAPI, Python, and GitHub Copilot.
Challenge: Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.
Top comments (0)