DEV Community: Abhishek Jha

ExamMate AI: When an Open-Weight AI Becomes Your Personal Study Buddy

Abhishek Jha — Wed, 28 Oct 2026 18:44:20 +0000

What I Built
ExamMate AI is an AI-powered study assistant designed to help students understand difficult concepts, revise topics, and prepare for exams.
The idea behind this project is simple: what if every student had a personal AI study partner available whenever they needed help?
Inspired by the theme Ghost in the Machine, this project explores how an AI system can feel like an invisible companion living inside a computer—ready to explain concepts, answer questions, and help students learn at their own pace.
Rather than replacing teachers, ExamMate AI aims to make learning more accessible, interactive, and less intimidating.
Demo
Try the live demo:
https://exammate-ai.vercel.app/⁠�
Code
Explore the source code on GitHub:
https://github.com/YOUR_USERNAME/exammate-ai⁠�
Note: Replace this repository link with your actual public GitHub repository. The demo URL is the previously proposed address, so verify that it works before submitting.
How I Built It
I planned ExamMate AI around an open-weight language model, Google Gemma 2 2B IT, using Hugging Face for model inference.
The proposed technology stack includes:
HTML, CSS, and JavaScript: For the user interface and interactive experience.
Google Gemma 2 2B IT: For generating AI-powered study responses.
Hugging Face: For accessing the model through inference.
Vercel Functions: For handling backend requests.
Vercel: For deployment.
The goal is to make the application simple to use while exploring how open-weight AI models can power practical educational tools.
Why Does Open Innovation Matter?
Open innovation makes AI experimentation more accessible to students and independent developers.
Open-weight models give developers more opportunities to understand how AI works, experiment with different applications, and build tools tailored to specific needs.
For students like me, this is especially valuable. We can move beyond simply using AI applications and start building our own.
Projects like ExamMate AI demonstrate how open-source tools, accessible development platforms, and open-weight models can help turn an idea into a practical application.
My Agent Session
This project was developed as an exploration of building a useful AI-powered application.
I don't have a verified DevRelay agent-session link to share, so I'm leaving this optional section out.
The Spirit of It 👻
The most interesting part of AI is that you cannot see the intelligence itself. You interact with a screen, type a question, and receive a response that can help you understand something you struggled with moments earlier.
For a student preparing for exams, that invisible companion can make learning feel less lonely.
That is my interpretation of Ghost in the Machine: intelligence operating inside a machine, creating experiences that feel surprisingly human.
Prize Categories
This project explores educational AI built around an open-weight language model.
Important: Select the actual partner categories listed on the official challenge page that your implementation qualifies for.
Before you publish — three important checks
Verify your GitHub repository. The repository link above is a placeholder, not a confirmed public repository.
Verify the demo. Make sure the application is deployed and its AI functionality works.
Confirm the Week 4 requirements. Your project must genuinely meet the challenge's open-source AI requirements. Don't claim that Gemma 2 or Hugging Face was used unless they are actually integrated into your working implementation.
One final tip: Simply publishing a post may not be enough to qualify for a challenge-specific badge. Check the official challenge rules and required tags.
I recommend submitting a genuine, working project rather than relying on a template alone.

FreelancerAI: I Built a Private, Local-First AI Expense Sorter for Freelancers 💸

Abhishek Jha — Wed, 14 Oct 2026 09:35:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle⁠�
What I Built
Meet FreelancerAI — a local-first invoice and receipt sorter designed for freelancers, solopreneurs, and small business owners who want to organize their expenses without uploading sensitive financial documents to third-party servers.
Freelancers have enough to worry about: finding clients, meeting deadlines, managing projects, and getting paid. Organizing receipts and preparing expense reports shouldn't consume hours of their time.
That's the problem I wanted to tackle.
With FreelancerAI, you can upload a receipt, extract its important details, categorize the expense, track your spending, and export your records for further analysis.
And the best part? Your financial data stays in your browser.
✨ What can FreelancerAI do?
🧾 1. Extract receipt information
Upload a receipt or invoice image and use browser-based OCR to extract text, including information such as the vendor, date, and amount.
🏷️ 2. Automatically categorize expenses
The built-in parser uses keyword matching and regular expressions to classify expenses into business categories.
📊 3. Track your spending
View your expenses through a dashboard with category breakdowns, spending statistics, and a monthly timeline.
📁 4. Export your records
Download expense data as CSV or JSON, or generate a formatted expense summary for your records.
🔒 5. Keep your financial data private
FreelancerAI processes receipt images in the browser instead of uploading them to a backend server. Extracted data is stored locally in the browser.
There are no accounts to create and no cloud AI API keys to configure.
🎯 Who would use it?
I built FreelancerAI with people in mind who need a straightforward way to manage business expenses:
Freelancers: Organize receipts from client projects and track work-related spending.
Solopreneurs: Maintain expense records without paying for a complicated accounting platform.
Small business owners: Categorize everyday expenses and export records for bookkeeping.
Independent consultants: Keep financial documents under their own control.
The goal is simple: make expense organization less tedious and give people more control over their financial data.
Demo
🚀 Try FreelancerAI here:
https://freelancerai-six.vercel.app/⁠�
Open the application, upload a sample receipt, and explore its expense extraction, categorization, dashboard, and export features.
Tip: Try the included sample receipt if you don't want to upload a personal financial document.
Code
💻 GitHub Repository:
https://github.com/ahanghosh77/FreelancerAI⁠�
The project is released under the MIT license. You can explore the implementation, run it locally, modify it, or build your own version.
How I Built It
I wanted to keep the application lightweight and accessible instead of introducing a complicated backend or relying on paid AI APIs.
Here's the technology behind FreelancerAI:
HTML: Structures the application interface.
CSS: Provides the responsive layout and visual design.
JavaScript: Handles receipt processing, expense extraction, categorization, dashboard updates, and exports.
Tesseract.js: Performs optical character recognition (OCR) directly in the browser.
Custom rule-based parser: Uses keywords and regular expressions to identify and categorize expense information.
Browser local storage: Stores expense records locally.
Vercel: Hosts the web application.
The architecture avoids a traditional backend for receipt processing. This helps keep the application simple, reduces infrastructure requirements, and gives users greater control over their information.
One important technical distinction: FreelancerAI uses browser-based OCR and a custom rule-based NLP parser rather than a large language model. I chose this lightweight approach to avoid cloud inference costs and keep the processing local.
What Makes It Different?
Many expense-management tools are designed around accounts, subscriptions, cloud storage, or external services.
FreelancerAI takes a different approach.
Local-first by design.
Instead of sending financial documents to a remote server for processing, the application performs its main receipt-processing tasks in the browser.
No cloud AI API bills.
The OCR and categorization pipeline doesn't depend on a paid cloud AI inference API.
Lightweight and accessible.
The application uses standard web technologies and doesn't require a complicated installation or backend setup.
Your data remains under your control.
Users can export their records instead of being locked into a proprietary data format.
These choices make FreelancerAI a practical starting point for people who want expense-management functionality without unnecessary infrastructure.
💸 The Side Hustle Angle
A side hustle doesn't always need to be another marketplace or a complicated business platform. Sometimes, it's a small tool that solves a repetitive problem for people who already run their own businesses.
Freelancers regularly handle receipts for software subscriptions, travel, equipment, internet bills, and other business expenses.
Manually organizing those documents can become frustrating, especially when it's time to prepare expense reports or share records with an accountant.
FreelancerAI aims to make that process easier.
Who might pay for it?
Potential customers include:
Freelancers who need simple expense tracking.
Consultants who want an organized record of business purchases.
Small business owners who need lightweight expense reporting.
Bookkeepers looking for a simple starting point for collecting expense records.
The current application is free to use. Possible future business models include optional paid features, customizable expense categories, batch receipt processing, and additional reporting tools.
I haven't assumed that potential customers will automatically pay for it. Validating that demand through real user feedback is an important next step.
🌍 Why Open Innovation Matters
For me, open innovation is about giving developers and users the freedom to understand, modify, and improve the tools they depend on.
FreelancerAI demonstrates this through its use of open-source browser technology and its MIT-licensed codebase.

Privacy should not require an expensive subscription Financial documents can contain sensitive information about a person's business and clients. Keeping receipt processing in the browser reduces the need to send those documents to external processing services.
Lower operating costs make small tools viable A traditional cloud-based AI application may require ongoing inference and hosting expenses. FreelancerAI's local processing approach avoids paid cloud inference for its core workflow. That makes it easier to experiment with the project without accumulating API bills.
Developers can build on the work The MIT license allows other developers to study the code, adapt the application, and create their own improvements. Someone could add regional expense categories, improve date extraction, introduce more export formats, or build integrations for a specific freelance workflow.
Users retain control over their records CSV and JSON exports help users move their data into other tools without depending entirely on one platform. I believe useful software should give people more control, not create another dependency. Open-source tools make that philosophy easier to put into practice. 🧠 Challenges and Lessons Learned One of the interesting parts of this project was working with receipt images. Receipt layouts are inconsistent. Vendors use different formats, dates can appear in multiple styles, and the final amount isn't always the easiest number to identify. OCR can extract text, but extracting text isn't the same as understanding a receipt perfectly. That is why the parsing and categorization logic matters. Keyword matching and regular expressions can handle common cases, but unusual layouts may require users to review or correct the extracted information. This project reinforced an important lesson for me: building a useful AI-assisted application isn't just about adding an AI model. Sometimes, a carefully designed processing pipeline can solve a specific problem more efficiently. There is still room to improve extraction accuracy, support more receipt formats, and test the application against a broader collection of real-world examples. 🔮 What's Next? I would like to explore several improvements: Batch processing for multiple receipts. Better handling of different date and currency formats. Improved detection of totals, taxes, and line items. Custom categories for different professions. More detailed monthly and yearly reports. Optional integrations with accounting tools. User testing to understand which features people would actually pay for. The priority is to improve reliability and usefulness before adding unnecessary complexity. Final Thoughts FreelancerAI started with a simple idea: expense management should be easier, more accessible, and more respectful of user privacy. By combining browser-based OCR, lightweight parsing, local storage, and open-source web technologies, I built a working starting point for a tool that could help freelancers spend less time organizing receipts. This is an ongoing project, and I would love feedback from freelancers, developers, and anyone interested in privacy-friendly applications. If you try FreelancerAI, I'd love to know: What's the most frustrating part of managing your business expenses, and what would make this tool genuinely useful to you? Thanks for reading! 🚀
Tags to add on DEV Add these four tags to your article: #devchallenge #hf26challenge #hacktoberfest #opensource These match the challenge's required tags and the project's theme. � DEV Community
How to submit it Open the official Hacktoberfest Week 2 challenge page⁠�. Sign in to your DEV Community account. Create a new post. Copy the title and article body above into the editor. Add the four tags listed above. Check that the demo opens and the GitHub repository is accessible. Preview the article to make sure the headings, links, and formatting look correct. Publish the article before the deadline. The Week 2 submission window ends October 18, 2026, at 11:59 PM PDT. � DEV Community
Important checks before publishing I have intentionally avoided claiming that you already have paying customers or that the application has achieved a particular accuracy rate. Before publishing, please verify these three things: Demo: Open the live application and confirm that its core features work. Privacy: Test the application with your browser's developer tools if you want to make a strong zero-network-requests claim. Browser storage and cached libraries should also be considered when evaluating privacy. Open-source AI eligibility: The project README identifies Tesseract.js and a custom rule-based parser as its processing components. The contest requires open-source AI or open-weight models to be central to the project. Whether this particular implementation qualifies may depend on the judges' interpretation, so check the official rules carefully before submitting. � DEV Community +1 My recommendation: Publish only after confirming that your implementation satisfies the challenge's open-source AI requirement. The article is ready to use as a draft, but no article can guarantee contest eligibility or a prize.

FoliageStride AI — Scenic Autumn Run & Park Route Explorer

Abhishek Jha — Thu, 08 Oct 2026 05:26:20 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

FoliageStride AI is a scenic autumn run & park route builder built to solve a modern fitness irony: runners going outdoors just to stare at GPS screens, pace charts, and turn-by-turn prompts every 30 seconds.

Instead of keeping runners glued to their devices, FoliageStride AI uses Google Gemma 2 to synthesize autumn running routes based on distance (2 km, 5 km, 8 km), terrain preference (Maple & Oak canopies, riverbank reflections, historic park perimeters, or hilltop ridges), and pacing style.

In under 30 seconds:

You select your distance and desired autumn scenery.
Google Gemma 2 synthesizes the route and extracts 3 to 4 distinct physical visual landmarks such as The Century Red Oak Grove, Heron Creek Footbridge, or Old Stone Wall.
You commit the visual landmarks to memory, hit Start Run, and pocket your phone.
A hands-free Web Audio synthesizer produces split cadence chimes at kilometer milestones so you know your checkpoints through your headphones without taking your phone out of your running belt.
Upon returning, you log your session and outdoor streak into the offline Stride Journal.

Demo

Live Web App: https://foliagestride-ai.vercel.app/
GitHub Repository: https://github.com/ahanghosh77/foliagestride-ai

The application runs in modern browsers and includes a fallback route-generation engine when the local AI model is unavailable.

Code

The complete open-source code is available on GitHub:

GitHub Repository:

https://github.com/ahanghosh77/foliagestride-ai

The repository contains:

index.html — Main application interface with distance selection, route visualization, elevation profile, visual waypoints, stopwatch, and Stride Journal.
style.css — Responsive autumn-themed UI with glassmorphism styling.
app.js — Gemma 2 integration through Ollama, fallback route generation, Web Audio API cadence chimes, and localStorage-based journal tracking.

How I Built It

FoliageStride AI is designed with an offline-first architecture.

Google Gemma 2

The core AI component uses Google Gemma 2 (gemma2:2b) through Ollama.

The model receives the runner's preferences, including:

Running distance
Autumn scenery preference
Terrain preference
Pacing style

It then generates structured route information and memorable physical landmarks that the runner can remember before starting the run.

Hands-Free Audio

The application uses the browser's native Web Audio API with OscillatorNode and GainNode to generate cadence chimes at kilometer milestones.

This means the runner does not need to continuously look at the phone during the run.

Dynamic Route Visualization

The application uses SVG-based graphics to display the route and elevation profile, together with visual markers representing foliage and important landmarks.

Offline Fallback

If the local Gemma 2 model is unavailable, the application uses a deterministic fallback route-generation engine.

This allows the application to remain usable even without a running local AI model.

Local Journal

The Stride Journal uses browser localStorage to keep track of completed sessions and outdoor streaks without requiring a cloud database.

Why Does Open Innovation Matter?

Open innovation and open-weight models like Google Gemma 2 are especially useful for outdoor and fitness applications.

1. Trail Readiness With Limited Connectivity

Outdoor runners can lose cellular reception inside parks, ravines, mountain trails, and nature reserves.

A local AI model reduces dependence on a continuously available cloud API.

2. Privacy of Physical Location & Movement

Running applications can involve sensitive information such as routes, workout frequency, and frequently visited locations.

FoliageStride AI is designed around local processing and local journal storage rather than sending this information to a third-party fitness server.

3. No Per-Request Cloud AI Cost

Running an open-weight model locally avoids paying for every AI request through a hosted API.

This makes experimentation more accessible to students, developers, and open-source communities.

My Agent Session

This project was built through pair-programming with Google Antigravity.

The agent helped with the responsive UI layout, autumn visual design, SVG course elevation profile, structured JSON schema for Google Gemma 2 prompting, hands-free Web Audio API split-chime synthesizer, and overall project structure.

The final project was refined around the core idea of helping runners touch grass instead of constantly checking a screen.

Prize Category

Best Use of Gemma — $200 USD

FoliageStride AI uses Google Gemma 2 (gemma2:2b) as the local route-synthesis engine, converting a runner's distance, scenery preference, and pacing style into structured scenic route information with memorable physical landmarks.

Conclusion

FoliageStride AI turns an ordinary run into a more screen-free outdoor experience.

The idea is simple:

Plan with AI → Remember the landmarks → Pocket the phone → Run → Touch Grass. landmarks.

DebugPal AI: An Offline-First Visual Socratic Pointer & Memory Tutor Built for my Classmate

Abhishek Jha — Sun, 04 Oct 2026 16:37:31 +0000

I Built an AI Debugging Tutor for My Friend Who Was Terrified of Segmentation Faults

I didn't build DebugPal AI because I wanted to make another coding chatbot.

I built it because my friend Rohan kept getting Segmentation fault (core dumped) in our Data Structures lab—and every time an AI fixed his code, he understood the bug a little less.

So I built him something different.

DebugPal AI is a visual, Socratic C/C++ debugging tutor that helps students understand why pointer and memory bugs happen instead of simply handing them corrected code.

🔗 Live Demo: https://debug-pal.vercel.app/

🔗 GitHub: https://github.com/ahanghosh77/debug-pal

🧑‍💻 The Friend I Built It For

Rohan is my classmate and lab partner.

We're working through university Data Structures labs where we use C and C++, including pointers, linked lists, dynamic memory allocation, and manual memory management.

For someone coming from a higher-level language such as Python, the hardest part isn't always writing the algorithm.

It's understanding what is actually happening in memory.

Rohan's recurring enemy was:

Segmentation fault (core dumped)

The compiler would tell him that the program crashed.

But it didn't give him the mental model he needed to understand why.

And when he asked cloud AI tools for help, the usual experience was:

"Here's the corrected code."

The code worked.

The understanding didn't.

That was especially frustrating because our university exams aren't just about getting a program to run. We also have to explain the concepts on paper.

So I wanted to build something that would make him think through the bug instead of simply copying the fix.

🧠 Meet DebugPal AI

DebugPal AI takes a C/C++ memory bug and turns it into a visual debugging lesson.

Instead of:

Your program crashed.
Here is the corrected code.

the experience is closer to:

What does this pointer currently contain?

        ↓

Where is that address pointing?

        ↓

Is that memory actually valid?

        ↓

What invariant did your program violate?

        ↓

Now... how would you fix it?

The goal is to create the "Ohhh, that's why!" moment.

🥞 1. Visual Memory Map

Pointers are difficult to understand when they're represented only as text.

DebugPal visualizes the simulated memory state with:

Call Stack frames
Stack variables
Heap allocations
Hex-style memory addresses
Pointer targets
Invalid memory destinations
Dangerous memory blocks

For example, instead of simply seeing:

head->next->next

the student can see the pointer chain and where the final arrow ends up.

When the destination is invalid, DebugPal makes the crash point visually obvious.

This is particularly useful for beginners who have learned the syntax of pointers but haven't yet developed a mental model of memory.

🎯 2. It Teaches the Invariant Behind the Crash

A segmentation fault is only the symptom.

The more important question is:

What rule did my program violate?

DebugPal tries to make that rule explicit.

For example:

head
  ↓
node
  ↓
NULL

and then:

head->next->next

Instead of immediately revealing the corrected code, DebugPal asks the student to reason about the next pointer and whether the next dereference is valid.

This turns debugging into a small reasoning exercise.

🤔 3. Three Levels of Socratic Guidance

DebugPal deliberately doesn't reveal everything immediately.

The guidance is split into three levels:

Level 1 — Observation

What does this pointer contain right now?

Level 2 — Invariant Check

Is the memory address you're about to dereference guaranteed to contain a valid object?

Level 3 — Root Cause

What exact operation caused the invalid memory access?

Only after thinking through the first two stages does the student get the root-cause explanation.

The idea is simple:

Don't remove the student's debugging problem. Teach them how to debug it.

💡 4. Everyday Mental Models

Low-level memory concepts can feel extremely abstract.

So DebugPal also explains them using everyday situations.

For example:

Dangling pointer

Imagine checking out of a hotel but continuing to use the room key.

The key still exists.

The room doesn't belong to you anymore.

That's roughly the mental model of a dangling pointer.

Memory leak

Imagine borrowing books from a library and never returning them.

You may still be able to use the books, but the library's available resources keep shrinking.

That's the intuition behind a memory leak.

NULL dereference

You're following an address to find a destination, but the address effectively says:

There is nothing here.

Then your program tries to use it anyway.

🛡️ 5. From Bug → Safe Code

DebugPal also provides a defensive code view.

Instead of only showing:

❌ This is wrong.

it shows the vulnerable version and a safer version side by side, followed by a checklist of the programming rule involved.

The objective is to connect:

bug → memory state → violated invariant → defensive programming practice

rather than treating each compiler error as an isolated problem.

🤖 Why Open-Weight AI?

This is the part of the project that mattered especially for this Hacktoberfest challenge.

The challenge asks participants to build something with open-source/open-weight AI at its core, including local inference with open-weight models.

DebugPal is designed around that idea.

For custom C/C++ code, the application can connect directly to a locally running Ollama instance.

The browser sends the code to the local Ollama API and asks the selected open-weight model to return a structured debugging analysis.

The model is instructed to produce:

Bug classification
Crash location
Stack state
Heap state
Pointer relationships
Execution timeline
Three Socratic hints
An everyday analogy
Before/after defensive code
A debugging checklist

The response is structured as JSON so the frontend can turn the model's reasoning into the visual debugging interface.

The relevant implementation is in app.js, where DebugPal calls the local Ollama /api/generate endpoint and requests a fixed JSON schema.

📴 And What Happens Without AI?

This was important because Rohan is a student.

University Wi-Fi isn't always reliable.

So DebugPal doesn't completely fall apart when Ollama isn't available.

It has a built-in heuristic fallback that can still identify common patterns such as:

Pointer dereferencing
Missing free()
Array-loop problems
Common linked-list mistakes

The application therefore has two modes:

             C/C++ Code
                  │
                  ▼
        ┌──────────────────┐
        │  Local Ollama AI  │
        │ Open-weight model │
        └────────┬─────────┘
                 │
                 │ unavailable?
                 ▼
        ┌──────────────────┐
        │ Heuristic Engine │
        └────────┬─────────┘
                 │
                 ▼
       Visual Debugging Lesson

That architecture means the student can still use the core learning experience without depending on a remote AI server.

🧪 Built-in Lab Traps

I included four common problems that map closely to what students encounter while learning C/C++:

1. Linked List Segmentation Fault

head->next->next

without safely checking whether the required nodes exist.

2. Dangling Pointer

Returning or using the address of memory whose lifetime has already ended.

3. Dynamic 2D Matrix Memory Leak

Allocating dynamic memory without correctly freeing the allocated blocks.

4. Buffer Overflow

An off-by-one loop accessing an array outside its valid bounds.

Each preset is designed to demonstrate a different memory-safety concept.

👨‍🤝‍👨 What Happened When I Gave It to Rohan?

This was the most important part of the project.

I didn't just build the website and call it "built for a friend."

I actually handed it to Rohan in our hostel study room while we were preparing for our Data Structures lab evaluation.

He tried the linked-list segmentation fault example.

His reaction was:

"During our linked list assignment, I kept getting segfaults because I was chaining head->next->next without verifying if the list had fewer than 3 nodes. Cloud AI just gave me the corrected code without explaining why my logic failed."

Then he saw the memory visualization:

"When DebugPal drew the Stack and Heap map and showed the arrow pointing into 0x00000000 [Unmapped Page 0], it instantly clicked why the CPU crashed."

And the part I cared about most:

"The Socratic hints made me think about the loop condition instead of guessing."

He has already bookmarked DebugPal on his laptop for our upcoming evaluations.

That's probably the best validation I could have asked for.

🏗️ How I Built It

The project is intentionally lightweight.

Frontend

HTML5
CSS3
Vanilla JavaScript

No heavy framework or build pipeline is required.

The repository can be opened directly in a browser.

AI Layer

Local Ollama inference
Open-weight model support
Structured JSON output
Socratic prompt architecture

Offline Fallback

A built-in heuristic analysis engine handles common pointer/memory patterns when local AI isn't available.

Export

DebugPal can generate a Markdown debugging report containing:

Bug classification
Pointer execution timeline
Memory explanation
Everyday analogy
Safe code
Debugging checklist

That turns a debugging session into something the student can keep as study notes.

🔐 Why Local AI Makes Sense for This

For this particular use case, local AI has some advantages.

Privacy

Student code can stay on the student's machine instead of being sent to a third-party cloud service.

Cost

A student shouldn't need an expensive subscription just to understand a segmentation fault in a lab assignment.

Reliability

The tool can be used even when internet connectivity is poor.

Control

Because the model is open-weight and runs locally, students can experiment with different models and prompts instead of being locked into a single cloud provider.

That's the part of open innovation I wanted to explore with this project.

🎮 Try It Yourself

Live Demo

👉 https://debug-pal.vercel.app/

GitHub

👉 https://github.com/ahanghosh77/debug-pal

The easiest way to try the application:

Open the website.
Select a bug preset.
Click Inspect Memory & Debug.
Explore the memory layout.
Reveal the three Socratic hints one at a time.
Read the everyday analogy.
Compare the vulnerable and defensive code.
Export the debugging report if you want to keep it as notes.

If you have Ollama running locally, you can also configure the local model from the application's model settings and analyze custom C/C++ code.

🎯 Why I Think This Fits "Build for a Friend"

The challenge wasn't just:

"Build an AI application."

It was:

Build something for a real person.

Rohan had a very specific problem.

He wasn't asking for another coding assistant.

He needed someone—or something—that would sit beside him and explain:

"Stop. Look at what your pointer is actually doing."

That's what I tried to build.

DebugPal AI is basically a visual teaching assistant for the moment when your C program crashes at 1 AM and you have no idea why.

And if it helps Rohan walk into our next Data Structures lab a little less afraid of pointers, then the project has already done what I wanted it to do.

🚀 What's Next?

There are several things I'd like to improve after the challenge:

More C/C++ memory bug patterns
Better parsing of arbitrary C/C++ programs
More accurate memory-layout simulation
Step-by-step pointer execution
More local model options
Interactive linked-list and tree visualizations
Sanitizer integration
A small collection of university-style debugging exercises

For now, though:

Rohan has stopped being scared of Segmentation fault.

And that's a pretty good first version.

🛠️ Built With

HTML · CSS · JavaScript · Ollama · Open-weight AI · C/C++ debugging concepts

📜 License

MIT

Built with ❤️ for Hacktoberfest 2026.

Hi

Abhishek Jha — Sun, 04 Oct 2026 09:17:16 +0000