CODERUNX

Enterprise AI debugger with autonomous self-healing loops powered by Gemini 3 Pro

Comment

CODERUNX: Enterprise AI Auto Fixer and Debugger

Inspiration

As a developer, I've lost countless hours stuck in the frustrating cycle of debugging complex projects. You fix one bug, run the code, and three more appear. You Google the error, try a solution, and something else breaks. The cycle repeats endlessly.

I realized that modern AI specifically Gemini 3 Pro has the reasoning capability to not just identify bugs, but to actually fix them autonomously. The question was: could I build a system that doesn't give up until the code works?

That's how CODERUNX was born an enterprise-grade debugger that implements autonomous self correction loops, treating debugging as an iterative problem-solving task rather than a one shot analysis.

What It Does

CODERUNX transforms buggy multi-file projects into production-ready code through AI-powered autonomous repair cycles.

Core Capabilities

Deep Neural Diagnostics

Goes beyond syntax checking to understand code intent. Identifies:

  • Architectural logical flaws across modules
  • Runtime vulnerabilities and edge cases
  • Asynchronous deadlocks and race conditions
  • Cross-file dependency issues

Autonomous Self-Healing Cycle

Implements a "Repair-Verify-Deploy" loop:

  1. Analyze: Gemini 3 Pro consumes error stack traces with full project context
  2. Hypothesize: AI identifies root causes using advanced reasoning
  3. Patch: Generates precision code modifications
  4. Simulate: Tests fixes in AI-powered sandbox
  5. Verify: Applies changes only after successful execution

The system retries up to 3 times, learning from each failed attempt to refine subsequent repairs.

Multi-File Workspace

  • Drag-and-drop entire project directories
  • Dynamic file tree navigation
  • Context-aware analysis across dependencies
  • Understands architectural relationships between modules

Polyglot AI Sandbox

  • Secure, isolated code execution
  • Universal runtime support: Python, JavaScript, TypeScript, C++, and more
  • Live terminal with AI diagnostic tags
  • No local setup required

How I Built It

Technology Stack

Frontend Core

  • React 19 + TypeScript
  • Tailwind CSS
  • Lucide React

AI Engine

  • Google Gemini 3 Pro API
  • Custom prompt engineering for code repair tasks

Code Editor

  • PrismJS with custom themes
  • Scroll-synchronized editor with line numbers
  • Real-time diff highlighting

File Management

  • JSZip for project archiving
  • Recursive FileTree components
  • Custom file system simulation in browser

Typography

  • JetBrains Mono

Development Process

Phase 1: Architecture Design (Days 1–2)

  • Designed multi-file workspace system
  • Architected autonomous self-correction loop
  • Planned Gemini API integration

Phase 2: Core Features (Days 3–4)

  • Drag-and-drop directory ingestion
  • Recursive file tree navigation
  • AI-powered sandbox
  • Context-aware Gemini integration

Phase 3: Self-Correction Loop (Day 5)

  • Iterative repair cycle with attempt tracking
  • Error recovery and fallback mechanisms

Phase 4: UI/UX Polish (Days 6–7)

  • Live debugging console
  • Code diff visualization
  • Theme toggle
  • Animations and loading states

Phase 5: Testing & Refinement (Days 8–9)

  • Stress-tested complex multi-file projects
  • Optimized Gemini prompts
  • Fixed edge cases

Key Technical Achievement

async function autonomousRepairCycle(
  projectFiles: File[],
  context: string,
  maxAttempts: number = 3
) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const analysis = await gemini.analyzeProject(projectFiles, context);
    const executionResult = await sandbox.execute(analysis.code);

    if (executionResult.success) {
      return { success: true, fixedCode: analysis.code, attempts: attempt };
    }

    analysis.code = await gemini.refineBasedOnError(
      executionResult.error,
      analysis.reasoning,
      attempt
    );
  }

  return { success: false, message: "Manual review needed" };
}

Challenges I Ran Into

Multi-File Context Management

Handled token limits using dependency-based context windowing and file importance scoring.

Autonomous Loop Stability

Implemented retry limits, confidence scoring, and fallback to human review.

Sandbox Security

Isolated execution with strict timeouts, memory limits, and API restrictions.

Real-Time State Synchronization

Centralized state management with optimistic UI updates and rollback.

AI Response Parsing

Built multi-strategy extraction pipelines for clean executable code.

File System Simulation

Created a virtual file system with recursive rendering and path resolution.

Accomplishments

  • Production-grade multi-file debugger
  • Fully autonomous repair loop
  • Deep Gemini 3 Pro integration
  • Enterprise-level developer UX
  • Universal language support
  • End-to-end debugging workflow

What I Learned

Technical Growth

  • Advanced Gemini prompt engineering
  • Async-heavy React architecture
  • Secure client-side code execution

AI Insights

  • Iterative repair improves accuracy
  • Confidence scoring guides stopping criteria
  • Context prioritization is critical

Product Design

  • Transparency builds trust
  • Real-time feedback improves usability

What's Next

Immediate Roadmap

  • GitHub and GitLab integration
  • Extended language support
  • Cloud sync and collaboration

Advanced Features

  • Real-time multi-user debugging
  • Custom AI training
  • Performance profiling
  • Auto-generated tests

Enterprise Vision

  • VS Code extension
  • CI/CD integration
  • Team analytics
  • Security scanning

Research Directions

  • Multi-agent debugging systems
  • Reinforcement learning for repair strategies
  • Knowledge graph of successful fixes

Built With

Share this project:

Updates