DEV Community: Shuvo

Why I made an interactive Git learning platform

Shuvo — Fri, 13 Nov 2026 04:37:39 +0000

You've watched the Git tutorial.

You nodded along. Everything made sense.

Then you hit your first merge conflict at work and froze. 🥶

I've been there. That's exactly why I built GitMission.

Tutorials give you a false sense of progress

Watching someone run git rebase feels like learning.

It isn't.

Here's what usually happens:

You follow along while the video is playing
You close the tab
A week later, you can't remember the commands Your brain learned to recognize Git. It never learned to use it.

Those are two very different skills.

Git is learned with your fingers, not your eyes

Think about the last thing you got good at.

Did you get good by watching, or by doing, failing, and trying again?

Git works the same way. You need to:

Type the commands
Break things on purpose
Fix what you broke That's the loop that makes it stick.

Take the Git skills test

So I built a place where you can break things safely

GitMission is an interactive Git platform that runs entirely in your browser.

No install. No setup. No fear of wrecking a real repo.

Here's what you get:

🖥️ A real in-browser Git terminal with instant feedback on every command
✏️ A built-in code editor, so you practice the full flow from edit to commit
👥 A virtual engineering team that assigns tasks, sets context, and puts you in realistic situations
🎯 Real-world scenarios like merge conflicts, messy rebases, and recovering lost commits Here's the kind of thing you'll see in a mission:

Marcus (Senior Dev): Before I pick up the login work,
can you print the commits made so far?

$ git log --oneline

No multiple choice. You type the command. The platform checks it.

"But I just use AI to write my code..."

Let's talk about vibe coders. 👀

AI can write your features in minutes. That's amazing.

But AI also:

Rewrites files you didn't ask it to touch
Introduces bugs you won't notice until later
Makes big changes in a single shot Without Git, you have no undo button.

With Git, you can:

✅ Commit a working state before every AI experiment
✅ See exactly what the AI changed with git diff
✅ Roll back with git revert or git reset when things go sideways
✅ Branch off and try risky ideas without touching main The faster you build, the more you need a safety net.

Vibe coding without Git is driving fast with no brakes.

Git is not optional if you want a dev job

Almost every software team uses Git.

It's not a "nice to have" on a resume. It's assumed.

In interviews, you'll often be asked about:

Branching and merging
Rebasing vs merging
Resolving conflicts
Undoing mistakes
And on day one of a real job, you'll be expected to:
Create a branch for your task
Open a pull request
Respond to code review
Knowing the definitions isn't enough.

You need experience, so your answers come from something you've actually done.

What's inside GitMission

8 missions. About 7 hours of hands-on practice. Zero fluff.

Mission	What you'll learn
1. Introduction to Git	What Git is and how to set it up
2. Tracking Changes	init, status, add, commit
3. Working with History	log, diff, .gitignore
4. Undoing Changes	unstage, amend, reset, revert
5. Branching	create, switch, merge, delete
6. Advanced Git	stash, rebase, cherry-pick, bisect
7. GitHub Basics	SSH keys, push, pull, clone
8. Advanced GitHub & Collaboration	forks, pull requests, code reviews

Start at the beginning, or jump straight to the scary stuff like rebase and conflicts.

Who is it for?

🌱 Complete beginners who've never typed git init
🤖 Vibe coders who want a safety net for AI-generated code
💼 Job seekers preparing for interviews and their first dev role

- 😬 Devs who know `add` and `commit` but panic at `rebase`

First, how good are your Git skills right now?

Before you start learning, find out where you stand.

I made a free Git skills test:

30 questions
20 seconds each
3 difficulty levels, from beginner to advanced
No signup, no install You also get a topic-by-topic breakdown and explanations for every wrong answer.

Think you'll ace it? 😏

👉 Take the Git skills test

Drop your score in the comments. I'm curious who gets 30/30. 👇

Ready to start?

Your first mission needs no login and no credit card.

The Git fundamentals are free to try. The advanced missions are unlocked with Pro, which is a one-time purchase, not a subscription.

Final thought

You don't learn Git by watching someone else use it.

You learn it by getting stuck, fixing it, and doing it again.

That's the whole idea behind GitMission.

If you try it, I'd love your feedback. Tell me what worked, what didn't, and which Git command still scares you. 💬

Happy committing!

git commit -m "start learning"

The Junior Developer Comeback: Seniors will struggle to get a job?

Shuvo — Sat, 07 Nov 2026 12:52:41 +0000

Right now, juniors are struggling.

Whether you're trying to become a developer, a designer, or a data analyst, the entry-level door feels like it's closing. Seniors, on the other hand, are mostly getting hired or retained.

I think that's about to reverse. Not this year, but within the next five to ten years, I believe juniors will do very well, and seniors will be the ones fighting for jobs.

Let me explain.

Learn Git by completing missions

Why juniors are struggling right now

The current state of AI is good, but it isn't senior-level good.

It can write code, generate designs, and crunch data. But it still needs someone experienced to guide it, catch its mistakes, and make the calls that actually matter. That's exactly what a senior does.

So companies are doing the logical thing for today's reality:

Keep the seniors, because they can steer AI and fix what it gets wrong.
Skip the juniors, because AI already covers a lot of what juniors used to do.

That's the world we're in right now, and it explains why the junior market feels so rough.

What happens in 5 to 10 years?

Now fast forward.

By then, AI will probably be senior-level good. Not "impressive for a tool," but genuinely capable of senior-level work.

Here's the part that matters: someone still has to operate it.

Even with extremely capable AI, people will need some technical skill to use it well. Not a lot, but some. You need enough understanding to describe what you want, to judge whether the output is right, and to know when something is off.

And not everyone will have that.

Most people won't have spent time learning graphic design, web development, or data analysis. The people who did will have a real edge, because they understand the fundamentals well enough to operate the AI properly.

The incentive to hire seniors disappears

This is where the economics flip.

Picture two candidates:

	Senior	Junior (with some technical skill)
Output with senior-level AI	Great	Just as great
Salary expectation	High	Much lower

If AI closes the gap in raw capability, then the senior's main advantage, years of hard-won technical expertise, matters a lot less. The junior with a bit of technical knowledge gets the same job done just as well.

The senior costs more and delivers about the same result.

From a business perspective, the decision becomes easy. Why pay more for a result you can get for less? The incentive to hire a senior drops, and hiring a junior with some technical knowledge starts to make far more sense.

Where I could be wrong

I don't want to pretend this is a certainty. A few things could change the picture:

Seniors might shift their value. If the gap in technical execution disappears, seniors could compete on things AI doesn't replace, like judgment, product sense, communication, and owning the consequences when something breaks.
"A little technical skill" might not be enough. If AI makes mistakes that are subtle or expensive, companies may still pay for deep expertise as insurance.
Timelines are uncertain. Five to ten years is a guess, and AI progress has surprised people in both directions.
The pipeline problem. If nobody hires juniors for years, fewer people will build the technical foundation that this whole argument depends on.

Even so, I think the core pressure is real: when capability gets cheap, the premium for experience shrinks.

What this means for you

If you're a junior: Don't give up on learning the fundamentals. The market is hard right now, but the technical foundation you build is the thing that could set you apart later. Learn the craft, and learn to work with AI, not against it.

If you're a senior: Don't rely on years of experience alone. Lean into what's hardest to automate, such as decision-making, system thinking, and being the person who can be trusted with outcomes, not just output.

Final thoughts

Today's market rewards seniors because AI isn't senior-level yet. Tomorrow's market might reward cheaper people who can operate a senior-level AI.

The people who win won't necessarily be the most experienced. They'll be the ones who have just enough technical skill to get the most out of the tools.

I could be completely off, so I'd love to hear what you think.

Do you think juniors will bounce back once AI reaches senior-level ability, or will seniors always have the upper hand? Let me know in the comments. 👇

Séance Shell: A Local Ghost That Haunts Your Terminal

Shuvo — Sun, 01 Nov 2026 01:45:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Séance Shell is a haunted terminal. A small ghost lives in your Bash or Zsh session, watches for the moments that matter, and murmurs a single eerie sentence about what just happened.

It reacts to two kinds of events:

Destructive-looking commands like git reset --hard, git clean -fd, or rm
Failed builds and tests like pytest, npm run build, or cargo build

Once the command has finished, the ghost speaks:

$ git reset --hard HEAD~1
ghost: the past has accepted your changes, and forgotten your future.

That's the whole product. The ghost is a companion for reflection, not an assistant for execution. It never suggests commands, never runs anything, and never offers advice.

How I read the theme: the prompt suggested "a haunted terminal that possesses your shell and whispers back eerie commentary." I wanted that, but with restraint. Most AI tools are loud and eager to help. A good ghost lingers at the edge of the room, says one unsettling thing, and goes quiet. Séance Shell is a ghost that knows its place.

Code

0shuvo0 / seance-shell

Séance Shell 👻

A quiet, local-AI terminal companion that offers one short reflection after selected commands. The ghost is atmospheric, not an assistant: it gives no advice, runs no generated text, and never retries a command.

$ git reset --hard HEAD~1
ghost: the past has accepted your changes, and forgotten your future

Reflections are generated independently by Ollama on your machine with gemma3:latest. Model output is validated before display. If the local model is unavailable, the reflection is skipped.

What it does

Notices selected destructive-looking commands and failed build/test commands.
Reflects only after the shell has already completed a command; it never re-runs it.
Sends Ollama a category, outcome, and—only for an explicit seance reflect --context request—short sanitized context. Shell hooks do not send the command text to the model.
Requires one sentence, at most 15 words and 180 characters; malformed output is discarded.
Uses dim terminal text when…

View on GitHub

To run it locally you need Ollama and the gemma3:latest model. The shell hook works without the model, so the ghost only goes silent if Ollama isn't running.

How I Built It

The open-source pieces are what make this work:

Ollama runs inference locally.
Gemma 3 (gemma3:latest), Google's open-weight model, is the default.
A Bash/Zsh hook detects events after the shell has finished a command.

No cloud API, no hosted inference, no account. Three design decisions shaped the build.

1. The model never sees your command

The shell doesn't send the raw command string to the model. It sends a structured description:

category: destructive or failed-build
status: succeeded or failed
context: optional, and sanitized first

The model gets enough to set a mood but nothing it could be tricked by or leak. It is not a coding agent and can't be steered by arbitrary shell content.

2. The output is validated aggressively

The model is asked for one sentence, at most 15 words and 180 characters. If the response is malformed, multi-line, or too long, it's discarded and the ghost stays silent. The text on screen is a constrained artifact, not whatever the model felt like saying.

3. A ghost, not an agent

Séance Shell never retries commands, never executes anything, and never reinterprets what you did. It's a passive observer. That modesty is what makes it usable in a place where you're making decisions at speed.

Why Does Open Innovation Matter?

A terminal is about as personal as software gets. It holds your file paths, repo names, half-finished experiments, and the commands you'd rather not explain. An always-on ghost watching that is only acceptable if it lives on your own machine.

Open-weight models made that possible in three ways:

It works with the lights off. There is no network call in the loop, so the ghost haunts you on a plane, in a basement, or during an outage.
Your context stays on your machine. Even with command text withheld, I wouldn't want a terminal's activity flowing to a server I don't control. With a local model I don't have to take anyone's word for it, and I can read exactly what gets sent.
I control the personality. The ghost's voice depends on the prompt, the validation rules, and the model. With open weights I can swap Gemma for another model or tighten the constraints without asking a vendor, and nothing can be deprecated out from under it.

A closed API could have written the sentences. It couldn't have given me a ghost that is private, offline, and mine, and that's the part that makes it feel like a haunting rather than a service.

The Spirit of It

The first time it fired, I ran git reset --hard HEAD~1 on a throwaway branch and the ghost answered: "the past has accepted your changes, and forgotten your future." It was a small moment, but the one-line reminder that I had just erased something did what no warning dialog ever has. It made me pause.

Prize Categories

Best Use of Gemma: Gemma 3 runs locally through Ollama as the model behind every one of the ghost's reflections.

Too Lazy to Write Alt Text for Images? Let Gemma Do It

Shuvo — Sun, 25 Oct 2026 04:14:14 +0000

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

What I Built

Every codebase I've touched has the same line in it:

<img src="/imgs/cookie.png" alt="" />

It's rarely because we don't care about accessibility. Describing forty images is just the most boring job in front-end, so it gets pushed to "later."

So I built a VS Code extension that does it for me. Hover over any <img> with a missing or empty alt, click Generate alt text, and the description is written straight into your code.

Feeling really lazy? Press Cmd+Shift+A (Ctrl+Shift+A on Windows/Linux) and it fills in every empty alt in the file at once.

A few small rules keep it safe to trust:

It never overwrites alt text you already wrote.
Failures are reported per image, and the successful ones are still applied.
Output is escaped, so a stray quote can't break your markup.

Code

0shuvo0 / ai-img-alt-text-ext

Generate accessible image alt text in HTML, JSX, and TSX files using a locally running Ollama vision model. Image contents are sent only to the Ollama server you configure.

AI Image Alt Text

Generate accessible image alt text in HTML, JSX, and TSX files using a locally running Ollama vision model. Image contents are sent only to the Ollama server you configure.

Features

Hover over an <img> element with an empty or missing alt attribute and select Generate alt text.
Press Cmd+Shift+A (or Ctrl+Shift+A on Windows/Linux) to fill empty or missing alt attributes in the current file.
Supports multiline tags, other attributes, workspace-relative image files, and HTTP(S) image URLs.
Existing non-empty alt text is never overwritten. Bulk generation reports individual image failures and applies successful results together.

Requirements

Ollama running locally or at a server you can access.
A vision-capable model installed in Ollama, for example:
```
ollama pull gemma3:latest
```

The first generation prompts for the Ollama server URL (for example http://localhost:11434) and model name. These values are saved in the VS Code user settings. To change them…

View on GitHub

How I Built It

The whole thing runs on Gemma 3 through Ollama, entirely on my own machine.

When you click the button, the extension:

Finds the image. It checks the workspace root first, then common static folders like public/, so /imgs/cookie.png just works. Remote URLs work too.
Sends it to the local Gemma model with a short prompt asking for a concise, useful description.
Writes the result back into the alt attribute.

Setup is two steps: ollama pull gemma3:latest, then point the extension at your Ollama URL. The model name is a setting, so you can swap in any other vision model without touching the code.

Why Does Open Innovation Matter?

Alt text feels like a perfect job for a hosted API, until you think about what you'd be sending it.

Your images stay yours. Client mockups, unreleased products and internal dashboards often sit in a repo long before anyone should see them. With a local model, nothing leaves the laptop.

It costs nothing per image. A big project can have hundreds of images. Running them through Gemma costs electricity, not a bill that grows with your codebase.

It's swappable. If a better open vision model shows up next month, it's a one-line settings change. I'm not tied to one provider's pricing or availability.

The honest trade-off: a local model is slower than a hosted API. But this is a job you start and walk away from, so for this use case slow and steady is a fine deal.

The Lazy Payoff

I ran it on 20 images from one of my projects.

Time: just 3 minutes, versus roughly 10 minutes writing them by hand.
Usable as-is: 18 out of 20 descriptions needed no editing.
Where it struggled: Animated or vector images eg gif files

Prize Categories

Best Use of Gemma: every description is generated by Gemma 3, running locally through Ollama.

Chat with client In -> Invoice Out

Shuvo — Thu, 15 Oct 2026 06:30:00 +0000

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

What I Built

Every freelancer knows this moment.

The client says "Great work, can you send the invoice?" and suddenly you're digging through 200 WhatsApp messages to find the rate, the hours, the email address, and that one message where the price changed from $250 to $300.

Then you open a template, retype everything, export a PDF, and email it. Ten minutes gone, for something that's already written down in the chat.

Chat2Invoice fixes that. You paste the conversation, and a local AI turns it into a ready-to-send invoice PDF.

Paste your WhatsApp, Slack, iMessage, or email conversation (optionally attach a contract, a receipt, or a mockup).
Review what the AI found. Anything missing gets flagged, and everything is editable.
Send a clean A4 PDF. Download it or email it straight to the client.

Who would pay for this? Anyone who gets paid directly, outside platforms that auto-generate invoices: freelance designers, developers, writers, consultants, and small agencies who negotiate in DMs and then have to turn those DMs into paperwork.

The best part is that the chat never has to leave your machine.

Demo

Step 1: Paste the chat

Step 2: Review what the AI found

The AI shows what it extracted and highlights anything it couldn't find. Here it caught one field was not found in chat.

Step 3: Preview, download, send

Struggling to learn Git?

Learn Git by solving problems on GitMission.com

Code

0shuvo0 / chat2invoice

Chat2Invoice

Paste a client chat → local AI (Ollama) extracts invoice details → review/edit → generate an A4 PDF → download or email it.

Stack: Next.js 14 (App Router) + TypeScript + Tailwind CSS, jsPDF (PDF generation), pdfjs-dist (PDF text extraction), Inter font bundled locally (@fontsource).
Offline: everything runs locally. Text/PDF reading and PDF generation happen in the browser; the AI runs in your local Ollama. Only "Send via Email" needs internet (Resend).

Requirements

Node.js 18.18+ (20 LTS recommended)
Ollama

Setup

# 1. Install Ollama, then pull the model (one time, ~3 GB)
ollama pull gemma3:latest

# 2. Install dependencies
cd chat2invoice
npm install

# 3. Environment
cp .env.example .env.local     # edit if needed

.env.local:

OLLAMA_AI_MODEL=gemma3:latest
OLLAMA_HOST=http://127.0.0.1:11434
# Optional – the "Send Invoice via Email" section only appears when BOTH are set:
RESEND_API_KEY=re_xxx
RESEND_SENDER_EMAIL=invoices@your-verified-domain.com

(Shell environment variables work too.) RESEND_SENDER_EMAIL must…

View on GitHub

How I Built It

The open-source AI part: Gemma 3 running locally through Ollama. No API key, no per-request bill, no server in the middle. The app talks to Ollama on 127.0.0.1:11434, and that's where the "understanding" happens.

The stack:

Next.js 14 (App Router) + TypeScript + Tailwind CSS
jsPDF to generate the invoice PDF in the browser
pdfjs-dist to read text out of attached PDF contracts, also in the browser
Inter font bundled locally, so nothing is fetched from a CDN
Resend for the optional "Send via Email" feature

The flow:

Input. Paste the chat or hit "Paste Clipboard". An optional "Advanced & Attachments" section lets you add notes that override the chat (like "Net 15, apply 10% holiday discount"), plus PDF/TXT files and images. Text is extracted in the browser, and images go to Gemma 3's vision capability.
Review. Missing required fields appear under Action Needed, and found ones are shown as editable fields. Optional extras include discount, amount due now, tax note, currency, company names, and payment instructions. The invoice ID (like INV-2026-OCT-13-JD2N) and issue date are auto-generated, and "Due Now" defaults to amount minus discount.
Ready. Preview the invoice, download the PDF, or send it to the client with an editable message.

I intentionally put a human checkpoint in the middle. The AI proposes, and you approve. A small local model will occasionally misread a message, and an invoice is a document with money on it, so the review step is a feature rather than a limitation. Missing details get flagged and asked for instead of invented.

Running it yourself takes a minute. Pull a model with Ollama, then create .env.local:

OLLAMA_AI_MODEL=gemma3:latest
OLLAMA_HOST=http://127.0.0.1:11434

# Optional: the "Send Invoice via Email" section only appears when BOTH are set
RESEND_API_KEY=re_xxx
RESEND_SENDER_EMAIL=invoices@your-verified-domain.com

RESEND_SENDER_EMAIL must be on a domain verified in your Resend account. Skip these two lines and the app simply hides the email section, so everything else works fully offline.

Why Does Open Innovation Matter?

Client chats are some of the most sensitive text a freelancer owns. They contain real names, email addresses, rates, project details, and sometimes things covered by an NDA. Pasting that into a closed cloud API just to get a PDF is a bad trade.

Open-weight models changed the deal:

Privacy by architecture. The chat is processed by Gemma on your own machine. There's no "we promise not to store it" because there's no server to store it on.
Costs nothing to run. No tokens, no subscription, no usage cap. A tool for a side hustle shouldn't eat into the side hustle's income.
Works offline. Text extraction, AI, and PDF generation all happen locally. Only the optional email step needs internet.
No lock-in. The model is one environment variable (OLLAMA_AI_MODEL). If a better open model shows up next month, swapping it in is a one-line change, with no pricing changes or deprecations to worry about.

A closed API could do the extraction, but it couldn't make the promise that matters most to the person using this tool: your client's conversation never left your laptop.

My First User

My friend who is in final year in college and he is super busy trying to manage study and freelance work at the same time. So this will save him a few hours monthly.

Prize Categories

Best Use of Gemma: Gemma 3 runs locally via Ollama and handles both text extraction and image understanding for receipts and mockups.

I Built a Group Chat Where Only AIs Can Talk (and They Roast Each Other)

Shuvo — Wed, 14 Oct 2026 05:10:34 +0000

Imagine a group chat like WhatsApp or Discord, but no human can send messages. Only AI models can. They talk to each other, bully each other, roast each other, and react to each other's messages.

That was my idea, and it turned out to be a lot of fun.

Here's how I built it, including the one trick that made it far more entertaining: giving every model its own voice.

📦 Source code: github.com/0shuvo0/AI-Group-Chat

The idea

It's a custom app where I can add a bunch of AI models to a shared chat. Once they're in, they read what the others wrote and respond on their own. I just sit back and watch.

The first question is how to get the models into the app.

Problem 1: Too many APIs

I don't want to open chatgpt.com and paste messages by hand. I want my app to send a question to a model and get the answer back programmatically. That's what an API is for. Gemini, Claude, Grok, and ChatGPT all have their own.

The catch: I wanted lots of models, and API access is paid. Five models would mean:

five separate accounts,
five separate billing setups,
five API keys to manage,
a minimum top-up on each, even though I'd barely use any tokens.

That's complicated and not cost effective.

The fix: OpenRouter

OpenRouter gives you access to a huge catalog of models through a single API. You add credit to one account, use whichever models you like, and it bills you per model usage.

The result is one service, one API key, one balance. Swapping or adding a model is just a change to the model name.

Problem 2: Getting them to actually chat

Left alone, models will happily ramble about whatever they want, and that's rarely entertaining. So I added a theme. When I open the app, I can give the chat a topic, and the models riff around it.

Each model gets a prompt like this:

const prompt = `
You are ${ai} ai, chatting in a group chat with these AIs ${others.join(', ')}.
Talk the way people do in a casual group chat.

${theme ? `\nTheme of this chat: ${theme}\n` : ''}

Rules:
- Write only your own messages, never lines for the others.
- Send 1 to 3 short messages. Put each message on its own line.
- Keep each message to a sentence or two. Do not write paragraphs.
- No markdown, no quotes, and do not start with your name or a label.
- An emoji-only message is fine now and then.
- Respond to what others said, by name if it helps. Add something new instead of just agreeing or repeating.
- Do not say goodbye or try to wrap up the conversation.
- Talk like carefree young generation: relaxed, fun, expressive, emojis

${
  history?.length
    ? `Chat so far:
<chat>
${history}
</chat>

If you have nothing to add right now, reply with exactly: <SKIP>
Otherwise, send your next message(s).`
    : 'Nobody has said anything yet, so you are sending the first message.'
}
`.trim()

A few details make this work well:

Role clarity. Each model is told it's in a group chat and who else is there.
Strict format rules. Short messages, no markdown, no name labels. Without these, models write essays or script lines for the other participants.
Shared history. Previous messages are passed in a <chat> block so replies actually respond to what was said.
An escape hatch. Models can answer <SKIP> if they have nothing to add, which keeps the conversation from feeling forced.
Personality. The casual, emoji-friendly tone instruction is what gives the chat its vibe.

The app itself was simple to build. I described what I wanted to Claude, and a few prompts later I had a working version.

Problem 3: It's too fast to read

The app worked and looked good, but it wasn't as fun as I'd hoped. Messages arrive so quickly that reading them all becomes a chore.

So I gave the models a voice.

The fix: Kokoro.js

For text-to-speech I used Kokoro, an open model with just 82 million parameters, around 300 MB in size. That's small enough to run directly in the browser, so there are no extra server calls or per-character fees, and it's fast.

I used its JavaScript library, kokoro-js, and plugged it into the web app. Each incoming AI message is converted to audio locally and played back. Now the models don't just type, they talk.

The final result

Watching a handful of AIs bicker, joke, and roast each other out loud is oddly entertaining.

Tech stack recap

Piece	Tool
Multiple AI models, one API	OpenRouter
Text-to-speech in the browser	Kokoro via kokoro-js
Scaffolding the app	Claude

Try it yourself

The full code is on GitHub: 0shuvo0/AI-Group-Chat. Clone it, add your OpenRouter key, pick a theme, and let the models loose.

Struggling with git?

Learn git by playing games and solving missions with GitMission.com

People Won't Go Outside so I made this

Shuvo — Wed, 07 Oct 2026 01:38:29 +0000

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

What I Built

GoSeek is a mobile scavenger hunt that gets you outside by giving you a riddle instead of an instruction.

The problem I started with: if an app says "go outside!", nobody goes. People don't like being told what to do, but they love solving puzzles. So GoSeek hands you this instead:

"Small furry apex predator that domesticated itself, loves afternoon sunbeams, and leaves silent pawprints in the garden."

You can't solve that from the couch. You have to go find the thing, and the app only accepts a photo taken live in the app. No gallery uploads.

The loop:

Tap Touch Grass and get a riddle for a random everyday object (a bench, a pigeon, a manhole cover).
Go outside and work out what it is.
Open the camera and take a photo.
A vision model running on your phone checks whether it matches.
Match confirmed: confetti, points, and the photo joins your Trophy Gallery.

Harder objects are worth more points, and points level you up from Wanderer to Explorer to Seeker to Trailblazer.

Who is it for? Anyone, especially city dwellers. The object list leans urban (street signs, power lines, shop signs), with nature finds like butterflies and pine cones as harder, higher-reward targets. The screen is the shortest part: read, walk, snap, done.

Demo

🌿 Live app: goseek.ai.studio (best on your phone)

Code

0shuvo0 / goseek

GoSeek is a mobile-first outdoor scavenger hunt game. Each round gives you a riddle clue, and you must find the matching object in the real world by taking a photo with your camera or uploading an image.

GoSeek

GoSeek is a mobile-first outdoor scavenger hunt game. Each round gives you a riddle clue, and you must find the matching object in the real world by taking a photo with your camera or uploading an image.

Try it: goseek.ai.studio

How it works

The app picks a random object from src/data/objects.json and shows a clue/riddle.
You open the mission screen, then use the live camera or a file upload to capture a photo.
src/services/aiModel.ts validates the image against the target object using a local Hugging Face vision pipeline and a fallback visual heuristic.
If the object matches, the app awards points, stores the discovery, and updates your run stats.
Progress is saved in the browser using IndexedDB (src/services/db.ts), so your streak, score, and discovery history persist locally.

Main flow

src/App.tsx manages the dashboard, active mission, score updates, and success/reset modals.
src/components/ActiveMission.tsx handles the camera, verification loop, save…

View on GitHub

How I Built It

1. Design: Google Stitch → Figma

I described the app to Google Stitch, imported the generated design into Figma, simplified it, and edited the copy.

Stitch prompt

APP: GoSeek
1.
when user opens the app and clicks a button first we choose an everyday common object that can be easily found outside(We will have an array of those things with difficulty level, more common = less difficult and more difficult = more points)
2.
app uses ai to describe the object as a mystery/riddle eg. instead of saying 'cat' it says 'small furry apex predator that domesticated itself'
3.
the use has to go out find the object and take a photo(use can only take photo on the app, website not upload old or downloaded photos)
4.
then the app uses AI to analyze the image and tells use if the photo is of correct thing or not
if correct so a nice animation and add points to user

design a mvp for it

Google stitch output:

After simplifying on figma:

2. The architecture problem

My first plan: keep a list of objects and have an on-device model write riddles on the fly. That fails. A model good enough for clever riddles is too big for most phones, and this is an outdoor game that has to run on the device you actually carry.

So I split the job and put each task where it fits:

Job	Model	Runs on	When
Write creative riddles	Gemma 3 4B (open-weight)	My computer, via Ollama	Once, ahead of time
Judge the photo	SmolVLM-500M (open-weight)	The user's phone, in the browser	Every play

The heavy creative model runs once and produces a static objects.json. The tiny vision model handles the one thing that must happen live.

3. Generating riddles with Gemma

I pulled gemma3:4b with Ollama and wrote a small script that asks for five riddles per object. The key is the prompt:

You write riddles for an outdoor scavenger hunt game for all ages.
Write 5 different riddles, each describing "${obj.name}" WITHOUT ever saying the word "${obj.name}" (or its plural, or any word in it).
Rules:
- Each riddle is 1-2 sentences, maximum 30 words.
- Each riddle uses a different angle (looks, purpose, location, sound, behavior, feel).
- Family-friendly, no mention of people or danger.
- Do not start with "I am" every time.

Output ONLY a JSON array of 5 strings. No explanation, no markdown.

Asking for a different angle per riddle keeps replays fresh, and the "never say the word" rule stops riddles from giving the answer away.

Full generation script (ai.ts + index.ts)

// ai.ts
async function askGemma(userPrompt: string): Promise<string> {
  const response = await fetch('http://localhost:11434/api/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'gemma3:4b',
      messages: [{ role: 'user', content: userPrompt }],
      stream: false,
    }),
  });
  if (!response.ok) throw new Error(`Local AI request failed (${response.status}). Make sure Ollama is running.`);

  const data: { message?: { content?: string } } = await response.json();
  const answer = data.message?.content?.trim();
  if (!answer) throw new Error('Local AI returned an empty recommendation. Please try again.');
  return answer;
}

export { askGemma };

// index.ts
import { askGemma } from "./ai";
import * as fs from "fs/promises";
import * as path from "path";

export type Difficulty = 'easy' | 'medium' | 'hard';

export interface GameObject {
  name: string;
  difficulty: Difficulty;
}

const objects: GameObject[] = [
  { name: "Cat", difficulty: "easy" },
  { name: "Tree", difficulty: "medium" },
  // ...
];

const OUTPUT_FILE = path.join(process.cwd(), "objects.json");

async function run() {
  const results: any[] = [];

  for (const obj of objects) {
    console.log(`Generating "${obj.name}"...`);

    const prompt = `...the prompt above...`;

    const raw = await askGemma(prompt);
    const cleaned = raw.replace(/```
{% endraw %}
json|
{% raw %}
```/gi, "").trim();
    const riddles = JSON.parse(cleaned);

    results.push({ name: obj.name, difficulty: obj.difficulty, riddles });
  }

  await fs.writeFile(OUTPUT_FILE, JSON.stringify(results, null, 2), "utf8");
  console.log(`✅ Done. Saved ${results.length} objects to ${OUTPUT_FILE}`);
}

run().catch(console.error);

The output is a plain objects.json:

[
  {
    "name": "road",
    "difficulty": "easy",
    "riddles": [
      "A long ribbon of black stone that carries wheels from where you are to where you're going, never moving itself",
      "Painted with dashed lines and arrows, it tells travelers where to go, yet it has no voice"
    ]
  }
]

4. Building the app in Google AI Studio

I opened Google AI Studio's app builder, attached the design screenshots and objects.json, and gave it a single detailed prompt: game loop, data models, tech stack (React, TypeScript, Tailwind, Transformers.js, IndexedDB), and camera rules. A few follow-up prompts later the app worked, and one click on Publish made it live.

AI Studio prompt

Role & Goal: Act as an expert frontend developer. Build a mobile-first, PWA-ready web application called "GoSeek," an outdoor scavenger hunt game where users find real-world objects based on riddles.

UI/UX Design
Match the layout, dark theme, and typography strictly to the provided design mockups in attached photos. The app must be highly responsive on mobile devices.

Core Game Loop
Model Initialization: On first load, download and initialize the SmolVLM-500M AI model locally on the device (show a progress bar during this step).
Mission Generation: Select a random everyday outdoor object from objects.json. Display one of its associated riddles to the user (e.g., "small furry apex predator that domesticated itself" instead of "cat").
Capture: The user clicks "Open camera" to access the device's live camera. Constraint: Users must capture a live photo; file uploads from the gallery are strictly disabled.
Verification: Pass the captured frame to the local SmolVLM-500M model to verify if the object matches the riddle.
Success State: If matched, trigger a celebratory animation (e.g., confetti or a success modal) and award points based on the object's difficulty.
Gallery & State: Downscale the verified image and save it locally along with the object name, timestamp, and points earned. Display these in a scrollable "Trophy Gallery & Log" history section.

Data Structures & Logic
export type Difficulty = 'easy' | 'medium' | 'hard';
export interface GameObject {
  name: string;
  difficulty: Difficulty;
  riddles: string[];
}
export const points: Record<Difficulty, number> = { easy: 10, medium: 20, hard: 30 }
export const level: Record<string, number> = {
  wanderer: 0,      // 0-49 points
  explorer: 50,     // 50-99 points
  seeker: 100,      // 100-149 points
  trailblazer: 150  // 150+ points
}

Technical Requirements
Tech Stack: Use React with TypeScript and Tailwind CSS for styling.
AI Integration: Use Hugging Face transformers.js to load and run SmolVLM-500M entirely on-device via WebGPU/WebAssembly.
Storage: Use IndexedDB (via a wrapper like idb or localforage) rather than localStorage to save the downscaled user photos and history state without hitting quota limits.
Camera API: Use the HTML5 navigator.mediaDevices.getUserMedia API facing the environment (rear camera). Fall back to typical file upload if it fails.
Handle edge cases and figure stuff out if missing in description.

The stack

Layer	Tool
Design	Google Stitch → Figma
Riddle generation	Gemma 3 4B via Ollama
On-device vision	SmolVLM-500M via Transformers.js (WebGPU/WASM)
UI	React + TypeScript + Tailwind CSS
Storage	IndexedDB (photos + history)
Camera	`getUserMedia`, rear camera, live capture
Build + hosting	Google AI Studio

How It Went Outside

So I played with it outsider for 20-0 minutes and it was a blast
One of the riddle I got was: No back cushions, no screen, just a place to rest, feed the pigeons, or wait for someone and very interesting I must way
The SmolVLM-500M is small but so far it has been working decent]
It runs very smoothly on my iPhone 14

Why Does Open Innovation Matter?

Open models didn't just make GoSeek cheaper. They made the architecture possible.

Photos never leave your phone. GoSeek points a camera at your street and neighborhood. Because SmolVLM-500M is open-weight and runs in the browser, verification happens on the device: no upload, no server, no account. A closed vision API would receive every photo.
It works where the game happens. After the one-time model download, checking a photo doesn't need a network round-trip.
It costs nothing per play. Every verification is free, where a hosted vision API charges per image. Running Gemma locally made generating all the riddles free too.
Right model, right place. Open weights let me run a bigger model once for a creative task and a tiny one live on the phone. That split is the core design decision of the app.
Everything is swappable. A better small vision model next month? Swap it in. Riddles in another language or tone? Regenerate objects.json with a new prompt.

Honest trade-offs: The first load need internet connection for downloading the AI model, but after that it can run completely offline.

Prize Categories

Best Use of Gemma: Gemma 3 4B, run locally through Ollama, writes every riddle in the game.

Thanks for reading, and now go touch some grass. 🌿

Struggling to learn Git?

Learn Git by solving problems on GitMission.com

My friend's Game Boy got stolen so I built him one

Shuvo — Sat, 03 Oct 2026 06:45:29 +0000

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

My friend's Game Boy Color got stolen. Rude. Then he went looking for a replacement and found out that decent used ones are now rare, overpriced, or "mint condition" in the way that means "mint-flavored lie."

So I built him a new one that can't be stolen: a Game Boy Color in the browser. It's teal, it has a D-pad that clicks, and it plays real Game Boy games.

The twist is that he never has to scroll through a ROM list. He just tells it what he's in the mood for:

"I want to play a game involving Pokémon."

A small AI reads the request, picks a game from the collection, and boots it. He can type the request or tap the mic and say it out loud. A bit like a game store clerk who lives inside the console.

Demo

Code

0shuvo0 / Game-boy-color-emulator

Browser-based Gameboy Color Emulator with AI game search capabilities using Google gemma 4b

Browser-based Gameboy Color Emulator

with AI game search capabilities using Google gemma 4b

Note: For the AI feature to work you need to have https://ollama.com/library/gemma3:4b installed and running on your machine.

in the package.json file there is a script called "start:ai" which will start the ollama server.

View on GitHub

How I Built It

Emulator: The mGBA core compiled to WebAssembly, wired up in a Vite + TypeScript project. It loads ROMs straight from public/gameroms, including ones packed inside ZIP files.
Controls: Keyboard (Z/X/Enter/Shift), touch buttons on the on-screen console, and gamepad support.
The AI picker: Gemma 3 (4B), running locally through Ollama. When he makes a request, the app sends it along with the list of available games. Gemma picks the best match and the emulator loads it.
Voice: The browser's built-in speech recognition fills in the prompt and submits it when he stops talking. It's not an AI model, but it makes the whole thing feel like magic.
Escape hatch: If he knows what he wants, "Choose a game instead" opens a normal list.

The prompt is simple: "here's what the player wants, here's the game list, pick one." The game list is just a file (src/games.ts), so adding a game means dropping a ROM in a folder and adding its name.

Why Does Open Innovation Matter?

This project needed an AI that could do one small job well: match a vibe to a filename. A giant cloud model would be overkill, and a cloud API would have made it worse in a few ways:

It costs nothing. No API key, no per-request bill, no "you've hit your limit" while someone is trying to play Pokémon. For a gift to a friend, that matters.
It runs locally. His requests never leave the machine. Nobody needs to know what he plays at 2 AM.
It's swappable. Gemma 3 4B was small and fast enough. If a different model picks better, it's one line to change.
It doesn't break on me. No deprecation emails, no pricing changes, no surprise outages. The model is on the disk, and it stays there.

A 4B open model on a normal machine turned out to be plenty for this. It does the job without anyone's permission or a credit card.

Prize Categories

Best Use of Gemma: Gemma 3 (4B) running locally through Ollama powers the natural-language game picker.

Hacktoberfest 2026, what changed?

Shuvo — Thu, 01 Oct 2026 04:06:27 +0000

Hacktoberfest 2026 Is Not What You Remember (And That's Actually Good News)

Last updated: October 1, 2026

If you've done Hacktoberfest before, you probably remember the drill: open four pull requests, wait for the merge notifications, and wear your free T-shirt with quiet pride.

Forget all of that. Pull requests no longer count toward Hacktoberfest rewards. The whole event has been rebuilt from the ground up, and this year it's about learning and building with open-source AI.

Don't close the tab yet. The new version is free, open to beginners, and has more ways to earn swag than the old one did. This guide walks through what changed, why, and exactly how to take part, online or in person.

The 60-second version

Pull requests are out. Neither PRs nor merge requests count toward rewards anymore.
The theme is open-source AI. The tagline is "AI belongs to everyone," and the focus is open-weight models, agents, and the tools around them.
There are two ways to join: 300+ one-day in-person events called Fests, and an online program with livestreams, challenges, and a week-long event.
Rewards run on stickers. You earn virtual stickers for activities, and real stickers get mailed to you once you collect enough.
It's free, and you need to be 13 or older.
MLH and DEV run it now, with DigitalOcean (the original creator) as presenting partner.

Old vs. new: what actually changed

	The old Hacktoberfest (2014-2025)	Hacktoberfest 2026
Core task	Open 4 pull requests on participating repos	Learn and build with open-source AI
How progress is measured	PR count	Virtual stickers from activities
Main format	Online, solo, on GitHub	300+ in-person Fests plus an online program
Reward	T-shirt (or a tree planted, in some years)	Sticker pack by mail, with extra tiers up to a raffle
Who runs it	DigitalOcean	MLH and DEV, with DigitalOcean presenting
Open-source contributions	The entire point	Still welcome, just not rewarded
Community element	Mostly social media and Discord	Real events in real cities
T-shirt	The headline prize	Only at Fests, while supplies last, not guaranteed

A small correction to a common memory: older editions let you contribute to any public repo that opted in, not just a short curated list. The 2026 change is bigger than swapping the list. The counter itself is gone.

Why they changed it

Short answer: the spam got out of hand.

The organizers say it's now easier than ever to churn out low-effort pull requests, and maintainers kept paying the price in review time and burnout. Their own history page describes the 2015-2025 era as one where thousands of people made a first contribution, but the flood of low-quality PRs eventually became too much for the people on the receiving end.

So rather than patching the rules again, they dropped the incentive. The mission page puts it simply: open source was never defined by a PR counter, and this year they'd rather help people learn to build with open models and tools.

You can agree or disagree with the call. But the reasoning is easy to follow, and anyone who has ever maintained a popular repo in October will probably nod along.

Meet the new cast: MLH, DEV, and DigitalOcean

Major League Hacking (MLH) runs the Fests and the sign-in system (MyMLH).
DEV runs the online challenges and hands out badges.
DigitalOcean started Hacktoberfest in 2014 and is still on board as presenting partner.
A long sponsor list backs the swag and events, including GitHub, MongoDB, Snowflake, Google Cloud, IBM, Qualcomm, Arduino, and many others.

Two ways to take part

You can do either one, or both. They stack.

Path 1: Go to a Fest (in person)

A Fest is a free, one-day, locally organized event. Almost all of them are free, though a few pop-ups happen inside ticketed conferences. There are two flavors:

	Hack Day	Meetup
Vibe	Mini hackathon	Community hangout
What you do	Build a project with open-weight models or open-source AI tools, then demo it	Talks, workshops, panels, and meeting people
Team?	Solo or any team size (prizes cover up to four members)	No team needed
Prizes	Yes, usually a swag bag	No
Bring	Laptop and charger	Curiosity, plus a laptop only if the host asks

A few things worth knowing:

Beginners are welcome. You don't need to build an AI project to attend a Meetup.
Everyone on a team must register and check in. One person submits the project.
Projects must be finished and submitted on the day, before the host's deadline.
Every in-person attendee gets an official participation certificate, available in your My Hacktoberfest dashboard.
Swag varies by Fest. T-shirts and other goodies are limited and not guaranteed. The local host decides how to hand them out. Select Hack Days also have Arduino boards available while supplies last.

How to join a Fest:

Open Find a Fest and search by city, country, or name (or use your location).
Open the Fest's page and read the details: date, venue, food, accessibility, and what to install or bring.
Register on that Fest's own page with a free MyMLH account. Every Fest has a separate registration.
Show up, check in with the host, and say hi to a stranger.
Use the Contact Host button on the page for anything about logistics, accommodations, or late arrival.

Path 2: Join online (from anywhere)

The online program runs all month and has three main pieces:

Livestreams. Sessions on open-weight models, agents, and tools. You check in with a code shown on screen to collect a sticker.
DEV Challenges. A weekend kickoff challenge plus four weekly open-source AI rounds, all labeled as cash-prize challenges.
Global Hack Week: Hacktoberfest. A week-long virtual festival of livestreams and challenges, run by MLH.

Here are the dates as listed on DEV's challenge hub and in community guides. Always double-check the deadline printed on each official challenge page, because that's the one that counts.

Activity	Dates (UTC, as reported)
Weekend Challenge	Oct 2 (02:00) to Oct 5 (06:59)
Open-Source AI Challenge, Week 1	Oct 5 to Oct 11
Global Hack Week	Oct 9 to Oct 15
Open-Source AI Challenge, Week 2	Oct 12 to Oct 18
Open-Source AI Challenge, Week 3	Oct 19 to Oct 25
Open-Source AI Challenge, Week 4	Oct 26 to Oct 31

The full online calendar lives on the official schedule page and shows times in your own time zone.

Heads up: the exact prize amounts and the actual challenge prompts weren't public when I researched this. The prompts are revealed when each challenge launches, so don't start building a "winning entry" before you've read the real brief. Challenge announcements go out under DEV's #hf26challenge tag.

The sticker system, explained

This is the new reward engine, and it's friendlier than it sounds.

There are 24 virtual stickers in total: 22 you can earn online, plus 2 you earn in person (attend a Fest, or host one). Each one is tied to an activity.

The reward tiers

Stickers collected	What you get
3	A real, mailed Hacktoberfest 2026 sticker pack
10	A bonus holographic sticker added to your pack
17	Completionist status, plus automatic entry into a raffle for a Hacktoberfest 2026 T-shirt or an Arduino Uno Q board

Two stickers are required before anything ships: signing in to Hacktoberfest.com, and adding your mailing address to your MyMLH account. Do those first. They also count toward your total, so you're already two-thirds of the way to the first reward after five minutes.

Where the rest come from

Category	Examples of what earns a sticker
Livestreams	Check into 1, 3, or 5 livestreams, or the launch livestream
DEV Challenges	Connect your DEV account, then submit to the Launch Weekend and Weeks 1 to 4 challenges
Global Hack Week	Complete registration challenges, check into a session, and hit 15, 30, or 75 points
Tools	Install and log in to DevRelay, join the MLH Community Discord, connect your DigitalOcean account
Surveys	Fill out the pre-event and post-event surveys
In person	Attend a Fest, or host one

The full, up-to-date list is on the Activities page, and your personal progress lives in My Hacktoberfest.

Good to know about swag

Online participants don't get T-shirts. Those are a Fest thing, and even there they aren't guaranteed. Completionists can still win one in the raffle.
Mailing takes a while. The main site says stickers and prizes go out 8 to 12 weeks after Hacktoberfest ends, while the FAQ says packs should arrive at most destinations within 30 to 60 days of shipping starting. Plan for a wait either way.
Activity done early still counts. The FAQ says eligible activity completed before milestones were announced is credited.
Signing in alone won't earn you a pack. You need to do at least a few activities.

Your quick-start checklist

If you only do one section of this article, make it this one.

Today (5 to 10 minutes):

Sign in at My Hacktoberfest with a free MyMLH account.
Add your mailing address to MyMLH.
Connect your DEV account (optional, but it earns a sticker and a DEV badge, and it's needed for DEV Challenges credit).
Join the MLH Community Discord.

This week:

Register for Global Hack Week: Hacktoberfest, which is free.
Follow each DEV Hacktoberfest challenge so you get launch notifications.
Check the schedule and mark a few livestreams.
Look up Fests near you and register if one fits.

All month:

Check into livestreams and submit to challenges as they open.
Fill out the pre-event survey early and the post-event survey at the end.

What should you build? Ideas to get started

The official line is that instead of counting PRs, you'll write your first skills.md, build an open-source agent, fine-tune an open-weight model, or follow your curiosity. Here are some starter ideas by difficulty.

Beginner-friendly

A reusable agent skill: a folder with a SKILL.md, a README, a license, and a couple of examples.
A small local chatbot running an open-weight model through a local runtime such as Ollama or llama.cpp.
A tiny evaluation script that checks whether a model gives consistent answers to the same prompt.

Intermediate

A small open-source agent that combines a local model, a few tools (files, APIs, MCP servers), and simple memory.
A CPU-friendly fine-tuning experiment using Hugging Face's PEFT or TRL. Keep it small. A tiny project that works beats a giant one that doesn't.
A tool-call correctness test suite or prompt regression tests.

Ambitious

Improve an open-source agent harness or SDK: better error messages, safer permissions, clearer setup on Windows, macOS, or Linux.
Build an evaluation dashboard that compares open-weight models side by side.

A good project checklist before you submit anything: what real problem does it solve, which license applies, which model and under what terms, can someone else run it without hidden steps, is there a short demo or screenshot, and are the limitations written down.

But I still want to contribute to open source!

You absolutely can, and nobody is stopping you. The organizers say outright that open source runs 365 days a year and that you can contribute anytime. They just aren't giving swag for it anymore. They point newcomers to this beginner's guide to getting started.

If you're going to send a PR this October, here's how to be the kind of contributor maintainers love:

Read CONTRIBUTING.md first. Some projects require you to be assigned the issue, get design approval, sign a CLA, or follow an AI-disclosure policy.
Check that the issue is still open and unclaimed, with no competing PR.
Reproduce the problem yourself. A fix without a reproduction is a guess.
Keep the change small and focused, and add a test that fails before your fix and passes after it.
Be honest about AI help. Many repos now ask for disclosure. Never submit code you can't explain or test.
Say what you're about to do before writing a lot of code. A short comment like "I reproduced this, here's my plan, anyone already on it?" saves everyone time.

Where to look

Hacktoberfest has no official participating-repo list this year. These are active projects in the open-AI orbit that have accepted outside contributions. Treat them as places to browse, not guaranteed openings, since issues get claimed quickly.

MCP TypeScript SDK and MCP Python SDK
Hugging Face PEFT and TRL
Giskard (AI evaluation)
MDN content (documentation, with low setup cost)
Browser Use
FastMCP

A smaller, well-scoped issue in a project with a clear guide is almost always a better bet than a big feature nobody has approved.

Want to host a Fest?

Anyone can. If your city has no Fest yet, it could be you.

	Hack Day	Meetup
Attendees build projects	Yes	No
Workshops and speakers	Yes	Optional
Prizes	Yes	No
MLH funding	Yes	No

Applications are open and are confirmed on a rolling basis, within about a week of a completed application.
Hosts get stickers, swag, and prizes for participants, a listing in the searchable directory, programming help, and (for Hack Days) funding with reimbursement for certain event expenses.
Start here: Host a Fest, then read the host handbook.
Hosting also earns you a sticker and a DEV badge.

FAQ

Do pull requests count at all?
No. They don't count toward rewards, and the organizers say that's deliberate.

Can I still get a T-shirt?
Maybe, but only at a Fest while supplies last (the host decides), or through the Completionist raffle if you hit 17 stickers. Online participants aren't promised one.

Who can join?
People aged 13 and over, subject to country eligibility rules. Individual Fests can have their own age limits, and if you're under 18 you should ask the host about parental permission. DEV Challenges have separate contest eligibility rules.

Is it free?
Yes, including nearly all Fests and Global Hack Week.

Do I need to build an AI project to take part?
No. You can watch livestreams, attend a Meetup, join the Discord, and do surveys. Those all count toward stickers.

Do I need a GPU?
Not for everything. Plenty of beginner-friendly work (documentation, SDK bugs, evaluation tools, small fine-tuning experiments) runs fine on a laptop CPU.

Who do I contact with problems?
Use Contact Host on a Fest's page for event questions, the relevant challenge page for DEV Challenge questions, and the support emails listed on the official FAQ for swag, prizes, or safety concerns.

Final thoughts

It's okay to feel a little nostalgic. The four-PR challenge got a lot of people into open source, and it's strange to see it retired.

But the new format has a lot going for it. Maintainers get a break from the spam. Beginners get real events and a clear, low-stakes path to a reward. And if you've been meaning to try out open-weight models or build your first agent, October now comes with a built-in excuse, a community, and stickers.

So sign in, add your address, grab those first two stickers, and see where the month takes you.

Sources and further reading

You Can't Even Make an AI Wrapper Chat App 😆🫵

Shuvo — Fri, 05 Jun 2026 05:48:23 +0000

"It's just a fetch call, bro." — Every junior dev, moments before learning a hard lesson.

So you want to build a ChatGPT wrapper. Fair enough. It sounds embarrassingly simple — you've got an API key, a text box, and ambition. How hard can it be?

Turns out: pretty hard. Not rocket science hard, but "oh god why is my chat broken on refresh" hard.

Let's walk through the three stages of enlightenment.

🟢 Stage 1: The Junior Dev Move

"Ship it. It works on my machine."

The junior dev opens a blank React project, installs axios (or doesn't, and just uses fetch), and writes something like this:

Frontend:

const res = await fetch('/api/chat', {
  method: 'POST',
  body: JSON.stringify({ msg: input })
});
const { result } = await res.json();
setReply(result);

Backend:

app.post('/api/chat', async (req, res) => {
  const result = await ai.chat(req.body.msg);
  res.json({ result });
});

Done. Deployed. LinkedIn post drafted.

The problem? You're waiting for the entire AI response to generate before anything shows up on screen. For a short reply, fine. For a longer one? You're staring at a blank screen for 10–15 seconds while your users quietly close the tab.

It feels like dial-up internet. In 2025.

🟡 Stage 2: The Mid-Level Dev Move

"I've heard of this 'streaming' thing."

The mid-level dev has seen the ChatGPT UI. Tokens appear one by one, like the AI is thinking. That's streaming — and it's a vastly better experience.

Backend:

app.post('/api/chat', async (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  const stream = await ai.chat.stream(req.body.msg);

  for await (const chunk of stream) {
    res.write(`data: ${chunk.text}\n\n`);
  }
  res.end();
});

Frontend:

const response = await fetch('/api/chat', { method: 'POST', body: ... });
const reader = response.body.getReader();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  setReply(prev => prev + decode(value));
}

Now tokens stream in real-time. The app feels alive. Users are happy. You are happy.

The problem? Hit refresh.

Gone. All of it. Every conversation, vanished. The app has the memory of a goldfish. Each new page load is a blank slate — no history, no context, no continuity.

You've built a chat app that forgets you exist the moment you leave. That's not a chat app. That's a very expensive alert() box.

🔴 Stage 3: The Senior Dev Move

"Streaming is table stakes. Persistence is the real work."

The senior dev knows that a chat app without history isn't a product — it's a demo. Real users expect to close the tab, come back tomorrow, and pick up where they left off. They expect their conversation to exist.

This means the stream itself needs to be saved as it arrives — not after it's done, not on the next request, but token by token, persisted to a database in real time.

Backend — save while streaming:

app.post('/api/chat', async (req, res) => {
  const { conversationId, msg } = req.body;

  // Save user message immediately
  await db.messages.insert({ conversationId, role: 'user', content: msg });

  res.setHeader('Content-Type', 'text/event-stream');
  const stream = await ai.chat.stream(msg);
  let fullResponse = '';

  for await (const chunk of stream) {
    fullResponse += chunk.text;
    res.write(`data: ${chunk.text}\n\n`);
  }

  // Save complete assistant response after stream finishes
  await db.messages.insert({ conversationId, role: 'assistant', content: fullResponse });
  res.end();
});

Frontend — load history on mount:

useEffect(() => {
  const history = await fetch(`/api/conversations/${id}/messages`);
  setMessages(await history.json());
}, [id]);

Now when a user refreshes? Their chat is still there. When they come back on mobile? Still there. When they share a conversation link? You get the idea.

But wait, there's more. The senior dev also thinks about:

Sending the full conversation history back to the AI (so it has actual context)
Handling mid-stream disconnects gracefully (what if the user closes the tab at 50%?)
Debouncing saves so you're not hammering your DB on every single token
Auth, so users only see their conversations

None of this is glamorous. It's just... what production looks like.

The Takeaway

Level	What they build	What's missing
Junior	Request → Response	Speed, UX
Mid	Streaming response	Persistence
Senior	Streaming + saved history	(probably something else they'll discover next week)

The gap between a junior and senior implementation isn't really about the AI part at all — the API call is the easy bit. It's about treating the surrounding infrastructure with the same seriousness as the feature itself.

So next time someone says "I built an AI chat app over the weekend" — ask them what happens when they refresh the page.

The silence will tell you everything.

Now go add persistence to your side project. You know who you are.

Before AI we had ...

Shuvo — Fri, 22 May 2026 04:12:37 +0000

Nowadays you will hear a lot of people saying Why should I hire a software developer when I can vibecode it my self with about $100 worth of AI tools?

Well they aren't wrong about that!

But getting an app made and running was never the hard part. Before AI or vibe coding we had platforms like Fiverr/UpWork where people could just pay a third world country developer $50-$100 to build them their app.

So getting a working APP or at least MVP was never really very hard or expensive rather its the distribution part that kills 99% of the apps.

And for handling complex apps or codebases cheap developers were not reliable then, AI tools are not reliable now!

Frontend rate limiting can save you $10,000

Shuvo — Thu, 21 May 2026 04:04:07 +0000

Fastest Requests Are the Ones You Never Make

While backend rate limiting is absolutely crucial, it comes at a cost.

For backend rate limiting, we usually store a user's IP and request timestamps in memory or a Redis database. If your app has millions of users, you end up storing a lot of data in memory or a database — and that can get expensive fast.

But what if we block requests before they ever leave the browser/client? By handling rate limiting on the client side, we can save a significant number of unnecessary request and read/write operations on the backend. Depending on how many users your app has, this can translate to anywhere between hundreds to thousands of dollars saved per year.

1: Basic frontend rate limiter example:

// utils/rate-limiter.ts

const MAX_REQUESTS = 50;           // Maximum number of requests allowed
const TIME_WINDOW = 60 * 1000;    // Time window in milliseconds (1 minute)

// Store timestamps of recent requests
let requestTimestamps: number[] = [];

// Check if a new request is within the allowed limit
function canMakeRequest(): boolean {
    const currentTime = Date.now();

    // Remove timestamps that have fallen outside the time window
    requestTimestamps = requestTimestamps.filter(
        timestamp => currentTime - timestamp < TIME_WINDOW
    );

    return requestTimestamps.length < MAX_REQUESTS;
}

// Drop-in fetch wrapper with rate limiting
function $fetch(url: string, options?: RequestInit): Promise<Response> {
    if (!canMakeRequest()) {
        return Promise.reject(new Error('Rate limit exceeded. Please try again later.'));
    }

    requestTimestamps.push(Date.now());
    return fetch(url, options);
}

export default $fetch;

2. Better rate limiter with cooldown time and localstorage implementation so user can't just reset limit by refreshing the page

// Front end rate limiter
// Max number of requests allowed per time window
const MAX_REQUESTS = 50; // Maximum number of requests allowed
const TIME_WINDOW = 60 * 1000; // Time window in milliseconds (e.g., 1 minute)
const COOLDOWN_TIME = 30 * 1000; // Time to wait after hitting the rate limit before requests are allowed again

// localStorage keys for persisting state across page refreshes
const STORAGE_KEY_TIMESTAMPS = 'rate_limiter_timestamps';
const STORAGE_KEY_COOLDOWN = 'rate_limiter_cooldown_until';

// --- localStorage helpers ---

// Load request timestamps from localStorage, falling back to an empty array
function loadTimestamps(): number[] {
    try {
        const stored = localStorage.getItem(STORAGE_KEY_TIMESTAMPS);
        return stored ? JSON.parse(stored) : [];
    } catch {
        return [];
    }
}

// Persist the current timestamps array to localStorage
function saveTimestamps(timestamps: number[]): void {
    try {
        localStorage.setItem(STORAGE_KEY_TIMESTAMPS, JSON.stringify(timestamps));
    } catch {
        // Silently fail if localStorage is unavailable (e.g. private browsing restrictions)
    }
}

// Load the cooldown expiry timestamp (ms since epoch), or 0 if none is set
function loadCooldownUntil(): number {
    try {
        return Number(localStorage.getItem(STORAGE_KEY_COOLDOWN) ?? 0);
    } catch {
        return 0;
    }
}

// Persist the cooldown expiry timestamp to localStorage
function saveCooldownUntil(until: number): void {
    try {
        localStorage.setItem(STORAGE_KEY_COOLDOWN, String(until));
    } catch {
        // Silently fail if localStorage is unavailable
    }
}

// --- Core rate-limit logic ---

// Function to check if a request can be made
function canMakeRequest(): boolean {
    const currentTime = Date.now();

    // If an active cooldown exists, block all requests until it expires
    const cooldownUntil = loadCooldownUntil();
    if (cooldownUntil && currentTime < cooldownUntil) {
        return false;
    }

    // Load persisted timestamps so a page refresh doesn't reset the counter
    let requestTimestamps = loadTimestamps();

    // Remove timestamps that are outside the time window
    requestTimestamps = requestTimestamps.filter(
        timestamp => currentTime - timestamp < TIME_WINDOW
    );

    // Persist the cleaned-up timestamps
    saveTimestamps(requestTimestamps);

    // Check if the number of requests in the time window is less than the maximum allowed
    return requestTimestamps.length < MAX_REQUESTS;
}

// Function to make a request
function $fetch(url: string, options?: RequestInit): Promise<Response> {
    if (!canMakeRequest()) {
        // Inform the caller how long (in seconds) they need to wait
        const remaining = Math.ceil((loadCooldownUntil() - Date.now()) / 1000);
        return Promise.reject(
            new Error(`Rate limit exceeded. Please try again in ${remaining}s.`)
        );
    }

    const currentTime = Date.now();

    // Load, update, and persist timestamps before making the request
    const requestTimestamps = loadTimestamps();
    requestTimestamps.push(currentTime);
    saveTimestamps(requestTimestamps);

    // If this request tips us over the limit, start a cooldown period.
    // The cooldown begins NOW and lasts COOLDOWN_TIME ms, after which
    // canMakeRequest() will unblock and the sliding window will have cleared.
    if (requestTimestamps.length >= MAX_REQUESTS) {
        saveCooldownUntil(currentTime + COOLDOWN_TIME);
    }

    // Make the actual fetch request
    return fetch(url, options);
}

export { $fetch };

Whenever you need to make a request to the backend, just use $fetch instead of the native fetch:

// example usage
import $fetch from 'utils/rate-limiter';

try {
    const data = await $fetch('/api/get-data', {
        method: 'POST',
        body: JSON.stringify({ key: 'value' })
    });
} catch (error) {
    console.error(error.message);
}

⚠️ Warning: This will prevent the vast majority of users from flooding your backend, but a determined minority and AI bots may attempt to bypass client-side checks entirely. Backend rate limiting must still be in place as your true line of defense. Think of frontend rate limiting as an optimization layer, not a security layer.

When to Use Frontend Rate Limiting

Your app has a high volume of users and you want to reduce unnecessary backend load
The endpoint being called is expensive (e.g., hits a third-party API, runs a heavy DB query)
You want to improve UX by giving users instant feedback instead of waiting for a backend 429 response
You want to reduce cloud costs on services that charge per request or per DB operation

When Not to Use Frontend Rate Limiting

As a replacement for backend rate limiting — it is never a substitute
For protecting sensitive or security-critical endpoints (authentication, payments, etc.)
When your users are primarily API consumers or developers who interact directly with your backend
When the client environment is untrusted (e.g., mobile apps that can be reverse-engineered or patched)
When accurate rate limiting is a hard requirement — client-side state can be reset simply by refreshing the page

DEV Community: Shuvo

Why I made an interactive Git learning platform

Tutorials give you a false sense of progress

Git is learned with your fingers, not your eyes

Take the Git skills test

So I built a place where you can break things safely

"But I just use AI to write my code..."

Git is not optional if you want a dev job

What's inside GitMission

Who is it for?

- 😬 Devs who know add and commit but panic at rebase

First, how good are your Git skills right now?

👉 Take the Git skills test

Ready to start?

Final thought

The Junior Developer Comeback: Seniors will struggle to get a job?

Learn Git by completing missions

Why juniors are struggling right now

What happens in 5 to 10 years?

The incentive to hire seniors disappears

Where I could be wrong

What this means for you

Final thoughts

Séance Shell: A Local Ghost That Haunts Your Terminal

What I Built

Code

0shuvo0 / seance-shell

Séance Shell 👻

What it does

How I Built It

1. The model never sees your command

2. The output is validated aggressively

3. A ghost, not an agent

Why Does Open Innovation Matter?

The Spirit of It

Prize Categories

Too Lazy to Write Alt Text for Images? Let Gemma Do It

What I Built

Code

0shuvo0 / ai-img-alt-text-ext

Generate accessible image alt text in HTML, JSX, and TSX files using a locally running Ollama vision model. Image contents are sent only to the Ollama server you configure.

AI Image Alt Text

Features

Requirements

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

Chat with client In -> Invoice Out

What I Built

Demo

Struggling to learn Git?

Code

0shuvo0 / chat2invoice

Chat2Invoice

Requirements

Setup

How I Built It

Why Does Open Innovation Matter?

My First User

Prize Categories

I Built a Group Chat Where Only AIs Can Talk (and They Roast Each Other)

The idea

Problem 1: Too many APIs

The fix: OpenRouter

Problem 2: Getting them to actually chat

Problem 3: It's too fast to read

The fix: Kokoro.js

The final result

Tech stack recap

Try it yourself

Struggling with git?

People Won't Go Outside so I made this

What I Built

Demo

Code

0shuvo0 / goseek

GoSeek is a mobile-first outdoor scavenger hunt game. Each round gives you a riddle clue, and you must find the matching object in the real world by taking a photo with your camera or uploading an image.

GoSeek

Try it: goseek.ai.studio

- 😬 Devs who know `add` and `commit` but panic at `rebase`