Your Codebase Doesn't Need AI. It Needs Context.

Every hackathon has the same 90-second moment of dread: someone hands you a codebase you've never seen, and you have to make sense of it before the clock runs out. File trees don't help. grep

doesn't help. You waste the first 30–60 minutes reading the wrong files, missing a hidden dependency, and stepping straight into a production trap nobody warned you about.

In other words: before writing code, you spend half your time trying to figure out where the hell the code is.

The idea wasn't "AI that writes your code." It was "AI that tells you where to look before you write it."

For InnovaHack Chapter-1, my team built Waypoint — a dev onboarding platform. Point it at any GitHub repo or a local folder, describe a task like "Add a new global configuration flag to app.set()", and instead of you reading the whole codebase to figure out where that even goes, it hands you a Mission Brief: exactly which files you'll touch, the traps waiting in them, what to learn first, and the order to do it in. Waypoint made the Top 50 — one of the 50 chosen to advance to Round 2. Here's how it actually works under the hood, what it took to build, what's next for it — and since I don't believe in only posting the highlight reel, what happened after we placed that made us walk away from the next round.

Every time a developer joins a new codebase, or picks up an unfamiliar task in one they already know, there's a tax paid in wrong files read, missed dependencies, and traps hit blind.

For me, that moment came when I wanted to contribute to Forem — the open-source project that actually powers DEV. I didn't know a line of Ruby on Rails, and between learning the language, understanding the framework, and preparing for interviews, I didn't have the time to read an entire unfamiliar codebase just to figure out where one feature belonged. I never ended up making that contribution. But the problem stuck with me. It's also a pattern for our team more broadly: we deliberately pick a different domain of tech for every hackathon instead of getting comfortable in one stack. It's less strategic than it sounds — mostly it just means Tarkash-Labs has ended up with a fairly scattered, fairly interesting portfolio of projects across domains that have nothing to do with each other.

A file tree tells you where things are. It tells you nothing about what matters for the thing you're trying to do right now. That's the actual gap Waypoint closes — not "here's a map of the codebase," but "here's the route for your specific task."

It's a map, not a GPS. Waypoint is supposed to give you the latter.

Type in a task — the README's own example is Add Google OAuth — and Waypoint runs a five-step pipeline:

Five steps in. One question answered: “Where should I actually start?”

That evidence log matters more than it sounds like it should — it's the difference between "trust me" and being able to see exactly which files the recommendation is grounded in.

The goal isn't to make the AI sound confident. The goal is to make it show its homework.

Screenshot 1 — the input/task

The task starts with a question, not a file path: tell Waypoint what you're trying to change.

Screenshot 2 — the analysis

Waypoint narrows an entire repository down to the files relevant to that task.

Screenshot 3 — the Mission Brief

The output isn't a generic codebase summary — it's a task-specific route with files, traps, prerequisites, and evidence.

Caption: The Mission Brief generated for adding a new configuration flag to Express.js — identifying the exact core files to touch, known framework traps, and the step-by-step route.

One decision I'm genuinely proud of: Waypoint doesn't depend on a single AI provider staying up. It runs a waterfall — because apparently even AI needs a backup plan:

Primary → Fallback → Second fallback

This isn't a hypothetical safety net. Gemini's free tier caps out at 20 requests a day, per model — fine for a polished five-minute demo, nowhere near enough for the number of test runs building and debugging actually takes. NVIDIA NIM's limits run per-minute instead of per-day, which is exactly why DeepSeek V4 Flash sits as the first fallback rather than the primary. Gemma 4 31B is the heaviest of the three — noticeably slower, but consistently the most thorough of the three, which is why it's the option of last resort rather than a weak one. Three providers, one mission: don't let the app go down because a free tier decided you'd had enough requests for the day.

Beyond the Mission Brief, Waypoint has two ways to actually see the codebase:

Architecture Map: the Express.js codebase rendered as a 3D city — building height represents lines of code, while color represents risk.

Dependency Galaxy: the same repository viewed as a network of file-to-file dependencies.

And then the entire thing white-screened.

Here's the one that actually made me sweat. Building the Architecture Map meant procedurally laying out a 3D cityscape — each file a building, grouped by directory — and for the floor plan we used d3-hierarchy

's treemapSquarify

layout, extruding the resulting 2D rectangles into 3D boxes with React Three Fiber.

It worked cleanly on most repos. Then, with no warning, a specific repo would white-screen the entire app — no error message, no fallback, the whole navigation state just gone.

The cause turned out to be a collision between D3's layout math and WebGL's geometry constraints. On repos with certain nested structures, or too few files, D3's padding calculations would subtract more space than the bounding box actually had — and the treemap would hand back leaf nodes with a width or depth of exactly zero, sometimes negative. Feed a negative dimension into a Three.js <BoxGeometry>

and WebGL throws a fatal NaN

vertex error. Because the 3D canvas lived inside the main React tree, that error bubbled straight up and unmounted the entire app.

A single negative pixel in a street calculation nuked the whole dashboard.

Fixing it took three layers: scaling the D3 canvas dynamically based on repo density instead of a fixed-size grid, clamping geometry on the Three.js side with a hard minimum size and a capped maximum height so nothing could ever go negative or infinite, and wrapping the whole 3D map in a React ErrorBoundary

so a geometry failure degrades gracefully to a "Map unavailable" panel instead of taking the rest of the app down with it.

Turns out making a codebase look like a city is considerably easier than making the city behave like one.

For the curious: Waypoint doesn't need a GitHub repo Waypoint can analyze a local folder directly through the browser's File System Access API — no GitHub repo required, and no code leaves your machine until the AI analysis step. This wasn't an accident: during any hackathon, we try hard not to introduce a persistent database or auth if we can avoid it. It's better for privacy, and just as importantly, it means judges can try the tool immediately instead of creating an account first — which saves everyone time during judging.There were 8,666 registered teams across the hackathon, but the number of teams competing in our Open Innovation track isn't something I know. So I'm not going to manufacture a denominator. Waypoint was simply one of the 50 teams selected to advance to Round 2. Top 50 gave us a waypoint, not a finish line.

Waypoint is an AI-powered developer productivity tool that analyzes any GitHub repository or local project and generates task-specific Mission Briefs — telling you exactly which files to touch, what traps to avoid, and the optimal execution route, before you start coding

When a developer joins a new codebase or picks up an unfamiliar task, they waste 30–60 minutes reading the wrong files, missing hidden dependencies, and hitting production traps. Waypoint eliminates this cold-start problem entirely.

Waypoint uses a Retrieval-Augmented Generation (RAG) pipeline with semantic embeddings to deeply understand a codebase and then generates:

Placing Top 50 wasn't the end of the story — it was supposed to be the start of Phase 2. And this is the part most "we won a hackathon!" posts leave out, so I'm not going to.

Instead, Phase 2 taught us something we didn't expect to learn at a hackathon: sometimes the thing you need to debug isn't your code.

Here's what happened, as plainly as I can lay it out:

For us, that wasn't worth paying to continue. Not because Waypoint wasn't worth continuing — a Top 50 finish says otherwise — but because the claimed value didn't add up to something we felt justified paying ₹1,000 for.

If you're deep in hackathon season this year: paying to continue is one decision. An organizer who won't stay answerable for what that payment covers is a completely different, much simpler decision. Walk, regardless of how far you've already placed.

For now, Waypoint is d — not abandoned. We know where we want to take it next: tighter retrieval, a real backend proxy so it's not stuck behind a dev-only CORS workaround, private repo support. Realistically, it's waiting on our next funding round, which comes in one of two forms: actual seed funding, or my co-founders finishing their job hunts and having bandwidth again. Whichever hits first, we're calling it **Series F** — for Friends.

Right now we've got Waypoint's idea and questionnaire submitted to Eureka! — E-Cell IIT Bombay's startup competition — under the AI & Deeptech track. No idea yet how far it goes, but it felt like the right next room to walk into.

Sometimes the most useful waypoint is the one that tells you not to keep going.

Have you ever walked away from an opportunity even after earning your way into it? I'd genuinely like to hear what happened.

Transparency note: the AI pipeline behind these screenshots

*(Dev Note: For the demo screenshots in this post, we ran Waypoint against the Express.js repository to show a realistic architectural task. Also, a quick transparency note on the AI pipeline: as of August 24, 2026, NVIDIA NIM officially deprecated the nv-embedcode-7b-v1

embedding model and sunset the free-tier API endpoint for deepseek-v4-flash

. Because this triggered a cascading 410 Gone

error across our semantic search and LLM fallback router, the screenshots above were generated locally by temporarily bypassing NIM and routing the entire pipeline through Gemini 3.5 Flash as a hotfix. We'll be migrating to NVIDIA's newer embedding models and a partner-hosted DeepSeek instance for production before our Eureka pitch.)*