I Built a Local AI 'Bad Cop' Because I Suck at Saying No to Freelance Scope Creep

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

What I Built

Let me tell you about the most expensive sentence in the freelance world: "Hey, quick question—this should only take 5 minutes, right?"

Two months ago, I took on a fixed-price freelance project to build a clean, static 3-page portfolio site for $1,200. Easy money, right? Well, halfway through week two, the client casually dropped a message asking if we could "quickly hook up a member login portal and a Stripe checkout before Friday so users can buy exclusive PDFs." Because I suffer from severe people-pleasing syndrome and hate awkward confrontations over money, I swallowed my pride, said "Sure, I'll squeeze it in," and spent my entire weekend fighting auth webhooks and database schemas for zero extra dollars. (╯°□°）╯︵ ┻━┻

When I finally did the math on Monday morning, I realized my effective hourly rate had tanked to pennies. And the worst part? It wasn't a coding problem—it was a boundary problem. Freelancers lose thousands of dollars every year not because they can't build, but because tracking contract drift and writing firm, polite pushback emails feels exhausting, awkward, and confrontational.

That is why I built ScopeGuard.

ScopeGuard is a local, zero-egress AI CLI tool that acts as an objective, non-emotional "bad cop" and Technical Project Manager for freelance developers, designers, and boutique agencies. You feed it two local files:

1. Your baseline Statement of Work (sow.txt).
2. The raw, chaotic email, Slack message, or WhatsApp text from your client (client_message.txt).

ScopeGuard cross-references the two locally, isolates every single feature request that falls outside your agreed baseline, calculates the hidden engineering complexity, and automatically drafts a warm, diplomatic, yet rock-solid Change Order email complete with itemized hour estimates, milestone impact, and pricing.

How the Side Hustle Works (Who Pays & Why?)

If you ask a solo freelancer to pay $49/month for a bloated enterprise project management SaaS, they will close the tab immediately. But if you offer a one-time $29 indie CLI license (or a $9/month micro-subscription) for a local tool that saves them $500 to $1,500 on the very first unbilled feature it catches? It pays for itself in thirty seconds. ¯\(ツ)/¯

Target Customers:

• Solo Freelance Developers & Designers: Who want to stay in their terminal and write code instead of playing contract lawyer every Tuesday.
• Student & Early-Career Freelancers: Who frequently get taken advantage of on fixed-price gigs because they are terrified of sounding "difficult" or losing a client.
• Boutique 2–5 Person Dev Agencies: Who need standardized, polite Change Order responses across their client communication channels without exposing confidential client contracts to third-party cloud tools.

---

Demo

Here is ScopeGuard running locally in my terminal, catching a classic "quick Stripe + login portal" scope creep attempt and generating a ready-to-send Change Order response:

Sample Input vs. Output

1. Baseline Contract (sow.txt):

Project: Modern 3-Page Portfolio Website ($1,200 Fixed Fee)

Agreed Scope: Home page, About Me page, Static contact form via Formspree, responsive layout hosted on GitHub Pages.

Explicitly Excluded: Custom database backends, user authentication, payment processing, dynamic CMS integrations.

2. Incoming Client Request (client_message.txt):

"Hey, looking great so far! Quick thought before we launch: can we also add a member login portal so returning clients can download exclusive PDFs? Also, we'll need Stripe integration to charge $20 for access. Should be super quick to hook up right? Let's get that live by Friday!"

3. ScopeGuard Local Audit & Generated Response:

Scope Drift Analysis

• In-Scope Confirmed: 3-page static layout (Home, About, Contact via Formspree), responsive design, static GitHub Pages deployment.
• Out-of-Scope Drift Flagged (Financial Risk: HIGH):
  1. Member Login Portal & Authentication: Violates the explicit Excluded clause ("user authentication, custom database backends"). Requires session management, user DB provisioning, and password reset flows.
  2. Protected Digital Asset Delivery (PDFs): Requires authenticated route guarding and secure storage permissions rather than static hosting.
  3. Stripe Payment Gateway Integration: Violates the Excluded clause ("payment processing"). Requires checkout session creation, webhook listeners, and payment state reconciliation.

Client Change Order Email

Subject: Re: Exciting additions! + Scope & Timeline Update for Member Portal & Stripe

Hi [Client Name],

Love where your head is at with monetizing the exclusive PDFs—adding a member portal and Stripe checkout is a fantastic way to turn the portfolio into a recurring revenue stream!

Because our original Statement of Work ($1,200 fixed fee) was scoped strictly for a static 3-page architecture without database backends, user authentication, or payment processing, transitioning the site into a full-stack application with secure login and Stripe webhooks falls outside our baseline agreement.

To build this securely and make sure your customers have a seamless checkout experience, I've put together a Change Order breakdown at my standard rate ($75/hr):

• User Authentication & Member Portal Setup: 8 hours ($600)
• Stripe Checkout & Webhook Integration: 6 hours ($450)
• Secure PDF Delivery & End-to-End Testing: 4 hours ($300)
• Total Change Order Addition: +18 Hours ($1,350 USD) | Timeline Impact: +5 Business Days

We have two great options to keep momentum going:

1. Phase 1 Launch (Recommended): We launch the static 3-page site this Friday as originally planned so you can go live on schedule, and tackle the Member Portal + Stripe as a separate Phase 2 milestone next week.
2. All-in Launch: I send over the formal Change Order for the additional $1,350 today, and we push our target launch date to next Friday to accommodate the backend engineering.

Let me know which path works best for you!

---

Code

arceuzvx / ScopeGuard

(If the GitHub embed takes a moment to load, you can explore the full repository here: https://github.com/arceuzvx/ScopeGuard)

Complete Implementation (scopeguard.py)

import sys
import time
from pathlib import Path
import ollama
import sentry_sdk
from rich.console import Console
from rich.panel import Panel
from rich.markdown import Markdown

# Initialize Sentry for agent execution & latency tracing
sentry_sdk.init(dsn="", traces_sample_rate=1.0)

console = Console()
RED = "bold red"
DARK_RED = "#8b0000"
MUTED = "#555555"

# Supports lightweight local models like gemma:2b or deep reasoning models like qwen3:14b
MODEL_NAME = "qwen3:14b"

def print_banner():
    banner = """
  ███████╗ ██████╗ ██████╗ ██████╗ ███████╗ ██████╗ ██╗   ██╗ █████╗ ██████╗ ██████╗ 
  ██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝ ██║   ██║██╔══██╗██╔══██╗██╔══██╗
  ███████╗██║     ██║   ██║██████╔╝█████╗  ██║  ███╗██║   ██║███████║██████╔╝██║  ██║
  ╚════██║██║     ██║   ██║██╔═══╝ ██╔══╝  ██║   ██║██║   ██║██╔══██║██╔══██╗██║  ██║
  ███████║╚██████╗╚██████╔╝██║     ███████╗╚██████╔╝╚██████╔╝██║  ██║██║  ██║██████╔╝
  ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝     ╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝ 
                 [ LOCAL SCOPE-CREEP & CONTRACT DRIFT DEFENDER ]
    """
    console.print(f"[{DARK_RED}]{banner}[/{DARK_RED}]")

def load_file(filename: str) -> str:
    path = Path(filename)
    if not path.exists():
        console.print(f"[{RED}][!] Error:[/{RED}] Missing file '{filename}'.")
        sys.exit(1)
    return path.read_text(encoding="utf-8")

def analyze_scope(sow_text: str, client_text: str):
    prompt = f"""You are a senior freelance contract negotiator and technical project manager.

ORIGINAL STATEMENT OF WORK (SoW):
{sow_text}

NEW CLIENT REQUEST:
{client_text}

TASKS:
1. Identify all items in the client's request that are OUT OF SCOPE relative to the original Statement of Work.
2. Draft a firm, polite, and professional email to the client:
   - Acknowledge their ideas enthusiastically.
   - Clarify that these additions fall outside the agreed baseline SoW.
   - Include a structured Change Order proposal with estimated hours, hourly rate ($75/hr), and milestone impact.

FORMAT YOUR RESPONSE AS:
# Scope Drift Analysis
- **In-Scope Confirmed:** <items>
- **Out-of-Scope Drift:** <items flagged with financial risk>

# Client Change Order Email
<Draft email here text>
"""
    console.print(f"[{MUTED}][*] Running local inference on {MODEL_NAME} via Ollama (Sentry tracing active)...[/{MUTED}]")
    start_time = time.time()

    with sentry_sdk.start_transaction(op="ai_inference", name="Scope Drift Check"):
        response = ollama.chat(
            model=MODEL_NAME,
            messages=[{'role': 'user', 'content': prompt}]
        )

    latency = time.time() - start_time
    return response['message']['content'], latency

def main():
    print_banner()
    sow_content = load_file("sow.txt")
    client_content = load_file("client_message.txt")

    console.print(f"[{DARK_RED}]─── Loaded Local Files ──────────────────────────────────────[/{DARK_RED}]")
    console.print(f"[{MUTED}][+] sow.txt ({len(sow_content)} chars) | [+] client_message.txt ({len(client_content)} chars)[/{MUTED}]\n")

    result, latency = analyze_scope(sow_content, client_content)

    console.print(Panel(Markdown(result), border_style=DARK_RED, title="[bold red]ScopeGuard Audit Report[/bold red]"))
    console.print(f"\n[{MUTED}][*] Trace Complete | Latency: {latency:.2f}s | Zero Cloud Data Egress.[/{MUTED}]")

if __name__ == "__main__":
    main()

---

How I Built It

Honestly, building this today was a pure hackathon rollercoaster. I originally planned to scaffold the entire application using cloud-based coding models inside OpenCode, and within ten minutes I slammed headfirst into an API Rate Limit Exceeded wall. Panic mode immediately set in. I decided to pivot entirely to my local machine, fired up ollama serve in PowerShell, and immediately got slapped with a nasty Windows error: listen tcp 127.0.0.1:11434: bind: Only one usage of each socket address is normally permitted. (－‸ლ)

After losing ten precious minutes wondering what rogue process hijacked my port, I realized the Ollama background tray daemon was already silently running and listening on 11434. Once I stopped fighting my own operating system, everything clicked into place.

Here is how the technical pipeline is architected:

1. Local Open-Weight Inference (Ollama + Qwen3:14b / Gemma:2b): The core reasoning engine runs 100% locally via the ollama Python SDK. The script is designed to be model-agnostic—working seamlessly with qwen3:14b for deep contract nuance or Google's lightweight gemma:2b for rapid inference on lower-spec laptops.
2. Adversarial & Role-Based Prompt Engineering: Out of the box, LLMs are trained to be helpful and agreeable. If you casually ask an AI to "reply to this client email," it will happily write a response agreeing to do 20 hours of free database work! I engineered the system prompt to force the model into the persona of a Senior Technical Project Manager & Contract Negotiator. It explicitly hunts for Exclusion Clauses in the SoW, translates vague client requests ("quick login") into concrete backend sub-tasks (database provisioning, session middleware, webhook security), and automatically introduces a "Phase 1 vs. Phase 2" psychological anchor so the client feels guided rather than rejected.
3. Minimalist Terminal UI (Rich): I wanted ScopeGuard to feel like a sharp cybersecurity CLI utility rather than a bloated web dashboard. Using Python's rich library, I styled the interface in a pitch-black and blood-red (#8b0000) aesthetic that parses and renders the LLM's Markdown output inside clean console panels.
4. Execution Telemetry (Sentry SDK): Running local models requires keeping a close eye on hardware responsiveness. I wrapped the ollama.chat() call inside a sentry_sdk.start_transaction() span to benchmark inference latency from prompt dispatch to completion.

---

Why Does Open Innovation Matter?

When I first pitched this concept to a friend, their immediate reaction was: "Wait, why wouldn't a freelancer just copy-paste their contract and client email into ChatGPT?"

Two words: Non-Disclosure Agreements (NDAs).

Almost every legitimate freelance contract, consulting agreement, or agency Master Services Agreement (MSA) contains a strict confidentiality clause. When a client sends over a Statement of Work and follow-up feature requests, those documents contain sensitive IP:

• Unreleased product roadmaps and proprietary business features.
• Internal software architectures and security boundaries.
• Private pricing tiers, hourly rates, and client identities.

If a freelancer copy-pastes their client's confidential SoW and private emails into a closed, third-party cloud API, they are actively violating their NDA and exposing client data to external servers.

Open-source, local AI isn't just a "nice-to-have" here—it is the only reason ScopeGuard can legally and financially work:

1. 100% Data Sovereignty & NDA Compliance: Because ScopeGuard executes open-weight models via Ollama strictly on 127.0.0.1, zero bytes of client contract data ever leave the freelancer's laptop. You can literally turn off your Wi-Fi on an airplane and audit five sensitive client contracts with zero compliance risk.
2. Zero Subscription Bleed ($0.00 Unit Economics): When building a micro-tool for indie freelancers, paying recurring cloud API token fees destroys your margins. By running open weights locally on the user's existing hardware, the marginal cost per contract audit is $0.00. ᕙ(⇀‸↼‶)ᕗ
3. No Vendor Lock-In or Sudden Deprecations: Closed API providers routinely deprecate model checkpoints or alter system behavior overnight, which breaks carefully tuned negotiation formatting. Open weights let developers lock in exact local model versions (gemma:2b or qwen3:14b) and swap them with a single variable change.

---

My First User

Right after I got the terminal output working, I hopped on Discord and demoed ScopeGuard to a close developer friend from our university hackathon community who builds freelance React and Next.js sites on the side to help pay for college.

We tested it on an actual WhatsApp message he received earlier this month from a local business client. The client had paid for a static landing page, and then texted asking for "a quick admin dashboard where I can log in and crop/upload new gallery photos myself." We dropped his original deliverables list into sow.txt and the client's text into client_message.txt.

ScopeGuard immediately flagged the request as high-risk scope creep—breaking down why an admin dashboard requires cloud storage buckets, image processing pipelines, and authentication—and drafted a polite Change Order quoting an extra $450 (6 hours) with a Phase 1 / Phase 2 launch option.

His literal reaction on the Discord call was: "Bro, push this to GitHub right now. Last month I built a whole Firebase admin panel for free because I was scared the client would leave a bad review if I asked for more money. The Phase 1 vs Phase 2 line in this email is actually genius."

He hasn't handed me $29 in cash yet (though he did promise to treat me to biryani next week ◕‿◕), and he already gave me my first two user feature requests:

1. Direct PDF/DOCX Ingestion: So he can drop a signed PDF contract directly into the folder without copy-pasting into .txt first.
2. A --tone CLI Flag: Allowing freelancers to toggle between --tone gentle (for long-term repeat clients) and --tone strict (for serial boundary-pushers).

---

Prize Categories

• Best Use of Gemma: Designed and validated the local Ollama prompt pipeline to support fast, lightweight local inference on Google's open-weight gemma:2b model alongside qwen3:14b.
• Best Use of Sentry Agent Tracing: Instrumented the local LLM inference execution block with sentry-sdk transaction spans to monitor local hardware latency.