CodeRedox

Home Page
Overview
Rescue
Redox Gate
Chat
Readme
Findings
Packages
Forecast
Time Machine
Awards

Code Redox: evidence before AI action, proof after it

Code Redox is a Windows desktop developer tool that helps developers turn codebase drift into a clear, reviewable recovery workflow.

Repositories rarely fail because of one dramatic mistake. They become difficult to work in through accumulated friction: duplicated logic, stale TODOs, debug statements, unsafe patterns, unused packages, formatting drift, complex files, and changes whose history is hard to understand. Existing tools can produce warnings, and AI coding agents can produce changes but developers still need to answer a harder question:

What is the safest, highest-value next change, and how can I prove it was made responsibly?

Code Redox is my answer.

Inspiration

I wanted to solve the gap between static analysis and AI-assisted coding. A warning alone does not explain its impact, history, or priority. An AI fix alone does not prove that it stayed in scope or preserved behavior.

The goal was not to build another dashboard full of red dots, or another unconstrained AI code editor. I wanted to build a guided engineering loop:

Scan → Understand → Prioritize → Preflight → Approve → Repair → Re-scan → Review → Hand off

That loop became Code Redox.

What it does

Code Redox opens a local repository and analyzes code quality, maintainability, reliability, security, runtime safety, accessibility, formatting, and dependency health.

It detects signals such as dead code, duplicate logic, debug code, TODO debt, magic values, long or complex functions, empty artifacts, formatting drift, suspicious packages, secrets, unsafe operations, injection risks, path traversal, weak cryptography, and more.

But the central value is not merely finding issues. It is helping a developer decide what to do next.

Understand the repository

The Overview shows project health, source composition, contributor and Git activity, quality signals, and active findings.

Time Machine links a current finding to the Git commit that last changed the affected line, including commit context and diff evidence.

Forecast combines active findings, dependency signals, and recent Git churn to identify likely maintenance bottlenecks before they become larger problems.

Decision Lens ranks a finding using local evidence such as risk tier, same-file pressure, repeated patterns, and release posture.

Fix Ripple lets developers simulate the likely effect of resolving a finding before any code is modified.

Turn a finding into a safe AI task

The key feature is the Repair Flight Plan.

Before Code Redox allows an AI repair, it generates a local preflight for the selected finding:

the behavior-preservation contract
likely blast radius and nearby references
recent Git history
an allowed file scope
suggested verification commands
explicit approval gates

The developer sees this plan before authorizing the repair.

When approved, Code Redox creates a temporary, narrowly scoped task and invokes the local Codex CLI. The app streams progress, removes the temporary instruction file afterward, and re-scans the repository.

This means Codex is not asked to "clean up the project." It receives a constrained task with evidence, scope, and verification expectations.

Prove the result

After an approved repair, Repair Receipt compares the Git working-tree changes with the Flight Plan’s allowed scope and pairs that result with a fresh scan.

Redox Gate then turns the current Git diff into a pre-merge passport. It maps changed files, links them to current scan signals, highlights sensitive paths, reports a release posture Awaiting Diff, Hold, Review, or Clear to Review and suggests the smallest relevant verification route.

It intentionally does not claim that code is safe. It provides evidence for a human merge decision.

Finally, Codebase Rescue Mode turns the experience into a guided recovery story: capture a baseline, inspect the highest-impact change, preflight an AI repair, verify the result, and generate a shareable team handoff brief.

How I built it

Code Redox is a Windows Electron application built with JavaScript and Node.js.

The renderer provides the desktop audit workspace. The Electron main process handles repository analysis, Git metadata, caching, package inspection, safe context-isolated IPC, and Codex CLI orchestration.

The project combines built-in static-analysis workers with:

Knip for dead-code analysis
JSCPD for duplicate-code detection
Prettier for formatting-drift repair
slop-scan for package-integrity signals
Git log, blame, and diff analysis
package inspection across npm, Composer, Maven, Gradle, Python, Go, and Rust

How Codex and GPT-5.6 accelerated the project

I built Code Redox with Codex and GPT-5.6 as the primary implementation collaborator during the hackathon.

Codex accelerated product exploration, multi-file Electron implementation, renderer and UX iteration, static-analysis workers, Git-powered features, package discovery, safe IPC boundaries, test coverage, packaging, and documentation.

GPT-5.6 was especially valuable for turning a broad idea "help developers clean up AI coding slop" into a coherent product system. It helped develop the evidence-first workflow behind Rescue Mode, Decision Lens, Fix Ripple, Repair Flight Plan, Repair Receipt, and Redox Gate.

The most important design decision was keeping developers in control:

Code Redox is local-first.
Ask mode is read-only.
Work mode requires explicit authorization.
Every repair is constrained by a focused task.
Flight Plans provide scope and verification before AI writes.
Re-scans, Git diffs, Repair Receipts, and Redox Gate make results reviewable afterward.

The human developer still decides what to repair, approves the AI action, reviews the diff, and runs the relevant tests.

Challenges and lessons

The biggest challenge was avoiding false confidence.

Static analysis can be noisy. Forecasts can be wrong. AI can make changes that look plausible but exceed the intended scope. Instead of hiding that uncertainty, Code Redox makes it visible: findings are signals, forecasts are evidence-backed rather than guaranteed, and Redox Gate is a review aid rather than a replacement for testing.

I learned that developer tools become more useful when they explain not only what is wrong, but also why it matters now, what could safely change, and how to verify the outcome.

Why Code Redox is different

Most linters answer: "What is wrong here?"

Most AI coding tools answer: "What should I change?"

Code Redox connects those with a third question:

"What is the safest and most valuable next change and how can I prove it?"

Its differentiator is the full evidence → constrained repair → proof loop. It gives developers the speed of Codex and GPT-5.6 without asking them to give up engineering judgment.