I built a machine that decides so I don't have to 🦥

Johnny Zhu — Sat, 24 Oct 2026 05:46:08 +0000

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

Week 3's theme — Slow and Steady — hit a nerve. Not because I'm fast and furious, but because I'm the opposite: I burn an embarrassing amount of brainpower every day on decisions that don't matter. What to eat. What
to watch. Whether to go. Whether to buy. Tiny, forgettable choices, yet each one charges a small tax of attention.
So I asked: what if I could outsource decisions themselves? Not the
execution — I can order food in three taps. The deciding. The part
where you stand in front of the fridge for six minutes, door open, like a confused penguin.

What I Built

DecideForMe — a decision outsourcing engine. You type your dilemma,
optionally throw in some options (or don't — the engine will invent them for you, that's part of the laziness), and hit one big red button. Out comes a verdict: one option, picked decisively, with a witty one-line justification and a confidence score between 87% and 99%. Never 100%. A true outsourcer leaves room for drama.
There's also a daily counter showing how many decisions you've outsourced today, and a "Disagree?" button that lets you appeal the verdict — where The Defender politely doubles down instead of re-deciding. ("Your regret has been noted and automatically discarded.")

Demo

Live demo: https://decide.motinextai.com — the Decision Outsource Machine on my own domain via Cloudflare Tunnel. Prefer local? python app.py → http://localhost:5001 (mock mode needs no API key).

Code

https://github.com/jiezantech-max/decideforme — public repo, MIT license.

How I Built It

The whole brain is an open-weight LLM (default: DeepSeek) called
through an OpenAI-compatible API. Two carefully written system prompts do all the work:
The Decider is explicitly forbidden from hedging. No "it depends",
no balanced pros-and-cons. It must return JSON —
{decision, reason, confidence, options_considered} — with exactly one winner.
The Defender handles appeals. Instead of re-deciding, it doubles
down with a one-liner that politely dismisses your regret.
The app itself is a small Flask service with a playful single-page UI, including a stamp animation ("OUTSOURCED ✓"). There's also a mock mode — curated option pools and canned witty reasons — so the full flow works with zero API key and a demo is one python app.py away.

Why Does Open Innovation Matter?

The engine is built around the open model ecosystem, not a closed black box. Because the brain is an open-weight LLM behind a standard OpenAI-compatible interface, the app stays portable and cheap: swap in any open model, run locally if you want, and never depend on a single vendor's pricing or uptime. Mock mode even works fully offline. Open innovation is what makes "outsourcing decisions" a toy anyone can run, not a service someone has to rent.

My Agent Session

I didn't record a DevRelay session for this build — but the whole thing happened in the open. The repo's commit history is the session log: github.com/jiezantech-max/decideforme/commits.
Five commits, four days, one lazy arc:

Scaffold — Flask app, the Decider/Defender prompts, mock mode, the OUTSOURCED stamp
Docs — bilingual README, deploy guide, first submission draft
Submission draft v2 — rewritten against the official template
Live demo — decide.motinextai.com via Cloudflare Tunnel
Final polish — post-ready

The laziest decision engine, built the lazy way: mock mode first (zero API key), demo link last, no yak-shaving in between.

The Lazy Payoff

Before: 5 minutes of fridge-staring, 20 tabs of "best ramen near me" reviews, one group chat poll that nobody answers.
After: type the dilemma, hit the button, 10 seconds, done — with a
confidence score high enough to blame.
I outsourced 14 decisions this week. I regret zero of them. The machine didn't even let me regret them.

DEV Community: Johnny Zhu