DEV Community: Aditi Shetty

Taking the Slow Road to Understanding Code with RepoNap

Aditi Shetty — Sat, 24 Oct 2026 22:57:42 +0000

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

Slow and Steady, One Codebase at a Time: Building RepoNap with Gemma

What I Built

I built RepoNap, an AI-powered codebase assistant that helps developers understand unfamiliar repositories without spending hours manually searching through files.

As a student developer, I know how confusing it can be to start exploring a new codebase. You have to find the important files, understand how different parts connect, and figure out where the logic lives.

RepoNap makes this process easier. You can connect a GitHub repository, scan its source files, explore the code, and ask questions in plain English to get AI-generated explanations based on relevant code.

Some of its main features include:

Connect and analyze GitHub repositories.
Browse scanned source files.
Index code into smaller chunks for context retrieval.
Ask questions about a codebase in plain English.
Get AI-generated explanations using the configured Gemma model.

The idea is simple: take things one step at a time and make understanding code a little less overwhelming.

Demo 🚀

Try the deployed application here:

🔗 Live Demo: https://reponap-jyuvhpugg5q32rhwfl6m8x.streamlit.app/

You can explore the source code here:

💻 GitHub Repository: https://github.com/aditikshetty/RepoNap

Code

RepoNap is an open-source project. You can check out the code, explore how it works, and share suggestions or improvements on GitHub.

🔗 https://github.com/aditikshetty/RepoNap

How I Built It

I built RepoNap using Python and Streamlit, with Google's Gemma 3 open-weight model running through Ollama for AI-powered code explanations.

Here's how the workflow works:

The user provides a GitHub repository URL.
RepoNap scans the repository's source files.
The code is split into smaller chunks and indexed.
When a user asks a question, RepoNap retrieves relevant code sections.
The retrieved context is sent to the configured Gemma model through Ollama.
The model generates an explanation based on the available code context.

I wanted to explore how open-weight AI models could be used for a practical developer tool rather than just another basic chatbot.

Why Does Open Innovation Matter?

Open innovation gives developers the freedom to experiment, learn, and build without depending entirely on closed AI services.

Using Gemma through Ollama helped me explore an open-weight model and build an application around it. It also gave me more control over the model setup and how code context is passed into AI requests.

Open-source tools make it easier for students and independent developers like me to turn ideas into working projects, learn from existing technology, and improve what we've built with help from the community.

That's one of the things I like most about building in the open: there's always more to learn and room to improve.

My Agent Session

I'm leaving this section out for now because I don't have a DevRelay session link to share.

The Lazy Payoff

RepoNap is all about saving time when exploring unfamiliar code.

Instead of manually opening file after file to find a particular function or understand a piece of logic, developers can start by asking a question and reviewing the relevant code context.

It's still a work in progress, but building it has helped me understand how code indexing and open-source AI can work together to make developer workflows easier.

Prize Categories

I'm entering Best Use of Gemma because RepoNap uses Google's Gemma 3 open-weight model through Ollama to help developers explore and understand codebases.

I wanted to build something practical with Gemma that could help solve a real developer problem: making unfamiliar code easier to understand.

Final Thoughts

Building RepoNap has been a learning journey for me. I've been exploring repository analysis, code indexing, and open-source AI, and bringing them together into one application has given me plenty of ideas for future improvements.

The theme Slow and Steady feels fitting because building useful tools is an ongoing process. Every feature, bug fix, and experiment is another step forward.

Thanks for checking out RepoNap!

GitHub: https://github.com/aditikshetty

Hacktoberfest #OpenSource #Gemma #Ollama #AI #Python #DeveloperTools

I Built ScopeGuard AI: An AI-Powered Scope Creep Detector for Freelancers

Aditi Shetty — Sun, 18 Oct 2026 12:44:47 +0000

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

What I Built

Freelancers often face scope creep when clients request additional features, revisions, or changes that were not included in the original agreement.

ScopeGuard AI is an AI-powered scope creep detector that helps freelancers compare new client requests against their original project proposal or contract.

Users upload a PDF proposal or contract and enter a new client request. ScopeGuard AI analyzes the request and helps classify it as:

In scope: The request appears to be covered by the agreement.
Potentially additional work: The request may go beyond the agreed scope.
Unclear: More information is needed before making a decision.

The application also provides supporting contract evidence and suggests a professional response that freelancers can adapt before replying to clients.

The target users are freelance developers, designers, independent consultants, and small agencies. A potential business model is a low-cost subscription, subject to validation with real users.

ScopeGuard AI is a decision-support tool, not legal advice.

Demo

🚀 Try the live application: https://scopeguard-ai-556q.onrender.com/

Upload a sample project agreement, enter a new client request, and explore the analysis.

Code

💻 GitHub Repository: https://github.com/aditikshetty/scopeguard-ai

The repository contains the source code for ScopeGuard AI.

How I Built It

I built ScopeGuard AI using Python and Streamlit, with PDF processing and AI-assisted analysis.

The main technologies include:

Python — Application logic.
Streamlit — Interactive web interface.
PyMuPDF — Extracting text from PDF agreements.
Ollama API — Connecting the application to an AI model.
Render — Deploying the application online.

The application extracts text from the uploaded agreement, evaluates the client's request against the available contract information, and produces a structured result.

I also worked on checking supporting quotations against the source document to help reduce unsupported claims.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to independent developers and small teams.

Open-source tools and open-weight models provide opportunities to experiment with different AI workflows, evaluate model behavior, and explore more affordable deployment options.

For ScopeGuard AI, this matters because freelance proposals and contracts can contain sensitive business information. Exploring local inference and alternative deployment approaches could give users more control over document processing.

This project also helped me understand that building a useful AI application involves more than generating a response. It requires careful document processing, evidence validation, error handling, and a user experience that communicates uncertainty.

What I Learned

Building ScopeGuard AI helped me explore how AI can be applied to a practical business problem.

One important design principle is that the system should not force every request into a definitive answer. Some requests require clarification, and the application should communicate that uncertainty rather than inventing contract terms.

My next goals are to improve automated testing, evaluate classification quality, and gather feedback from freelancers.

I'd love feedback from the community:

Would you use an AI tool to help identify scope creep before agreeing to additional client work? What features would make you trust it?

Prize Categories

devchallengesvg #hf26challengesvg

10th K AI: I Built an AI Tutor for My Sister Who Was Stuck on Textbook Questions

Aditi Shetty — Sun, 04 Oct 2026 22:02:45 +0000

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

10th K AI — An AI Tutor I Built for My Sister

My sister is a Class 10 student.

I noticed something frustrating when she was studying: sometimes she knew the subject, but still got stuck because the textbook language was difficult to understand.

The bigger problem wasn't always "I don't know the answer."

It was:

"I don't understand what type of question this is asking me."

A question might be asking for a person and their contribution, a cause and its effect, a formula and a calculation, or a definition and a term.

So I built 10th K AI specifically for her.

It is an AI-powered Karnataka SSLC Class 10 textbook tutor that doesn't just give an answer. It helps a student understand:

What is the concept? → What question pattern is this? → How do I solve it? → How do I remember it?

What I Built

10th K AI lets a student ask a question from their Class 10 textbook and get a response grounded in the actual textbook.

For example, if the student asks:

Who derived the quadratic formula?

10th K AI searches the Karnataka SSLC textbook and finds the relevant passage:

"Sridharacharya (C.E. 1025) derived a formula, now known as the quadratic formula..."

Instead of stopping there, the tutor turns the information into a learning structure:

Answer
Textbook Evidence
Simple Explanation
Question Pattern
Memory Trick
Similar Practice Question

The goal is not just to help a student get one answer.

The goal is to help them recognize the pattern the next time they see a similar question.

Who I Built It For

I built 10th K AI for my sister.

While helping her study, I realized that students can struggle even when the information is technically available to them.

A textbook may say something like:

"Sridharacharya derived a formula..."

But an exam question might ask:

"Who derived the quadratic formula?"

The student needs to recognize:

Person → Contribution

That small recognition can make a big difference during an exam.

That became the central idea behind 10th K AI.

How It Works

10th K AI uses a Retrieval-Augmented Generation (RAG) pipeline.

The textbook PDFs are processed into smaller chunks.

Each chunk stores information such as:

Subject
Book
Page number
Textbook content

I created embeddings for the textbook chunks using:

Sentence Transformers — all-MiniLM-L6-v2

Those embeddings are stored in a FAISS vector index.

When a student asks a question:

Student Question
↓
Keyword Search
↓
Semantic Search
↓
Hybrid Retrieval
↓
Relevant Textbook Passage
↓
Open-Source LLM
↓
Learning-focused Answer

The LLM is instructed to use the retrieved textbook evidence rather than simply inventing an answer from general knowledge.

Open-Source AI at the Core

The project uses Ollama and an open-weight model for the AI generation layer.

This was important to me because I wanted the project to be built around an AI system that I could actually control and run locally.

With Ollama, I can run the model on my own machine during development instead of making my application completely dependent on a closed AI API.

The architecture also keeps the LLM layer replaceable, which means I can experiment with different open models without rebuilding the entire RAG system.

Why Open Innovation Matters

For an educational tool, I think control over the AI layer matters.

With a closed API, the model is essentially a service I depend on.

With an open model through Ollama, I can:

Run inference locally
Experiment with different models
Control the prompting
Change the retrieval strategy
Keep the textbook retrieval pipeline under my control
Build the system without locking the entire project to one proprietary model

For 10th K AI, the combination of open model + local inference + textbook RAG makes the project much more understandable and controllable.

The Interesting Part: Question Patterns

This is the part I care about most.

I don't want 10th K AI to become another chatbot where a student asks:

"What is the answer?"

and immediately copies it.

Instead, I want the student to gradually recognize patterns.

For example:

Person → Contribution

Cause → Effect

Event → Person

Definition → Term

Formula → Numerical calculation

The student starts learning:

"I've seen this type of question before."

That is the skill I wanted to build into the tutor.

Tech Stack

Frontend / App

Streamlit

Ollama
Open-weight LLM

RAG

FAISS
Sentence Transformers
all-MiniLM-L6-v2

Text Processing

PyMuPDF
Python

Data

Karnataka SSLC Class 10 English-medium textbooks

Deployment

Streamlit Community Cloud
Demo

Live Demo:
https://10thk-ai-d6w3ycqcfe6i4zdecucqxp.streamlit.app/

Try asking:

Who derived the quadratic formula?

or another question from the Karnataka SSLC Class 10 Mathematics, Science, or Social Science textbooks.

Code

GitHub:
https://github.com/aditikshetty/10thK-AI

The repository contains the RAG pipeline, application code, textbook processing code, and retrieval system.

Why I Built It

I didn't start this project because I wanted to build another AI chatbot.

I started because I saw someone I care about getting stuck while studying.

That made me think about what an AI tutor should actually do.

Maybe the most useful answer isn't always:

"Here is the answer."

Sometimes it is:

"This is the kind of question you're looking at. Here's how you recognize it next time."

That's what I wanted 10th K AI to teach.

What's Next

There is still a lot I want to improve:

Better question-pattern classification
Support for textbook diagrams and images
More accurate similar-question generation
Student progress tracking
Personalized practice sets
Voice-based interaction
More regional-language support
Better evaluation of RAG accuracy

But the first version is now working, and more importantly, it was built for a real person with a real problem.

What I Learned

The biggest lesson from this weekend wasn't just about RAG or embeddings.

It was that a small, specific problem can be much more meaningful than a generic AI idea.

Instead of asking:

"What AI app can I build?"

I started with:

"What is frustrating someone I care about, and can I build something to help?"

That changed the entire project.

Prize Categories

I am submitting 10th K AI for the overall Hacktoberfest Weekend Challenge: Build for a Friend.

hacktoberfest #ai #rag #education