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

What I Built

Every freelancer knows this message:

"Bhai, ek chhota sa quick change tha. Razorpay integrate kar do na, aur 25 products bhi add kar dena."

It is never small. A payment gateway and 25 products can be a full day of work, and it isn't in the contract. But saying "that's extra" feels rude, so most of us reply "haan haan, ho jayega" and quietly work for free.

Scope-Creep Guard is a local-first AI tool that does the awkward part for you. You paste your original scope and the client's message, and it:

• Decides whether the request is IN_SCOPE, OUT_OF_SCOPE or UNCLEAR
• Shows the exact clause from your contract that the decision is based on
• Estimates extra hours and an extra charge from your hourly rate
• Writes three replies you can send: Polite, Firm, or Friendly Upsell
• Generates a change-order mini quote for the extra work
• Keeps a Scope Ledger that tracks how many requests you caught and how much money you recovered

Who would pay for it? Solo freelancers and small studios working on fixed-price projects. Every out-of-scope request caught is billable work that would otherwise be given away. Client messages are often in Hinglish or mixed languages, so the built-in samples include those too.

Demo

• Try it (Demo Mode): https://week-iota.vercel.app/
• Video walkthrough (Live Mode): https://youtu.be/dZLzZrbIEg0?si=KEZdGOorXY8A8VD5

!Scope-Creep Guard result screen: verdict, matched clause, extra charge,reply drafts

An honest note: a Vercel site can't run a local LLM, so the deployed version runs in Demo Mode. It serves pre-recorded outputs from the real Gemma model for the built-in samples, and a banner says so. To analyze your own contract, run it locally (setup below). The video shows Live Mode.

30-second test: open the site, click Load sample, choose the Hinglish message, press Analyze.

Code

MIT licensed. Local setup: install Ollama, pull a Gemma model, then npm install && npm run dev.

How I Built It

Open-source AI: Gemma (open-weight), running locally through Ollama. The model name lives in .env, so swapping models needs no code change.

Stack: Next.js (App Router), Tailwind CSS, and browser localStorage for the ledger. No database, no server to maintain.

Making a small model trustworthy. The hard part wasn't calling the model. It was stopping it from inventing things. A contract tool that hallucinates a clause is worse than no tool. So:

1. The system prompt tells the model to judge only from the pasted contract, never invent clauses, and answer UNCLEAR when the contract is silent.
2. The model must return strict JSON: verdict, matched clause, reason, hours, charge and three replies.
3. The server validates that JSON. If it's broken, it retries once with a repair prompt, then shows a friendly error instead of garbage.
4. The validation and repair logic has unit tests.

Live Mode vs Demo Mode. On startup the app checks whether Ollama is reachable. If yes, you get live analysis and an "Ollama Connected" badge. If not (like on Vercel), it switches to Demo Mode with a clear banner. I chose this over faking a "live" feel with a closed API, because that would break the whole point of the project.

What it can't do yet: [CHECK AND EDIT: e.g. it only reads text you paste, with no PDF upload yet.] A small local model can also misjudge unusual clauses, so treat the verdict as a strong second opinion, not legal advice.

Why Does Open Innovation Matter?

A freelancer's contract and client chats are private. With a closed cloud API, every contract would travel to someone else's server. Open-weight models make a different promise possible:

• Privacy: in Live Mode, contracts and client messages never leave the laptop.
• Zero running cost: no per-request bill, which matters when you're just starting out.
• Works offline: the model runs on your machine.
• Swappable and tunable: try a bigger Gemma, or fine-tune on your own contract style.
• No lock-in: it's MIT licensed, so anyone can fork it.

With a closed API, I couldn't honestly write "your contract never leaves your device" on the screen. With a local model, I can.

My Agent Session

My Agent Session

I built Scope-Creep Guard using Google Antigravity as my coding agent. I provided a detailed spec covering the tech stack, standout features, JSON schema, Live/Demo modes, and deployment, then used the agent to build, test, and deploy the application. My goal was to turn a real freelancer pain point into a practical tool with explainable scope-creep detection and actionable insights.

Things I Changed After the First Build

• Improved scope analysis to distinguish included work from potential scope creep.
• Refined verdicts and explanations to help freelancers understand why a request might require additional time or payment.
• Improved input instructions and UI clarity to make analyzing client requests easier.

My First User

I asked a friend who freelances as a web developer to try Scope-Creep Guard on a real client message requesting extra features beyond the original project scope.

What worked: "I liked how it pointed out the extra requests and explained why they might count as scope creep. It made the situation easier to understand."

What didn't: "At first, I wasn't sure whether I should paste the entire client conversation or just the latest message. I also wanted a clearer explanation of what was included in the original scope."

What I changed because of it: I made the instructions clearer and added guidance to help users provide the original project scope alongside the client's message, so the comparison could be more useful.

Would they pay? "I'd use it for free right now. If it consistently helped me handle difficult client conversations and save time, I'd consider paying for it later."

Prize Categories

• Best Use of Gemma: the whole analysis runs on local Gemma via Ollama.

If you've ever worked for free because of a "small change", this one's for you.
Thanks for reading!