DEV Community: Anushka Bhardwaj

RepoJourney — Making Unfamiliar Codebases Make Sense

Anushka Bhardwaj — Mon, 05 Oct 2026 06:51:04 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Have you ever opened a GitHub repository, looked at dozens of folders and files, and thought:

“Where am I even supposed to start?”

That was the problem behind RepoJourney.

I built RepoJourney for a friend — and, honestly, for any developer who is trying to understand someone else's codebase.

When you're learning from open source, contributing to a new repository, or simply exploring how another developer built something, the hardest part often isn't reading the code. It's figuring out what to read first and how everything connects.

RepoJourney turns a public GitHub repository into a guided journey through the codebase.

Instead of randomly opening files, you can follow the project from:

Project Setup → Entry Points → Components → Data Flow → APIs → Architecture

The goal is simple:

git clone → “I get it.”

RepoJourney analyzes the repository structure and helps surface the important parts of the project so that understanding an unfamiliar codebase feels more like following a path than solving a puzzle.

Demo

🌐 Live Demo:

https://repo-journey-ten.vercel.app/

Paste a public GitHub repository URL and click Explore Journey to try it.

Code

💻 GitHub Repository:

AnushkaBhardwaj15 / repo-journey

This is a Next.js project bootstrapped with create-next-app.

Getting Started

RepoJourney currently supports a landing experience and bounded ingestion of public GitHub repositories, deterministic repository intelligence, and a personalized LEARN view grounded in repository evidence See the ingestion contract and setup and Phase 3 schema, evidence rules, acceptance results and limitations Copy .env.example to .env.local to configure optional server-side credentials. GITHUB_TOKEN enables authenticated public-repository ingestion; GEMINI_API_KEY enables personalized teaching through the gemma-3-27b-it model. Neither key is exposed to the browser.

Run npm test for analyzer, teaching validation, and simulator tests, including an actual SHA-pinned snapshot of hacktober-showcase. The suite requires Node 22.12+.

First, run the development server:

npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev

Open http://localhost:3000 with your browser to see the result.

You can start editing the page by modifying app/page.tsx. The page auto-updates as you edit the…

View on GitHub

The project is open source, so you can explore how the repository analysis and journey generation work internally.

How I Built It

RepoJourney is built with Next.js and TypeScript.

The first part of the system is deterministic repository analysis.

Given a public GitHub repository, RepoJourney examines information such as:

Repository structure
Languages and technologies
Dependencies
Important files
Entry points
Imports and relationships between files
Framework-specific signals

That information is transformed into a structured representation of the project.

Rather than sending an entire repository blindly to an AI model, RepoJourney first gathers evidence from the actual codebase and uses that context to construct the learning journey.

For the AI layer, I used Gemma, Google's open-weight model family, to help turn the analyzed repository information into explanations that are easier for a developer to understand.

The important part for me was keeping the repository analysis separate from the AI explanation layer.

The code provides the evidence.

The model helps explain it.

That approach makes RepoJourney much more useful than simply asking an AI model, “What does this repository do?”

Why Does Open Innovation Matter?

RepoJourney exists because of open source.

The entire idea comes from something developers experience constantly: discovering an interesting repository, cloning it, and trying to understand how another person built it.

Using an open model such as Gemma also means the intelligence layer doesn't have to be permanently tied to one closed AI provider.

Open-weight models create possibilities for developers to experiment with different inference providers, run models in different environments, inspect how their systems behave, and continue improving projects without designing everything around a single proprietary API.

That matters especially for developer tools like RepoJourney.

A project designed to help people explore open-source software should itself embrace the same ideas: experimentation, transparency, learning, and the ability for other developers to build on top of it.

Open innovation didn't just help me build RepoJourney.

It's the reason a project like RepoJourney can exist in the first place.

Prize Categories

Build for a Friend
Best Use of Gemma

I built a Hackathon Finder - with AI!

Anushka Bhardwaj — Mon, 13 Jul 2026 06:59:35 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

As a student developer, I constantly found myself searching across multiple platforms to discover hackathons, coding competitions, workshops, open-source programs, fellowships, and developer events.

Then I stumbled upon the way Google Maps work. Then I realized- the problem wasn't a lack of opportunities — it was discoverability.

Important opportunities are scattered across different websites, communities, and social platforms, making it difficult for students to know:

What opportunities are available right now?
Which ones are relevant to one's skills?
Which deadlines are approaching?

HackFinder.ai is a centralized opportunity discovery platform built to solve this problem.

It helps students and developers discover relevant tech opportunities in one place through a clean, searchable dashboard.

Users can:

Explore curated hackathons, events, workshops, and programs
Filter opportunities by category, mode, and tags
Track upcoming deadlines
Bookmark opportunities for later
Get AI-powered explanations on why an opportunity matches their profile

The goal is simple:

Make finding the next opportunity as easy as finding a place on Google Maps.

Demo

Code

AnushkaBhardwaj15 / hackfinder.ai

React + Vite

This template provides a minimal setup to get React working in Vite with HMR and some Oxlint rules.

Currently, two official plugins are available:

@vitejs/plugin-react uses Oxc
@vitejs/plugin-react-swc uses SWC

React Compiler

The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see this documentation.

Expanding the Oxlint configuration

If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the TS template for information on how to integrate TypeScript and Oxlint's TypeScript related rules in your project.

View on GitHub

How I Built It

The Story Behind HackFinder.ai

The idea came from my own experience as a student developer.

While exploring hackathons, open-source programs, workshops, and developer events, I noticed that opportunities were everywhere — but discovering them was difficult. They were scattered across websites, communities, and social platforms.

I realized many students don't miss opportunities because they lack skills, but because they never find the right opportunities at the right time.

That became the motivation behind HackFinder.ai — a platform to bring tech opportunities into one searchable space.

Building the Product

I started by defining a simple MVP:

"Help students discover relevant opportunities in seconds."

I focused on building the core experience:

Search and filter opportunities
View detailed opportunity information
Bookmark interesting opportunities
Get AI-powered explanations about why an opportunity matches their profile

For the frontend, I built a responsive dashboard experience using:

React.js
Vite
Tailwind CSS
Lucide React
Local Storage

The biggest UI challenge was keeping the experience simple while handling many categories of opportunities.

Backend & AI

I built the backend using:

Node.js
Express.js
MongoDB Atlas

The backend manages opportunity data and creates a foundation for future features like user profiles and personalized recommendations.

For AI, I focused on making it useful rather than adding AI just as a feature. HackFinder.ai helps users understand why an opportunity could be relevant to them and how it connects with their skills.

Challenges & Learnings

Building this project taught me how important product decisions are during development.

The biggest challenges were:

Prioritizing features for an MVP
Connecting frontend and backend smoothly
Making AI add real value
Building a polished experience within a limited timeframe

This project helped me improve my full-stack development skills and taught me how to turn a personal problem into a usable product.

What's Next

Future improvements I would love to add:

User authentication and personalized profiles
Email alerts for upcoming deadlines
More automated opportunity discovery
Better AI recommendations based on user goals and skills

Prize Categories

Best use of Google AI✨