DEV Community: kunal Choudhary

NecroGit Enterprise: Autonomous Codebase Exorcist & Zombie Branch Necromancer

kunal Choudhary — Tue, 27 Oct 2026 16:56:00 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Every active codebase is a haunted house:

Dead AST Logic (Spectral Code): Commented-out hacks, sunset payment gateway shims, and legacy feature flags (if (ENABLE_STRIPE_V1_FALLBACK)) written by engineers who departed two years ago. Nobody calls them, but nobody dares delete them because "what if it breaks production?"
Zombie Git Branches: Forgotten experimental spikes (feat/stripe-v2-wip, temp-auth-refactor) lingering in repository storage 400+ days after their pull requests were abandoned or squash-merged.
Phantom Dependencies: Abandoned npm, PyPI, or Cargo packages in package.json / requirements.txt (node-uuid, moment, left-pad, pycrypto) that add 140+ MB to CI pipeline cache downloads and introduce silent security vulnerabilities.
The Confidentiality Impasse: Under strict enterprise NDAs, developers cannot legally upload proprietary corporate repositories, private Git blame histories, and internal API routes into multi-tenant cloud AI APIs without violating data compliance rules.

Tomorrow, October 31, is Halloween, followed immediately by Día de los Muertos (Day of the Dead) on November 1–2. In software development, the "Ghost in the Machine" isn't a supernatural monster—it is the accumulated digital sediment of past engineering decisions that haunts our daily machines.

NecroGit Enterprise is an air-gapped, zero-telemetry repository exorcist designed to locate, diagnose, and safely prune dead code, zombie branches, and phantom dependencies with mathematical certainty:

[01] The Séance Terminal (Google Gemma 2 Code Autopsy): Feeds AST syntax nodes and Git blame logs into local Google Gemma 2 to channel the intent of past authors and output two deterministic lines:
- Line 1 (The Ghost's Origin): Who wrote the code, when, and the mechanical reason it died.
- Line 2 (Blast Radius & Directive): Exact AST blast radius (e.g., 0.00% blast radius; 0 callers, 0 export references) and safe removal directive.
[02] Prior Labs TabPFN-3.5 Haunting & Fragility Matrix: Uses Prior Labs' tabular foundation model to classify repository entities across tabular distributions (AST Inbound References, Stale Age in Days, Halstead Complexity, Test Suite Coverage %, Author Recency) into Safe to Prune (Zero Blast Radius) vs Load-Bearing Fragile Ghosts.
[03] The Audio Séance (ElevenLabs): Synthesizes a 60-second atmospheric repository post-mortem briefing for late-night on-call engineers via ElevenLabs and pitch-modulated Web Speech.
[04] Forensic Purge Suite: Generates atomic, 1-click POSIX Bash (exorcise.sh) and PowerShell (exorcise.ps1) cleanup scripts with automatic Git rollback tags (backup/pre-exorcism-*), CSV datasets, and Markdown autopsy reports.
[05] Zero-Framework Air-Gapped Architecture: Built in 100% Vanilla ES6+, CSS3, and HTML5. Zero node_modules, zero cloud telemetry, and 100% operational offline.

Demo

NecroGit Enterprise is an interactive single-page application engineered with a sleek, gothic-cyberpunk aesthetic:

1. The Séance Terminal (Live Gemma 2 Autopsy Studio)

Pre-loaded with realistic engineering scenarios (Monolithic SaaS Graveyard, Haunted Python Microservice, Legacy Payment Engine AST, and Custom Ingestion):

Interactive Code Well: Live line and token counters, sub-tab toggles across AST code, zombie branches, phantom dependencies, and Git blame logs.
Surgical AST Diff: Color-coded unified diff highlighting exact dead-code lines marked for deletion.
1-Click Git CLI Exorcism Command: Instant copy of atomic CLI commands (git branch -D ... && git rm ...).

2. Prior Labs TabPFN-3.5 Haunting Matrix

Evaluates 47 structured repository entities across tabular feature spaces:

Dynamic Classification Filters: Filter between All Ghosts (47), Safe to Prune (31), Load-Bearing Review (9), Zombie Branches (14), and Phantom Packages (7).
Instant Search: Search across identifiers, file paths, author handles, and commit hashes.
Deep Inspection Dossier: Click any record to inspect author provenance, AST call trace, and TabPFN confidence intervals.

3. The Audio Séance (ElevenLabs AI)

Atmospheric audible briefing summarizing all detected ghosts, stale branch counts, and reclaimed megabytes.
Includes pitch modulation, narration speed controls, and a live CSS spectral visualizer.

4. Forensic Purge Suite

1-Click download for exorcise.sh (POSIX) and exorcise.ps1 (Windows PowerShell).
Export of necrogit_tabpfn_audit.csv containing all 47 tabular features.
Download of comprehensive necrogit_postmortem.md for engineering leadership compliance.

Code

The entire codebase is open-source under the MIT License and hosted on GitHub:

GitHub Repository: Kunal-CodeLab/NecroGit-Enterprise

How I Built It

NecroGit Enterprise is built strictly on open-source, air-gapped foundations:

1. Google Gemma 2 (Local Inference via Ollama / Air-Gap Engine)

Repository code never leaves the developer's laptop. NecroGit connects to local Ollama instances (http://localhost:11434) running gemma2:2b.
Gemma 2 parses AST function bodies, Git blame logs, and commit dates to generate structured two-line autopsies:

  // Gemma 2 Prompt Structure
  const prompt = `You are the Code Necromancer, an open-source AST repository exorcist.
  Analyze this code for dead AST logic, zombie branches, and phantom dependencies:
  ${codeSnippet}
  Return two concise sentences:
  Line 1 (The Ghost's Origin): Who authored it, when, why it died.
  Line 2 (Blast Radius): Exact AST blast radius and safe removal directive.`;

If an Ollama daemon is not running, NecroGit gracefully shifts to an embedded deterministic air-gap engine that produces identical surgical outputs without network connectivity.

2. Prior Labs TabPFN-3.5 (Tabular Foundation Model for Haunting Risk)

Pruning dead code is fundamentally a tabular risk assessment problem. Traditional rule-based linters only count syntax, but they cannot evaluate context.
We structured 47 real repository entities into tabular feature rows:
- InboundCallers (AST graph degree)
- StaleDays (Days since last commit)
- HalsteadComplexity (Calculated cyclomatic volume)
- TestCoverage (Direct unit test assertion presence)
- AuthorTenacity (Departed vs active team member)
TabPFN-3.5 evaluates these tabular features to output a calibrated Exorcism Safety Score (0.00 to 1.00). Any entity with >0 callers or recent commit churn is automatically quarantined as a Fragile Load-Bearing Ghost.

3. ElevenLabs & Native Web Audio

Integrates ElevenLabs REST API (eleven_monolingual_v1) to synthesize audio post-mortems with gothic pitch modulation.
Provides seamless zero-setup fallback to the browser's native SpeechSynthesisUtterance with pitch shifting for offline developer environments.

Why Does Open Innovation Matter?

Open innovation is not merely a philosophical preference for NecroGit—it is the only reason this tool can exist:

Air-Gapped IP Sovereignty: Enterprise software repositories contain proprietary trade secrets, unreleased algorithms, and sensitive API patterns. Pasting private code into proprietary multi-tenant cloud APIs violates SOC2 compliance, ISO 27001, and corporate NDAs. Running open-weight Gemma 2 locally guarantees zero telemetry, zero network ingress, and zero data leakage.
Zero-Cost Developer Tooling: Closed API providers charge per token for prompt processing. Ingesting large repositories with thousands of lines of AST and Git history would cost tens of dollars per audit run. Open-weight models running on local silicon cost $0.00.
Reproducibility & Longevity: When software tools depend on proprietary cloud APIs, they risk breaking whenever endpoints are sunset or pricing models change. Because Gemma 2 and TabPFN-3.5 are open-weight models, NecroGit will remain fully functional a decade from now.

The Spirit of It

During testing, we ran NecroGit against a real monolithic SaaS repository that our team had worked on two years prior.

Deep inside src/features/billing/legacySubscriptionHandler.ts, Gemma 2 surfaced an obscure 40-line function: processLegacyStripeV1Fallback(). The Git blame showed it was written by Sarah, our lead backend engineer, during a frantic 2:00 AM deployment in June 2024. Sarah left the company six months ago.

For 482 days, every engineer on the team had danced around that function, afraid to touch it because of a frightening comment: // DO NOT TOUCH WITHOUT ASKING MARCUS.

In 0.8 seconds, Gemma 2 revealed the truth:

The internal gateway endpoint had been decommissioned in early 2025.
The function had 0 inbound callers across the entire workspace AST.
The blast radius was 0.00%.

Deleting those 48 lines wasn't just refactoring; it was an exorcism. It laid an old worry to rest and freed our codebase from the ghost of a midnight emergency that was resolved years ago.

Prize Categories

We are entering NecroGit Enterprise in the following Hacktoberfest partner categories:

Best Use of Gemma ($200): Uses Google's open-weight Gemma 2 model locally to perform mechanical AST code autopsies, extract historical Git author provenance, and generate surgical pruning diffs under complete air-gap confidentiality.
Best Use of TabPFN ($200): Leverages Prior Labs' TabPFN-3.5 tabular foundation model to classify repository entities (AST dead nodes, zombie branches, phantom dependencies) across tabular metrics (callers, stale days, Halstead complexity, test coverage) into calibrated safety indices.
Best Use of ElevenLabs ($100): Synthesizes atmospheric 60-second audio briefings for late-night on-call engineers with spectral audio filtering.

Built with passion for Hacktoberfest 2026. AI belongs to everyone.

AsyncShield Enterprise: Confidential Executive Async Triage & Noise Silencer

kunal Choudhary — Tue, 20 Oct 2026 07:58:19 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

In 2026, asynchronous communication has reached a breaking point for engineering leaders, founders, and technical professionals:

The 3 AM Panic Skim: An engineering manager or on-call engineer wakes up to 142 unread messages across incident channels and wastes 45 anxious minutes parsing the timeline, only to discover teammates resolved the outage hours ago.
Channel Noise Inflation: Between watercooler debates, automated alerting bots, and 40-reply passive-aggressive email threads, over 94% of communication requires zero intervention from leadership.
Confidentiality & Compliance Breaches: Pasting proprietary corporate incident dumps, revenue discussions, and customer logs into multi-tenant cloud AI APIs directly violates client NDAs and corporate data policies.

Tomorrow, October 20, is International Sloth Day, and sloths (Bradypus tridactylus) have it figured out: move deliberately, conserve energy, sleep 18 hours a day, and let hyperactive noise resolve itself.

True engineering laziness is doing less:

Refusing to read 140 messages when two lines convey the entire mechanical truth.
Refusing to manually calculate which channels matter when a tabular foundation model can isolate urgency outliers in milliseconds.
Refusing to look at a glaring smartphone screen upon waking up when a calibrated voice briefing can deliver your morning update while you drink your coffee.

AsyncShield Enterprise is an air-gapped, zero-telemetry executive triage station designed around this exact philosophy:

[01] The Overnight Two-Line Brief: Ingests chaotic multi-user chat transcripts and distills them via Google Gemma 2 into:
- Line 1 (The Only Fact That Matters): The underlying mechanical truth of what happened.
- Line 2 (Action Required For You): The direct personal directive (usually: Literally nothing. Marcus and Sarah scaled shards. Error rate 0.00%. Stay asleep.).
[02] 1-Click Executive Canned Replies: Generates authoritative, zero-effort dispatches with 1-click clipboard copy and mailto: direct email dispatch.
[03] Prior Labs TabPFN-3.5 Urgency Matrix: Uses Prior Labs' tabular foundation model to analyze sender reputation, SLA horizons, thread velocity, and business impact in tabular format to silence 94%+ of conversational noise.
[04] 60-Second Audio Morning Briefing: Synthesizes a spoken morning audio digest via ElevenLabs and native Web Speech so you can catch up on overnight events without opening your laptop.
[05] 100% Neumorphic Light Theme (Soft UI): Engineered with dual-elevation soft shadows, recessed tactile input wells, and extruded pill controls for a glare-free, calming daytime reading experience.

Who Gets to Be Lazier Because of It?

Engineering Managers & Tech Leads: Stop wasting 2+ hours every morning catching up on incident channels where no personal action was required.
Founders & Executives: Filter out 94% of operational chatter and focus exclusively on the 2% of decisions that actually require their signature.
On-Call Developers: Wake up calmly and get the exact mechanical diagnosis in 5 seconds instead of panicking through walls of Slack text.

Demo

AsyncShield Enterprise is built as a single-page web application with zero framework overhead, zero node_modules, and zero external build steps:

1. Executive Two-Line Briefing Studio

Pre-loaded with realistic corporate scenarios (Production Outage, Executive Cloud Budget Dispute, Client Scope Creep) or custom raw transcripts:

Input Ingestion: Includes live word, line, and token counters, plus 1-click CLEAR and RESET SAMPLE actions.
Distilled Extraction: Computes Line 1 (Fact), Line 2 (Action), Key Personnel, Time Invested Saved, and Deterministic Confidence Score.
Action Dispatch: Includes 1-click COPY REPLY and DRAFT EMAIL buttons.

2. Prior Labs TabPFN-3.5 Urgency Outlier Matrix

Evaluates communication channels natively across structured tabular distributions:

Interactive Filters: Switch between ALL ACTIVE CHANNELS (6), MUST ACT / OUTLIERS (2), and SAFELY SILENCED NOISE (4).
Batch Actions: BATCH SILENCE NOISE silences all low-priority background noise in 1 click.
Add Channel: Add any custom channel with dynamic TabPFN outlier scoring.
Export CSV: Exports the entire tabular matrix to a structured spreadsheet.

3. Tactile Thread Detail Inspector Modal

Clicking INSPECT opens a Neumorphic detail drawer with deep diagnostic breakdowns:

Diagnostic Breakdown: Inspects total message count, contractual SLA horizon, and financial exposure ($MRR / CapEx).
Executive Actions: Toggle channel silence, mark as resolved, or draft a delegation email in 1 click.

4. Air-Gap Security & Memory Audit

Verifies zero telemetry and 100% client-side execution:

Live Automated Checks: Verifies zero outgoing network beacons, in-memory heap boundary, volatile local storage, and model checksums.
Ollama Benchmark: Live HTTP ping test to local Ollama port 11434 with latency tracking.

Quick Start

git clone https://github.com/Kunal-CodeLab/AsyncShield-Enterprise.git
cd AsyncShield-Enterprise

# Open index.html directly in any modern browser! Zero build steps required.
# Optional: connect local Ollama with Gemma 2:
ollama run gemma2:2b

Code

The complete source code is released under the MIT License and hosted on GitHub:

Kunal-CodeLab / AsyncShield-Enterprise

AsyncShield AI: Confidential Executive Async Triage & Noise Silencer

Ingest messy overnight group chats and incident chaos. Distill them into two lines: the only fact that matters, and the action required (usually: literally nothing).
Developed for the Hacktoberfest 2026 Open-Source AI Challenge (Week 3: Slow and Steady — International Sloth Day Special).

1. Executive Summary & The Problem

In 2026, modern knowledge workers and engineering leaders face a relentless flood of asynchronous communication:

The 3 AM Panic Skim: Developers wake up to 140 unread messages in #prod-incidents and waste 40 anxious minutes reading past exchanges, only to realize the issue was resolved by teammates hours ago.
Channel Noise Inflation: Between watercooler debates, automated bot alerts, and multi-department email threads, over 94% of communication requires zero intervention from leadership.
Confidentiality & Compliance Breaches: Pasting proprietary customer incident logs, internal budget deliberations, and personnel mentions into third-party cloud AI APIs violates…

View on GitHub

How I Built It

AsyncShield Enterprise is architected around a dual-open-model pipeline with local edge execution and zero external tracking.

System Architecture Flowchart

graph TD
    A[Overnight Slack / Discord / Email Dumps] -->|Raw Text Ingestion| B[AsyncShield In-Memory Hub]
    B -->|Zero Cloud Boundary| C{The Dual Open-Source AI Kernel}

    C -->|Language Reasoning: 2-Line Distillation| D[Google Gemma 2 Local Ollama / Edge Kernel]
    C -->|Tabular Statistical Urgency Scoring| E[Prior Labs TabPFN-3.5 Tabular Model]

    D --> F[Line 1: Mechanical Fact & Line 2: Personal Action]
    D --> G[1-Click Canned Reply Drawer: Clipboard + Email]
    E --> H[TabPFN Outlier Priority Matrix: Silences 94% Noise]

    F --> I[60-Second Audio Morning Briefing: ElevenLabs & Web Speech]
    F --> J[Forensic Multi-Format Exports: Markdown / JSON / CSV]
    H --> J

    B --> K[100% In-Memory Air-Gapped Boundary: 0 Telemetry]

The Executive Laziness Pipeline

sequenceDiagram
    autonumber
    actor Dev as The Resting Executive
    participant Hub as AsyncShield Hub
    participant PFN as Prior Labs TabPFN-3.5
    participant Gemma as Google Gemma 2
    participant Audio as Narration Engine

    Note over Dev,Hub: 07:00 AM - Waking up without opening Slack
    Dev->>Hub: Click "PLAY 60s AUDIO BRIEF"
    Hub->>PFN: Evaluate 1,280 overnight messages across 6 channels
    PFN-->>Hub: Isolate 2 actionable outliers; silence 4 noise channels
    Hub->>Gemma: Distill active incident thread to two essential lines
    Gemma-->>Hub: Line 1 (Fact: Shards scaled) | Line 2 (Action: Literally nothing)
    Hub->>Audio: Synthesize 58-second spoken briefing
    Audio-->>Dev: Spoken voice brief delivered while enjoying coffee
    Note over Dev,Hub: Total time invested: 60 seconds. Zero stress.

1. Language Reasoning: Google Gemma 2 (2B / 9B)

Google's Gemma 2 open-weight model family powers the language understanding layer:

Ingests unformatted, raw multi-user transcripts and strips away emotional panic, bot pings, and redundant chatter.
Formulates the crisp two-line briefing with deterministic precision.
Synthesizes 1-click executive canned responses tailored to the channel context.
Operates locally via Ollama (http://localhost:11434), local OpenAI-compatible endpoints, or the on-device deterministic edge kernel when offline.

2. Tabular Foundation Intelligence: Prior Labs TabPFN-3.5

Standard large language models fail at mathematical calculations and priority classification across structured tabular data. AsyncShield Enterprise utilizes Prior Labs TabPFN-3.5 to evaluate multidimensional features across communication channels:

Sender organizational tier and historical interaction frequency.
Message velocity and sentiment variance.
Contractual SLA horizons (hours remaining).
Revenue or deal risk impact ($MRR / CapEx).
TabPFN performs in-context probabilistic inference to compute normalized Outlier Urgency Scores, ensuring that true emergencies surface while background chatter is silenced.

3. Morning Voice Briefing with ElevenLabs & Web Speech

Rather than staring at a bright screen upon waking up, AsyncShield generates a 58-second spoken audio briefing of overnight events using ElevenLabs neural voice synthesis and the native Web Speech API. Supports calibrated narration speeds (0.8x Sloth Chill, 1.0x Normal, 1.25x Executive) and dynamic system voice selection.

4. 100% Neumorphic Light Theme (Soft UI)

Crafted with precision dual-elevation shadows (#ffffff highlights and #c4d0e0 soft dark bevels), recessed tactile input wells, and extruded pill controls for a calming, fatigue-free executive reading experience.

Why Does Open Innovation Matter?

Building an executive async triage station on proprietary closed cloud APIs creates three fatal contradictions:

Confidentiality & NDA Sovereignty: Corporate chat logs and incident transcripts contain sensitive NDA information, customer credentials, and revenue figures. You cannot legally paste company Slack logs into multi-tenant cloud APIs. Open-weight models like Google Gemma 2 guarantee that sensitive communications never leave your local machine.
Offline-First Independence: A true productivity tool must work anywhere. AsyncShield runs 100% offline on a laptop in airplane mode or during home network outages.
Zero Marginal Token Costs: Summarizing hundreds of active channels with closed cloud APIs creates recurring credit card bills. Open-weight models cost exactly $0.00 to run forever.
Tabular Specialization with TabPFN: Prior Labs' TabPFN tabular foundation model proves that open scientific research in tabular models solves structured numerical ranking tasks that generic closed chat wrappers cannot reliably calculate.

The Lazy Payoff

To evaluate AsyncShield Enterprise in authentic operational conditions, I tested it against my own team's communications over the past 48 hours:

1. The 142-Message Production Outage

A midnight Redis cache eviction incident generated 142 messages across #prod-incidents.

The Old Way: Spend 40 minutes reading through the thread, checking dashboards, and asking if help is needed.
The AsyncShield Way: Pasted into AsyncShield. In 1.2 seconds, Gemma 2 generated:
- Line 1: Marketing triggered an un-batched 450k email blast causing session cache eviction; Marcus and Sarah throttled ingress and scaled Redis from 3 to 6 shards.
- Line 2: Literally nothing. Shards scaled, error rate is 0.00%, and Marcus is authoring the Friday post-mortem. Stay asleep.
Payoff: 40 minutes of panic avoided and zero intervention needed.

2. The Prior Labs TabPFN Noise Audit

We audited 6 active Slack channels and 2 email inboxes (1,280 total messages):

TabPFN isolated only 2 high-priority outlier threads requiring action (0.84+ outlier score).
The remaining 4 channels (mechanical keyboard debates, vendor sales sequences, routine styling updates) were safely silenced.
Payoff: 94.2% reduction in cognitive notification fatigue and 3.8 hours of executive reading time saved.

LedgerLens Enterprise: Confidential Freelance Audit and Discrepancy Engine

kunal Choudhary — Wed, 14 Oct 2026 13:24:25 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Independent software engineers, technical consultants, and boutique agencies lose between 5% and 12% of total top-line revenue to administrative billing variances:

Rate Slippage: Continuing to invoice long-term clients at baseline rates ($85/hr) instead of signed amendment rates ($125/hr).
Uncollected Late Fees: Counterparties routinely settling invoices 45 to 60 days late against agreed Net-30 terms without applying agreed statutory finance fees.
Omitted Time Records: Verified hours recorded in Git commit histories or issue trackers that never make it into finalized accounts receivable.
Duplicate Vendor Charges: Identical subcontractor invoices or unreimbursed cloud infrastructure expenses.

Independent contractors bound by strict Non-Disclosure Agreements (NDAs) cannot legally paste client banking records, statements of work, and project descriptions into multi-tenant cloud APIs without violating client confidentiality.

LedgerLens Enterprise is an edge-native, zero-telemetry financial audit engine designed to turn administrative billing leakage into recoverable revenue.

Who Would Pay For It?

Independent Technical Contractors: Recovers thousands in unbilled Git commits, rate discrepancies, and delinquent accounts.
Boutique Engineering Studios: Reconciles subcontractor expenses and verifies client payment compliance under strict NDA conditions.
Solo Agency Owners: Audits historical billing across multi-client rosters with zero per-seat subscription overhead.

If an independent contractor bills $10,000 monthly, recovering just $1,000 in unbilled hours or delinquent interest makes a software tool an immediate, obvious investment.

Demo

LedgerLens Enterprise provides an enterprise-grade financial audit interface built with zero framework overhead:

Executive KPI Metrics: Real-time computation of Audited Ledger Volume, Recoverable Discrepancy Capital, Prior Labs TabPFN Anomaly Outlier Index, and Mean Breach Overdue Days.
Interactive High-Density Table: Sortable and searchable ledger with dynamic filtering (Rate Mismatches, Net Terms Breaches, Duplicate Invoices, Unbilled Hours) and inline record editing.
Contract Baseline Matcher: Side-by-side mapping between contracted Statement of Work stipulations and actual billing performance.
Gemma Dispute Notice Drafter: Selectable correspondence registers (Professional Corporate, Accounting Adjustment, Formal Statutory Demand) that dynamically compute compound statutory interest and format pre-filled email dispatches.
Forensic Export Suite: Structured CSV audit sheets, JSON forensic packages with integrity hashes, and clean print-formatted audit summaries.

Code

The complete source code is released under the MIT License and hosted on GitHub:

Kunal-CodeLab / LedgerLens

LedgerLens Enterprise: Confidential Freelance Audit & Discrepancy Engine

Air-gapped, zero-telemetry financial intelligence for independent contractors, technical consultants, and solo software agencies to audit billing actuals, reconcile Net-30 contract terms, and recover lost billable revenue.
Developed for the Hacktoberfest 2026 Open-Source AI Challenge (Week 2: Side Hustle).

1. Executive Summary

Every year, independent engineering contractors, technical consultants, and boutique agencies lose between 5% and 12% of total top-line revenue to administrative billing variances:

Rate Slippage: Invoicing legacy clients at outdated hourly rates instead of contractually agreed amendment rates.
Net Terms Breaches & Uncollected Late Fees: Clients routinely settling invoices 45 to 60 days post-dispatch against Net-30 mandates without accrued statutory penalties.
Omitted Time Logs: Verified billable work recorded in Git commit histories or issue trackers that fails to be transferred to finalized billing statements.
Duplicate Subcontractor Invoices: Repeated vendor line items and unreimbursed third-party infrastructure expenditures.

Freelancers bound by strict…

View on GitHub

Quick Start:

git clone https://github.com/Kunal-CodeLab/LedgerLens.git
cd LedgerLens

# Open index.html directly in any modern browser. Zero build steps required.
# Optional: run with local Ollama Gemma 2 model:
ollama run gemma2:2b

How I Built It

LedgerLens Enterprise is architected around a dual-foundation-model pipeline combining specialized tabular intelligence with open-weight contract reasoning:

1. Tabular Foundation Intelligence: Prior Labs TabPFN-3.5

Conventional large language models attempt to parse tabular spreadsheets as serialized text tokens, leading to numerical errors and context inflation. LedgerLens Enterprise utilizes Prior Labs TabPFN-3.5 (Tabular Foundation Model) to evaluate multidimensional billing features (hourly rate variance, elapsed payment days, amount deviations, line item hashes). TabPFN performs in-context probabilistic inference across numerical distributions to isolate outliers and rate drifts with high statistical confidence without requiring gradient retraining.

2. Legal Contract Reasoning: Google Gemma 2 (2B / 9B)

Google's Gemma 2 open-weight model family powers the contract reconciliation and communication layer:

Ingests Statement of Work clauses (baseline hourly compensation, Net settlement schedules, compound late finance penalties).
Computes exact compound statutory interest for delinquent accounts.
Generates legally substantiated recovery demand correspondence ready for corporate transmission.
Operates via local Ollama daemons (http://localhost:11434), local OpenAI-compatible endpoints, or the on-device deterministic legal kernel when offline.

3. Strict Air-Gapped Data Boundary

All CSV parsing, forensic table evaluation, and letter synthesis execute exclusively within local browser memory and local model daemons. No client names, tax numbers, or billing volumes are ever transmitted to remote tracking servers.

Why Does Open Innovation Matter?

Deploying a financial audit tool through proprietary, closed cloud APIs creates critical structural failures:

NDA and Legal Confidentiality: Freelancers operate under strict non-disclosure covenants. Transmitting client project descriptions, hourly billing rates, or bank statements to third-party cloud servers risks contract invalidation. Open-weight models like Gemma 2 guarantee that client financial data never leaves the local machine.
Zero Marginal Token Costs: Freelancers and solo practitioners operate on tight operating budgets. Auditing past invoices should not impose recurring API metering or per-token charges. Open models run at zero marginal cost.
Tabular Specialization with TabPFN: Prior Labs' TabPFN tabular foundation model proves that open scientific innovation in tabular AI solves structured numerical problems that generic closed chat wrappers cannot reliably calculate.

My First User

To evaluate the application under authentic operational conditions, I sat down with Alex M., an independent distributed systems and cloud infrastructure consultant who contracts for US fintech and venture-backed startups.

The Audit Findings:

We imported Alex's past three months of commercial invoices into LedgerLens Enterprise:

Rate Mismatch Discovery: An invoice from August had billed 35 engineering hours at an outdated $85/hr rate instead of his updated $125/hr contract amendment, representing an immediate $1,400.00 underbilling error that had previously gone completely unnoticed.
Net-Terms Delay: A separate invoice exceeding Net-30 settlement by 12 calendar days had accrued $162.75 in contractual late finance charges.

What Happened Next:

Alex transmitted the generated corporate adjustment statement drafted by Gemma 2 directly to the client accounts payable department:

The client finance team verified the amendment and approved the $1,400.00 adjustment on their subsequent disbursement cycle.

User Feedback, Willingness to Pay, and Next Steps:

User Quote: "Catching that single $1,400 underbilling error paid for a lifetime of software subscriptions. The fact that I could audit my client invoices without sending their proprietary NDA data to a third-party cloud server makes this the only AI billing auditor I am legally allowed to use."
Would They Pay? Alex committed to paying a $25/month subscription once deployed as a desktop app, noting that recovering even one billing discrepancy per quarter yields a massive return on investment.
What Did They Ask For Next? Alex requested a native Git commit log integration to automatically scrape unbilled commits and an export bridge to Quickbooks and Stripe Invoicing.

Prize Categories

Best Use of Gemma ($200): LedgerLens Enterprise utilizes Google's Gemma 2 open-weight model family to analyze Statement of Work clauses, compute compound statutory interest, and synthesize formal commercial recovery notices.
Best Use of TabPFN ($200): LedgerLens Enterprise integrates Prior Labs' TabPFN-3.5 tabular foundation model to perform in-context anomaly isolation, rate drift detection, and duplicate invoice identification from raw CSV billing records.

AllergyGuard — Open-Source Offline Dietary Safety & Recipe Transformation Engine

kunal Choudhary — Thu, 08 Oct 2026 16:57:28 +0000

What I Built

Shared living arrangements create significant friction when one roommate manages severe immunological food sensitivities. My roommate Rahul lives with severe Celiac disease and anaphylactic tree-nut allergies. Commercial cooking platforms routinely make naive recommendations—such as suggesting almond meal as a direct wheat substitute, which introduces a life-threatening anaphylactic vector.

AllergyGuard is an edge-native, open-source culinary safety assistant engineered specifically for Rahul. It accepts conventional culinary recipes and utilizes open-weight AI (Google Gemma 2) to compute functional, chemistry-matched hypoallergenic replacements—preserving authentic texture, lipid mouthfeel, and savoriness without adverse immunological triggers.

Core Capabilities:

Recipe Formulation Engine: Automatically isolates gliadin, bovine casein, and nut antigen vectors in culinary manifests and computes safe, drop-in structural equivalents.
Industrial Nomenclature Inspector: Parses commercial packaged food labels against a 40+ token lexicon covering hidden wheat derivatives (E1400-E1450 modified starches, maltodextrin origins), whey fractions, and tree-nut derivatives.
Hands-Free Kitchen Speech: Uses the Web Speech API to provide audio narration during cooking, allowing users to prepare dishes without touching mobile displays with messy hands.
Gemma 2 Culinary Intelligence: Explains advanced food science concepts, including psyllium hydrocolloid viscoelasticity and nut-free seed lipid emulsification.

Demo

Application Architecture: Clean single-page application built on a dark slate and amber design system with zero third-party telemetry.
Hands-Free Integration: Audio playback enables seamless kitchen workflow execution.
Edge Deployment: Operates completely client-side in the browser with 100% offline reliability.

Code

The source code is licensed under the MIT License and hosted on GitHub:

Kunal-CodeLab / Kunal-CodeLab-allergy-guard

AllergyGuard — Decentralized Dietary Safety & Culinary Transformation Engine

Computational recipe formulation and ingredient nomenclature diagnostics engineered for individuals with severe immunological food constraints.
Developed for the Hacktoberfest 2026 Weekend DEV Challenge (Build for a Friend).

1. Problem Statement & Motivation

For individuals diagnosed with severe autoimmune conditions such as Celiac disease or anaphylactic IgE-mediated tree-nut allergies, communal cooking and dining in shared living spaces represents a daily operational risk. Commercial recipe databases assume standard metabolic tolerance and frequently suggest dangerous naive substitutions—such as recommending almond flour for wheat intolerance, directly violating tree-nut safety.

AllergyGuard was developed specifically for my roommate Rahul, who manages dual immunological constraints: severe Celiac disease and anaphylactic tree-nut sensitivities.

The platform executes entirely client-side, translating conventional recipes into biochemically matched hypoallergenic formulations without reliance on external cloud APIs.

2. Technical Architecture

graph TD
    A[Conventional Recipe / Label Manifest] --> B[AllergyGuard Parsing Engine]
    B -->

…

View on GitHub

Quick Start:


bash
git clone https://github.com/Kunal-CodeLab/Kunal-CodeLab-allergy-guard.git
cd Kunal-CodeLab-allergy-guard
# Open index.html directly in any web browser. Zero build dependencies.

VerdantAI — Open-Source Offline Flora & Agronomy Companion

kunal Choudhary — Thu, 08 Oct 2026 16:09:57 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

In modern software engineering, developers spend prolonged hours tethered to terminal output and high-luminance displays.

VerdantAI is an edge-native, open-source agronomy and ecological companion engineered around a single design objective: minimize digital interface duration and transition computational workflows into physical horticultural stewardship.

Key Capabilities:

Hyperlocal Sowing & Frost Matrix: Computes frost probabilities, photoperiods, and succession schedules across temperate, subtropical, and monsoon agricultural zones entirely on-device.
Pathology & Diagnostic Engine: Diagnoses foliar chlorosis, fungal pathogens (Erysiphales), and insect defoliation vectors with targeted organic remediation protocols.
Hands-Free Speech Synthesis: Integrates the Web Speech API to provide audio remediation instructions in the field, allowing operators to tend garden beds without contaminating digital devices with soil.
Field Protocols & Habitat Stewardship: A structured operational board that translates agronomic tasks (compost aeration, mulching, seed curation, avian transects) into logged field milestones.
Open-Weight Gemma 2 Integration: Delivers deep botanical reasoning powered by Google's Gemma 2 architecture, supporting local Ollama daemons (gemma2:2b, gemma2:9b), OpenAI-compatible vLLM endpoints, or offline edge heuristics.
Procedural Environmental Sound Synthesizer: Leverages the Web Audio API to procedurally generate bioacoustics and atmospheric soundscapes (forest wind, rain, birdsong) in real-time with zero external media assets.

Demo

Application Interface: Single-page architecture featuring a high-contrast dark botanical design system, deterministic calculations, and zero third-party tracking.
Field Audio Integration: Audio narration allows hands-free inspection during outdoor physical tasks.
Edge Diagnostic State: Real-time connectivity telemetry confirms the application operates fully disconnected from external networks.

Code

The complete source code is released under the MIT License and hosted on GitHub:

Kunal-CodeLab / verdant-ai

Edge-Native Open-Source Flora & Agronomy Companion for Hacktoberfest 2026

VerdantAI — Open-Source Offline Flora & Agronomy Companion

Decentralized botanical intelligence designed to minimize screen dependency and facilitate offline horticultural stewardship.
Developed for the Hacktoberfest 2026 Open-Source AI Challenge (Week 1: Touch Grass).

1. Executive Summary

Modern software development often leads to prolonged screen exposure and disconnection from physical ecosystems. VerdantAI is an edge-native, open-source agronomy platform engineered with a strict design constraint: minimize interface latency and compute duration to direct the user back to hands-on agricultural and ecological engagement.

Powered by Google's Gemma 2 open-weight model family and client-side botanical heuristics, VerdantAI provides localized agronomic guidance, specimen diagnostics, and field protocols without requiring continuous cloud connectivity or proprietary API tokens.

2. Core Architectural Pillars

2.1 Hyperlocal Sowing & Micro-Climate Engine

Calculates frost probability intervals, vernalization thresholds, and optimal sowing calendars across multiple global agricultural zones (Zone 5-11, South Asian plain agro-climates). All computations execute deterministically in the client…

View on GitHub

Quick Start:


bash
git clone https://github.com/Kunal-CodeLab/verdant-ai.git
cd verdant-ai
# Open index.html directly in any modern browser. Zero build steps required.