Main landing page of choicely where the user logs all decisions and they get feedback for all the decisions which they have logged.
Part of the survey which the user takes so that choicely gets a detailed idea about the user and their habits.
The reflections provided by choicely based on the previous logged decisions.
Here users gives positive feedback for a decision he logged earlier.
Here users gives negative feedback for a decision he logged earlier ie he ended up regretting the decision.
Choicely giving an overview for the previous decisions which the user logged explaining the likelihood of regret.
User is logging a new decision under the read it back mode.
The track record section showing the difference between the predicted regret and what actually happend.
The regret forecast section of choicely showcasing the regret probability of the users common decisions.
All the recent decisions are logged here along with how they actually turned out.
Choicely giving the user a detailed suggestion about the decision the user asked providing a regret estimate and weighing in the criteria.
The agent section displaying what all choicely has done for the user.

Inspiration

Most of what wears me out isn't the big decisions it's the small ones I never close. Should I skip the gym again. Should I text her back. Should I quit that club I still pay dues to. I'd already "decided" most of these a dozen times over; I just never let myself off the hook. I wanted a second brain that carries that weight instead of just tracking it one that notices when I've basically already decided and tells me, follows up on the rest, and reasons from my own history when I'm actually stuck. That became Choicely.

What it does

Log a decision in one line, and Choicely estimates how much you'll regret it blending a population average with your own recorded outcomes as history builds. Once it's genuinely sure, it stops asking and just answers: "You always regret skipping meals, so: eat something." It checks back on its own when a decision should've played out, and surfaces patterns you haven't put into words "your mornings go sideways 90% of the time." If you're actually stuck, a grounded debrief takes a messy paragraph and reads it back the real question, what's at stake, a recommendation every claim tied to a number from your own log. An Agent tab shows everything Choicely did on its own, in plain language, so none of it happens behind your back.

How I built it

FastAPI + SQLite backend, no ORM. The regret model blends a population prior with the user's onboarding style and their own outcomes, confidence climbing toward 1.0 with more history auto-answer only fires once it's fully confident and lopsided. Every closed prediction gets scored against reality for a real Track Record tab. Frontend is React + Vite, charts hand-drawn in SVG. The agent log is an append-only event table, a true audit trail, not generated for show. Also: an installable PWA with Web Push, opt-in community priors, crisis guardrails, compare-options mode, 74 pytest tests. For Claude: the model does the arithmetic, Claude only ever reasons over a context block I've pre-computed and pinned. It writes the debrief, triages the agent's backlog, phrases check-ins, writes the weekly reflection, and handles classification, the interpersonal read, and the crisis screen each with its own fallback, so the app works with no API key.

Challenges I ran into

Keeping Claude honest. Early on it saw raw history and invented details. Fix: all retrieval and math in Python, Claude only gets a pinned context block it writes the sentence, not the facts. The agent tab drowning in noise. A normal history produced 40+ near-identical events. Split into "signal" (always shown) and "routine" (last few only), collapsed repeats into one entry. Timezones. SQLite's UTC vs. the app's local wall-clock, everywhere — unglamorous but it took real time to get right. A "Log it" button that looked broken, not slow. Logging a decision could take 7-9 seconds with zero feedback looked crashed. Traced it to three or four sequential Claude calls in one request; moved the non-critical one to a background task and added real loading feedback.

Accomplishments that I'm proud of

Choicely grades its own predictions Track Record scores every closed decision against what happened, misses included, not a marketing claim. The agent's log is a genuine audit trail, written the moment things happen. It's honest about not knowing: auto-resolve needs real history and a lopsided result, and self-harm or medical-crisis inputs get refused a score, on purpose. It works with zero API key. And I caught the slow-logging bug by actually profiling it, days before recording the demo not glamorous, but exactly what I'm glad I didn't ship.

What I learned

Grounding beats prompting trust came from what Claude wasn't allowed to see, not better wording. Saying nothing is a real design problem, not a fallback case. Perceived speed and actual speed are different bugs same request, different fix. And small, honest demo data beats impressive-looking data: I cut a whole category out late because two clean stories beat three.

What's next for Choicely

A real scheduler for the agent loop instead of activity-triggered. Voice-note input into the debrief. Multi-user, with community priors becoming a real shared signal. Calendar hooks, so Choicely catches a decision before the event, not after.