What I Built

I built NirvanaPilot, an ambient, non-intrusive VS Code Extension integrated with GitHub Copilot Chat that acts as the "subconscious mind" of your codebase. Honoring the essence of International Sloth Day, NirvanaPilot consumes 0% CPU while you are actively coding. However, the exact millisecond you take a break (15 seconds of complete typing inactivity), it wakes up in the background to scan your local repository for uncommitted drifts (git diff).

Instead of running superficial linting, it passes this context to a local open-weight model to perform Counterfactual Simulations—projecting how your system's structural complexity and entropy (Δ Entropy) will degrade over a 6-month high-scale horizon, generating localized, protective refactoring recommendations.

Demo

Our system architecture functions seamlessly inside the IDE:

  Active Typing State (Developer building)
             │
             ▼
  [NirvanaPilot Sleeps — 0% Resource Overhead]
             │
   (15 Seconds of Complete Inactivity)
             │
             ▼
   [Sloth Heartbeat Wakes Up] ──► Reads local `git diff HEAD`
             │
             ▼
   [Local Inference Isolation] ──► Pipes context to local Gemma 2 (Ollama)
             │
             ▼ (If developer types again, process immediately aborts!)
             │
   [Strict JSON Parsing Pipeline] ──► Caches Counterfactual Risk Metrics
             │
             ▼
   [GitHub Copilot Chat Interface] ──► Query via `/incubate` or `/simulate`
                                       Renders immediate defensive patches

Code

The entire production-grade, compile-ready repository bundle is public and accessible here:

HazemAbabneh / NirvanaPilot

An ambient, privacy-first VS Code extension for GitHub Copilot that runs background architectural simulations on local Git diffs during developer inactivity, powered entirely by local Gemma 2 via Ollama. Built for Hacktoberfest 2026.

NirvanaPilot

Hazim Yousef Ababneh · 2026-10-20T01:16:56Z

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady What I Built I built NirvanaPilot , an ambient, non-intrusive VS Code Extension integrated with GitHub Copilot Chat that acts as the "subconscious mind" of your codebase. Honoring the essence of International Sloth Day, NirvanaPilot consumes 0% CPU while you are actively coding. However, the exact millisecond you take a break (15 seconds of complete typing inactivity), it wakes up in the background to scan your local repository for uncommitted drifts ( git diff ). Instead of running superficial linting, it passes this context to a local open-weight model to perform Counterfactual Simulations —projecting how your system's structural complexity and entropy (Δ Entropy) will degrade over a 6-month high-scale horizon, generating localized, protective refactoring recommendations. Demo Our system architecture functions seamlessly inside the IDE: Active Typing State (Developer building) │ ▼ [NirvanaPilot Sleeps — 0% Resource Overhead] │ (15 Seconds of Complete Inactivity) │ ▼ [Sloth Heartbeat Wakes Up] ──► Reads local `git diff HEAD` │ ▼ [Local Inference Isolation] ──► Pipes context to local Gemma 2 (Ollama) │ ▼ (If developer types again, process immediately aborts!) │ [Strict JSON Parsing Pipeline] ──► Caches Counterfactual Risk Metrics │ ▼ [GitHub Copilot Chat Interface] ──► Query via `/incubate` or `/simulate` Renders immediate defensive patches Enter fullscreen mode Exit fullscreen mode Code The entire production-grade, compile-ready repository bundle is public and accessible here: HazemAbabneh / NirvanaPilot An ambient, privacy-first VS Code extension for GitHub Copilot that runs background architectural simulations on local Git diffs during developer inactivity, powered entirely by local Gemma 2 via Ollama. Built for Hacktoberfest 2026. NirvanaPilot Slow code review for the future. NirvanaPilot is a VS Code extension that waits until you stop editing, inspects the current Git changes, and asks a local Gemma 2 model to reason about architectural risks that may emerge as the codebase grows. The sloth stays quiet while you work. After 15 seconds without an edit, it scans the working tree and a small amount of context from visible editors. If there are changes to consider, it sends that bounded context to Ollama on your machine and caches a counterfactual report. Resume typing at any point and the active scan or model request is cancelled. Nothing is sent to a cloud model. When you return, use NirvanaPilot in Copilot Chat: /incubate shows the cached idle report, or runs one immediately if none exists. /simulate forces a fresh architectural simulation. /status checks whether the configured local Ollama model is available. Generated… View on GitHub How I Built It NirvanaPilot brings open-source AI directly into the modern developer environment: Ecosystem Frontend: Built natively over the VS Code Extension framework utilizing the modern contributes.chatParticipants protocol to stream insights right inside GitHub Copilot Chat. The Core Brain: Powered entirely by the Google Gemma 2:9B open-weight model running locally via Ollama ( http://localhost:11434/api/generate ). Resource Protection: Engineered around explicit vscode.CancellationTokenSource controls. The moment your finger touches a single key on the keyboard, any active local model inference or git scanning process is instantly aborted to prevent developer machine lag. Why Does Open Innovation Matter? Open Innovation is the structural core of NirvanaPilot. A closed cloud-based API introduces two massive friction points that local open-weights completely eliminate: Absolute Code Base Privacy: Software architecture blueprints and confidential uncommitted code should never traverse to external hosted cloud servers. By executing Gemma 2 locally, your intellectual property remains bounded entirely within your machine's physical memory space. Infinite Tokens at Zero Marginal Cost: Full codebase context simulation involves millions of tokens over a week of development. Cloud provider pricing would generate heavy operational bills. Open innovation grants developers unlimited simulation matrices for absolute zero incremental API fees. My Agent Session The extension was prototyped, built, and compiled cleanly via autonomous multi-file generation cycles. You can view the engineering logic directly embedded within the repository file system. The Lazy Payoff Software engineers get to be completely lazy. You do not have to drive the AI or prompt it line-by-line. NirvanaPilot watches over your architectural integrity while you step away, sleep, or make coffee. This week, we noticed it catches deep tight-coupling flaws and provides a clean, validated unified diff via a secure verification step ( git apply --check ) that saves hours of downstream codebase refactoring and structural maintenance. Prize Categories I am entering NirvanaPilot into the following categories: Gemma Category: Best Use of Gemma (Utilizing local Gemma 2 via Ollama as the foundational simulation brain). Grand Prize Category: Hacktoberfest Open-Source AI Challenge Overall Winner .

Slow code review for the future. NirvanaPilot is a VS Code extension that waits until you stop editing, inspects the current Git changes, and asks a local Gemma 2 model to reason about architectural risks that may emerge as the codebase grows.

The sloth stays quiet while you work. After 15 seconds without an edit, it scans the working tree and a small amount of context from visible editors. If there are changes to consider, it sends that bounded context to Ollama on your machine and caches a counterfactual report. Resume typing at any point and the active scan or model request is cancelled. Nothing is sent to a cloud model.

When you return, use NirvanaPilot in Copilot Chat:

/incubate shows the cached idle report, or runs one immediately if none exists.
/simulate forces a fresh architectural simulation.
/status checks whether the configured local Ollama model is available.

Generated…

View on GitHub

How I Built It

NirvanaPilot brings open-source AI directly into the modern developer environment:

Ecosystem Frontend: Built natively over the VS Code Extension framework utilizing the modern contributes.chatParticipants protocol to stream insights right inside GitHub Copilot Chat.

The Core Brain: Powered entirely by the Google Gemma 2:9B open-weight model running locally via Ollama (http://localhost:11434/api/generate).

Resource Protection: Engineered around explicit vscode.CancellationTokenSource controls. The moment your finger touches a single key on the keyboard, any active local model inference or git scanning process is instantly aborted to prevent developer machine lag.

Why Does Open Innovation Matter?

Open Innovation is the structural core of NirvanaPilot. A closed cloud-based API introduces two massive friction points that local open-weights completely eliminate:

Absolute Code Base Privacy: Software architecture blueprints and confidential uncommitted code should never traverse to external hosted cloud servers. By executing Gemma 2 locally, your intellectual property remains bounded entirely within your machine's physical memory space.

Infinite Tokens at Zero Marginal Cost: Full codebase context simulation involves millions of tokens over a week of development. Cloud provider pricing would generate heavy operational bills. Open innovation grants developers unlimited simulation matrices for absolute zero incremental API fees.

The Lazy Payoff

Software engineers get to be completely lazy. You do not have to drive the AI or prompt it line-by-line. NirvanaPilot watches over your architectural integrity while you step away, sleep, or make coffee. This week, we noticed it catches deep tight-coupling flaws and provides a clean, validated unified diff via a secure verification step (git apply --check) that saves hours of downstream codebase refactoring and structural maintenance.

DEV Community

The Sloth That Never Sleeps: Building NirvanaPilot, the Ambient Architectural Subconscious for GitHub Copilot