DEV Community: Nillohit Roy

Init.dev - Your AI-powered Career Assistant that enables you to prepare for jobs and interviews

Nillohit Roy — Sun, 18 Oct 2026 03:46:38 +0000

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

What I Built

I built init.dev, an offline-first, agentic career co-pilot designed to run locally on low-resource machines without a GPU.

Navigating a tech career can be overwhelming. Developers need to figure out what skills to learn, how to structure their studies, and whether their resumes will actually pass Applicant Tracking Systems (ATS). Existing tools are often fragmented, expensive, or require sending personal data (like resumes and study habits) to closed cloud models.

init.dev solves this by providing a unified, local tool that:

Parses your career intent and current skills.
Generates a structured, modular learning roadmap.
Scores your resume locally using the TabPFN-3.5 foundation model (with a local Gemma fallback) to predict ATS pass probability.
Acts as a persistent, chat assistant to help you study.
Conducts realistic, role-specific mock technical interviews right in the terminal.

Demo

Code

nillohitroy / init-dev-cli

How I Built It

init.dev is a terminal-first application built with Node.js, combined with a Next.js web interface for visualizing roadmaps and chatting with the agent.

The core of the project relies on open-weight models and agentic workflows:

Local Inference: I used Ollama running the gemma:2b model locally. Gemma handles natural language intent parsing, formats the learning roadmaps, conducts mock interviews, and acts as the conversational engine for the Next.js chat interface.
ATS Scoring: I integrated TabPFN-3.5 (via Prior Labs' API). TabPFN handles the structured tabular data extracted from resumes (years of experience, skill match, keywords). If TabPFN rejects the unstructured text, the system seamlessly falls back to gemma:2b to analyze the raw text.
Agentic Data Fetching: The system dynamically switches between a "Simple Search" (using free GitHub/OpenLibrary APIs) and a "Professional Search" (SerpApi) to scrape real-time market data and resources to inform the roadmap generation.

Why Does Open Innovation Matter?

Open innovation is the entire reason init.dev can exist as an accessible tool for students and developers worldwide.

Privacy & Cost: By running gemma:2b locally via Ollama, users don't have to pay for API credits to chat with their study buddy or parse their career goals. It also means they aren't forced to upload their personal resumes or learning histories to a closed-source cloud provider.
Resilience: The application was specifically designed to run on low-resource machines without a GPU. By utilizing small, open-weight models, init.dev democratizes access to AI-powered career coaching.
Flexibility: The open-source ecosystem allowed me to build a seamless fallback mechanism. If the TabPFN API is unavailable or the data doesn't fit its tabular expectations, the local Gemma model steps in to ensure the user still gets a valuable ATS evaluation.

Prize Categories

Best Use of Gemma: gemma:2b is the core intelligence engine for init.dev, running locally via Ollama to handle intent parsing, mock interviews, and the chat interface.
Best Use of TabPFN: Used TabPFN-3.5 as the primary engine to predict ATS pass probabilities based on tabular features extracted from user resumes.
Best Use of ElevenLabs: Used ElevenLabs to create the audio for the product demo which explains how the product works and how you can use it for your day-to-day tasks.

Treasure Hunt: A Game to Play with your Friends with Tech to ditch Tech

Nillohit Roy — Fri, 09 Oct 2026 17:53:41 +0000

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

When I was a child, I used to play various kind of outdoor games. Be it hide and seek, Baraf-Pani (Ice-water, A South Asian version of Freeze-tag game), Kumir Danga (Crocodile and Land) - a Bengali game (search it up! quite interesting) and the list will go on and on but you'll get tired counting it. However, as tech and AI emerged and with the pandaemic that had occurred, each of those games vanished into thin air.

So to recall those memories and maintain a good health, I created this game of Treasure Hunt which uses AI for both Pirates and Protectors, where the Protectors hide the treasure (anything considers as treasure) while the Pirates hunts them as well as the treasure.

What I Built

Open Treasure Hunt is a real-world, proximity-based multiplayer game that transforms outdoor parks and neighborhoods into a live game board.

The game splits players into two competing factions:

The Protectors: They are tasked with stealthily hiding the treasure with the help of AI for suggestions

The Pirates (Hunters): They are tasked with AI to find the protectors and they can also use AI (but it won't give them their coordinates, just suggestions)

The phone acts as a tactical support. Players keep their devices in their pockets while outside. As both teams move through the real world, the AI Game Master constantly monitors live GPS coordinates, detects movement patterns, and provides one-sentence tactical updates.

Also, once a player selects Protector or Pirate, their device locks to that role using localStorage to ensure game integrity during physical outdoor movement unless otherwise changed when game is over.

Demo

Frontend: On Render
My Demo Video: Go to YouTube

Code

To set up the code, let us first know the Prerequisites:

A computer with a decent gpu (because gemma 2 model will have to run locally, if you can use ollama. I have used huggingface because I don't have that kind of hardware)
Python 3.9+
Hugging Face Access
A free TabPFN License Token

Github Repo:

nillohitroy / open-treasure-hunt

To clone and install:

git clone https://github.com/nillohitroy/open-treasure-hunt.git
cd open-treasure-hunt

python -m venv venv
# On Windows:
venv\Scripts\activate
# On Mac/Linux:
source venv/bin/activate

pip install -r requirements.txt

Next, create environment variables .env:
HF_TOKEN=hf_your_hugging_face_token_here
Your TabPFN code will generate when you run it in VS Code (create an account and accept license).

To run the app: python app.py

To run it in your phone, after you have server is running:
Open up the terminal -> go to Ports -> Forward a Port -> Enter the port number (5000) -> it will generate an address -> Copy it in your phone and just accept when asking about devtunnels.

How I Built It

The game runs on a lightweight, modular open-source AI architecture built on a standard laptop with no dedicated GPU.

Instead of wasting our dev time on if/else blocks, we used TabPFN as a zero-shot foundational model. It evaluates whether a player is "wandering aimlessly" or "moving towards the treasure or the target" instantly on standard CPU threads without model training overhead.

The game state is synthesized into dynamic prompts for Google's Gemma 2 (2B) model.

Lastly, we are serving the game locally by running the flask app using: python app.py when you clone the repo and go to the root directory. After that we port forward (through VS code) to get a https url.

Why Does Open Innovation Matter?

Through this project, we have showcased three ways where Open Innovation over closed proprietary APIs.

GPS Data Privacy: We do not want the corporate companies to have our live location. For this very reason, the open innovation shines where we can enjoy to the fullest without worrying about data breach.
Real-time Economies: Live proximity games require background pings every 5–10 seconds. On closed, pay-per-token commercial APIs, a single 30-minute play session with several players would rack up substantial API costs. Another win for Open Innovation.
Hardware Accessibility: AI shouldn't require expensive hardware and GPUs to run the models for this simple game. We can just use open-weight models to run the game effectively.

Prize Categories

Best Use of Gemma
Best Use of TabPFN
Best Use of Render