DEV Community: Vineet Negi

I built a journaling app where the database deletes your letter the day after we send it. Day 13 of 30.

Vineet Negi — Sun, 03 May 2026 14:36:31 +0000

FutureMe has 15 million letters in its database. They've been there since 2002. Some of them will be there in 2050.

Evengood will have zero.

This week I shipped The Quiet Letter — a feature where you write to your future self today, we email it on a date you pick, and we hard-delete the row from our database within 24 hours of sending it. The email is the only artifact. We don't keep a copy.

Every feature in Evengood is built around a question: what would a journaling app look like if it weren't trying to maximize for retention?

What I shipped this week

A new page at /letter. You write a letter to yourself. Voice or text. You pick a delivery date between 7 days and 5 years from now. You enter your email. You hit seal.

We send a confirmation email — double opt-in, same as our Sunday pattern email. You confirm. The letter sits in our database in exactly the state you wrote it.

On the date you picked, an hourly cron job picks it up and emails it to you. The subject line is a letter you wrote on [the day you sealed it]. The body is the letter, verbatim, plus one footer line: this letter has now been deleted from our server.

A daily cron job at 3am UTC hard-deletes every row whose sent_at is more than 24 hours old. Unverified drafts get purged after 7 days.

One table. Four edge functions. Three new pages. One small new link on the home page that says or write a letter to a future you →. That's it.

What we deliberately did NOT build

No letter inbox. No list view of pending letters. There is no screen anywhere in Evengood where you can see what you've written. The only place the letter exists, between sealing and delivery, is in a Postgres row you can't read.

No edit-after-seal. No "oh wait, I changed my mind." Once you hit seal, the letter is committed.

No public letters wall. FutureMe has one. We deliberately do not.

No reminder emails. No "you have a letter coming in 30 days!" notification. The whole point is that you forget you wrote it. The surprise IS the feature.

No analytics on the body content. We don't read your letter. We just hold it long enough to deliver it.

No account, no login. The verification token IS the only identity.

Why this took a full week

The code itself is small — maybe 500 lines across the whole feature. What took the time was the deletion architecture.

Most "send me a letter in the future" features that already exist treat the database as permanent. The letter sits forever. The user data accumulates. That's the default in Postgres because nothing deletes itself.

To make deletion the actual default required:

Two separate cron jobs (one for delivered letters, one for unverified drafts)
A clean separation between verified and unverified state, so unconfirmed drafts also get purged
Copy on every screen that says, in plain language, what gets deleted and when
An email body that ends with the deletion confirmation, so the user has receipts

The email is the only artifact. That sentence is the whole product.

The weird part

FutureMe — which I love and respect — has been operating since 2002 and has delivered over 15 million letters. The site is still standalone. It's never been integrated into a daily reflection practice. You can't write a letter on FutureMe and also do anything else with your day there.

Evengood is the opposite shape. The Quiet Letter sits inside a daily reflection app, but the letter itself doesn't accumulate. It passes through. The only thing that stays is the practice.

Day One can't ship this. Their pricing is justified by lifetime data retention. A feature whose primary verb is delete would directly undermine the upsell.

Reflectly and Stoic can't ship this. Their growth model is daily re-engagement. A feature that says we'll be quiet for 6 months and then send you one email destroys their DAU.

Apple Journal can't ship this. Apple doesn't run scheduled outbound email infrastructure for users.

It's a feature only an app with the wrong incentives would build.

Where Evengood stands at Day 13

60-second voice or text reflection. No account. Nothing saved server-side.
Witness Mode: one quiet sentence as tomorrow's invitation.
A Quiet Pattern: weekly summary detecting heavier and lighter days.
The Pattern by email: 52 sentences a year, one every Sunday morning. Double opt-in. One-click unsubscribe.
The Quiet Letter (new this week): write to your future self. We deliver once. Then we forget.

Five features. Zero notifications. Zero streaks. Zero "you haven't journaled in 3 days."

The live app is here: https://app-b3tuv7opfegx.appmedo.com

The letter compose page is here: https://app-b3tuv7opfegx.appmedo.com/letter

17 days left. One more weekly feature to go.

Built entirely on MeDo. The whole feature shipped in a single Deep Build turn — 30 credits, ~500 lines of new code, zero edits to existing reflection or pattern code.

I built a journaling app where the only email it sends is 52 sentences a year. Day 12 of 30.

Vineet Negi — Sat, 02 May 2026 11:56:56 +0000

Day 10, 11, and 12 of building Evengood — a 60-second journaling app — for the Build with MeDo $50K hackathon.

If you've read my previous posts, you know the spine of this project: every product decision is a fight to NOT add the thing every journaling app already has. No streaks. No gamification. No therapy voice. No human face in any generated image. No auto-play audio. No "you've been quiet for 3 days, are you okay?" notification.

This week the fight was about email.

The default email behavior of every wellness app

Open any journaling or wellness app and look at what lands in your inbox after a month. You'll find:

A weekly digest you didn't ask for.
A "your week in numbers" report with charts.
Streak reminders ("don't lose your 14-day streak!").
"We noticed you've been quiet" check-ins.
Promotional emails for the premium tier.
Affiliate emails for meditation apps.
Surveys, NPS prompts, "how are we doing?".

The unsubscribe link is usually 9-point grey on grey at the bottom, behind a confirmation page that asks if you're sure, with a final "are you really sure?" modal.

Email is the unwell part of wellness apps.

What I shipped this week

Evengood now has exactly one email surface, and it's called The Pattern, by email.

Here's the entire copy on the home screen, verbatim:

The Pattern, by email.
One sentence about your week, every Sunday morning. Nothing else.

That's the feature. That's the whole feature.

If you opt in, you get one email per week. The email contains exactly one sentence — the same Pattern sentence the app generates for you on Sunday morning, the one that reads something like "there is a rhythm of late meetings leaving you drained, followed by quiet walks that steady you."

Header in Georgia italic. Body in a single Helvetica paragraph. The app's locked palette in a soft gradient. No subject-line cleverness. No "hey [first name]". No tracking pixel. No unsubscribe footer in 9-point grey.

52 sentences a year if you stay opted in for the full year. Most people won't. That's fine.

What I deliberately did NOT build

Here's the email-feature backlog I rejected this week, in the order it was tempting:

1. Streak reminders. Easy engagement win. Rejected because shame is not a habit loop I want to build for someone closing their laptop at midnight.

2. "You haven't reflected in 3 days" emails. Rejected because if someone stops using the app, the app should be okay with that. Notifications-as-guilt is the entire problem.

3. Weekly digest with multiple sentences, bullet points, and charts. Rejected because the Pattern is one sentence. The email is the same one sentence. Adding anything dilutes it.

4. A welcome email when you opt in. Rejected because every app does this and nobody wants it. If you opted in, you already know what the app is.

5. Tracking pixel for open-rate analytics. Rejected because I don't need to know if you read it.

6. An unsubscribe confirmation page. Rejected because if you click unsubscribe, you've unsubscribed. No confirmation. No "are you sure?". No survey about why.

The unsubscribe link is at the top of the email in the same font size as the body. One click via signed token and you're out. No login. No "sign in to manage your preferences."

What I did build

Four edge functions and one table:

subscribe-pattern — validates the email, stores it as unconfirmed, generates a confirmation token, sends the one-time confirmation email.
confirm-pattern-subscription — verifies the token, flips the row to confirmed. That's the only thing it does.
send-pattern-emails — runs Sunday morning. Pulls confirmed subscribers. Generates each person's Pattern from the most recent week of reflections. Sends one email per subscriber.
unsubscribe-pattern — verifies the unsubscribe token, marks the row unsubscribed. Token is one-click, no auth required.

The table has row-level security so the anon key can write new subscriptions but can't read anyone else's email — not even its own row after insert. The server doesn't store your reflections. It only knows your email and a device ID, in separate tables that don't join.

Total bytes the server stores about you per year if you opt in: your email address, plus 52 timestamps of when emails went out. That's it.

Why this took a full week

It didn't take a week to build. The four edge functions are maybe 200 lines of TypeScript total. The email template is 60 lines of HTML.

It took a week to NOT build the seven other features I kept wanting to add. To delete the welcome email I wrote on Tuesday. To delete the digest format I prototyped on Wednesday. To delete the "you used the word 'tired' three times this week" insight email I wrote on Thursday and was very proud of.

Every deleted feature was a feature.

Where Evengood stands at Day 12

Days 1–3: built the 60-second reflection loop and the watercolor keepsake.
Days 4–7: shipped Pattern detection — heavier-day words in peach, lighter-day words in lavender, one quiet sentence about the rhythm of your week.
Days 8–9: shipped Witness Mode (the once-a-week night the app refuses to reflect on your day).
Days 10–12: shipped The Pattern, by email — one sentence, every Sunday, that's the whole feature.

18 days remain.

The list of things I'm not going to build is longer than the list of things I am.

That's still the whole product.

Live: https://app-b3tuv7opfegx.appmedo.com

BuiltWithMeDo

I built a journaling app where the AI refuses to talk on Sundays. Day 8/9 of 30.

Vineet Negi — Mon, 27 Apr 2026 03:49:08 +0000

Day 8 and 9 of building Evengood — a 60-second journaling app — for the Build with MeDo $50K hackathon.

This one took two days because I went the wrong way first.

The trap I almost fell into

By Day 7 I had what looked like a finished product. Voice capture, a calm Tomorrow line, a Kling watercolor keepsake, a 7-day streak ribbon, a Pattern detection that surfaces a one-line rhythm of your week, and a Quiet Mode that shuts the AI up entirely on grief days. v28. Working. Pretty. People could use it.

So Day 8 the obvious move was: ship a small polish feature. Maybe surface yesterday's Tomorrow line in tiny grey above the mic. Maybe a "save the week" export. Maybe a streak ribbon that pulses on the dot for today. Safe. Iterative. The kind of thing every journaling app already has.

I asked Claude to scan every competitor — Stoic, Day One, Reflectly, Daylio, Finch, Apple Journal, How We Feel, Mood Meter, Rosebud, Mindsera, Replika. Then to brainstorm a Day 8 feature that didn't exist in any of them.

The first answer was a "Yesterday's Tomorrow" line. Surfacing yesterday's prompt above the mic. Soft. Tasteful. On-brand.

I killed it.

I didn't want to ship a feature that any other journaling app could build in an afternoon. Restraint is supposed to be the thesis of this product. If the thesis is real, there should be features the category structurally cannot copy. Not because they're hard — because they're contrary to how every other product makes money.

So Day 8 became research and Day 9 became the build.

The thing nobody is building

Here is the structural observation. Every AI journaling app on the market is built around the assumption that the AI's job is to say more. Go deeper. Probe. Reframe. Suggest. Coach. Mentor. Advise.

Rosebud's UVP is literally "go deeper." Mindsera's is mental models. Stoic's is mentor advice. Replika's whole pitch is the AI talking back. Their entire business model — and their reflex to ship more from the model — is more output.

The 2025 Brown University study of LLM "therapy chatbots" catalogued fifteen distinct ethical violations across the major models. The biggest one they named was "deceptive empathy" — phrases like "I hear you" and "that sounds so hard" that mimic care without holding any. The category's failure mode is structural. The AI talks too much, in a register it doesn't actually have authority for.

Quiet Mode (v28) was my first move against that. When the user types "my dad died last week" or "I had a panic attack," Evengood doesn't reframe. The model is silenced. The screen says: "some days don't need reframing. be gentle with yourself tonight." No popup. No emoji. No analytics event. It just gets quieter.

That worked. It felt right. But it was content-triggered — only on heavy days. Calm days still got the full 2-minute reflection. Which meant Quiet Mode was a single point, not a thesis.

For Day 9, I wanted the second point on the same axis.

Witness Mode

What I shipped is called Witness Mode. It runs once a week. By default Sunday evening, but you pick the day in settings.

When you open the app on a Witness Night and reflect for 60 seconds — typed or voice — the response screen does not load a 2-minute reframe. It does not load a Tomorrow line. It does not load a theme word. It does not play TTS speech.

Instead, the AI returns one sentence. Under fifteen words. About the form of what you just said — a recurring word, a surprising word, an absence — never the meaning. Then the screen sits with you in silence for four seconds. Then the closing line reads come back tomorrow. and that is the whole evening.

Examples of what the model is allowed to return:

i noticed you said the word "tired" four times
tonight you didn't talk about work
what stood out was the gap between what you wanted and what you did
you returned to the word "ok" — three different times, three different ways

That's it. No advice. No empathy phrases. No compliments. No follow-up questions. No interpretation of meaning.

The role is borrowed almost verbatim from a forty-year-old practice in narrative therapy called outsider witnessing, formalized by Michael White and David Epston in Maps of Narrative Practice (2007). The witness's job is structurally bounded: never advise, never applaud, never interpret meaning, never offer follow-up. The witness names what resonated in the form of what the person said — and then sits with them.

The category does not have a verb for this. The verbs are: track, write, coach, chat, record, reflect-back. None of them are witness. Now one is.

Why no competitor will copy this

This is not hard to build. The whole feature is one new lib file, a few new localStorage keys, one replaced LLM system prompt, one new regex guard module, two new settings rows, and a restructured response screen. About 2,800 lines of TypeScript change in total. MeDo did the build in seven minutes.

The reason no one else has it is not technical. It is structural.

A subscription journaling app with monthly retention metrics needs the AI to talk more, not less, on the days when nothing is wrong. Calm days are when streak-driven products quietly maximize session length. A weekly evening where the AI deliberately does less than on a normal night reads as a regression on every dashboard the category lives on.

It is also philosophically backwards for them. Their pitch is the AI as coach, mentor, friend. A bounded outsider-witness role is not a brand position they can hold without rewriting their UVP.

So the moat isn't the code. It's the position the code asserts.

The calm-tech lineage

While I was building this I went back and re-read Mark Weiser, John Seely Brown, and Amber Case's calm-technology principles. Weiser and Brown wrote that "technology should communicate but doesn't need to speak" and "the right amount of technology is the minimum needed to solve the problem." Case formalized eight of these principles in 2015 and now runs a Calm Tech Certified program.

Evengood was always intuitively calm-tech. I just hadn't said it out loud. Witness Mode is the moment I'm naming the lineage. The thesis is: in 2026, an AI product that gets quieter as the user gets more vulnerable is not just a feature choice — it is a different product category from the one all my competitors are competing in.

Streak research is moving the same way. Katy Milkman's recent work argues that streak design trains people to care more about not failing than about succeeding — surveillance dressed as resilience. Evengood has a 7-day streak ribbon, but it does not show a number. It does not lecture. It just fills a dot. Witness Mode entries fill the dot the same as any other entry, with no special badge, no count, no "you witnessed three times this month" notification. That last one would be gamification, which is forbidden by the spec.

What I deliberately did not build

This list is half the work.

No "tonight is witness night" push notification. The reframe must be in the response, not in the prompt — pre-framing the capture screen would corrupt what the user says toward the system's expectation.
No streak counter as a number. Anywhere.
No "Witness Night" badge or progress ring.
No mood-trend chart, no leaderboard, no level system, no XP.
No popup, no toast, no red error state. Failure is silent fallback, every time. If the LLM returns something that violates any of the spec's word rules, a default line — tonight, i'm just sitting with you — is substituted on the client and the user never knows anything went wrong.
No login, no account, no password, no SSO. None of the previous 28 versions had auth. This one didn't add it either.
No Witness Mode firing on a heavy day. Quiet Mode supersedes always — a heavy-day signal must always route to Quiet, even if it happens to be Sunday. Witness is a calm-day ritual; Quiet is a heavy-day refusal. They never overlap.

The regex guards

Defense in depth. After the LLM returns its single sentence, the client runs five guards before rendering or storing:

export const FORBIDDEN_WORDS = /\b(should|must|need|ought|try|maybe|perhaps)\b/i;

export const EMPATHY_PHRASES = [
  "i hear you", "that sounds", "i'm sorry", "be kind to yourself",
  "you could", "you should", "i feel", "you feel", "must be",
];

export const ALLOWED_OPENERS = [
  "i noticed", "tonight", "what stood out was",
  "you said the word", "tonight you didn't", "you returned to",
];

export const DEFAULT_LINE = "tonight, i'm just sitting with you";

export const MAX_WORDS = 15;

If the line exceeds 15 words, contains a forbidden word, contains an empathy phrase, doesn't start with an allowed opener, or contains CJK characters (English-only enforcement), it is silently swapped for DEFAULT_LINE. Sentry breadcrumb. No console error. No user-visible failure.

This is the part the LLM industry mostly does not do. The system prompt tells the model what the role is. The client guard refuses to render anything that violates the role even if the model drifts. Trust the model less than the spec.

What ships next

Day 10 onward, on the same spectrum:

A v40-ish feature called anonymous definitional ceremonies — opt-in, three users on the same day each pick the same theme word, and on Sunday evening each one sees one anonymous line from another about how that word sat with them. No content shared. No chat. No identity. Just three witnesses, one word, one Sunday. This is the long arc Witness Mode is the seed of.
A feature called The Wake — programmable forgetting. Reflections expire after a window the user sets unless they explicitly mark them "kept." Default: let the day go. The opposite of every product whose business model depends on the user's data accumulating forever.
A feature called Letter to Tomorrow — once a month, instead of a Tomorrow line, you write one to your future self. Sealed. Returned on a date you pick. No notification. No reminder. It just appears.

All three obey the same axis. Restraint as feature, not absence.

Try it

https://app-b3tuv7opfegx.appmedo.com/

Open settings. There's a new section called evening. Toggle on witness night. Pick a day. Come back that evening.

If the model returns one sentence about a word you used, and the screen sits still for four seconds, and nothing else happens, the feature worked.

That is the entire feature.

— Day 9 of 30. v29. #BuiltWithMeDo

The most important feature in our AI journaling app is the one where the AI shuts up. Day 6/7 of 30. 🌿

Vineet Negi — Sat, 25 Apr 2026 06:56:11 +0000

Day 7 of building Evengood — a 60-second end-of-day reflection app — in public on the Build with MeDo hackathon.

Today I shipped the feature I'm most proud of in seven days of building.

It's the feature where the AI doesn't do anything.

The problem

Every AI journaling app I've ever tried has the same failure mode. You type something heavy — "my dad died last week," "I had a panic attack on the train," "I think I'm getting fired Monday" — and the LLM cheerfully reframes it into a growth-mindset Hallmark card. "What a meaningful day of self-reflection! Here are three things to be grateful for..."

It's the worst possible response. It tells the user the product wasn't built by anyone who has ever had a hard day.

And it's the default behavior of every "wrap GPT in a textarea" app shipped this year.

What I shipped today

Quiet Mode. A pure-function detector that runs on the user's reflection text before it ever leaves the device. If the text contains signals from four categories — grief (died, funeral, passed away), crisis (panic attack, breakdown, can't breathe, want to die), breakup/loss (broke up, divorce, fired, miscarriage, diagnosis), or extreme overwhelm (I can't do this anymore, I give up) — the app does less, not more.

Specifically:

The Gemini reframe call is skipped entirely. No API hit, no token spend, no AI rewriting your grief into a productivity tip.
The text-to-speech call is skipped too.
Instead, a soft acknowledgment card replaces the reframe card:

Some days don't need reframing.

Be gentle with yourself tonight. This one's saved, untouched.

Quiet Mode · we noticed this might be a heavy day

The entry is saved to history with isQuiet: true. Original text preserved exactly. No reframe text stored.
The weekly Pattern detection (also a Gemini call, runs over the last 7 entries) excludes quiet entries from its corpus. The pattern is about your rhythms, not your tragedies.
Streak still counts. Quiet days are still days you showed up.
For self-harm signals only, one calm line appears below the card: "If you need to talk to someone right now: text or call 988 (US) or befrienders.org (global)." No emoji, no red, no popup, no urgency styling. One line.

The whole thing is invisible until it's needed. There's no banner saying "Quiet Mode protects you," no settings tour, no onboarding card. It just sits there silently and does nothing 99% of the time. The 1% it does something, it does the smallest possible thing.

Why this is the most important feature

Hackathon judges in 2026 have watched a thousand "we wrapped an LLM" demos this season. The thing that cuts through is a product that demonstrates judgment about when not to use the LLM. Quiet Mode is that demonstration in a single 15-second beat:

Type "my dad died last week"
Hit share
App goes quieter, not louder

That's the demo. That's the whole pitch.

It's also the thing that makes the product feel like it was made by humans who have thought about humans.

How it's built

The detector is a 40-line pure function in src/lib/quietMode.ts:

export function detectQuietMode(text: string): { quiet: boolean; signal?: string } {
  if (!text) return { quiet: false };
  const lower = text.toLowerCase();
  for (const signal of QUIET_SIGNALS) {
    const re = new RegExp(`\\b${signal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
    if (re.test(lower)) return { quiet: true, signal };
  }
  return { quiet: false };
}

No LLM. No external call. Word-boundary regex against a hand-curated signal list. Runs in microseconds. Costs zero. Privacy-respecting (the matched signal is stored only in the local entry, never logged or sent anywhere).

The submit handler in App.tsx checks the detector before deciding what to do:

const { quiet, signal } = detectQuietMode(reflectionText);
if (quiet && quietModeEnabled) {
  saveQuietEntry({ text: reflectionText, signal, date: today });
  showQuietAcknowledgment(signal);
  return; // no Gemini call
}
// otherwise: normal reframe flow
const reframe = await callGemini(reflectionText);

The Pattern detection edge function (Supabase) added a single filter:

const entries = allEntries.filter(e => !e.isQuiet);

That's the whole feature. ~80 lines of code. Half a day of work. The hardest part was deciding what not to add.

What I deliberately didn't build

No popup or modal. Quiet Mode never interrupts you to congratulate itself.
No emoji on the acknowledgment card. This isn't a moment for sparkles.
No red or alarming colors. The card uses the same calm lavender→peach gradient as the rest of the app.
No "we detected crisis keywords" language. The user-facing copy says "we noticed this might be a heavy day." One word change, completely different feeling.
No analytics event when Quiet Mode triggers. We don't need to know.
No required settings tour. It's on by default and you can find the toggle if you want to turn it off.
No fancy ML classifier. A regex list curated by hand is more honest about what we're doing — looking for specific words — than a black-box model that might silently change behavior.

The restraint is the feature.

What's live right now

Evengood, Day 7 of 30:

60-second voice or text reflection (whisper for transcription)
Calm AI reframe via Gemini (when not in Quiet Mode)
Weekly Pattern detection — your last 7 reflections turn into one sentence
Moment of the Week — one keepsake auto-pulled from the week
Save-as-image keepsake (lavender/peach card with your moment)
Streak counter, history view, ambient sound (rain / piano / silence)
Email opt-in for the Sunday Pattern
Quiet Mode (today's ship)

No account. No password. Nothing about you leaves the device except an anonymous device_id and (if you opt in) your email for the Sunday note.

Try it

Live: https://app-b3tuv7opfegx.appmedo.com

Built entirely on @MeDo with Supabase + Gemini.

If you build AI products: I think the next year of differentiation isn't going to be about which model you wrapped. It's going to be about whether you have the judgment to not call the model.

More tomorrow.

— Day 7 / 30 🌿

BuildInPublic #BuildWithMeDo

I built an app to help myself end the day without spiraling. Day 4 of 30. 🌿

Vineet Negi — Thu, 23 Apr 2026 19:08:11 +0000

11:47 PM. Again.

I was lying in bed, staring at the ceiling, running the day on loop.

The meeting I should’ve pushed back on. The message I left on read. The three tabs of “I’ll think about this later” that quietly piled up.

I’ve tried the things. Journaling apps that felt like homework. Meditation timers that felt like a second job. Notion templates with seventeen sections I abandoned by day three.

What I actually wanted was something that took 60 seconds, left me with a small, quiet gift, and then got out of the way.

So on Day 1 of the MeDo hackathon, I decided to just build the thing.

The result is Evengood. It’s live here: https://app-b3tuv7opfegx.appmedo.com/

This is the story of the four days it took to go from “60-second voice note” to “a week that remembers you.” Including the three disasters that almost made me ship nothing.

What Evengood actually does

One screen. A soft lavender-to-peach gradient. One prompt:

How was today?

You tap once. You talk for up to 60 seconds — or type instead if you’re somewhere quiet.

Then Evengood does four small things:

It holds space for a few seconds (now with a gentle “writing your tomorrow…” line, more on that in a minute).
It plays back a calming Tomorrow prompt in a soft TTS voice — not advice, not a to-do, just one small thing to notice tomorrow. Things like “Notice the way the steam rises and curls from a warm cup.”
It paints you a watercolor keepsake of the feeling behind your day using the Kling image plugin.
It drops a dot into a 7-day streak ribbon, so you come back tomorrow.

No login. No account. Nothing saved to a server. Just your browser, your 60 seconds, and one tiny thing to notice tomorrow.

The stack (and why each piece)

Piece	What it does	Why I picked it
MeDo	Full-stack scaffolding, routing, deploy	I didn’t want to spend day 1 on Vite config
Speech-to-Text plugin	Turns the 60-sec voice note into text	Whisper-grade, no API key juggling
LLM (2 calls)	One for the Tomorrow prompt, one for the theme word	Split keeps each call small + retries cheap
Text-to-Speech plugin	Plays the Tomorrow prompt back in a soft voice	The voice is the whole feel of the app
Kling image plugin	Watercolor keepsake card	Softer than DALL·E, fits the palette
Tailwind + Playfair Display + Inter	The visual calm	Serifs make reflection feel like reflection
localStorage	Keeps reflections + keepsakes, keyed by ISO date	No DB, no account — your week lives in your browser

Total backend code I wrote myself: zero lines. MeDo’s agent wired the plugin calls and I focused on the feel.

Three disasters

Disaster 1: The silent 15 seconds

Day 2, first real user test. I handed my phone to a friend, she talked for 45 seconds about her day, tapped submit…

and the screen went silent. A soft spinner. Ten seconds. Twelve seconds. Fifteen seconds.

She looked up and said: “Did it break?”

It hadn’t. The TTS + watercolor were cooking in the background. But in a reflection app, silence reads as “we lost your thoughts.” That’s the exact opposite of what I was trying to build.

💡 Lesson: in a calm app, every second of silence has to feel intentional. Silence without a cue reads as a bug, not peace.

Fix (shipped Day 4): During the wait, the screen now says “writing your tomorrow…” in soft Playfair italic, with “(usually about 10 seconds)” underneath at 60% opacity. Same wait. Completely different feeling.

Disaster 2: The keepsake that spoke Mandarin

Day 3. Everything was working. I was happy.

Then a fellow hackathon builder flagged a bug: the LLM was occasionally slipping Chinese characters into the keepsake text for English input.

The model I’m using has a multilingual base. Every few calls, it would decide today was a Mandarin day.

💡 Lesson: multilingual models don’t need you to ask for another language — they just vibe into one. You have to actively clamp the output.

Fix (shipped Day 4): A strict English-only system instruction + a CJK-unicode validator that re-generates the response once if any non-Latin script is detected. Logs the retry to the console so I can see how often it happens.

Disaster 3: The streak that lied

The 7-day streak ribbon under YOUR WEEK was gorgeous. Seven little dots. One pulsing for today.

And it did absolutely nothing.

Tap a past dot? Nothing. Hover? Nothing. It was pure decoration. Which, in an app whose entire emotional promise is “the week is building you something,” felt like a lie.

💡 Lesson: if you’re going to visualize continuity, the visualization has to be a door, not a sticker.

Fix (shipped Day 4): Tap any filled dot → the reflection text from that day slides in on top, the Keepsake Card (tomorrow prompt + watercolor) below, little back arrow to return. Every reflection is persisted in localStorage keyed by ISO date, so the week actually accumulates. The streak finally does what it was pretending to do.

What I learned about building small things

A journaling app is mostly feel. The LLM does 5% of the work. The other 95% is:

The soft gradient.
The serif on the prompt.
The breathing animation on the spinner.
The fact that nothing is saved to a server.
The one small thing to notice tomorrow, instead of a list of things to fix.

I could have spent Day 4 adding “emotional trends” charts, or a share-as-long-image export, or an AI coach tab. All impressive. None of it would’ve fixed the three things that actually made the app feel broken.

💡 The best Day-4 features are usually the ones that make Day 1 finally feel finished.

Try it (60 seconds, no account)

👉 https://app-b3tuv7opfegx.appmedo.com/

Talk or type for a minute about your day. You’ll get back one small thing to notice tomorrow, a watercolor of the feeling behind it, and a dot on your week.

If it leaves you slightly calmer than it found you, I’ve done my job.

And if you’re also building something small for the MeDo hackathon — drop your link in the comments, I’ll genuinely try it. The builders on this one are absurdly good.

🌿

Built with MeDo. Day 4 of 30.

I built a 60-second reflection app that paints you a watercolor keepsake. Days 2 + 3 of the $50K MeDo hackathon.

Vineet Negi — Thu, 23 Apr 2026 04:40:09 +0000

TL;DR

I spent the weekend building Evengood — a 60-second end-of-day reflection app — on MeDo, a no-code AI platform. You talk or type how your day was, it plays back a calming Tomorrow prompt in a soft voice, and it paints you a watercolor keepsake from the feeling behind your words.

Live: https://app-b3tuv7opfegx.appmedo.com/

The idea

Every journaling app I've tried feels like homework. Notebooks full of dashboards, streaks I fail at, prompts I resent. I wanted the opposite: a tiny ritual that takes under a minute, leaves you with something beautiful, and then gets out of the way. No login. Nothing saved on a server. Come back tomorrow if you want to.

The aesthetic target: a soft lavender-to-peach gradient, Playfair Display for the headings, deep-indigo text, a single breathing microphone circle. Feel, not features.

The MeDo stack

For non-builders reading this: MeDo is a chat-driven platform where you describe the app you want and it generates the full React + Vite + Tailwind codebase, wires in plugins, and hosts it. You iterate by sending follow-up prompts. It's not a template tool — it writes real code you can inspect and edit.

Evengood uses four MeDo plugins:

Speech-to-Text — captures the 60-second reflection when the user chooses to talk
Large Language Model (x2) — one call generates the Tomorrow prompt, a second call extracts a one-word "theme" like peaceful, proud, tender
Text-to-Speech — reads the Tomorrow prompt back in a calm voice
Kling (image generation) — paints the watercolor keepsake card using the theme word

The keepsake card — the part I'm proudest of

The theme word drives a Kling image prompt like:

soft dreamy watercolor, lavender to peach gradient, abstract calm feeling of peaceful, no text, no people, serene, ethereal, minimal

For my test reflection about finishing hard work and noticing the light through a kitchen window, the LLM picked peaceful and Kling painted me a field of lavender dissolving into a peach watercolor sky. The Tomorrow line ("Notice the way the air feels when you first open a window.") overlays in white serif. It's the kind of image you'd actually screenshot and keep.

Bugs, and how I debugged them without writing code

On v8, the Kling image silently fell back to a CSS gradient every time. Turned out the timeout was 15 seconds; Kling typically needs 20–40. I sent MeDo a fix prompt: bump the timeout to 45 seconds and add console.log statements before the call, on success, and on error. Next build, the logs made the whole flow observable:

[keepsake] calling Kling with prompt: soft dreamy watercolor, lavender to peach gradient, abstract calm feeling of peaceful...
[keepsake] Kling returned image url: https://...keepsake-ea752a84-....jpg

22 seconds end-to-end, and the watercolor rendered. That's the pattern I keep returning to on MeDo: ask for observability first, then debug.

Three things I learned

Feel is a spec. The best prompt I wrote wasn't a feature list — it was a paragraph describing how the app should feel when you use it. MeDo builds noticeably better when you give it emotional direction alongside technical constraints.
Persist client-side, aggressively. No-account apps live or die by localStorage. The 7-day streak and ambient soundscape choice both persist without a backend, and that keeps the app feeling lightweight.
One bundled prompt beats five small ones. I grouped my v8 changes (keepsake card + streak + soundscape) into a single well-scoped prompt with an explicit "DO NOT" list, and the output was dramatically cleaner than when I'd tried incremental changes.

Day 3 update — three things actually shipped

Between Day 2 and Day 3 I did one tight fix pass on MeDo (30 credits, one prompt, 38 tasks) and all three v8 rough edges are now solid:

1. Kling watercolor keepsake works end-to-end. Timeout bumped from 15s to 45s, console logs wrapped around the call. The image is now generated from the single theme word inferred from your reflection (calm, peaceful, hopeful, grateful…) and renders in ~22 seconds. No more gradient fallback.

2. Ambient soundscape toggle is wired. A small pill above the microphone lets you switch between Silent, Rain, and Soft piano. Choice persists in localStorage so it carries over between sessions. Audio fades in when the reflection starts and fades out on Tomorrow.

3. Streak tracker is real. Seven dots along the bottom of the keepsake card, today filled in deep indigo, past days filled in lavender, future days faded. Powered by a tiny localStorage array of ISO dates — no account, no server, still works.

The meta-lesson: on a no-code platform, observability is the superpower. One prompt asking for console.log before, on-success, and on-error made the Kling bug diagnosable in a single build cycle. I keep returning to that pattern.

Try it

https://app-b3tuv7opfegx.appmedo.com/

It takes 60 seconds. If it leaves you with a watercolor you actually want to keep, I'd love to hear about it.

Built for the Build with MeDo Hackathon — $50K in prizes, submissions open until May 20, 2026.

I joined a $50K no-code hackathon with zero coding experience. Day 1.

Vineet Negi — Tue, 21 Apr 2026 01:01:39 +0000

So here's what I did today.

I signed up for the Build with MeDo Hackathon on Devpost. $50,000 in prizes. 30 days. 2,343 people already registered before me. And my coding experience is basically: I once changed the background color on a Wordpress site and felt like a hacker for a week.

The twist: MeDo is a no-code platform. You describe what you want in plain English, an AI builds the app. So technically you don't need to know how to code. In theory.

I figured the smartest play wasn't to compete for the grand prize — 2,000+ developers with years of experience are going after that. There's also a Creative Content Award (10 winners × $500) for blog posts and videos about your project. And a Community Choice Award (5 × $500) voted on by the MeDo Discord. Those are way more winnable if you show up consistently and actually document the journey.

So I'm documenting the journey. That's what this post is.

What I'm building

It's called Evengood. The pitch is one sentence: end every day on an even, good note.

You open it at night, spend 60 seconds typing how your day went — the rough parts, the wins, whatever. Evengood gives you back a short, calm 2-minute audio reflection that actually mentions what you said, names one real win, and gives you one clear thing to carry into tomorrow. It saves a one-line journal entry automatically. Over a month you end up with a readable year-in-sentences thing.

I picked this because (a) I'd actually use it, (b) it's small enough to be buildable in 30 days of evening work, and (c) the story is easier to tell than "I built another todo app."

The plan

Week 1: post publicly every day (you're reading day 1), set up the scaffolding in MeDo, don't over-scope.
Week 2: build the three core features. One per day. No heroics.
Week 3: polish, deploy, record a demo video.
Week 4: write the retrospective, rally the community, submit on Devpost.

Why I'm writing this on day zero of code

Because by the end of 30 days this is either a story about a no-code beginner who shipped a real app and won some money, or it's a story about a no-code beginner who tried and flamed out on day 11. Both are useful. Both are worth writing down.

If you want to watch what happens, I'll be posting on X too (I won't link it here to keep this post tag-compliant — you can find me from my profile). Or just follow along on DEV.

Back tomorrow with day 2.