DEV Community: Mukund Jha

I Built an AI That Understands My Entire Codebase—And It Changed Everything

Mukund Jha — Sun, 14 Jun 2026 15:05:45 +0000

The Moment That Changed Everything

It was 2 AM. My screen was flooded with 47 open files. I was trying to understand how authentication worked in a project I'd joined.

I asked myself: "How does this auth token actually get validated?"

I clicked through auth.js → middleware.js → database.js → config.js. Five files. Twenty minutes. Zero clarity.

Then I asked: "Wait, where is this function even USED?"

Another twenty minutes. Another ten files. My brain felt like it was running on 2% battery.

That's the moment I realized: Developers don't spend their time writing code. We spend it UNDERSTANDING code.

20–30% of every developer's week. That's 8–12 hours. Lost. Just trying to figure out what exists.
The Problem Nobody Talks About

Everyone talks about AI coders.

"Copilot will autocomplete your code!"

"Cursor will write functions for you!"

"AI will replace junior developers!"

But nobody asks:

"What happens when you join a 100K-line codebase and have to understand it in 3 days?"

Current AI tools are surface-level:

They autocomplete lines

They don't understand cross-file dependencies

They hallucinate when context is missing

I tried Copilot. I asked: "How does auth work?"

It gave me: "Check line 45 in auth.js."

That's not an answer. That's a pointer to another question.
The Breakthrough: What If AI Could Be a Senior Engineer?

I imagined something different:

"What if an AI could sit next to me and answer questions like a senior engineer who already knows the codebase?"

Not: "Check line 45."

But: "Auth works like this: The token flows from login() → validateToken() → database.getUser(). The expiry is 15 minutes because of security policy in config.js. Here's the full flow."

That's Lexithm.
What Lexithm Actually Does

Lexithm = AI Senior Engineer for Your Codebase

You ask:

"How does authentication work?"

"Where is validateToken used?"

"Explain this module."

"What changed in auth.js last week?"

Leixthm answers with:

Full cross-file context (not just one file)

Data flow traces (where functions are called)

Human-like explanations (like a senior dev explaining)

Real code references (lines, files, modules)

Examples:

text
Q: "How does auth work?"
A: "Auth flows: 1) User calls /login → 2) authController.login() validates credentials → 3) TokenService.generate() creates JWT → 4) Token stored in DB with 15-min expiry. See authController.js:45, tokenService.js:12."

Q: "Where is User model used?"
A: "User is imported in: 1) auth.js (login), 2) profile.js (getProfile), 3) admin.js (deleteUser). Total: 17 references across 5 files."

Q: "Explain validateToken"
A: "validateToken(token) checks: 1) Token exists, 2) Not expired, 3) Signature matches. Returns user object or throws error. Used in 3 endpoints: /profile, /admin, /settings."

This is not autocomplete. This is understanding.
How I Built It (From a 9th-Grade Bedroom in Nepal)

I'm Mukund Jha. I'm 14 years old. I'm in 9th grade. I live in Dipayal, Nepal—a small town with no tech giants, no startup incubators, no VC money.

My setup:

A laptop I'll upgrade after 10th grade (currently struggling)

Python + FastAPI (what I'm learning)

LLM APIs (NVIDIA NIM LLMS)

Vector DB for semantic search

3 months of late nights

Tech stack:

text
Backend: Python + FastAPI
AI: LLM APIs + AST parsing
Storage: PostgreSQL + Vector DB
Frontend: React/Next.js

I didn't have a team. I didn't have funding. I had a problem I felt every day and the stubbornness to solve it.
Why This Is Different (The Real Magic)
Copilot / Cursor Leixthm
Autocompletes lines Answers questions
Local file context Entire repo context
No cross-file tracing "Where is this used?" in sec
Hallucinates without context Real code references
"Check line 45" "Here's the full flow"

Lexithm thinks like a human senior engineer.

It doesn't just show code. It explains code.
The Impact: 5+ Hours/Week Saved

I tested Lexithm on my own projects:

Before: 2 hours to understand auth flow

After: 12 minutes with Leixthm

That's 10x faster.

For a developer working 40 hours/week:

8 hours/week lost on understanding code

With Lexithm: 2 hours/week

Saved: 6 hours/week = 1 full workday

That's the value.
It's Free. For Now.

I'm launching Lexithm free for everyone right now. No credit card. No limits (yet).

Why?

I need feedback to make it better

I need testimonials to prove value

I believe developers should access this tool without paying upfront

Try it: https://lexithm.vercel.app/

Ask: "How does [feature] work in this repo?"
The Future: What's Next

Lexithm is just the beginning. Here's what I'm building:
Week 1-2: CLI

bash
$ lexithm q "How does auth work?"
$ lexithm trace "src/auth.py"
$ lexithm explain "function_name"

Week 3-4: Code Review

bash
$ lexithm review
$ lexithm review --fix # Auto-applies fixes

Month 2: VS Code Extension

Click "Lexithm" in sidebar → ask questions

Daily use (developers open VS Code every day)

Month 3: Teams

Team dashboards

PR integration

Custom rules

Why You Should Care

If you're a developer:

You spend 20–30% of your time understanding code

You're frustrated with AI tools that don't give real answers

You want to ship faster, not debug slower

Lexithm solves this.

If you're building a startup:

Your team spends hours onboarding new devs

Your codebase grows, understanding gets harder

You lose time on READMEs, docs, explanations

Lexithm solves this.

If you're an engineer:

You want tools that save time, not add complexity

You want AI that understands, not just autocomplete

You want to focus on building, not deciphering

Lexithm solves this.
The Real Story: Why I Built This

I didn't build Lexithm to become rich.

I built it because I felt the pain.

Every time I joined a new project. Every time I open-sourced code. Every time I tried to understand a 100K-line repo.

I asked: "Why is this so hard?"

And I realized: It shouldn't be.

AI should be a senior engineer sitting next to you. Not a autocomplete bot showing line numbers.

Lexithm is my answer.
Join Me

I'm Mukund. I'm 14. I'm from Nepal. And I'm building the AI tool that every developer needs.

Try Lexithm: https://lexithm.vercel.app/

Feedback? I read every comment. DM me: jhamukunda2@gmail.com /

Share this: If you think this helps developers, share it with your team.
The Bottom Line

"Developers don't spend time writing code. They spend time understanding code."

Lexithm changes that.

It's free. For now.

Try it before it's not.

https://lexithm.vercel.app/

I Built a Free Open-Source Alternative to Sourcegraph — Here's Why"

Mukund Jha — Sun, 14 Jun 2026 03:43:35 +0000

It was 2 AM on a Tuesday, and I was staring at a function I had never seen before.

The codebase had 47,000 files across six microservices, written by people who had left the company years ago. I needed to understand how authentication flowed from the mobile app to the backend, through three different services, and back. I had grep open in one tab, the codebase in another, and ChatGPT in a third — copying and pasting files one at a time.

This isn't a workflow. It's a coping mechanism.

Every developer I know does some version of this. We read five files to understand one function. We trace imports manually. We build mental models that evaporate the moment Slack pings. We accept that understanding a new codebase takes weeks — sometimes months — as if that's just how software is made.

I don't think it has to be this way.

The Problem Nobody Solved

Sourcegraph exists. It's excellent at what it does — code search at enterprise scale. But it's built for organizations with dedicated infrastructure budgets. You need to self-host it, configure it, maintain it. For a solo developer, a small team, or an open-source project, the overhead doesn't make sense.

There are other tools too. But they all have the same gap: they search for text, not meaning.

When you type "where is auth handled," you don't want grep results. You want someone to tell you: "Auth starts in src/middleware.ts, the login form lives in src/auth/login.tsx, and the token exchange happens in src/api/auth/route.ts — here are the line numbers."

I wanted a search bar for codebases that understood how things connect. A tool that reads every file, builds a mental model of the dependency graph, and answers questions in plain English.

So I built one.

What Lexithm Does

Lexithm reads your entire repository — every file, every function, every import — and lets you ask questions about it in natural language. It extracts symbols, builds dependency graphs, detects API routes, and generates embeddings for semantic search.

Here's the flow:

Sign in with GitHub — no CLI, no config, no setup.
Pick a repository — public or private, works the same way.
Wait for indexing — AST-level parsing for Python, JavaScript, TypeScript, Go, Java, and Rust. Most repos finish in 2-5 minutes.
Ask questions — "what does this project do," "how does authentication work," "find the bug in the payment flow." Every answer cites the file paths and line numbers it references.

The key design decision was: no installation. Everything runs in the browser. You don't install a plugin, set up a server, or configure anything. It's a web app that connects to your GitHub and starts working.

The Architecture

The backend is Python with FastAPI. The indexing pipeline has 16 stages:

File discovery — categorize every file by type
AST parsing — build structured representations of each source file
Graph construction — connect symbols into dependency and call graphs
Embedding generation — convert every code chunk into vector embeddings
Storage — persist the indexed data for instant retrieval

When you ask a question, the system classifies your intent, retrieves the most relevant code chunks from the index, and feeds them to an LLM with a tailored prompt. Only the relevant context is sent — never your entire codebase.

The frontend is Next.js with a terminal-inspired chat interface. It streams responses token by token so you see the answer build in real time.

Why It's Free

Lexithm runs on free tiers. NVIDIA NIM provides the LLM inference at no cost. OpenRouter serves as a fallback. The embedding model runs on NVIDIA's API. Supabase handles the database and authentication. Everything stays within the free usage limits.

I built this because I wanted a tool like this to exist. Not everything needs to be a startup. Not everything needs an enterprise license. Some things can just be useful.

FAQ That People Actually Ask

How is this different from Sourcegraph?
Sourcegraph is built for enterprise code search at scale — think regex across thousands of repos. Lexithm is built for conversational code understanding — ask questions in English, get answers with citations. It's also free, requires no infrastructure, and takes zero setup.

Is my code safe?
Your repository is indexed on the backend, not stored by any LLM provider. Only the relevant context is sent for each question. You can delete the index at any time.

How long does indexing take?
Most repositories finish in 2-5 minutes. Larger projects with over 100,000 files can take up to 20 minutes.

Do I need to install anything?
No. Everything runs through your browser.

Try It

The site is live at lexithm.vercel.app. Sign in with GitHub, pick a repository, and ask a question.

The code is on GitHub at — well, it will be as soon as I push it. (I wanted to write this post first.)

If you've ever spent hours tracing code in an unfamiliar repository, you know exactly why I built this. I hope it saves you some of those hours.

Built with Next.js, FastAPI, NVIDIA NIM, Supabase, and a lot of late nights.