DEV Community: Daibik Barik

Reboot AI: Give Your Forgotten Projects a Second Wind

Daibik Barik — Sat, 24 Oct 2026 06:09:04 +0000

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

What I Built

We've all done it: start a project with a burst of enthusiasm, get busy with something else, and return weeks or months later to a repository that feels like someone else's code.

You know there's something worth finishing in there. But before you can make progress, you have to reconstruct the context. What was already implemented? Which parts were unfinished? What was that promising idea you wanted to explore? And where do you even begin?

Reboot AI helps you pick up where you left off.

Give it the path to a local Git repository, and Reboot inspects the README, files, recent commits, working-tree status, TODOs, and selected source-code excerpts. It builds a picture of the project's current state, searches arXiv for potentially relevant research, and uses Gemma to turn the available evidence into a practical project revival report.

Instead of merely saying "here are some things you could improve," the goal is to connect recommendations to actual files, functions, research papers, and concrete implementation steps.

The research component is important. A forgotten project might not need another generic list of coding suggestions; it might need a paper that explains a better algorithm, a missing benchmark, or a technique the original author never got around to implementing.

For example, I tested Reboot on a Poker-Bot repository built around Counterfactual Regret Minimization (CFR), Bayesian opponent modelling, and exploitation in imperfect-information games. Its report identified empty Leduc poker and Deep CFR modules, highlighted limitations in the opponent-model evaluation, and suggested relevant research directions with implementation steps.

That is the kind of comeback I want Reboot to make easier.

The people who benefit are students with abandoned research prototypes, developers returning to side projects, and anyone whose enthusiasm for a project outlasted their available time.

The ambition is simple: less time remembering what you were doing, more time actually doing it.

Demo

Project walkthrough:

The demo shows Reboot inspecting the Poker-Bot repository, identifying unfinished components, retrieving relevant arXiv papers, and generating a project-specific restart plan.

Repository:

theikosB / reboot-ai

Revive forgotten projects with open-source AI, persistent project memory, and evidence-backed research. For submission to Hacktoberfest 2026 Week 3 Challenge: Slow and Steady

Reboot AI

Give forgotten projects a second wind.

Reboot AI helps developers return to unfinished or abandoned code projects without spending hours reconstructing what they were building Point it at a local Git repository and it builds a project report searches arXiv for potentially relevant research, and uses the repository evidence and retrieved papers to suggest a practical restart plan.

Project status: Early-stage prototype. Research matches and AI-generated recommendations are leads to verify, not guaranteed fixes.

Why Reboot?

Returning to an old repository often means rereading the README, scanning files and commit history, hunting for TODOs, and trying to remember which ideas were worth pursuing. Reboot brings these clues together in one report and suggests concrete next steps.

The goal is not to write the entire project for you. It is to reduce the friction of getting started again.

What it does

Inspects a local repository: gathers the README, file…

View on GitHub

Code

The project is built with Python and Flask, with separate modules for repository inspection, arXiv research retrieval, and AI-assisted synthesis.

The main components are:

app.py — Flask application and web interface routes.
reboot/workspace.py — gathers repository evidence.
reboot/arxiv_search.py — searches arXiv and attempts limited PDF text extraction.
reboot/agent.py — derives research queries, ranks candidate papers, and generates the restart plan using Gemma.
tests/test_research.py — initial automated tests for paper ranking, deduplication, and PDF extraction failures.

Source code: https://github.com/theikosB/reboot-ai

How I Built It

I built Reboot AI in Python, using Flask for the interface and Google's GenAI SDK to access Gemma. The research pipeline retrieves papers from arXiv and ranks candidates using repository-derived queries and a heuristic relevance score.

The application has three main stages.

1. Recover the project's context.

Reboot inspects the repository for evidence of what exists and what remains unfinished. It gathers the README, file inventory, recent commits, working-tree information, TODO/FIXME markers, and selected source excerpts.

2. Find relevant research.

Rather than making the user manually search for papers, Reboot derives a small number of research queries from the repository itself. It searches arXiv, removes duplicate results, ranks candidate papers, and attempts to extract text from the opening pages of a limited number of PDFs.

3. Turn the evidence into a restart plan.

Gemma receives the repository evidence and retrieved research material and is prompted to produce a Markdown report covering the project's current state, research-backed opportunities, concrete implementation steps, and limitations. The agent is instructed to distinguish observations from inferences and not to invent research findings or pretend that a partial PDF excerpt represents a complete paper review.

I also added a fallback path so that a model failure does not automatically discard the repository analysis and retrieved paper information.

The current model configuration is gemma-4-26b-a4b-it. I verified that a direct API request to this model returns a response; the complete restart-plan workflow still needs to be verified against the same configuration.

Why Does Open Innovation Matter?

Reboot is a project about helping people continue work that matters to them. I wanted its AI component to be built around an open-weight model rather than treating the model as an interchangeable black box.

Gemma gives the project a model whose weights are available under Google's applicable terms, creating room to explore different deployment arrangements and, potentially, future local inference or model customization. That matters for a tool that reasons over people's source code and unfinished research projects.

There is an important limitation in the current implementation: Reboot calls Gemma through Google's hosted API. It does not currently run the model locally. Repository content sent for synthesis therefore follows the configured provider's data-handling terms. I am not claiming that the current version works offline or keeps all source code on the user's machine.

The value of open innovation is the flexibility it creates for the next iteration. Reboot can investigate different serving options, compare models on the same repository-revival task, and eventually explore local inference for users who cannot send private code to a hosted service.

For this challenge, I am using Gemma as an actual part of the application's synthesis pipeline, not simply mentioning it in the README. The next step is to validate the complete workflow and document its performance and limitations honestly.

The Lazy Payoff

The time Reboot is designed to save is the time spent reconstructing context before any meaningful work can resume.

A returning developer would otherwise have to read the README, browse source files, inspect the commit history, search for unfinished work, and manually investigate research directions. Reboot brings those steps into one report and provides a shortlist of possible next actions.

I have demonstrated the workflow on a real Poker-Bot repository, but I have not yet measured the time saved against a manual baseline. I would rather report a measured result after testing than invent an impressive number.

My intended payoff is straightforward: instead of spending an evening remembering how a project works, spend that evening making the first meaningful change.

Prize Categories

Best Use of Gemma — Reboot uses Google's Gemma model for AI-assisted project analysis and restart-plan synthesis.

What's Next?

Before calling Reboot finished, I want to verify the complete restart-plan workflow with Gemma, expand end-to-end tests, improve error handling, and make the evidence behind each recommendation easier to inspect.

The long-term goal is to make returning to an unfinished project feel less like starting over and more like continuing a conversation with your past self.

Because sometimes the hardest part of finishing a project isn't the code. It's remembering why you started.

Boundary: Know Where the Agreement Ends

Daibik Barik — Wed, 14 Oct 2026 00:32:53 +0000

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

What I Built

Boundary is an AI-powered assistant that helps freelancers and small businesses handle customer requests without losing sight of their agreements and policies.

If you've ever freelanced, you probably know the situation: a client asks for a few "small additions" that weren't discussed initially, or a customer requests a refund that doesn't quite fit your policy. You want to be helpful, but you also need to protect your time, money, and boundaries.

That's the problem I wanted to tackle with Boundary.

It currently has two modes:

Project Scope: Compare a client's new request against the original project agreement and identify potentially out-of-scope work.
Customer Policy: Compare a customer's request against a business policy and flag potential conflicts.

For each request, Boundary provides a classification, relevant evidence from the supplied terms, uncertainties to consider, a suggested next step, and a professional reply ready for review.

The important part is that Boundary doesn't just say yes or no. It shows you why a request may be problematic and what information might be missing.

Who would pay for it? Freelancers, independent consultants, designers, agencies, and small online businesses that regularly handle client requests but don't have dedicated contract-management or customer-support teams.

The goal is simple: spend less time figuring out how to handle awkward customer conversations and more time doing the work that matters.

Demo

The input prompts and output answer photos of both the "Project Scope" and "Customer Policy" modes are attached below.

Project Scope

Customer Policy

Code

GitHub repository:

theikosB / boundary-ai

An open-weight AI assistant that helps freelancers and small businesses handle customer requests against their agreements and policies. For submission to Hacktoberfest 2026 Week 2 Challenge: Side Hustle

Boundary

Know where the agreement ends. Respond with confidence.

Boundary is an AI-powered assistant for freelancers and small businesses that helps them evaluate customer requests against their existing project agreements and business policies.

Whether a client requests additional work beyond a project's agreed scope or a customer asks for a refund that conflicts with a business's policy, Boundary helps identify relevant terms, highlight uncertainties, suggest a next step, and draft a professional response.

Instead of making decisions on your behalf, Boundary gives you the context to make better-informed decisions.

The Problem

Freelancers and small businesses regularly face situations where a customer request conflicts with an agreement, a policy, or an expectation that was never clearly established.

Handling these situations can be difficult:

Is a client's new request included in the original project scope?
Does a refund request meet the business's stated conditions?
Which clauses are relevant to the situation?
How…

View on GitHub

The project is built with Python, Flask, HTML, CSS, and JavaScript, with Gemma powering the core analysis.

The repository includes the application, prompt construction, hosted model integration, frontend, configuration example, and setup instructions.

How I Built It

I built Boundary using Gemma, an open-weight language model, through Google's hosted inference API. The application uses Python and Flask for the backend, with HTML, CSS, and JavaScript for the interface.

How it works

User enters agreement + customer request
                  |
                  v
          Flask Backend
          (app.py)
                  |
                  v
           Prompt Builder
       (prompts/boundary.py)
                  |
                  v
          Hosted Gemma Model
        (services/gemma.py)
                  |
                  v
          Structured JSON
                  |
                  v
 Classification | Evidence | Uncertainties
         Next Step | Draft Reply
                  |
                  v
             Human Review

The application has two modes: Project Scope, which compares client requests against project agreements, and Customer Policy, which evaluates requests against business policies.

I designed the prompts to ground the analysis in the user's supplied terms, avoid inventing clauses or obligations, and explicitly identify missing information. Gemma returns structured JSON containing a classification, supporting evidence, uncertainties, a suggested next step, and a draft response. Flask validates this output before the frontend presents it to the user.

I chose hosted inference rather than running the model locally, keeping development lightweight on my laptop without requiring a local GPU or a large model download. This let me focus on building the application around Gemma and turning its capabilities into a practical tool.

The result is a working prototype in which the model does more than draft text: it helps connect a recommendation to the evidence behind it, while leaving the final decision to the human user.

My First User

My first user was me!

I tested Boundary against two realistic scenarios: a client requesting extra deliverables and revision rounds beyond a logo package, and a customer requesting a refund that conflicted with a digital-product policy.

Boundary correctly identified the relevant terms, highlighted the potential scope or policy conflict, and drafted a professional response in both cases.

These initial tests helped me validate the core workflow before putting it in front of other users. My next goal is to get feedback from freelancers and small-business owners who regularly handle these situations.

What I Learned

Building Boundary reinforced something I find important about AI applications: generating a convincing answer isn't enough.

A useful system should also explain what supports its conclusion, acknowledge what it doesn't know, and avoid presenting an inference as an established fact.

That distinction is particularly important when a tool helps people make decisions involving money, customer relationships, and contractual expectations.

Boundary is an initial step toward that goal, and there's plenty more to improve as I test it with a wider range of real-world scenarios.

Prize Categories

Best Use of Gemma — Boundary uses Gemma as the core reasoning engine for comparing customer requests against supplied agreements and policies, extracting relevant evidence, identifying uncertainty, and drafting actionable responses.

NPC: Nature's Personal Companion - Loading Reality...

Daibik Barik — Wed, 07 Oct 2026 16:30:42 +0000

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

What I Built

NPC — Nature's Personal Companion 🌿 is a small AI-powered field game designed to get people off their screens and into the real world.

Most AI tools give you another reason to stay on your screen. NPC does the opposite.

You tell it:

📍 Where you are
⏱️ How much time you have
🧠 Your current mood
👥 Who you're with

Gemma then turns that information into a Field Assignment: a temporary persona, a mission, several objectives, a special rule, and a completion condition.

You might become a Wildlife Detective, Urban Explorer, Sound Collector, or Tiny Things Investigator.

The idea is simple: the AI gives you the quest, and then you put the screen away.

NPC is designed for anyone who feels bored, stressed, stuck in a routine, or simply needs an excuse to pay more attention to the world around them.

Demo

You tell NPC:

Where: University campus
Time: 20 minutes
Mood: Bored
Company: A friend

NPC might respond:

🪪 FIELD ASSIGNMENT

Persona: Campus Cartographer

Mission: Your campus has more landmarks than you think. Explore the area around you and build a mental map using only things you notice along the way.

Objectives:

Find three things that could serve as landmarks.

Notice something you have walked past before but never really looked at.

Find two different sounds coming from different directions.

Compare one part of the campus with another.

🚫 Field Rule: No photographs. Your memory is the map.

✅ Mission Complete When: You and your companion can describe your route and three things you noticed that you probably wouldn't have noticed otherwise.

Your phone has done its job.

Now go.

Code

The complete source code is available on the GitHub Repository:

theikosB / nature-personal-companion

An open-source AI field companion that turns ordinary places into small adventures. For submission to Hacktoberfest 2026 Week 1 Challenge: Touch Grass

NPC 🌿

Nature's Personal Companion

Most AI wants you to stay on your screen. This one wants you to leave it.

NPC (Nature's Personal Companion) is a tiny AI-powered field game that turns an ordinary place into a small adventure.

Tell NPC where you are, how much time you have, your mood, and who you're with. It gives you a field persona, a mission, and a set of objectives designed to make you notice and interact with the world around you.

Then you put your phone away and go complete the quest.

Because sometimes you need an NPC to tell you to touch grass. 🌱

🎮 What does NPC do?

NPC generates a personalized real-world Field Assignment based on your situation.

You choose:

📍 Where you are — park, campus, city, neighbourhood, waterfront, etc.
⏱️ How much time you have — from 5 to 60 minutes
🧠 Your…

View on GitHub

The project is intentionally lightweight:

Python + Flask backend
Vanilla HTML, CSS and JavaScript frontend
Gemma for AI generation
No database
No accounts
No GPS tracking

How I Built It

The core of NPC is Gemma, an open-weight AI model accessed through the Google GenAI API.

The basic flow is:

Choose your surroundings
        ↓
Choose your time + mood + company
        ↓
       Gemma
        ↓
   Field Assignment
        ↓
     Go outside 🌿

Gemma isn't just being used as a chatbot or as an optional feature. It is responsible for generating the actual game experience.

The Flask backend takes the user's four inputs and constructs a structured prompt containing the user's situation and safety constraints. Gemma generates a structured JSON response containing:

Persona
Mission
Objectives
Special Rule
Completion Condition

The frontend then turns that response into an interactive Field Assignment card.

The application is deliberately small so that the AI remains the interesting part of the project rather than hiding behind a large technical stack.

Why Does Open Innovation Matter?

NPC is built around a simple idea: AI can be useful even when its goal is to make you stop using AI.

Open models make experimentation with ideas like this much more accessible. Instead of building a product around a black-box conversational interface, developers can experiment with how an AI model behaves when it is given a very specific role and responsibility.

For NPC, that means treating the model as a game designer and field-assignment generator, rather than simply asking it to have a conversation with the user.

Open innovation makes these kinds of small, unconventional experiments possible: developers can take an AI model and build something playful around it without needing to reproduce an entire AI platform.

Prize Categories

Best Use of Gemma

NPC uses Gemma as the core AI model responsible for generating personalized real-world field assignments.

What Now?: because every long email hides a to-do list

Daibik Barik — Fri, 02 Oct 2026 12:52:32 +0000

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

What I Built

I built What Now? 🤔, a small AI tool for the friend who gets a long email, announcement, or message and thinks:

"Okay... but what am I actually supposed to do?"

What Now? turns messy text into a clear overview of:

📝 Summary — What is this about?
✅ Action Items — What needs to be done?
📅 Deadlines — When does it need to be done?
👥 People / Organizations — Who is involved?
⚠️ Important Information — What shouldn't be missed?

The idea was to build something simple and genuinely useful: instead of reading through a wall of text trying to figure out what matters, you can paste it into What Now? and immediately see what needs your attention.

Demo

The app currently runs locally using Gradio.

Here is an example of What Now? turning a messy message into structured, actionable information:

Input:

Hi Ananya, please submit the revised assignment to Prof. Mehta by Monday. Make sure you attach the updated bibliography and send a confirmation to Prof. Mehta once you've submitted it. Also, please fill out the feedback form from the ISI Mathematics Department before Friday. If you have any questions, contact Rahul from the Academic Office.

Output:

📝 Summary: Ananya needs to submit a revised assignment and complete a feedback form.
✅ Action Items: Submit the assignment, attach the bibliography, send confirmation, and complete the feedback form.
📅 Deadlines: Monday and Friday.
👥 People / Organizations: Prof. Mehta, ISI Mathematics Department, Rahul, Academic Office.
⚠️ Important Information: The assignment needs the updated bibliography and a confirmation must be sent after submission.

Code

The complete source code is available on GitHub:

https://github.com/theikosB/what-now

The project is intentionally small and easy to run locally. The main application is built in Python using Gradio, with Gemma 4 handling the text analysis.

How I Built It

The project is built with Python, Gradio, and the Google GenAI Python SDK.

At the core of What Now? is Gemma 4 (gemma-4-26b-a4b-it), an open-weight model. I prompt the model to analyze the user's text and return a structured JSON response containing the summary, action items, deadlines, people or organizations, and important information.

The basic flow is:

Email / Notice / Message
          ↓
        Gradio
          ↓
       Gemma 4
          ↓
    Structured JSON
          ↓
  Clear actionable output

Why Does Open Innovation Matter?

Open innovation made it possible for me to build this project around an open-weight AI model rather than treating the AI as a completely closed black box.

Using Gemma 4 meant I could experiment with the model directly and build a small application around it without needing to develop an AI model myself.

For a weekend project like What Now?, having access to capable open models makes it much easier for individual developers to experiment, build useful tools, and learn by actually working with the technology.

Prize Categories

Best Use of Gemma

I used Gemma 4 (gemma-4-26b-a4b-it), an open-weight model, as the core AI model behind What Now?.

The model analyzes unstructured emails, notices, and messages and returns structured information that the application turns into summaries, action items, deadlines, people/organizations, and important information.

Credits

Thanks to the Gemma team for making Gemma available as an open-weight model.

AI tools assisted with the implementation and preparation of this write-up.