Breathe - The first app for rebuilding self-trust.

Things felt heavy. I knew what to do — but everything felt too big, too vague, too much. So I did nothing. The voices got louder. Until I named one and proved it wrong. That's Breathe.

Comment

Inspiration

For 4 months, I was in a state of burnout. The kind where you’re tired. The kind where nothing excites you anymore. The kind where everything feels heavy. The kind where you stop believing you’re capable.

I knew what to do, but everything felt too big, too vague, too much. So I did nothing. The voices got louder—until I named one and proved it wrong.

That’s Breathe.

Now when the voice comes back, I don't start from scratch — I have proof to re-wire my brain.

Who It's Built For

Breathe is built for people like me. For people in a state of burnout recovery. For people who've been let down by life and pretend to be fine. For people who know exactly what they need to do, but still can't begin.

Burnout isn’t the problem. The voice that says you can’t is.

I built Breathe because I needed it, and it didn’t exist.

What It Does

Healing from burnout has many parts. Breathe is built around one: rebuilding self-trust. Not managing symptoms. Not building habits. Not calming you down. Starting from where you actually are.

Here’s How It Works

  • First, you name the voice. Not a mood. Not a feeling. The specific thought that keeps coming back. "I'm not capable of finishing what I start." "I am not important." Breathe helps you get there and reflects it back in your own words.
  • Then it suggests tiny actions based on your context — something small, but meaningful.
  • Breathe breaks that down into micro-steps so nothing feels vague or overwhelming.
  • When you finish, you create an artwork — a mood background, an icon, a frame, a title. Not a badge. Not a streak. A piece of evidence.
  • Evidence that you helped create. Evidence that proves the painful voice in your head isn’t fully true.
  • Over time, you create more of these artworks, and the gallery becomes the argument your brain couldn't make on its own.
  • Breathe never tells you the voice is wrong. It simply helps you collect proof until you don’t need to be told anymore.

What makes it different

Every app tells us to meditate or track habits. None of them starts from the assumption that we’ve stopped trusting ourselves.

  • Calm, Headspace → help calm you down. Breathe → helps you act.
  • Therapy apps → help you understand your thoughts and emotions. Breathe → helps you challenge them through lived evidence.
  • Habit trackers → help build consistency. Breathe → helps rebuild self-trust first.

How I built it

This is my first time vibecoding all the way to production-ready code. I built Breathe with Claude Code — Next.js, the Anthropic API to power the app itself, Supabase for storage, deployed on Vercel, analytics captured by Novus.ai. The UI started as paper and pen sketches. I used Lovable to get a first structure and pull some inspiration, then built the real thing from there.

Novus required almost no implementation work on my end — just authentication and a couple of PR merges. It automatically tracked events and even generated a funnel for the AI conversation itself, which is genuinely hard to instrument given how unpredictable a conversational flow is compared to a fixed click-path. A few pages and events weren't tracked initially; after working with the Novus AI agent, page view tracking is now complete across every page in the app. Funnel tracking currently covers part of the core loop — I wasn't able to get full funnel coverage configured for the most recently added pages in the time available. Page-level data confirms real sessions moving through the product end to end.

I built it the way I build everything as a PM: persona, problem, one-liner solution. Then the flow — separating the job, the UI, the copy, and the AI prompt. From there: figure out what actually matters for this ICP, write the prompt, test it against different versions of the persona, design the flow, wire it up, test end to end.

What the Breathe AI Actually Does

  • Listens during onboarding and responds to what the person actually shared
  • Reflects the voice back in the user's exact words
  • Generates three task suggestions as structured JSON, rendered in the app's own UI
  • Breaks the chosen task down into micro-steps small enough to actually do
  • Suggests an artwork title based on the conversation and the task — the user can always edit it

Conversation Structure

The onboarding conversation that helps you name the voice isn't a freestyle chat. It's a structured five-move arc, built into the system prompt:

  • Open wide — one neutral question, no assumptions
  • Validate and widen — reflect what was said, then ask what's underneath it
  • Mirror exactly — reflect the voice back in the user's own words, never paraphrased
  • Sit with it — one beat of acknowledgment before moving forward
  • Transition — a fixed line that never varies: "That thought has been loud. We're not going to argue with it. We're going to prove it wrong — one small real thing at a time."

The AI can't move forward until it can actually answer three things from what the person shared: what area of life is affected, what a hard day looks like for them, what feels most stuck. If it can't answer all three, it keeps listening.

The prompt also defines what the AI never says — clinical phrases, wellness-app language, confident statements about how someone feels unless they said it directly. It's also built to handle someone who's actually fine, and someone testing whether this is "just ChatGPT.

The Design Principle of the Breathe App

  • The whole design principle is calm, meaningful, and non-overwhelming. Burnout is loss of control — everything feels like it's happening to you. Every small decision is shaped by that thought. That's the whole emotional register of the app.
  • The entire app could have been one conversation. I didn't build it that way. Given my ICP's emotional state, one long conversation risks overwhelming the person using it — so I broke everything into small, controllable chunks instead.
  • One decision that looks small but isn't: every screen transition in Breathe is user-initiated — you decide when you're ready.
  • The wave that runs through the visual design does the same job. Each screen could feel like a separate room — the wave is a constant anchor: I'm still in the same safe place. It carries from landing through the hardest moments — naming the voice, choosing a task — to the gallery.
  • Every part of the app has a fallback. If the AI doesn't respond the way it should, the user still walks away with something. The app has to hold up even when the model doesn't.
  • A crisis safety system runs underneath all of it — two layers: a keyword layer, and an AI layer that catches what keywords alone would miss.

Challenges I Ran Into

Being a non-coder building something technically complex.

  • I'm a product manager. I had never shipped production code.
  • The hybrid architecture — server-side API routes, state machines, crisis detection, localStorage persistence — isn't a beginner build.
  • Claude Code made it possible. But I still had to understand what I was asking for and why.

Writing copy that doesn't sound like an app.

  • The words are the product. "Let's find out" instead of "this is not true." "You did something real" instead of "great job!" Every scripted line went through multiple versions.
  • The hardest part wasn't knowing what to say — it was protecting those words from every instinct to make them sound more professional, more polished, more product-like. They had to sound like a person.

Making the AI safe for people in burnout — not just functional.

  • Technically the API works fine with a good system prompt. But "technically working" isn't the bar. The bar is: would I give this to someone on their worst day?
  • That required a crisis detection layer (keyword pre-filter before any API call), structured JSON output for task suggestions (so the app renders them, not the AI), and scripted fallbacks for every AI state.
  • Trust is brittle for people in burnout. The system had to be designed around that.

Designing for micro-agency at every step.

  • Every UI decision in Breathe had to return agency in small ways: you pick the task, you edit the steps, you choose the artwork, you decide when you move forward.
  • The product can never feel like it's pushing. There is no "next" button that fires without you. That constraint has no off switch — it's in the bones of the thing.

Realizing mid-build that local state wasn't enough.

  • I built the early screens with hardcoded data just to get the flow working. When I pulled the hardcoding out and tested with real data, things broke — and chasing those breaks is what told me I needed an actual backend.
  • Everything had been living locally, no login, no persistence. I hadn't planned for that. A lot of this got figured out late, not early.

Assuming the conversation prompt would be straightforward.

  • I tested the prompt early, but not in real depth — not against different personas in detail — until later in the build. I assumed a single well-written prompt would be enough.
  • When I finally tested it properly, the quality wasn't there. The structured five-move conversation arc came out of fixing that — it wasn't the original plan.

Accomplishments That I am Proud Of

  • The copy. Every scripted line in Breathe was written by me — not generated by AI. In a hackathon built with AI tools, that was a deliberate choice. The words are the product. They had to come from someone who has been there.
  • The gallery mechanic. "2 artworks disagree" is not a notification. It's not a reward. It's a counter-argument. No existing app is built around collecting evidence against a specific painful belief.
  • Shipping it. I'm a product manager who had never written production code. I've designed plenty of UI concepts before — but never shipped a real app with a backend and an LLM behind it. Solo. Taking an idea all the way to a working product is the achievement on its own.

What I Learned

  • That the architecture of an AI product is a product decision, not an engineering one. Where you put the AI, how much you let it say, what you hardcode instead — those are design choices with direct consequences for the user's emotional experience. I didn't learn this from a framework. I learned it by trying to build something I'd trust on my own worst day.
  • That copy is infrastructure. The specific words you choose change the entire relationship between the app and the user. The words determine the trust. The trust determines whether the product works at all.
  • That micro-agency is a design principle, not a feature. When your user has had agency stripped from them, you don't add agency as a feature — you remove every moment where the product decides for them. It has to be in the bones of the thing.
  • That the ICP is everything. Breathe is not for everyone in burnout. It's for people who've been let down by things that pretend to be fine. Once I had that sentence, every decision became easier — what to cut, what to keep, what the voice of the app sounds like, what success looks like.
  • And that shipping is the point. Not a perfect product. A real one. Something a stranger can land on and feel less alone in.

What's Next for Breathe

  • The Capsule. Everything shared in onboarding that wasn't chosen as the primary voice — saved with a promise made on day one: "Nothing gets lost. We'll come back when you're ready." When the first voice has enough evidence against it, you pick the next one. The loop continues.
  • Re-entry. One door back in. "Hey. How are you right now?" The AI reads the answer: grounding activity if you're spiraling, next tiny task if you have energy. One question. No menu. No dashboard.
  • Witnessed evidence. The option to show someone you trust a piece of evidence you've built — not to be comforted, but to be seen proving the voice wrong. Still your proof. Just not kept to yourself.
  • And ten real users. Not beta testers. People going through a hard period who need this. That's the next thing that matters most.

Built With

  • claude-code
  • next.js
  • novus.ai(pendo)
  • supabase
  • typescript
  • vercel
Share this project:

Updates