Building ScopeMate: My Journey Fine-Tuning an Open-Weight AI Model

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

What I Built

Have you ever received a client message that sounds exciting but doesn't actually explain what they want?

Something like:

"Hey! I really like your content. We'd love to collaborate sometime. Let me know if you're interested!"

It's a nice message, but what happens next? What kind of content do they expect? Is it a paid collaboration? When do they need it? And what exactly am I agreeing to?

That's the problem I wanted to explore with ScopeMate.

ScopeMate is an AI assistant I'm building to help content creators, freelancers, and other creative professionals make sense of vague client briefs. It takes an informal message and turns it into a structured project scope, highlighting what's already known and what still needs to be discussed.

The output includes the project type, requirements, deliverables, budget, timeline, revision limit, missing information, assumptions, and questions worth asking the client.

The idea is simple: help creators get clarity before committing to a project.

Demo

I'm currently demonstrating ScopeMate through a Google Colab notebook, so there's no separate frontend yet.

Notebook

Code

github

I'll include the training notebook, dataset, inference code, and instructions for running the project.

How I Built It

I wanted to do more than just send a prompt to an existing AI API. I wanted to experiment with fine-tuning an open-weight model for a specific task.

For ScopeMate, I used Google's google/gemma-4-E2B model and worked through a LoRA-based fine-tuning workflow in Google Colab.

Here's how I approached it.

Starting with the dataset

I created 40 examples based on content creation briefs and potential client collaborations:

• 30 training examples
• 5 validation examples
• 5 test examples

Each example contains a client message and the structured JSON response I want ScopeMate to produce.

I also checked the dataset's JSON structure and required field types before starting training. Building the dataset helped me think more carefully about the difference between information a client actually provided and information the model should ask about instead of inventing.

1. Fine-tuning Gemma I used Hugging Face tools, PyTorch, TRL, and PEFT to experiment with parameter-efficient fine-tuning using LoRA and 4-bit quantization.

The process involved loading the model, preparing the data, configuring the adapter, setting up the training loop, and evaluating the model on validation data.

Training completed for three epochs and 12 steps. The final training loss was around 1.78, while the final validation loss was around 2.00.

These numbers are useful for tracking the experiment, but they don't tell the whole story. I still need a larger dataset and more systematic testing to understand how reliably the model handles different types of client messages.

1. Testing and saving the model After training, I tested ScopeMate with client briefs and checked its generated responses. I also saved the trained adapter and backed it up to Google Drive so I can load it again without repeating the training process.

My current focus is making the inference workflow reproducible and improving the quality of the output on examples the model hasn't seen before.

Tools I used:

• Google Gemma 4 E2B
• Python and PyTorch
• Hugging Face Transformers
• TRL and PEFT
• LoRA and 4-bit quantization
• Google Colab
• JSONL datasets

Why Does Open Innovation Matter?

One thing I liked about this project was being able to experiment with the model itself instead of treating AI as a black box behind an API.

Using an open-weight model gave me the opportunity to prepare my own dataset, experiment with fine-tuning, inspect the training process, and keep the adapter for future improvements.

It also made this a useful learning experience. I had to think about data quality, training configuration, model outputs, and evaluation—not just how to write a prompt.

I think this kind of flexibility is valuable when you're trying to build AI tools for specific problems that general-purpose assistants might not handle consistently.

Prize Categories

I'm entering the Google Gemma category with ScopeMate.

ScopeMate uses Google's open-weight Gemma 4 E2B model, which I fine-tuned using a custom dataset and a LoRA-based workflow.