Unstick: One Tiny Action Instead of a Plan

Vinks Goyal — Sun, 04 Oct 2026 06:11:52 +0000

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

What I Built

Unstick gives you one tiny action instead of a plan.

Every productivity tool, every AI chatbot, every roadmap does the same thing: it shows you the whole mountain. Ask ChatGPT how to start a creative portfolio and it gives you five sections, twenty sub-bullets, and an implied skill tree you didn't ask to see. That's technically helpful and completely useless if you're already overwhelmed.

I built Unstick because I've been that person. I've started my portfolio fourteen times and never finished. Not because I'm lazy — because every time I opened a tool, it showed me how much I didn't know yet, and I closed the tab.

Unstick does the opposite. You give it a goal. It gives you exactly three cards:

Start here — one physical action you can do in five minutes
If you have 15 minutes — a slightly bigger one
Not today — a greyed-out card that says: "The rest of the plan exists. You don't need to see it."

That third card is the whole product. The absence of a plan is the feature. No progress bars. No "step 3 of 47." No skill tree.

Who it's for: me. I'm the friend I built this for. I don't have someone else to hand it to this weekend, and I'm not going to invent one. I've started my portfolio fourteen times. This is the tool that would have made me finish.

Demo

Live app: https://unstick-api-c7va.onrender.com

Type a goal. Click the button. Three cards.

API endpoint (for the terminal-inclined):

bash

curl -X POST https://unstick-api-c7va.onrender.com/api/unstick \
  -H "Content-Type: application/json" \
  -d '{"goal":"start a creative portfolio","minutes":15,"energy":2,"location":"home","time":"21:30"}'

Video: https://www.youtube.com/video/JtzAP9eyUZc

Note on the demo: the fine-tuned classifier is trained specifically for creative portfolio goals. For other goals it still returns scope-safe actions, but the domain fit is weak — a "finish my thesis" prompt will give you portfolio-shaped actions. That's a real limitation, not a hidden one. A next step would be broadening the training set.

Code

GitHub: github.com/vinksgoyal/unstick

Structure:

app/ — FastAPI backend + Tinker + Backboard clients
frontend/ — the three-card UI
training/ — dataset, label helper, Tinker fine-tune script
eval/ — base vs fine-tuned evaluation harness
unstick-evidence/ — every screenshot, log, and number cited in this post

How I Built It

The prompt says to use open-source AI at the core. Here's what that actually means in this project.

The engine: local open-weight models

The candidate generator runs Gemma 2B locally through Ollama. When you type a goal, the app asks Gemma to decompose it into candidate actions. That call happens on your machine. No cloud API sees the raw brain-dump.

Gemma is not good at this task out of the box. Here's what it produced when I asked it to generate actions for "Start a creative portfolio":

text

"Stand up and stretch for 30 seconds."
"Go to the kitchen and pour a glass of water."
"Pick up a pen and paper and start doodling for 5 minutes."
"Shuffle a deck of cards."
"Take a five-minute walk in your neighborhood."

None of those have anything to do with starting a portfolio. The base model drifts into generic wellness advice because it can't hold the goal in mind. That's the "before" state.

The classifier: Tinker fine-tune

The scope-safety classifier is the actual product. Its job is to look at a (goal, action) pair and decide: is this action safe to show an overwhelmed person?

I defined six ways an action can fail:

Failure	Example
`reveals_scope`	"Sketch your homepage layout"
`needs_new_skill`	"Learn Figma"
`needs_decision`	"Pick your best five pieces"
`not_physical`	"Think about your design style"
`needs_other_person`	"Ask a friend for feedback"
`off_topic`	"Pour a glass of water" (for a portfolio goal)

I hand-labeled 128 (goal, state, action) triples across those six categories, plus safe examples. 100 went to training, 44 to a held-out set.

Then I fine-tuned Qwen3-8B with LoRA on Tinker, using the SDK directly with masked cross-entropy loss on the answer tokens only.

Results

Model	Accuracy	Safe-F1	Fail-F1	Latency	Rows
Base Qwen3-8B	0.2727	0.4000	0.3721	96s	44
Fine-tuned (Tinker LoRA)	0.7045	0.7778	0.9429	118s	44

Base model: 27% accuracy. Fine-tune: 70%. The fail-class F1 — how well the model catches bad actions — went from 0.37 to 0.94. That's the difference between a demo and something you'd actually use.

The memory layer: Backboard

Unstick remembers how you act, never what you said.

After you complete an action, the app stores an abstract signal in Backboard:

json

{
  "goal_id": "abc123",
  "energy": 2,
  "minutes": 15,
  "time_bucket": "evening",
  "action_type": "file_rename",
  "completed": true
}

No content. No goal text. No draft titles. Just six fields about what kind of moment this was.

On the next request, Backboard's semantic search returns the signals that match the current state: "This user completes file-rename actions at 9pm with energy 2 about 80% of the time." That context shapes which candidate the model ranks highest.

The record() method enforces the boundary at the code level — any field outside the allowed set raises ValueError. There is no path by which your draft titles or half-formed thoughts reach Backboard.

Deployment: Render

The whole thing runs on Render — FastAPI backend, static frontend, one service. The deployed version uses Tinker for both candidate generation and classification (Ollama doesn't run on Render's free tier).

Live URL: unstick-api-c7va.onrender.com

Cold start is 60–90 seconds on the free tier. Subsequent requests are fast.

Why Does Open Innovation Matter?

Three specific reasons, not abstract philosophy.

1. The content never leaves your machine.

The raw material for a portfolio is unfinished work. Half-drawn things. Abandoned drafts. Songs you're embarrassed by. That's the most personal stuff a person owns, and it's exactly the stuff that has to go into the tool for it to be useful.

If this ran on a closed API, every abandoned draft and every "I don't know what I'm doing" brain-dump would sit on someone else's server. With Gemma running locally through Ollama, it doesn't. That's not a talking point — it's the reason the tool can be honest with you.

2. The classifier is trained on one person's patterns.

I fine-tuned the model on 100 examples I labeled by hand. Not 100,000 scraped examples. Not a commercial dataset. Mine. The fail taxonomy — reveals_scope, needs_new_skill, needs_decision — those categories exist because I noticed those were the exact things that make me freeze.

You cannot fine-tune a closed API on one person's patterns. The model belongs to a vendor, and you get the vendor's judgment about what "good" means. With Tinker and an open-weight base model, the model belongs to me.

3. It costs nothing to run.

Gemma 2B runs on a laptop with no GPU. Ollama serves it with one command. The local version of Unstick costs $0 per message. I can use it 30 times a night without thinking about the bill. For a tool designed to be used 30 times a night, that matters.

4. The model is swappable.

I ran Gemma, then Llama, then Qwen on the same prompt during development. I swapped the classifier architecture between fine-tuning runs. With a closed API, you get one model and one behavior, forever. With open weights, the whole design space stays available.

That's what open innovation made possible here: a tool that was honest because it was private, and personal because it could be trained on one person.

My Agent Session

The whole project was built with GitHub Copilot's coding agent. You can see it in the git history — Copilot commits its own session state:

text

261a8ba Wire Backboard behavioural memory (signals only, never content)
0d7f165 Agent host session 177818fb-a6ca-41c7-be2d-f5476e619709 - turn 1
db22d40 Drop separate static service; FastAPI serves the frontend
242fbbb Serve frontend from FastAPI at root; use relative API base
33be99c Agent host session d5a1d459-9a19-48f0-93b5-d32eae080cc7 - turn 7
5aafbfb Wire Tinker fine-tuned classifier into the app
26d73d6 Fine-tuned Qwen3-8B via Tinker: 27% -> 70% accuracy on held-out set
03d3beb Agent host session 4de8b0e3-5d57-4107-917a-5535793c011b - turn 3
7cb3fd0 Build Unstick scaffold

Three Copilot agent sessions are visible in the log:

4de8b0e3-5d57-4107-917a-5535793c011b — initial FastAPI + frontend scaffold
d5a1d459-9a19-48f0-93b5-d32eae080cc7 — Tinker integration
177818fb-a6ca-41c7-be2d-f5476e619709 — Backboard wire-up

What Copilot did well:

Scaffolded the entire repo from a single mega-prompt
Wrote the FastAPI backend, frontend, and test suite
Created the GitHub Actions workflow and initial render.yaml
Correctly refused to invent Tinker API endpoints (left TODO: verify docs comments)
Debugged the Datum length mismatch after I described the exact error

Two bugs Copilot missed that I fixed by hand:

Constraint checker was treating the user's available minutes as the action's duration, so every action failed the "5 minutes" rule. Fixed by removing the state read and only checking the action text.
Tinker Datum construction used only the prompt as model_input while target_tokens used the full sequence, causing a 3-token mismatch. Fixed by using full_ids[:-1] as input and full_ids[1:] as targets, then adding an assertion to catch future mismatches.

Prize Categories

Tinker (Thinking Machines) — Fine-tuned Qwen3-8B with LoRA on 100 hand-labeled examples. Base model: 27% accuracy. Fine-tune: 70%. Fail-F1: 0.37 → 0.94. Full recipe in training/tinker_finetune.py, evaluation in eval/run_eval.py.

Render — Live app at unstick-api-c7va.onrender.com. FastAPI backend + static frontend, one service. Deploy config in render.yaml.

Backboard — Behavioural memory layer storing only abstract signals (never content). Verified end-to-end: stored a signal, searched for it, got it back with a 0.61 relevance score.

GitHub Copilot — Whole project scaffolded in agent mode. Three session IDs visible in the git log. Two Copilot bugs caught and fixed by hand.

Ollama + Gemma 2B — Local open-weight model for candidate generation. Runs offline, costs $0 per message, keeps the raw brain-dump on the user's machine.

FastAPI + Pydantic — Backend. Tests pass, CI green.

What I Learned

The hard part wasn't the fine-tune. It was deciding what "bad" means.

Defining the six failure categories was the real product work. Once I could name why an action was bad — reveals scope, needs a decision, requires a new skill — the classifier became tractable. Without those labels, the fine-tune was just vibes.

Open-source AI is a specific advantage, not a slogan.

For this project, "open" meant four concrete things: the drafts stay on my laptop, the model is trainable on my patterns, running it costs nothing, and I can swap the base model when I want. All four of those are real features, not philosophy.

The base model is 27% wrong in ways that look helpful.

The most important finding: the base model didn't produce garbage. It produced generic wellness advice that looked reasonable. "Stand up and stretch." "Take a walk." Those are fine sentences. They're just not portfolio actions. A closed API would have shipped that behavior forever because it looks fine in a demo. The fine-tune is what catches it.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

DEV Community: Vinks Goyal