Daily Noodle · AI product
Rethinking mental wellbeing and growth with AI
A journaling app with a bet on mental wellbeing: one question a day teaches an AI your emotional and behavioral patterns, then reflects them back with concrete things to try. I designed and built it solo, with AI.
What is Daily Noodle?
Daily Noodle started as a strategic bet: that the retention problem below is a matter of product shape, not willpower. The shape I bet on is a single daily loop — one question that teaches an AI your patterns over time, then reflects them back with something to try.
Every day the loop repeats, and it compounds over a year.
Why it doesn't stick
The Problem
Self-understanding drives growth — and it's exactly what you can't see from inside a single day. Those patterns only surface over months, but journaling has a brutal retention problem: most people drop off within weeks, so the patterns never accumulate.
Retention craters in weeks; the payoff only builds over months. The whole product exists to close that gap.
Retention craters in weeks; the payoff only builds over months. The whole product exists to close that gap.
Two forces kill the habit
The blank page. Deciding what to write is a tax you pay before a single word — and some days you just don't.
No visible payoff. Understanding yourself arrives months later; day four feels exactly like day three.
What “solved” would mean
- 1People come back — no consistency, no record for the AI to learn from.
- 2The patterns ring true — recognizably you, not horoscope-generic.
- 3The insight moves something — a behavior shifts; you feel more understood.
The Approach
A one-person product team, with AI as the execution layer
I set a constraint: ship a complete product solo, fast, without dropping the bar. So I ran it as a pipeline of AI tools — each owning a stage, my judgment on top. It's the same operating model I run with enterprise teams: own the direction and the quality bar, delegate the execution — except here the team was AI. Once execution is cheap, the scarce skill is deciding what to make and knowing when the machine is wrong.
The tools are swappable. What shipped a good product is the calls they don't make — which four mood families, what to cut, when the convincing thing the model produced was wrong.
The tools are swappable. What shipped a good product is the calls they don't make — which four mood families, what to cut, when the convincing thing the model produced was wrong.
Designing with Pencil.dev, deciding with judgment
Design started in Pencil.dev — fast exploration, with my judgment picking the direction. The clearest example is the mood system: ~45 moods are far too many to read on a calendar, so I compressed them into four families, ordered by intensity and colored for meaning.
Where judgment overruled the obvious choice
Muddy — hard to scan
Reads in half a second
Same year of entries, two groupings. Six categories muddied; four read in half a second — so I reverted. The git history still shows the arc.
Building with Claude Code
From design I moved into Claude Code and built the real thing — a typed React app, not a prototype. The split that matters for how I work: I architected the experience; AI executed the code.
And it ships continuously: Cloudflare deploys from the repo on every push, as an installable PWA, so every commit is a release and I iterate against the live product, not a local copy.
I architected
- The two-tier mood detection — an instant local keyword tag, with the AI classifier refining it in the background.
- The observation engine — what counts as a strength, a challenge, a pattern, and how insight is framed so it feels earned rather than generic.
- The privacy model — what's private, what's shareable, and the explicit per-entry toggles that draw the line.
AI executed
- The React component layer, state management, and responsive behavior.
- The Supabase queries, the edge functions, and the data plumbing.
- The unglamorous 80% — wiring, types, and refactors that would otherwise eat the timeline.
66
commits to ship
76%
AI-paired
1
person team
0 → 1
live product
50 of 66 commits were paired with Claude (Sonnet 4.6, Opus 4.7 & 4.8) — the build is genuinely AI-made, and version-controlled to prove it.
Process · Decisions
The product calls that don't show up in a screenshot
Never make the writer wait — reflecting should never feel like it's buffering. That bar is what drove the whole instant-save design.
Sharing is always a deliberate, per-entry choice — never an accident.
Write before you sign up. The unsaved entry is held and auto-submitted after sign-in, so the value lands before the ask.
One shared question a day. Because everyone answers the same prompt, community stays a quiet, opt-in moment — never a feed you perform for.
Privacy was the starting constraint
Journal entries are the most personal data a person has, so privacy was the starting constraint: a Postgres schema with row-level security, private by default. The AI features run as edge functions so nobody's writing — or the API key — goes anywhere it doesn't have to. I owned the schema and security model; AI wrote the functions against it.
The Gemini key — and your writing — never reach the browser.
The Gemini key and your writing never reach the browser.
The Core · Product AI
The AI that learns who you are
This is the heart of the product — and mostly a design problem, because a tool about your inner life can't feel like it's buffering or sound like a generic chatbot. Two Gemini functions do the work: one tags the mood behind each entry the instant you save; the other — diagrammed below — reads a whole year of them to find who you are.
It learns the patterns in how you feel and behave and the goals you keep circling, then ties them together — here's what's recurring, here's how it relates to who you're trying to become, here's one thing to try.
The constraints are the design: grounded in your own words, capped at four observations so it reads as clarity not an audit, and responsible — when a heavy pattern persists, it points toward real help, not just another app screen.
The Result
A mirror that helps you grow
The output of all of this is a complete, live product with one job: helping a person see themselves clearly.
The daily question removes the blank page. The resurfaced past answers let you watch yourself change. And the Reflect page assembles a year of writing into a streak, a mood heatmap, the themes you keep returning to, and the AI's observations — understanding you earn just for showing up.
Nobody fills out a goals form or drags a mood slider. The picture is a byproduct of the habit — which is the order of operations mental growth actually needs.
Responsive and installable: every surface reflows to a single column, and navigation drops to a thumb-reachable bottom bar.
Validation
How I know whether it worked
Here's where I'll be straight: as a self-initiated project, this hasn't run long enough for a clean retention verdict, and I'd rather show you my thinking than invent a number. So I'll measure it against the three criteria I set at the start — what's validated, and what's still a hypothesis with a test attached.
People come back
I use it daily — the person most likely to quit (me) hasn't.
The patterns ring true
In my own use, the observations read as recognizably me. Needs a real n.
The insight moves something
Instrument whether suggestions get read — and taken.
Return rate vs. a blank-journal baseline
Day-7 and day-30 return — the number that proves the bet.
Would it matter at scale?
Back-of-envelope unit economics: at a category-typical ~4% free-to-paid, every 10K active users is ≈400 subscribers — on the order of $30K ARR per 10K, and it scales with reach. The point is the model, not the figure.
Reflection
Execution got cheap. Judgment didn't.
I set out to build something genuinely personal — an AI that learns who you are and helps you grow — the way I now think product gets made: with AI as both the intelligence inside it and the team that ships it.
When a model can design the screen, write the code, and generate the insight, a designer's value doesn't disappear — it concentrates into the decisions: what to build, what to cut, how to make machine insight feel humane, and when the convincing thing the model produced is wrong. Here the delegate was AI; on a team it's engineers, PMs, and designers — the posture is the same: set direction, hold the bar. That's the version of this skillset I'd want a team to hire.
