CASEFILE: Every Bug Has a Story. Every Fix Needs Proof.

Srinivas P — Sun, 18 Oct 2026 17:46:17 +0000

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:

srinivas2s / casefile

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…

View on GitHub

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.

DEV Community: Srinivas P

CASEFILE: Every Bug Has a Story. Every Fix Needs Proof.