#devchallenge #weekendchallenge #hf26challenge #ai
This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.
What I Built
My friend was practicing DSA, but there was one problem.
Whenever he got stuck on a problem, the easiest thing to do was search for the solution.
He didn't need another chatbot that would immediately write the code for him.
He needed something that would ask:
"What have you tried so far?"
And then give him just enough help to keep thinking.
So I built HintLoop.
HintLoop is a small AI-powered DSA tutor that gives progressively stronger hints instead of immediately revealing the solution.
The flow is simple:
- Paste a DSA problem.
- Explain what you've tried.
- Ask for a hint.
- Get a small nudge.
- Ask for another hint if you're still stuck.
- Reveal the full approach only when you actually need it.
The goal isn't to solve the problem for you.
It's to help you solve it yourself.
HintLoop
Demo
Live Demo: [https://hintloop.onrender.com/]
For the demo, I recommend using a problem that clearly shows the hint progression.
For example, Two Sum.
Instead of immediately saying:
"Use a hash map."
HintLoop can start with a smaller nudge:
"Think about whether you really need to compare every pair."
The next hint becomes more specific.
Another hint points toward the relevant data structure.
Only when the user asks for the approach does HintLoop explain the complete solution.
Progressive Hints
1st Hint
2nd Hint
This is the core idea behind HintLoop.
The AI isn't just answering the problem.
It's controlling how much information to reveal.
Why I Built This
I've been practicing DSA myself, and I've noticed something easy to underestimate:
Getting stuck is part of learning.
The problem is that modern AI makes it incredibly easy to skip that part.
You paste a LeetCode problem into an AI chatbot.
You get the optimal solution.
You copy it.
It passes.
But the next time you see the same pattern, you might still not know how to start.
My friend was running into exactly this problem.
So I wanted to build something with a different rule:
The AI should help you think before it helps you code.
That's where HintLoop came from.
How It Works
The core loop is intentionally small:
DSA Problem
↓
Friend's Attempt
↓
Open-weight AI Model
↓
Hint 1
↓
Hint 2
↓
Hint 3
↓
Implementation Guidance
↓
Full Approach
The hints become progressively more specific.
Hint 1 Direction
Identify the general direction without revealing the solution.
Hint 2 Pattern
Point toward the relevant algorithm, pattern, or data structure.
Hint 3 Key Observation
Reveal the important insight needed to move forward.
Hint 4 Implementation Guidance
Give enough information to turn the idea into code.
Full Approach
Only when requested, explain the complete approach and complexity.
The important part is that the student controls when the AI becomes more specific.
Before vs After
Before
After
The Model
HintLoop uses Gemma-2-9b-it as its core AI model.
The model is responsible for understanding:
- the DSA problem
- the user's current attempt
- what the user already understands
- what they are missing
- how much help should be given next
It then generates a hint at the appropriate level.
The open-weight model isn't included just because this challenge requires AI.
It is actually part of the tutoring behavior.
The model helps determine what the next useful hint should be.
Why Open Innovation Matters
This project could have been built around a closed AI API.
But using an open-weight model gives me something important:
control.
I can change the model.
I can change the prompt.
I can change the tutoring rules.
I can experiment with different models.
And with a model/runtime that supports local inference, this type of educational tool can potentially run without sending a student's problem-solving history to a third-party API.
For an educational tool, that control matters.
I also don't want the product to depend completely on one provider's pricing, API limits, or model behavior.
The model is replaceable.
The tutoring logic is mine.
That's the part I like most about building with open models.
What I Learned
The interesting part wasn't making an AI call.
That was the easy part.
The difficult part was deciding:
How much help is too much help?
If the first hint already tells the student:
"Use a hash map and store the complement."
then the student doesn't really need to think anymore.
So I had to treat the AI response as part of the learning experience, rather than just an answer-generation problem.
I also learned that a good AI product sometimes needs constraints more than features.
Instead of adding:
- agents
- multiple dashboards
- authentication
- dozens of settings
- complicated workflows
I focused on one behavior:
Don't give me the answer too early.
Testing It With My Friend
I didn't want to build this entirely based on what I thought my friend needed.
So I gave it to him and asked him to use it on a DSA problem.
The important question wasn't:
"Did the AI answer correctly?"
It was:
"Did the hint help you move forward without giving away the solution?"
My friend said the progressive hints made it easier to keep working on the problem instead of immediately looking up the solution. The earlier hints gave enough direction to think about the problem, while the later hints helped when he was completely stuck.
That was exactly what I wanted HintLoop to do: help without taking over the problem-solving process.
The point of this challenge is that the project was built for a real person with a real problem.
Technical Architecture
The application is intentionally small.
┌──────────────────┐
│ HintLoop UI │
│ │
│ Problem + Attempt │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Backend / API │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Open-weight AI │
│ Model │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Progressive Hint │
└──────────────────┘
Tech Stack
| Layer | Technology |
|---|---|
| Frontend | NEXTJS |
| Backend | NONE |
| AI Model | Gemma-2-9b-it |
| AI Runtime | Groq |
| Deployment | Render |
The Design
I intentionally kept the interface simple.
No giant dashboard.
No complicated configuration.
No unnecessary features.
Just:
Problem → Attempt → Hint
The UI is designed around the idea that the student should focus on the problem, not the application.
Final UI
Code
The complete source code is available on GitHub:
GitHub: [https://github.com/SudhanshuMatrix/HintLoop]
The repository contains the application, setup instructions, environment configuration, and information about the AI model.
I've also documented the reasoning behind the hint system and the project's open-model approach.
Try It
Live Demo: [https://hintloop.onrender.com/]
If you try HintLoop, don't ask it for the solution immediately.
Give it a problem.
Tell it what you tried.
Then ask for a hint.
That's the whole point.
What I'd Build Next
There are a few things I'd like to explore next:
- Track the types of mistakes a student repeatedly makes.
- Adapt hint difficulty based on previous attempts.
- Add more programming languages.
- Add a "review my solution" mode after the problem is solved.
- Allow students to run the model locally.
But I intentionally didn't build all of that for this challenge.
The first version only needed to solve one real problem for one real person.
Final Thoughts
I originally thought my friend needed an AI that was better at solving DSA problems.
I changed my mind.
He needed an AI that was better at not solving them too quickly.
That's what I wanted HintLoop to be.
A small tutor that sits between:
"I'm completely stuck."
and
"Just give me the answer."
And hopefully keeps the student thinking in between.
Links
Live Demo: [https://hintloop.onrender.com/]
GitHub: [https://github.com/SudhanshuMatrix/HintLoop]
Built for a friend, with an open-weight model, for Hacktoberfest 2026.
#devchallenge #weekendchallenge #hf26challenge
Top comments (0)