DEV Community: razorbill

SlothOps: Finding the Cloud VMs I Was Too Lazy to Turn Off

razorbill — Sun, 25 Oct 2026 10:03:09 +0000

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

What I Built

Every cloud engineer knows the dread of opening a monthly invoice and spotting an n1-standard-4 instance that has been running silently for weeks. You spun it up on a Friday afternoon to test something, promised yourself you'd turn it off before leaving, and closed your laptop instead.

Stopping it should be easy, but the friction gets in the way:

Open the Google Cloud Console.
Wait for the dashboard to load.
Jump into Compute Engine.
Cycle through a dozen regions because you can't remember if the test box was in us-central1 or europe-west3.
Click through monitoring graphs to confirm CPU has been flat at zero.

SlothOps is built to reward pure developer laziness. It's a local cloud auditor that turns multi-region cleanup into a single terminal command. It lists your compute instances, passes the inventory to a local Gemma 2 (2B) open-weight model, and hands you the exact gcloud command to shut the waste down.

No console hopping, no forgotten test boxes, and no metered API charges.

Demo

SlothOps running inside Google Cloud Shell, auditing a sample idle-instance snapshot:

Running in offline mode against the bundled instances.json snapshot.

Code

Razorbillworks / slothops

Local-first GCP FinOps CLI powered by Gemma 2. Identifies idle compute instances and prints ready to run cleanup commands.

🦥 SlothOps

A lazy-friendly GCP cost auditor that finds the VMs you forgot to turn off.

If you spin up test VMs, sandbox boxes or throwaway Redis nodes on Google Cloud and then forget about them, you know the pain: clicking through every region in the console just to check what's idle. SlothOps does that in one command. It lists your compute instances, hands the metadata to a local Gemma 2 (2B) model, and prints a verdict along with ready-to-run gcloud commands to shut the waste down.

Everything runs on your machine. No inference API, no extra bill.

Demo

SlothOps running in Google Cloud Shell in offline mode, auditing the sample instances.json snapshot.

⚙️ How it works

              +---------------------+
              |    SlothOps CLI     |
              |       (Rust)        |
              +----------+----------+
                         |
          +--------------+--------------+
          |                             |
     Live mode                    Fallback mode
 gcloud compute instances     read local instances.json
   list --format=json                   |
          |                             |
          +--------------+--------------+
                         |
                         v
              +---------------------+
              |

…

View on GitHub

Open source under the MIT License. The repo has the Rust CLI, the Terraform IAM policy, the TypeScript formatting script, and the fallback dataset.

How I Built It

I wanted low friction, predictable behavior, and nothing that can wreck your cloud account.

       +------------------------------------+
       |          SlothOps CLI              |
       +-----------------+------------------+
                         |
           +-------------+-------------+
           |                           |
     [Live Mode]                [Fallback Mode]
gcloud compute instances        Read instances.json
   list --format=json                 snapshot
           |                           |
           +-------------+-------------+
                         |
                         v
       +------------------------------------+
       |   Ollama Local Inference Engine    |
       |       Model: Gemma 2 (2B)          |
       +-----------------+------------------+
                         |
                         v
       +------------------------------------+
       | Terminal Audit Verdict             |
       | - Flags zero-utilization instances |
       | - Computes estimated spend         |
       | - Prints exact `gcloud stop` flags |
       +------------------------------------+

Architecture and components

Component	Technology	What it does
CLI core	Rust (`tokio`, `reqwest`, `serde`, `colored`)	Native binary in `src/main.rs` with sub-second startup and a small memory footprint.
Local AI	Gemma 2 (2B) via Ollama	Reads the instance metadata, flags idle ones, and extracts the affected names. Nothing leaves your machine.
IaC	Terraform / HCL (`terraform/main.tf`)	Creates a service account limited strictly to `roles/compute.viewer`.
Scripts	TypeScript (`scripts/summary.ts`)	Structured audit output formatting and JSON summaries.

Safety first: no destructive surprises

Tools that delete cloud resources on their own are risky. SlothOps never executes anything. It isolates the waste, estimates the monthly burn, and prints the exact gcloud command for you to review and run yourself. You stay in control of your cloud state, and the read-only service account backs that up at the permission level.

Execution modes

Live mode: when gcloud is authenticated, it runs gcloud compute instances list --format=json against your active project.
Offline / sandbox fallback: if you're not logged in, or you're in an environment like Google Cloud Shell that can't run an Ollama daemon, it falls back to the bundled instances.json with built-in evaluation logic, so testing never stalls.

Known limitations

Gemma 2 (2B) is a small model and can misjudge an instance, so always read the suggested commands before running them. SlothOps currently covers Compute Engine VMs only, not every GCP resource type.

Why Open Models Matter Here

Zero inference cost: using an LLM to avoid a surprise $50 bill shouldn't need a paid API. Running Gemma 2 locally costs nothing.
Privacy: project IDs, zone layouts, and service names stay on your hardware instead of going to a third-party endpoint.
Offline portability: the model lives on your workstation, so you can audit infrastructure dumps without a connection.

The Lazy Payoff

Instead of logging in through SSO, opening a pile of console tabs and cross-checking charts region by region, you run one command and get the line you need to stop the billing burn. It turns a chore you keep avoiding into something you can do before locking your screen.

Prize Categories

Primary track: Hacktoberfest Week 3 - Slow and Steady
Partner category: Best Use of Gemma

ScopeCheck: An Air-Gapped Scope Creep & Contract Auditor for Freelancers

razorbill — Sun, 18 Oct 2026 20:45:53 +0000

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

What I Built

ScopeCheck is an offline, air-gapped auditor that evaluates client revision requests, late-stage change emails, and Statement of Work (SOW) terms without letting a single byte of client data leave your laptop.

Almost every independent developer knows this exact message pattern near a milestone delivery:

"The dashboard looks great! While you have the repo open, could you quickly wire up Stripe, user auth, and PDF export before tomorrow? It should only take a few minutes since the UI is done."

When that lands in your inbox, you usually have two bad choices:

Absorb 10+ hours of unbilled architectural labor just to keep the client happy.
Draft a blunt, defensive response that strains the relationship right before milestone sign-off.

Pasting a client's proprietary technical spec or signed contract into commercial cloud AI tools isn't an option either—doing so leaks unreleased business logic and breaches confidentiality agreements.

ScopeCheck gives freelancers a safe third option. You paste the client's message into a local studio interface, and it gives you:

A Severity Rating (1–10): An immediate diagnosis of how far the request steps outside standard delivery boundaries.
Architectural Flagging: Calls out the actual technical debt hiding behind innocent wording (e.g., distinguishing between a CSS tweak and new database migrations or payment webhooks).
A Pushback Draft: Generates a polite, firm negotiation script that validates the idea while framing additions as Phase 2 deliverables with separate pricing.

Freelancers and boutique technical agencies lose thousands of dollars every year to unpaid scope creep. ScopeCheck catches that creep before work starts.

Demo

ScopeCheck runs locally via Ollama to guarantee client text never hits external servers.

1. Ingestion & Model Selection

Paste raw emails, Slack messages, or contract clauses directly into the interface:

2. Breakdown & Negotiation Draft

When auditing a typical "quick revision" asking for payment hooks and logins, the local engine flags the unbilled work and drafts a clear response:

Code

Razorbillworks / scopecheck

Local, zero-leak scope creep and contract auditor for freelancers powered by Gemma.

🛡️ ScopeCheck

An air-gapped, local contractual and scope-creep auditor built for freelance engineers, technical consultants, and boutique digital agencies. Powered by local Google Gemma inference via Ollama.

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 (Side Hustle Track).

The Real Problem with Freelance "Quick Revisions"

Every independent developer or agency freelancer knows this exact message pattern:

"The dashboard looks super clean! Hey, while you still have the codebase open, could you quickly wire up user authentication, Stripe webhooks, and an export-to-PDF button before tomorrow? Should only take a few minutes since the UI is already finished!"

When this happens, freelancers are caught in a bad trade-off:

Eat the cost: Do 10+ hours of unpaid architecture, backend plumbing, and QA to avoid an awkward confrontation.
Burn the bridge: Send a blunt, defensive email that strains client relations right before milestone sign-off.
Leak client data to cloud AI: Paste the…

View on GitHub

Repository: https://github.com/Razorbillworks/scopecheck
License: Apache 2.0

How I Built It

Local Reasoning Engine: Google Gemma (gemma2:2b / gemma3:4b). Gemma's instruction following is remarkably sharp at dissecting contract nuances and technical requirements without hallucinating clauses that don't exist.
Runtime: Connected directly to Ollama via local loopback (localhost:11434), eliminating external API calls and third-party prompt caching.
Interface: Built with Python 3.10+ and Streamlit, styled with an editorial slate-obsidian layout designed for reading dense contracts cleanly.
Prompt Architecture: The audit harness strictly separates risk calculation from diplomatic script drafting so the model doesn't blend technical debt with negotiation pleasantries.

Why Does Open Innovation Matter?

Most side hustles and freelance agencies operate under strict non-disclosure agreements (NDAs).

When you paste an unreleased product brief, API structure, or signed agreement into a proprietary cloud AI service, you lose control of that data. Closed platforms routinely log inputs, retain telemetry, and use prompts for future training cycles. For a contractor, that is an immediate legal liability.

Open innovation is what makes an offline auditor viable:

True Data Sovereignty: Gemma runs entirely inside your machine's RAM. Zero outbound network calls means client NDAs stay completely intact.
Predictable Unit Economics: Closed APIs charge variable per-token fees that add up fast with long documents. A local open model costs exactly $0.00 to run.
No Vendor Lock-In: You don't have to worry about sudden API rate limits, deprecations, or outages while traveling or working on restricted client networks.

Prize Categories

Best Use of Gemma: ScopeCheck uses local Google Gemma models (gemma2:2b / gemma3:4b) as its primary analytical engine. Gemma's reasoning ability isolates technical deliverable creep, parses ambiguous client communications, and drafts commercial pushback scripts—all running efficiently on standard developer hardware.

I Stopped Guessing Why My Walk Sucks: Building a Zero-Cloud Street Auditor with Gemma

razorbill — Mon, 12 Oct 2026 06:58:30 +0000

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

What I Built

Most outdoor and fitness tech introduces a contradictory loop: it encourages you to get outside, then demands that you spend your entire walk staring at an OLED display to check live stats, track badges, or babysit an app interface.

I wanted the opposite: an open-weight tool where screen time outside is under two seconds per snapshot.

I built walkaudit, a lightweight, zero-cloud Python tool that turns an everyday outdoor walk into an empirical pedestrian walkability audit using a local vision model running via Ollama.

Instead of relying on vague impressions like "the road behind our hostel is terrible," walkaudit provides structured civic data:

You walk down a lane with your phone at chest height, snapping a photo every 25–30 paces and capturing critical hazards (open drains, broken paths) or amenities (shade, benches).
You transfer the photos to your laptop via USB cable.
A local Gemma model processes each image and extracts strictly constrained JSON categories (footpath, surface, shade, obstructions, hazards, positives).
The tool applies transparent arithmetic on those labels to compute an objective 1 to 5 walkability score, highlights the hardest and best spots, and prompts Gemma to generate three prioritized civic action points.
Outputs: A standalone audit_report.html visual dashboard and an audit.csv dataset.

It is designed for students, daily walkers, and local community groups who want to document their street infrastructure empirically without sharing private photos online.

Demo

I field-tested walkaudit on the 350-meter access lane behind my student hostel block across 16 photos taken in daylight.

1. Overall Audit Report & Scores

The aggregate audit revealed an average score of 2.2 / 5.0, with 50% of the lane completely missing a footpath and 81% flagging uneven, broken, or unpaved walking surfaces.

2. Full Walking Order Table & Labeled Hazards

The detailed breakdown captured the contrast between functional sections (interlock pavers, benches) and hazardous stretches (open drain pits, standing water, and construction debris narrowing the pedestrian path):

3. Terminal Run (Local Execution)

Local inference ran via Ollama on a consumer laptop GPU with zero external API calls:

Code

Razorbillworks / walkaudit

Street walkability audit from walk photos using local Gemma

walkaudit

Take photos on a walk, get a walkability report for the street.

I wanted to know what was actually wrong with the lane I walk every day, in more detail than "it's bad". So I take a photo every few steps and let a small Gemma model that runs on my own laptop label each one: is there a footpath, what is the ground like, is there shade, is anything blocking the way. The tool turns the labels into a one-page report with the worst spots, the best spots and three things to fix first.

Taking the photos

Pick a street or lane you can walk in 10 to 15 minutes, in daylight.
Hold the phone at chest height, pointed along the way you are walking, with the ground in the frame.
Take a photo every 25 to 30 steps, and one more wherever something is wrong (broken pavement…

View on GitHub

GitHub Repository: https://github.com/Razorbillworks/walkaudit

Licensed under the MIT License.

How I Built It

Open-Weight Model: Google's Gemma (gemma4:e2b) running locally via Ollama.
Zero-Dependency Architecture: walkaudit.py relies exclusively on Python standard libraries (urllib.request, json, csv, html, argparse, pathlib). There are no complex virtual environments or package installations required.
Constrained JSON Schema: The prompt strictly enforces structured JSON extraction from Gemma. Invalid tags are discarded, and fallbacks are handled deterministically.
Deterministic Math over Hallucinated Scores: Instead of asking an LLM to generate an arbitrary rating, the 1–5 score is computed with fixed Python arithmetic:

s = 5.0
s -= {"absent": 2.0, "partial": 1.0}.get(r["footpath"], 0)
s -= {"uneven": 1.0, "broken": 2.0, "unpaved": 1.0}.get(r["surface"], 0)
s -= min(1.5, 0.5 * len(r["obstructions"]))
s -= min(1.0, 0.5 * len(r["hazards"]))
if r["shade"] == "none":
    s -= 0.5
s += min(0.5, 0.25 * len(r["positives"]))
return max(1.0, min(5.0, round(s * 2) / 2))

Local Caching: Images are cached in audit_cache.json keyed by file size and model name. Interrupted runs can be resumed instantly without reprocessing completed images.

Why Does Open Innovation Matter?

For local physical infrastructure and civic mapping, closed cloud APIs introduce fundamental problems:

Uncompromised Street Privacy: Neighborhood street photography inevitably captures residential doorways, building gates, and passersby. Uploading raw images to proprietary third-party servers creates unnecessary privacy risks. With local open-weight models, image buffers exist strictly in memory on the local machine and never leave it.
Zero Marginal Cost: Commercial vision endpoints charge per image token. Auditing a 5 km neighborhood route requires hundreds of snapshots, creating budget barriers for student clubs or civic groups. Open models on consumer hardware cost zero marginal dollars.
Reproducibility: Proprietary cloud APIs change, deprecate endpoints, or alter internal safety alignments without notice. Running open weights locally guarantees that an audit performed today will run identically next year.

Prize Categories

Best Use of Gemma (runs Google's Gemma model locally via Ollama for multi-image vision extraction and civic synthesis).

DormChef: Midnight Pantry Rescue for Abhishek (Built with Gemma 2 & Ollama)

razorbill — Sun, 04 Oct 2026 21:48:05 +0000

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

The Friend & The Problem

Meet my friend and hostel roommate, Abhishek. Like many engineering students, Abhishek hits the gym regularly and tries to stay consistent with his daily protein intake.

Hostel life makes that tricky. By late evening, the dining mess is closed, takeout is either unhealthy or completely out of a student budget, and in-room cooking tools are strictly constrained.

Whenever he searches online for quick recipes, standard cooking apps assume access to a four-burner stove, an oven, and fresh groceries. Worse, general AI models often give dangerous advice. They often suggest cracking raw eggs directly over bare electric kettle heating coils, which burns out the element, sparks a short circuit, and risks hostel fines.

I built DormChef specifically for Abhishek to rescue midnight meals from random pantry items while respecting real hostel appliance limits and safety constraints.

What I Built

DormChef is an offline-first, local AI culinary assistant built for minimal dorm setups.

Adaptive Appliance Support: While Abhishek's daily room defaults are an electric kettle and a sandwich toaster, DormChef also supports induction plates or no-cook (assembly only) situations.
Flexible Dietary Priorities: Abhishek can pivot between goals depending on the night: High protein, Ready in 5 minutes, Comfort food, or Cheap (budget survival), alongside an adjustable spice dial.
Hardware-Safe Generation: The system prompt enforces strict safety boundaries: it forbids dropping solid food or eggs directly into electric kettle elements (suggesting hot-water bath poaching or mug steeping instead) and advises greaseproof wrapping inside sandwich toasters to avoid messy spills.
Editorial Slip Interface: The generated recipe streams token-by-token directly onto a clean, distraction-free receipt slip, complete with macro estimates and a practical "Heads-up" safety tip.

Demo

DormChef in action: translating 3 eggs, brown bread, and an electric kettle into a realistic, high-protein meal without endangering the kettle coil.

Why Open Innovation Matters

The prompt asks why an open-based approach works better than a closed one, and for dorm life, the answer is practical:

Hostel Wi-Fi Independence: College Wi-Fi in our dorms frequently drops or throttles past midnight. A closed cloud API is useless without an active internet connection. Because DormChef runs locally via Ollama, it functions 100% offline.
Zero Cost for Students: College students cannot afford $20/month AI subscriptions or recurring per-token API charges just to figure out how to cook eggs and bread. Open-weight models ensure reliable, free access.
Hardware-Safe Behavioral Alignment: By leveraging Google's Gemma 2 (2B) open weights, we can align the system instructions specifically around dorm appliance safety without running into cloud rate limits or latency bottlenecks.

The Two-Stage Allergen & Safety Filter

Small language models (like 2B parameter weights) often struggle to strictly follow negative constraints. Asking the model "don't use dairy" will often still result in a recipe with butter.

To prevent this, DormChef uses a two-stage filter built into the Python application layer:

Pre-filter (Input sanitization): Before the prompt reaches the model, Python scans the pantry items against common allergen groups (dairy, eggs, peanuts, tree nuts, gluten, soy, fish, shellfish). Any matching ingredient is stripped out automatically, and the UI notifies the user.
Post-filter (Verification): When Gemma 2 streams the finished recipe, the text is re-scanned. If a blocked word somehow slipped through, a prominent warning is displayed.

How I Built It & The Tech Stack

Model: Google Gemma 2 (2B) running locally via Ollama. It operates comfortably on a laptop GPU (taking ~1.6 GB VRAM) and streams responses almost instantaneously.
Frontend: Streamlit with custom ivory-slip styling and real-time token streaming.
Safety Logic: Python regex filters that catch and remove allergens before the prompt reaches Gemma, with a secondary check on the output.

Handing It Over: What Abhishek Said

I had Abhishek test it using the basic pantry items in our room. When he entered dairy as an allergy, the app removed butter and instructed him to poach the egg mixture inside a heatproof bowl set into the boiling kettle water instead of cooking raw egg directly against the coil:

"The bowl in boiling water idea is clever; our kettle doesn't get messed up, and it runs without needing hostel Wi-Fi."

Prize Categories

Best Use of Gemma (Google's open-weight model running locally)

Code Repository

GitHub: https://github.com/Razorbillworks/dormchef