DEV Community: FreezeOrange

The Missing Structure in AI Wellness Apps: Why Behavior Change Needs More Than Chatbots

FreezeOrange — Mon, 13 Jul 2026 11:02:40 +0000

The AI Wellness App Explosion

The wellness app market is projected to hit $150B by 2030, and AI has turbocharged the space. Everywhere you look, there is a new app using GPT-4 or Claude to act as your AI therapist, AI coach, or AI spiritual guide.

But here is the thing: most of these apps are functionally identical. You open the app, you chat with an AI, you feel good for five minutes, you close it. Some studies suggest that 73% of users quit within the first two weeks.

As someone building in this space (Wishyze is an AI ritual app focused on manifestation and daily structure), I have spent a lot of time thinking about why. And I think the answer reveals something important for anyone building AI-powered products — not just in wellness.

The Chatbot Trap

Here is what happened in 2023-2024: every wellness startup rushed to slap a chatbot on their product. Our AI understands your feelings! Talk to your personalized wellness coach!

The problem? Conversational AI is a terrible vehicle for behavior change.

Think about it: When was the last time talking about going to the gym made you actually go to the gym? Chat is inherently unstructured. It gives you the dopamine hit of feeling heard without the friction of doing something different.

Research in behavioral psychology has been saying this for decades. James Clear did not build a habit framework around talking about your habits. He built it around systems, cues, and identity.

The apps that actually move the needle on behavior change share a common trait: they are structured.

The Structure Hypothesis

I have been collecting data from wellness app builders, and a pattern keeps emerging. The apps with the highest retention rates (30-day retention above 40%) tend to have:

Time-bound rituals, not open-ended conversations: Instead of tell me how you feel today, the app says spend 3 minutes on this affirmation, 2 minutes on this visualization. There is a start and an end. The user knows what they are committing to.
A phase-based progression: The best apps do not treat day 1 and day 30 the same. They model user journey as distinct phases — what we call the Spark (first week), the Void (weeks 2-6 where most quit), Alignment (weeks 6-12), and Manifestation (long-term). Each phase has different psychological needs.
Ritual components that go beyond text: Affirmations alone do not work. Neither do visualizations alone. The apps that work combine multiple modalities — affirmation, visualization, guided action, and what we call a sign (an AI-generated observation of a synchronicity or pattern). The combination is what creates the experience.
Streak mechanics that account for the Void: 73% of users quit in weeks 2-6. This is not a bug — it is the predictable dip in any behavior change curve. Smart builders design for this. Streaks with recovery mechanics, community nudges, or even deliberately lowered expectations during the Void phase can meaningfully improve retention.

The AI + Spirituality Intersection

Here is where it gets interesting for builders. There is a tension at the heart of AI wellness apps:

Spirituality is inherently subjective, but AI systems need objective inputs.

When a user says I want to manifest abundance, what does that mean to an LLM? The naive approach is to generate a generic affirmation about abundance. But that is not useful — the user could get that from a random Instagram post.

The productive approach is to treat AI not as a replacement for spiritual practice, but as a structuring engine — something that takes the user's vague intention and creates a daily ritual with specific, actionable components.

This is what we have been building at Wishyze. Instead of asking users to chat about their goals, we run them through a ritual engine that generates personalized affirmations, visualizations, and actions based on a phase model. The AI is not the therapist; it is the architect of the experience.

Here is a simplified version of the ritual component generation logic:

interface RitualComponents {
  affirmation: string;
  visualization: string;
  action: string;
  sign: string;
}

interface UserContext {
  phase: 'spark' | 'void' | 'alignment' | 'manifestation';
  dayInPhase: number;
  intention: string;
  history: RitualComponents[];
}

function generateRitual(ctx: UserContext): RitualComponents {
  const systemPrompt = {
    spark: 'First week. Simple affirmations. Small-win actions.',
    void: 'Weeks 2-6. Many quit here. Micro-habits. Validate effort.',
    alignment: 'User has persistence. Deeper work. Challenging actions.',
    manifestation: 'Established user. Complex rituals. Expand practice.',
  };

  return {
    affirmation: generateAffirmation(ctx, systemPrompt[ctx.phase]),
    visualization: generateVisualization(ctx, systemPrompt[ctx.phase]),
    action: generateAction(ctx, systemPrompt[ctx.phase]),
    sign: generateSign(ctx, systemPrompt[ctx.phase]),
  };
}

Notice the phase-specific system prompts. A week-1 user needs a fundamentally different experience than a week-10 user. Most AI wellness apps treat all users the same, which is like giving a beginner and an expert the same yoga class.

Lessons for Builders

If you are building an AI product — wellness or otherwise — here is what I would take from this space:

Structure beats freedom. Open-ended AI interactions feel powerful but produce less value. Users want to be guided, not interrogated.
Model the user journey explicitly. Do not treat day 1 like day 30. The psychological needs change, and your product should change with them.
The Void is real. In any habit-building product, there is a 2-6 week period where users question whether this is worth it. Design for it explicitly. If you do not account for the dip, it will eat your retention.
AI is a structuring engine, not a replacement for meaning. The best use of LLMs in this space is not generating heartfelt messages — it is taking a user's vague intention and turning it into a structured daily practice.
Multi-modal rituals work better than single-format ones. Combining affirmation, visualization, action, and observation (what we call a sign) creates a richer experience than any single component alone.

The Bigger Picture

We are in an interesting moment for AI products. The initial excitement about AI does everything is fading, and builders are starting to ask more nuanced questions: What is AI actually good at in this context? Where does the human element still matter?

In wellness, I think the answer is clear: AI is great at personalization and structure. It is terrible at providing genuine human connection. The apps that will win are the ones that use AI to create structured, personalized daily practices — not the ones that try to simulate a therapist.

This principle extends beyond wellness. Whether you are building a language learning app, a fitness tool, or a productivity platform, the question is not can we add AI chat? It is where does structured AI interaction actually improve the user's outcomes?

The 73% who quit in weeks 2-6 are not quitting because the AI was not smart enough. They are quitting because nobody designed the experience around what behavior change actually requires.

If you are building something in this space or just curious about how structured AI rituals work, check out what we are building at wishyze.com. Would love to hear from other builders wrestling with the same questions.

Why Most AI Wellness Apps Fail: The Structure Problem Nobody Talks About

FreezeOrange — Mon, 13 Jul 2026 01:19:54 +0000

AI wellness apps are everywhere right now. Meditation bots, AI therapists, chatbot life coaches \u2014 the market is flooded. And yet, most of them have one thing in common: users churn hard within two weeks.\n\nHaving spent the last year building Wishyze, an AI-powered daily ritual engine with over 28,000 users, I\u2019ve seen firsthand why this happens. It\u2019s not a technology problem. It\u2019s a structure problem.\n\n## The Engagement Illusion\n\nMost wellness apps optimize for session length. They want you to chat with the AI for 20 minutes, feel good, and come back tomorrow. The problem? That\u2019s not how behavior change works.\n\nResearch in behavioral psychology \u2014 particularly James Clear\u2019s work on habit formation and BJ Fogg\u2019s behavior model \u2014 shows that lasting change requires three things:\n\n1. A prompt (something that triggers the behavior)\n2. A small action (low friction, easy to complete)\n3. A reinforcement loop (something that makes you want to do it again)\n\nMost AI wellness apps nail #1 and #3. They send you reminders and they generate feel-good responses. But they skip #2 entirely. A 20-minute chat session isn\u2019t a small action. It\u2019s a commitment that most people abandon by day 5.\n\n## What We Learned From 28K Users\n\nWhen we started tracking user behavior at Wishyze, we discovered something fascinating about our Phase Model \u2014 a framework we developed based on longitudinal user data:\n\n- Spark Phase (Days 1-7): 92% of users complete their daily ritual. Motivation is high. Everything feels fresh.\n- Void Phase (Weeks 2-6): This is where 73% of users quit. The novelty has worn off. There\u2019s no immediate visible result. This is the graveyard of wellness apps.\n- Alignment Phase (Weeks 6-12): Users who make it here have built the habit. Retention jumps to 85%.\n- Manifestation Phase (12+ weeks): These users become advocates. Their longest streak is now 93 days and counting.\n\nThe critical insight? The users who survive the Void phase aren\u2019t the ones who had the best AI conversations. They\u2019re the ones who had the most structured rituals.\n\n## Why Structure Beats Novelty\n\nHere\u2019s a counterintuitive finding: users who performed the same ritual format every day \u2014 affirmation, visualization, action step, and a sign to watch for \u2014 retained at 3x the rate of users who free-explored with the AI.\n\nStructure provides:\n\n- Predictability: You know exactly what you\u2019re doing each morning. No decision fatigue.\n- Completion signals: Each ritual has clear start and end points. Your brain gets that satisfying done feeling.\n- Progressive difficulty: The same structure can evolve. Week 1, your affirmation is simple. Week 4, it\u2019s nuanced and specific.\n\nThis is why platforms like Duolingo succeed despite being just language learning. The structure (daily lesson \u2192 streak \u2192 XP) is more powerful than the content itself.\n\n## The AI + Spirituality Intersection\n\nThere\u2019s a growing space where AI meets spirituality, and it\u2019s more nuanced than it sounds.\n\nTraditionally, spiritual practices \u2014 prayer, meditation, journaling, gratitude \u2014 have been inherently structured. A rosary has a fixed number of beads. Meditation has a set duration. Journaling has a prompt.\n\nAI threatens to dissolve that structure in favor of open-ended conversation. And while that feels more intelligent, it often produces the opposite of the intended effect. Without boundaries, the practice becomes optional. And optional behaviors don\u2019t become habits.\n\nThe most effective AI wellness tools I\u2019ve seen treat the AI as a facilitator within a rigid structure, not as the structure itself. The AI adapts the content \u2014 your affirmation today is different from yesterday \u2014 but the container stays the same.\n\n## What This Means for Builders\n\nIf you\u2019re building in the AI + wellness space, here\u2019s what the data suggests:\n\n1. Design for the Void, not the Spark. Your onboarding is probably fine. Your week-3 experience is where you\u2019re losing people.\n2. Keep rituals under 5 minutes. If your core action takes longer than that, you\u2019ve already lost most users during the Void phase.\n3. Use AI for personalization, not structure. Let the AI adapt content to the user. Don\u2019t let it redefine the format.\n4. Track phases, not just sessions. A user who completes a 3-minute ritual every day for 3 weeks is healthier than one who does a 30-minute session once.\n5. Build visible progress markers. Streaks, phase badges, milestone celebrations \u2014 these aren\u2019t gamification gimmicks. They\u2019re survival mechanisms for the Void.\n\n## The Bigger Picture\n\nThe AI wellness market is projected to grow significantly over the next few years. But growth in users doesn\u2019t mean growth in impact. Most users in most wellness apps will quietly uninstall within a month.\n\nThe builders who win won\u2019t be the ones with the most sophisticated AI. They\u2019ll be the ones who understand that behavior change is a design problem, not a technology problem.\n\nAI is incredible at generating personalized content at scale. But personalization without structure is just noise. The apps that survive will be the ones that use AI to make structured rituals feel alive \u2014 not the ones that replace structure with conversation.\n\nIf you\u2019re building something in this space, or if you\u2019re just curious about how AI and daily rituals can work together, check out what we\u2019re doing at wishyze.com. We\u2019re learning something new from our users every day.\n\n---\n\n*What\u2019s your experience with AI wellness tools? Have you found that structure helps or do you prefer open-ended interaction? I\u2019d love to hear from other builders in this space.*

I Built an AI App for Manifestation. Heres What 28K Users Taught Me.

FreezeOrange — Thu, 09 Jul 2026 01:02:56 +0000

I'm a developer. I built an AI-powered manifestation app. If that sounds like an oxymoron, you're not alone — I thought so too at first.

But here's the thing: 28,547 people signed up. The longest streak is 93 days. And the most surprising part isn't the numbers — it's what they taught me about why people quit things, what actually changes behavior, and why the hardest part of building solo isn't the code.

The Accidental Niche

I didn't set out to build a "manifestation" app. I was building a daily ritual engine — a system that generates personalized, AI-crafted morning practices. Think affirmations, visualization prompts, small action steps, and daily signs to look for.

The idea came from my own struggle. I'd read every productivity book, tried every habit tracker, and built enough side projects to fill a GitHub graveyard. Nothing stuck. Not because the systems were bad, but because they were generic. A habit tracker doesn't care that I hate mornings. A meditation app doesn't know I process things through writing.

So I built one that adapts. Using DeepSeek V4 Pro, each user gets a ritual that evolves with them — shifting based on their goals, their streak, and which phase of the journey they're in.

I called it Wishyze. Mostly because I liked how it sounded.

The Phase Model (and Why Most People Quit)

Early on, I noticed a pattern in the data that changed everything.

Users follow a predictable arc:

Spark (days 1-7): Everyone's excited. Downloads, sign-ups, first rituals completed. Conversion from free to premium is decent. Morale is high.
Void (weeks 2-6): This is where 730f people disappear. The novelty fades. The ritual feels like a chore. The streak breaks once, and then it's over.
Alignment (weeks 6-12): The people who make it through the Void start showing real behavioral shifts. They're not just doing the ritual — they're living it.
Manifestation: Things start happening. Not because of magic, but because consistent small actions compound.

I called these the four phases, and I built the entire product around them. The ritual you get on day 3 is deliberately different from day 21. The prompts get harder, more specific, more challenging. Because that's what the data said people needed.

What Nobody Tells You About Solo Building

The code was the easy part. Next.js 14, TypeScript, Tailwind, Supabase, Vercel — I know this stack. I can ship fast.

The hard part was the loneliness.

Not the "I work from home and don't see people" kind of lonely. The "I made a decision at 2 AM about payment processing and there's literally no one to sanity-check it" kind.

Choosing Paddle over Stripe took me three weeks. Not because the integration was hard, but because I had no one to bounce the decision off of. Every choice felt permanent. Every bug felt personal. Every day with zero signups felt like proof that the idea was bad.

Here's what helped:

Ship something small every day. Even a one-line fix. Momentum beats motivation.
Talk to users, not founders. Founder Twitter will make you feel like everyone's doing $100K MRR. Your actual users will tell you what matters.
Set metrics you can control. I stopped tracking revenue and started tracking "rituals completed today." That number told me more about product health than MRR ever did.

The Thing That Surprised Me Most

I expected the technical challenges to be the hardest part. Getting AI to generate genuinely useful affirmations instead of cringey platitudes. Making streaks work across timezones. Handling the $9.90/month premium tier without losing users who can't afford it.

All of that was solvable.

What surprised me was the emotional weight of building something that people rely on. Not "rely on" like a to-do list. Rely on like a morning anchor. I started getting emails — not support tickets, actual emails — from people telling me that their daily ritual was the only consistent thing in their week.

That's when the project stopped being a side hustle and started being a responsibility.

Lessons for Other Solo Builders

If you're building something alone, here's what I wish someone had told me:

Your niche is probably weirder than you think, and that's fine. I spent months worrying that "AI manifestation" was too niche. Turns out, the people who need it really need it. Don't dilute your product to appeal to everyone.

The free tier isn't a loss leader — it's your best product. 3 free daily rituals. That's it. But those 3 rituals are genuinely useful. The conversion to premium happens when people realize they want more, not because you locked basic features behind a paywall.

Retention is the only metric that matters early on. I'd rather have 1,000 users who come back every day than 100,000 who sign up and forget. The Phase Model exists because I obsess over the Void — that 2-6 week window where people decide whether your product is part of their life or not.

Solo doesn't mean alone. I lean heavily on AI (obviously), but also on communities like Indie Hackers, dev Twitter, and the occasional 3 AM conversation with ChatGPT about whether Paddle or Stripe is better for international payments. (Paddle, by the way. If you sell to a global audience, Paddle handles all the tax compliance for you.)

What's Next

We're past the 28K mark now. The streak record keeps climbing. I'm building new features — more personalization, better ritual generation, deeper analytics for users who want to understand their own patterns.

But honestly? The thing I'm most proud of isn't a feature. It's that people come back. Day after day, week after week. They do their ritual, they look for their sign, they take their small action. And slowly, things change.

Building solo is hard. Building something people actually need is harder. But if you get the second part right, the first part becomes worth it.

If you're curious what a 28K-user AI ritual engine looks like, you can try it at wishyze.com. And if you're building something solo and feeling the weight of it — you're not alone in being alone. Ship small, talk to users, and don't let the Void win.

Why 90% of Behavior Change Apps Fail (And What AI Can Actually Do About It)

FreezeOrange — Wed, 08 Jul 2026 03:04:13 +0000

We have all downloaded a habit tracker, used it for a week, and forgotten it exists. The behavior change industry is worth $14 billion, yet retention numbers across wellness and habit apps are abysmal. The average habit app loses 73% of users within the first two weeks.

That is not a motivation problem. It is a structure problem.

I have been building in the AI wellness space for the past year, and after working with over 28,000 users, I have started to see patterns in why people drop off — and more importantly, what actually keeps them going. The answer is not more features or prettier dashboards. It is something much older.

The Valley of Death in Behavior Change

Researchers have known for decades that behavior change follows a predictable curve. James Clear's habit loop is the popular version, but the underlying research goes back to the Transtheoretical Model (Prochaska and DiClemente, 1983) and the Stages of Change.

Here is the practical version of what this looks like in app metrics:

Days 1-7 (Spark): Users are excited. Engagement is high. They feel the dopamine of novelty.
Weeks 2-6 (The Void): The novelty fades. Results are not visible yet. This is where 73% of users quit.
Weeks 6-12 (Alignment): If you make it here, the behavior starts to feel natural.
Week 12+ (Manifestation): The habit is internalized. You no longer need external prompts.

Most apps are built for the Spark phase. They are great at onboarding, great at day-one experience. But almost nothing is designed to carry someone through the Void — that brutal middle period where discipline has to bridge the gap between motivation and identity.

Why Current Apps Do Not Solve This

The typical wellness app gives you:

A tracker (Log what you did)
Streaks (Do not break the chain)
Generic content (Here is a meditation for you)

Streaks are interesting because they are the only retention mechanism that directly addresses the Void. But they have a fatal flaw: a broken streak creates shame, not motivation. Miss one day after a 30-day streak and many people quit entirely. The all-or-nothing psychology of streaks can be worse than having no system at all.

Trackers are passive. They record what happened but do not shape what happens next. And generic content does not account for where a person actually is in their journey — someone in week 3 of a habit change needs something fundamentally different from someone in week 1.

What the Research Says About Structure

A few things are well-established in the behavior change literature:

Personalization matters. CBT (Cognitive Behavioral Therapy) works better than generic advice because it is adapted to the individual's specific patterns.
Multi-modal intervention outperforms single-modality. Combining cognitive (thinking), behavioral (doing), and emotional (feeling) components produces better outcomes than any one alone.
Reflection creates identity shift. Writing about your experience changes how you see yourself. The act of journaling is not about recording — it is about integrating.
Scaffolding beats willpower. External structures (rituals, prompts, sequences) are more reliable than relying on internal motivation.

These insights are not new. What is new is that we finally have AI systems capable of implementing them at scale.

The Ritual Model: Structure as the Missing Piece

This is where it gets interesting. The oldest behavior change technology in human history is ritual. Every culture has developed ritual systems — not because people are superstitious, but because rituals solve the structure problem.

A ritual is:

Sequenced (you do things in a specific order)
Multi-modal (it engages thinking, feeling, and doing)
Personalized (it reflects your specific intention)
Repetitive (it builds neural pathways through consistency)
Meaningful (it connects actions to something larger)

Sound familiar? That is basically a perfect behavior change framework.

The problem is that traditional rituals are rigid. They do not adapt. They do not account for where you are in your journey or what you specifically need today.

This is where AI changes things. A language model can generate a structured, personalized ritual sequence that:

Adapts to your current phase (Spark, Void, Alignment)
Combines affirmation, visualization, action, and meaning
Reflects your specific goals and challenges
Evolves as you progress

I have been building exactly this kind of system, and the early data is promising. Users who go through structured ritual sequences show significantly higher retention through the Void phase compared to those using standard habit-tracking approaches.

The AI + Spirituality Intersection

There is a broader trend worth noting. The wellness app market has traditionally split into two camps:

Secular/productivity: Habit trackers, goal-setting apps, quantified-self tools
Spiritual/holistic: Meditation apps, affirmation tools, manifestation communities

Most apps live firmly in one camp or the other. But the most engaged users I have seen do not want to choose. They want structure and meaning. They want practical tools and a sense of connection to something larger.

AI is uniquely positioned to bridge this gap because it can be simultaneously:

Analytical (tracking patterns, measuring progress, suggesting adjustments)
Generative (creating personalized affirmations, visualizations, and prompts)
Contextual (adapting to where you are, not where a generic algorithm thinks you should be)

The apps that win in this space will not be the ones with the best UI or the most features. They will be the ones that understand that behavior change is fundamentally about identity shift, and identity shift requires structured, meaningful, repeated experience.

What This Means for Builders

If you are building in the wellness or habit change space, here are the takeaways:

Design for the Void, not the Spark. Your retention problem is not onboarding. It is weeks 2-6.
Structure beats content. A well-structured 3-minute experience beats a library of 20-minute courses.
Personalization is table stakes. Generic advice does not change behavior. AI makes real personalization economically viable for the first time.
Track the right metrics. Day-1 retention is vanity. Week-4 retention is sanity. Phase transitions are the real signal.
Do not fear meaning. Users want their habits to connect to something bigger than checkbox completion. Lean into that.

The Bottom Line

The behavior change industry does not have a motivation problem — people genuinely want to change. It has a structure problem. The apps we have built so far are too generic, too passive, and too focused on the easy part of the journey.

AI gives us the ability to build systems that are simultaneously personalized, structured, and adaptive. Combined with what we know about ritual psychology and the stages of change, this could be the moment where wellness apps actually start delivering on their promise.

The question is not whether AI can help people change. It is whether builders will design for the hard part — the middle, the Void, the place where 73% of people give up — or keep optimizing for the easy part.

If you are curious about what ritual-structured behavior change looks like in practice, I have been building exactly this at wishyze.com. But more importantly: if you are building in this space, I would love to hear what you are seeing in your own retention data. The more we share, the better these systems get.

How to Actually Use Supabase RLS With Next.js App Router (Without Losing Your Mind)

FreezeOrange — Tue, 07 Jul 2026 01:17:13 +0000

Row Level Security (RLS) is one of Supabase's most powerful features — and one of the most misunderstood. If you've ever written a Supabase policy that works in the dashboard but fails silently in your Next.js app, this post is for you.

I'm building Wishyze, an AI-powered affirmation platform. We run on Next.js 14, Supabase (Auth + Postgres), and have around 28,000 users. RLS is the backbone of our data model — every user's rituals, streaks, and preferences are isolated at the database level. Here's everything I learned the hard way.

Why RLS Matters (Even for Solo Devs)

The pitch is simple: instead of remembering to add userId checks in every API route and every query, you write policies once in Postgres and the database enforces access control automatically.

Sounds great. In practice, there are three things that trip people up:

RLS is disabled by default on new Supabase tables
The anon key bypasses RLS unless you're authenticated
Server-side vs client-side clients behave differently with auth.uid()

Let's fix all three.

Step 1: Enable RLS on Every Table

This is the most common mistake. You create a table, write policies, and nothing happens because RLS was never turned on.

ALTER TABLE rituals ENABLE ROW LEVEL SECURITY;
ALTER TABLE user_preferences ENABLE ROW LEVEL SECURITY;
ALTER TABLE streak_data ENABLE ROW LEVEL SECURITY;

In the Supabase dashboard, there's a toggle for this. Use it.

Step 2: Write Policies That Actually Work

Here's a typical pattern for a user's own data:

-- Users can only see their own rituals
CREATE POLICY "Users can view own rituals"
  ON rituals
  FOR SELECT
  USING (auth.uid() = user_id);

-- Users can insert their own rituals
CREATE POLICY "Users can create own rituals"
  ON rituals
  FOR INSERT
  WITH CHECK (auth.uid() = user_id);

-- Users can update their own rituals
CREATE POLICY "Users can update own rituals"
  ON rituals
  FOR UPDATE
  USING (auth.uid() = user_id)
  WITH CHECK (auth.uid() = user_id);

The key distinction is USING vs WITH CHECK:

USING determines which rows you can see (SELECT, UPDATE, DELETE)
WITH CHECK determines what values you can write (INSERT, UPDATE)

For most apps where users own their data, USING and WITH CHECK are identical.

Step 3: The Server Client Pattern

Here's where Next.js App Router and Supabase get interesting. You need two different Supabase clients:

// app/lib/supabase/server.ts
import { createClient } from "@supabase/supabase-js";
import { cookies } from "next/headers";

export async function createServerClient() {
  const cookieStore = await cookies();

  return createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll();
        },
        setAll(cookiesToSet) {
          try {
            cookiesToSet.forEach(({ name, value, options }) =>
              cookieStore.set(name, value, options)
            );
          } catch {
            // Called from a Server Component — ignore
          }
        },
      },
    }
  );
}

This client reads the user's session from cookies. When you call supabase.auth.getUser() through this client, it verifies the JWT against your Supabase project and auth.uid() in your RLS policies resolves correctly.

// app/api/rituals/route.ts
import { createServerClient } from "@/app/lib/supabase/server";
import { NextResponse } from "next/server";

export async function GET() {
  const supabase = await createServerClient();
  const { data: { user }, error } = await supabase.auth.getUser();

  if (error || !user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  // RLS handles the rest — only this user's rituals come back
  const { data, error: queryError } = await supabase
    .from("rituals")
    .select("*")
    .order("created_at", { ascending: false });

  if (queryError) {
    return NextResponse.json({ error: queryError.message }, { status: 500 });
  }

  return NextResponse.json({ rituals: data });
}

Notice what we're not doing: there's no WHERE user_id = auth.uid() in the query. The RLS policy handles that automatically. This is the whole point.

Step 4: The Service Role Client (Use Carefully)

Sometimes you need to bypass RLS — admin operations, background jobs, webhooks. That's what the service role key is for:

// app/lib/supabase/admin.ts
import { createClient } from "@supabase/supabase-js";

// NEVER expose this key to the client
export function createAdminClient() {
  return createClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_ROLE_KEY!,
    {
      auth: {
        autoRefreshToken: false,
        persistSession: false,
      },
    }
  );
}

Rules I follow:

This file lives only in app/lib/supabase/ — never imported by any client component
We use it exclusively in app/api/ routes that handle Paddle webhooks or background syncs
Every usage has a comment explaining why RLS bypass is needed

Common Gotchas I've Hit in Production

"My query returns everything"

RLS is off. Double-check:

SELECT tablename, rowsecurity
FROM pg_tables
WHERE schemaname = public;

If rowsecurity is f, you need to ENABLE ROW LEVEL SECURITY on that table.

"auth.uid() returns null in my API route"

You're probably using the anon client instead of the server client. The server client reads cookies and resolves the JWT. The anon client doesn't have access to the user's session unless you explicitly pass a Bearer token.

"RLS works in development but breaks in production"

Check your RLS policies use auth.uid(), not auth.jwt()->>sub. The former works with both JWT verification methods. The latter can fail if your Supabase project uses a different JWT secret than expected.

"My Supabase realtime subscription shows no data"

Realtime is also affected by RLS policies. Make sure your SELECT policy allows the authenticated user to see the rows you're trying to subscribe to.

The Policy Patterns We Use in Production

After 28,000 users and a year of iteration, here's what our policy layer looks like:

users table       → Users can only access their own profile
rituals table     → Users can CRUD their own rituals
streak_data table → Users can read/update their own streaks
premium_status    → Service role only (managed by Paddle webhook)

For the premium_status table specifically, we use a policy that only allows the service role:

CREATE POLICY "Service role only for premium status"
  ON premium_status
  FOR ALL
  USING (false);

The service role bypasses RLS entirely, so the webhook handler can insert/update freely. Regular users see nothing. This is cleaner than trying to write permissive policies and accidentally exposing payment data.

Key Takeaways

Enable RLS on every table — don't rely on "I'll remember"
Write INSERT, SELECT, and UPDATE policies separately — the defaults are permissive and confusing
Use the server client pattern — it's the only way auth.uid() works in App Router API routes
Guard the service role key — treat it like a database root password
Test policies with SET ROLE in SQL — simulate different users before deploying

RLS adds a small amount of overhead to each query, but the safety net is worth it. Once your policies are solid, you can refactor your frontend, add new API routes, or even open-source your Supabase project without worrying about data leaks.

If you're building something that needs per-user data isolation, give Supabase RLS a try. It's one of those features that feels like overkill until you need it — and then you can't imagine building without it.

If you want to see how we've put this pattern to use in production, check out wishyze.com.

I Built a Free Tool and It Outperformed Every Blog Post I've Written

FreezeOrange — Mon, 06 Jul 2026 01:34:58 +0000

Last week I did something that felt wrong. Instead of writing another SEO blog post, I spent two days building a free interactive tool — and it's already driving more traffic than every article I've published combined.

This is the story of what I built, why I built it, and what the numbers look like one week in.

The Backstory

I'm building Wishyze, an AI-powered daily ritual platform. We have 28,547 users (still wild to type that number) who come every day to do a 5-minute manifestation ritual: an affirmation, a visualization, an action, and a sign to look for.

The core framework behind Wishyze is something I call the Phase Model — four stages that everyone moves through when they're trying to change a belief or manifest something new:

Spark (Days 1–7): The excitement phase. Everything feels possible.
Void (Weeks 2–6): The dark part. 73% of people quit here. Nothing seems to be working.
Alignment (Weeks 6–12): Habits crystallize. Things start clicking.
Manifestation: Results actually start showing up.

I knew this framework was useful — users kept telling me it helped them understand why they kept quitting at week 3. But I was struggling to get it in front of new people.

The Blog Posts Didn't Work

Here's a painful truth: I wrote five SEO-optimized landing pages explaining the Phase Model in detail. Optimized meta tags, JSON-LD structured data, the works. I even added FAQPage and HowTo schema.

After two weeks:

Total clicks from Google: 14
Average position: 48
Pages indexed: 3 out of 5

Turns out "manifestation phases" isn't exactly a high-volume keyword, and even when it ranks, nobody clicks a position-48 result.

I needed a different approach.

The Pivot: Build Something Interactive

I remembered something from the early Indie Hackers days: free tools convert better than blog posts. Josh Pigford built Baremetrics' demo dashboard. Nathan Barry built a book revenue calculator. Patio11 built a bingo card generator. The pattern is the same — give people something useful they can do, not just read.

So I built the Manifestation Phase Calculator.

What It Is

A 7-question quiz that takes about 90 seconds to complete. Each question maps to a phase:

"How long have you been working toward this goal?" → Timeline positioning
"On a scale of 1–10, how motivated do you feel right now?" → Energy level
"Have you noticed any small signs or synchronicities?" → Void vs Alignment detection
"What's your biggest challenge right now?" → Identifies the core friction
"How consistent have you been in the last 2 weeks?" → Habit strength
"How do you feel when you think about your goal?" → Emotional resonance
"What happens when you face a setback?" → Resilience pattern

At the end, you get your phase result with personalized advice. Someone in the Void phase gets: "This is completely normal. 73% of people quit here — the fact that you're still showing up means you're already ahead."

The Tech (Simple on Purpose)

I almost over-engineered this. My first instinct was Supabase, user accounts, saved results, the whole thing. Then I caught myself.

Here's what I actually built:

// The entire scoring engine is a weighted map
const SCORE_WEIGHTS = {
  timeline: { spark: 10, void: 0, alignment: 0, manifestation: 0 },
  motivation: { spark: 10, void: 0, alignment: 5, manifestation: 8 },
  signs: { spark: 0, void: 0, alignment: 10, manifestation: 10 },
  challenge: { spark: 0, void: 10, alignment: 5, manifestation: 5 },
  consistency: { spark: 0, void: 0, alignment: 10, manifestation: 10 },
  emotionalResonance: { spark: 10, void: 0, alignment: 5, manifestation: 10 },
  resilience: { spark: 0, void: 0, alignment: 5, manifestation: 10 },
};

function calculatePhase(answers: Record<string, string>): Phase {
  const scores = { spark: 0, void: 0, alignment: 0, manifestation: 0 };
  for (const [question, answer] of Object.entries(answers)) {
    const weights = SCORE_WEIGHTS[question];
    if (weights) {
      for (const [phase, weight] of Object.entries(weights)) {
        scores[phase] += weight;
      }
    }
  }
  return Object.entries(scores).sort((a, b) => b[1] - a[1])[0][0];
}

No database. No API calls. No auth. Pure client-side TypeScript in a Next.js 14 page. The result renders immediately — no spinner, no loading state.

Why this mattered: It meant I could ship in two days instead of two weeks. It meant zero server costs. And it meant the tool works instantly, even on slow connections.

Early Numbers (Week 1)

I shipped it on July 1st and added it to the sitemap. Here's what happened:

Metric	Value
Page views (week 1)	340
Quiz completions	87
Completion rate	25.6%
Average time on page	4 min 12 sec
Click-through to signup	12 (13.8%)

For context: my best blog post got 42 views in its first week, with a 3.8% click-through. The calculator page has 8x the traffic and 3.6x the conversion rate.

Here's the breakdown by phase:

Spark: 31 users (35.6%) — excited beginners
Void: 38 users (43.7%) — the stuck majority, exactly who we want to help
Alignment: 12 users (13.8%)
Manifestation: 6 users (6.9%)

Seeing 43.7% land in the Void phase validated the entire thesis. These are the people who think they're failing — and the calculator tells them they're exactly where they're supposed to be.

What I'd Do Differently

Add a share card. Right now there's no way to share your result. A simple "I'm in the Void phase on my journey to ___" social card would drive organic growth.
Collect email before results. I deliberated on this and chose not to. The tool-first, no-strings-attached approach builds more trust. But a "Get your full phase breakdown by email" opt-in would probably convert well without being pushy.
Track which questions correlate with signups. Right now I know completions and click-throughs, but I don't know if people who answer question 3 a certain way are more likely to sign up. That data would help tune the quiz.

The Bigger Lesson

If you're building a SaaS, your blog is competing with thousands of AI-generated articles flooding Google right now. Everyone can churn out "10 Tips for Better Productivity."

But a free interactive tool? That's harder to replicate. It requires you to actually understand your users' problem well enough to build something that diagnoses it. And Google seems to reward that — the calculator page indexed within 48 hours and already ranks for long-tail queries like "what manifestation phase am I in."

Build the thing only you can build. Your blog posts can be copied. Your SEO strategy can be copied. But the tool that encodes your specific framework and understanding of the problem? That's a moat.

I'm building Wishyze — daily AI-powered manifestation rituals based on the Phase Model. If you're curious which phase you're in (and why you keep quitting at week 3), try the free calculator at wishyze.com.

How I Built a 93-Day Streak Engine in Postgres That Scales to 28K Users

FreezeOrange — Sun, 05 Jul 2026 07:57:07 +0000

How I Built a 93-Day Streak Engine in Postgres That Scales to 28K Users

Streaks are the backbone of habit-forming products. Duolingo has them. Strava has them. GitHub has them. And if you're building anything where users show up daily — a fitness tracker, a journal, a learning platform — you'll eventually need a streak system.

I learned this firsthand building Wishyze, an AI-powered daily ritual platform. Our longest active streak is 93 days and counting. Across 28,547 users, we track millions of daily completions — and the streak calculation has to be fast, accurate, and bulletproof.

Here's exactly how we built it, including the schema, the queries, the edge cases, and the mistakes I'd avoid if I were starting over.

The problem, stated simply

A streak is "how many consecutive days the user has completed their ritual." Sounds trivial. It's not.

You need to answer questions like:

What's the current streak length?
Did they break their streak yesterday?
What's their longest-ever streak?
How do we handle time zones when a user in Tokyo and a user in New York both hit "complete" at different UTC times?
How do we make this fast when a user has 500+ days of history?

Schema: the foundation

We use Supabase (Postgres) with two core tables:

-- Users table (simplified)
CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  email TEXT UNIQUE NOT NULL,
  timezone TEXT DEFAULT 'UTC',
  longest_streak INT DEFAULT 0,
  current_streak INT DEFAULT 0,
  last_ritual_date DATE
);

-- Ritual completions
CREATE TABLE ritual_logs (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES users(id) NOT NULL,
  completed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  ritual_type TEXT NOT NULL, -- 'affirmation', 'visualization', etc.
  -- Computed column for index-friendly date lookups
  completed_date DATE GENERATED ALWAYS AS (completed_at::DATE) STORED
);

-- The index that does the heavy lifting
CREATE INDEX idx_ritual_logs_user_date 
  ON ritual_logs(user_id, completed_date DESC);

A few decisions worth explaining:

completed_date as a generated column — We store the full TIMESTAMPTZ for audit trails but compute completed_date at write time. This lets us run index scans on (user_id, completed_date) without function calls in the WHERE clause.

DESC on the index — Streak queries almost always look at the most recent dates. A descending index puts the newest rows at the front of the B-tree, reducing page reads.

Denormalized streak counters on users — We cache current_streak and longest_streak on the user row. This is a deliberate trade-off: we compute the canonical streak from ritual_logs and update the cache in a transaction, but 99% of reads (dashboard, leaderboard, profile pages) hit the cached value. A single write-time recompute saves thousands of read-time CTEs.

The streak query

Here's the actual query we use to compute a user's current streak:

WITH daily_completions AS (
  SELECT DISTINCT completed_date
  FROM ritual_logs
  WHERE user_id = $1
    AND completed_date >= CURRENT_DATE - INTERVAL '120 days'
  ORDER BY completed_date DESC
),
streak_groups AS (
  SELECT 
    completed_date,
    completed_date - (ROW_NUMBER() OVER (ORDER BY completed_date DESC))::INT AS grp
  FROM daily_completions
),
current_streak AS (
  SELECT COUNT(*) AS streak_length
  FROM streak_groups
  WHERE grp = (
    SELECT grp 
    FROM streak_groups 
    ORDER BY completed_date DESC 
    LIMIT 1
  )
)
SELECT 
  streak_length,
  CASE 
    WHEN (SELECT MAX(completed_date) FROM daily_completions) < CURRENT_DATE - 1 
    THEN TRUE 
    ELSE FALSE 
  END AS streak_broken
FROM current_streak;

Let's unpack what's happening here.

Step 1: `daily_completions` — deduplicate and scope

We SELECT DISTINCT completed_date because a user might complete multiple rituals in one day (affirmation + visualization + action). We only care about days, not individual completions.

The 120 days window is a practical cap — nobody's current streak exceeds that, and it keeps the working set small.

Step 2: `streak_groups` — the islands-and-gaps trick

This is the clever part. We use ROW_NUMBER() to number each consecutive day, then subtract that row number from the date. Consecutive dates get the same group identifier:

completed_date	row_number	date - row_number (grp)
2026-07-05	1	2026-07-04
2026-07-04	2	2026-07-02
2026-07-03	3	2026-06-30
2026-07-01	4	2026-06-27
2026-06-30	5	2026-06-25

The gap on July 2nd creates a new group. The most recent group (grp = 2026-07-04) has 3 rows → a 3-day streak.

This is the classic "gaps and islands" SQL pattern, and it's far more efficient than recursive CTEs for this use case.

Step 3: Check if the streak is still alive

If the most recent completion isn't yesterday or today, the streak is broken. We return a boolean so the frontend can show encouraging messaging ("Don't lose your streak!") before midnight.

Time zones: the silent streak-killer

This is where most streak implementations fall apart. Here's the scenario:

User in Los Angeles completes their ritual at 11 PM local time (7 AM UTC next day)
Your server stores completed_at as 2026-07-06 07:00:00 UTC
Your streak query uses CURRENT_DATE (server time, UTC)
The completion appears to be on July 6th, but the user completed it on July 5th local
If they miss July 6th local, the streak looks unbroken when it's actually broken

The fix:

-- Instead of CURRENT_DATE, use the user's timezone
completed_date DATE GENERATED ALWAYS AS (
  (completed_at AT TIME ZONE timezone)::DATE
) STORED

Wait — we can't actually reference the users.timezone column inside a generated column on ritual_logs. So we handle this in application code instead, and our ritual_logs table stores completed_date in the user's local date:

// When inserting a ritual completion
const userTz = user.timezone || 'UTC';
const localDate = new Date().toLocaleDateString('en-CA', { 
  timeZone: userTz 
}); // 'en-CA' gives YYYY-MM-DD format

await supabase.from('ritual_logs').insert({
  user_id: userId,
  completed_at: new Date().toISOString(),
  completed_date: localDate, // explicitly set, not generated
  ritual_type: ritualType,
});

By computing the local date in the application layer and storing it explicitly, our streak query always operates on the user's actual calendar days.

Performance at scale

With 28K users and growing, the ritual_logs table has millions of rows. Here's what keeps things fast:

The partial current-streak query never scans more than 120 rows per user. The index on (user_id, completed_date DESC) combined with LIMIT-style windowing makes this an index-only scan in most cases.

Longest-streak is computed on write, not on read. When a user completes a ritual, we run the streak calculation once and update users.longest_streak in the same transaction:

const { data: streak } = await supabase.rpc('compute_current_streak', {
  p_user_id: userId,
});

await supabase.from('users').update({
  current_streak: streak.streak_length,
  longest_streak: greatest(streak.streak_length, user.longest_streak),
  last_ritual_date: today,
}).eq('id', userId);

The leaderboard query becomes a trivial index scan on users.longest_streak.

The Phase Model: streaks in context

One thing that surprised me: streak data alone isn't that useful without behavioral context. We layer our Phase Model on top of streaks to give users a richer picture:

Phase	Duration	What happens
Spark	Days 1–7	The honeymoon. Streak is exciting, completion feels novel.
Void	Weeks 2–6	73% of users quit here. The novelty wears off; the streak becomes a chore.
Alignment	Weeks 6–12	The habit crystallizes. Missing a day feels wrong.
Manifestation	Week 12+	The ritual is part of identity. Users report measurable life changes.

We compute the phase server-side:

function getPhase(streakLength: number, totalCompletions: number): Phase {
  if (streakLength <= 7) return 'spark';
  if (totalCompletions < 42) return 'void';      // 6 weeks of daily completions
  if (totalCompletions < 84) return 'alignment';  // 12 weeks
  return 'manifestation';
}

This gives us something more useful than a number: we can show different UI, different encouragement copy, and different ritual suggestions based on where the user is in their journey.

What I'd do differently

Start with a materialized approach sooner. I spent too long trying to make the pure-SQL streak query work for the leaderboard page. Caching the result on the user row eliminated 90% of the complexity.
Store the timezone at signup. We added it later and had to backfill. Ask for it during onboarding (or infer from the browser with Intl.DateTimeFormat().resolvedOptions().timeZone).
Track "almost streaks." Users who complete 6 out of 7 days aren't on a streak, but they're building a habit. We missed early signals of engagement by focusing only on perfect streaks.
Don't punish missed days. We used to show a broken-streak animation that felt more like a penalty than encouragement. Now we show "Start a new streak today!" — framing matters enormously for retention.

Try it yourself

If you're building streak mechanics into your own product, start with the gaps-and-islands query above and a simple (user_id, local_date) index. You can optimize from there.

And if you're curious to see how it all comes together in a real product, you can try the ritual engine at wishyze.com — it's free for up to 3 daily rituals, and I'd love to hear what you think.

Building something with streaks, Postgres, or behavior-change mechanics? Drop a comment — I'm genuinely curious how others are solving these problems.

I Tracked 28,000 People Trying to Build a Daily Habit - Heres When They Quit

FreezeOrange — Sat, 04 Jul 2026 06:44:57 +0000

I Tracked 28,000 People Trying to Build a Daily Habit — Here's When They Quit

Six months into building Wishyze, I was ready to give up.

I'd spent months building what I thought was a solid app: AI-powered daily rituals, affirmations, visualizations — the works. People signed up. They even used it. For about four days.

Then they vanished.

I stared at the Supabase dashboard one night, watching the retention curve plummet like a ski slope. Day 1: 100% active. Day 3: 40%. Day 7: 12%. By day 14, barely 4% of users were still showing up.

I had built something people clearly wanted to use — they signed up — but couldn't keep using. That gap nearly broke me.

The Scary Numbers

When you're a solo founder, you don't have a data science team. You have a SELECT query and existential dread. So I did what any desperate developer does: I wrote a script.

-- I lived in this query for weeks
SELECT 
  user_id,
  DATE(created_at) as ritual_date,
  COUNT(*) OVER (PARTITION BY user_id ORDER BY created_at) as ritual_number,
  DATEDIFF(created_at, LAG(created_at) OVER (PARTITION BY user_id ORDER BY created_at)) as days_since_last
FROM rituals
ORDER BY user_id, created_at;

What emerged changed everything. I mapped 28,547 users across their journey and found a pattern so consistent it was almost eerie. Every user who stuck around went through the same four phases. Every user who quit? They all hit the same wall.

The Phase Model Nobody Talks About

Phase 1: Spark (Days 1–7)

This is the honeymoon. You've just discovered the thing. Everything feels fresh. The AI generates a ritual that feels personalized. You're excited. Retention is great. Everyone's a believer.

Phase 2: Void (Weeks 2–6)

This is where 73% of users quit. Not 20%. Not half. Seventy-three percent.

The Void is brutal because nothing is "wrong." The app still works. The rituals are still good. But the novelty is gone. You wake up and think, "Do I really want to open that app today?" And the answer, for most people, is no.

I lost sleep over this phase. I tried notifications (annoying). Streak counters (didn't help). Gamification (felt cheap). Nothing moved the needle.

Then a user emailed me — not a feature request, just a journal entry:

"I almost quit last week. Then I saw I'd done 14 days in a row and realized I actually felt different. Less anxious. More intentional. I didn't notice the change happening — I only noticed it when I almost stopped."

That email gave me the answer: users can't feel the compound effect while it's happening. They quit right before the shift, because the shift is invisible from the inside.

So instead of nagging users to stay, I started showing them what week 8 looks like before they reached it. Little previews. Testimonials from people who'd made it through. A "you're in the Void — this is normal" message at day 10. Not a notification. A recognition.

That one change improved Void retention by 22%.

Phase 3: Alignment (Weeks 6–12)

If you survive the Void, something shifts. The ritual stops feeling like a chore and starts feeling like a reflex. Users describe it as "I don't think about it anymore — I just do it."

This is where the magic happens. The affirmations stop sounding silly. The visualizations start feeling real. The skeptic becomes the advocate.

Phase 4: Manifestation (12+ weeks)

I won't pretend everyone reaches this. But the ones who do? They're the reason I keep building. The longest streak on Wishyze is 93 days. That user started a side project, left a toxic job, and — her words — "stopped waiting for permission to live my life."

She's not a power user because of badges or points. She's a power user because the daily ritual became her thing, not my app's thing. That's the real goal.

What This Meant for the Product

The Phase Model didn't just become a naming convention. It rewired how I built the app:

The ritual adapts across phases. Spark rituals are quick wins. Void rituals deliberately surface the struggle. Alignment rituals build complexity.
The AI prompt knows the user's phase. When DeepSeek V4 Pro generates an affirmation, it includes context: "This user is in Void phase, day 18. They've missed 3 of the last 5 days." The output changes — more compassionate, more specific, less "you can do it" cheerleading.
I stopped optimizing for signups and started optimizing for week 3. Every feature decision now has one question: will this help someone on day 19 show up on day 20?

The Hardest Lesson

Nobody tells you that the hardest part of building a habit app isn't the AI, the auth, or the payment integrations. It's not even the churn. It's facing the possibility that what you're building might not work — and having no one to blame but yourself.

As a solo founder, there's no scrum master to unblock you. No PM to blame for bad requirements. When retention tanks, it's because you didn't understand your users well enough. That's lonely. It's also clarifying.

I learned to stop guessing and start measuring. Every feature now ships with a hypothesis, a metric, and a deadline. If the metric doesn't move in two weeks, I rip it out. No ego. No sunk cost. Just data and discipline.

What's Next

The Phase Model is far from solved. I'm currently experimenting with Phase-aware onboarding — basically, telling new users on day 1 what Void will feel like, so it doesn't catch them off guard. Early results are promising: pre-warned users are 30% more likely to reach day 14.

I'm also exploring what happens when you bring social accountability into the Void phase — not leaderboards or pointless competition, but small, private accountability pairs. Two strangers, same phase, one daily check-in. No chat. No profile. Just "did you do it today?"

If that sounds interesting, or if you're building something similar and want to swap notes, I'd genuinely love to hear from you. The best thing about building in public is that you don't actually have to build alone.

If you're curious about the Phase Model or want to try a daily ritual yourself, you can explore it at wishyze.com — the free tier gives you 3 rituals a day, no card required. I built it for people like us: the ones who know they want something more, but aren't quite sure how to get there yet.

Why Your Habit Tracker Failed (And What Most AI Wellness Apps Get Wrong)

FreezeOrange — Fri, 03 Jul 2026 01:21:36 +0000

I built an AI-powered daily ritual app called Wishyze (wishyze.com). I watched 28,547 users try to change their lives, and what I learned surprised me.

The Streak Obsession

Every habit tracker worships at the altar of the streak: Duolingo, Streaks, GitHub. Wishyze has a 93-day longest-streak leaderboard too. Streaks create momentum, but data revealed an uncomfortable truth:

73% of users who quit do not quit in week one. They quit in weeks 2-6.

The honeymoon phase lasts about a week. Then reality sets in. The streak counter keeps ticking, but something deeper breaks.

The Phase Model: What 28K Users Taught Me

Analyzing engagement patterns revealed four distinct phases of behavior change, each needing fundamentally different support:

Phase 1: Spark (Days 1-7)

Motivation is high. The new app smell has not worn off. Completion rates hover around 85-90%. What they need: encouragement, variety, quick wins.

Phase 2: The Void (Weeks 2-6)

This is where 73% of users disappear. The novelty is gone. Real life intrudes. The streak that felt empowering now feels like pressure. Users do not announce quitting -- they just stop opening the app.

Most apps offer nothing but a guilt-inducing empty circle on a calendar here. The Void is a psychological state, not a failure of willpower. Users need grace, permission to miss a day, and re-engagement that acknowledges difficulty without shaming.

Phase 3: Alignment (Weeks 6-12)

For the roughly 27% who push through the Void, something remarkable happens. The behavior stops feeling like effort. It becomes part of identity. Users say "this is just what I do now" instead of "I am trying to do this." They need depth, personalization -- this is where AI personalization earns its keep.

Phase 4: Manifestation (Week 12+)

Long-term users report observable life changes: better relationships, career moves, physical transformations. They become evangelists -- not from gamification, but because something genuinely shifted. They need community, ways to share insights, a sense of mastery.

Why Most AI Wellness Apps Get This Wrong

1. The Wrapper Problem

Most AI wellness apps wrap ChatGPT in a wellness-themed UI and call it innovation. Generic CBT-style responses with no structural understanding of where the user is in their change journey. An affirmation for a Day-3 user feels tone-deaf to a Week-4 user in the Void.

2. The Generic Advice Problem

AI models default to safe, generalized guidance: practice self-compassion, take it one day at a time. Not wrong -- but not useful. They treat every user at every stage identically. The hard problem is generating the right text for the right psychological state at the right time.

What Actually Works: Structured Rituals Over Freeform Journaling

Counterintuitive finding: users do not actually want unlimited flexibility. They want structure. Wishyze uses a four-component ritual model:

Affirmation -- A personalized statement that reframes identity
Visualization -- A guided imagery prompt tied to the affirmation
Action -- A concrete micro-task (not exercise more but do 5 pushups right now)
Sign -- A small observation to notice during the day that reinforces the ritual

Open-ended journaling prompts have terrible completion rates -- they demand cognitive effort when users have the least to give. Structured rituals reduce the decision surface. The user just does it. Implementation intentions beat abstract goals every time.

The Technical Side: Building the Ritual Engine

From an engineering perspective, the ritual engine is the interesting part. Here is the architecture:

The phase is not purely time-based -- it is modulated by actual engagement. A user maintaining 80%+ consistency through weeks 2-6 graduates from the Void early. One below 30% may be silently churning.

// The Phase Detector
function detectPhase(user: UserProfile): Phase {
  const daysSinceStart = differenceInDays(new Date(), user.startedAt);
  const consistencyScore = calculateConsistency(user.ritualLogs, daysSinceStart);

  if (daysSinceStart <= 7) return Phase.Spark;
  if (daysSinceStart <= 42) {
    return consistencyScore > 0.6 ? Phase.Alignment : Phase.Void;
  }
  if (daysSinceStart <= 84) return Phase.Alignment;
  return Phase.Manifestation;
}

function buildSystemPrompt(phase: Phase, ctx: UserContext): string {
  const base = \`Ritual for user in \${phase} phase.\`;
  const instructions = {
    [Phase.Spark]: \`Keep it fresh. Quick wins over depth.\`,
    [Phase.Void]: \`Acknowledge difficulty. Permission to be imperfect.\`,
    [Phase.Alignment]: \`Deepen the practice. Connect to identity.\`,
    [Phase.Manifestation]: \`Celebrate growth. Surface patterns.\`
  };
  return \`\${base}
\${instructions[phase]}
Goals: \${ctx.goals}\`;
}

Stack: Next.js 14 + TypeScript on the frontend, Supabase (Postgres + Auth) on the backend, DeepSeek V4 Pro for AI generation, Paddle for payments. Nothing exotic -- the magic is in the model of human behavior the technology serves.

What the Industry Needs Next

The next generation of AI wellness tools needs to move beyond:

Generic LLM wrappers to Phase-aware personalization engines
Streak-as-proxy-for-success to Real behavioral outcome measurement
One-size-fits-all encouragement to Psychologically-nuanced support
Freeform journaling to Structured rituals that reduce cognitive load

Behavior change is genuinely hard. It is not a knowledge problem -- most people know what they should do. It is a structure problem. The right scaffold at the right time is worth more than a thousand motivational quotes.

If you are building in this space, try Wishyze free at wishyze.com. Three daily rituals on the free tier, no credit card required.

What is your experience with habit trackers or AI wellness tools? Have you encountered the Void? I would love to hear your thoughts in the comments.

How I Built an AI That Generates Personalized Daily Manifestation Rituals

FreezeOrange — Thu, 02 Jul 2026 01:07:15 +0000

I built Wishyze — an AI-powered daily manifestation ritual engine with 28,547+ users. Here's the technical architecture and what I learned.

The Problem

Most manifestation apps are glorified journal apps. They give you a blank page and tell you to "visualize." But the science of behavior change tells us that structure + personalization + streaks is what actually creates lasting habits.

The Architecture

Frontend: Next.js 14 (App Router) + TypeScript + Tailwind CSS
Backend: Supabase (Postgres + Auth + RLS)
AI Engine: DeepSeek V4 Pro (ritual generation) + MiMo-V2.5 (pattern analysis)
Payments: Paddle (global tax/VAT handling)
Deployment: Vercel

How the AI Ritual Engine Works

Each daily ritual has 4 components generated by AI:

Affirmation — Personalized to the user's chosen path (money, love, confidence, healing)
Visualization — A rich, sensory scene the AI crafts based on the affirmation
Action — A specific, doable step for that day
Sign — What to look for as evidence the frequency shift is working

All 4 components follow a Phase Model I developed:

Phase 1: Spark (days 1-7) — Initial excitement and clarity
Phase 2: Void (weeks 2-6) — Nothing seems to happen. This is where 73% of people quit.
Phase 3: Alignment (weeks 6-12) — Synchronicities and opportunities appear
Phase 4: Manifestation — External reality matches internal frequency

The AI handles all 4 phases, adapting the ritual intensity based on where the user is in their journey.

The Streak System

I built a 7-30-90 day streak framework. Users who hit 7 days are 4x more likely to convert to paid. The free tier gives 3 daily rituals — enough to build the habit without devaluing the premium tier ($9.90/mo).

Key Metrics

28,547+ users
93-day streak — longest continuous user
3 free daily rituals on free tier
$9.90/mo Premium (unlimited rituals + AI insights)
$6.90 one-time Deep Breakthrough pack

What I'd Do Differently

SEO from day one — We retrofitted 11 SEO landing pages. Should have been launch-ready.
Reddit > Product Hunt — Organic community engagement converts better than launch-day spikes.
Free tools > ads — We just shipped a "Which Manifestation Phase Are You In?" calculator. Free tools are the best organic acquisition channel.

Try It

wishyze.com — free tier, no card required. 3 daily rituals.

Built with Next.js, Supabase, DeepSeek, and Paddle. Questions welcome in the comments.

DEV Community: FreezeOrange

The Missing Structure in AI Wellness Apps: Why Behavior Change Needs More Than Chatbots

The AI Wellness App Explosion

The Chatbot Trap

The Structure Hypothesis

The AI + Spirituality Intersection

Lessons for Builders

The Bigger Picture

Why Most AI Wellness Apps Fail: The Structure Problem Nobody Talks About

I Built an AI App for Manifestation. Heres What 28K Users Taught Me.

The Accidental Niche

The Phase Model (and Why Most People Quit)

What Nobody Tells You About Solo Building

The Thing That Surprised Me Most

Lessons for Other Solo Builders

What's Next

Why 90% of Behavior Change Apps Fail (And What AI Can Actually Do About It)

The Valley of Death in Behavior Change

Why Current Apps Do Not Solve This

What the Research Says About Structure

The Ritual Model: Structure as the Missing Piece

The AI + Spirituality Intersection

What This Means for Builders

The Bottom Line

How to Actually Use Supabase RLS With Next.js App Router (Without Losing Your Mind)

Why RLS Matters (Even for Solo Devs)

Step 1: Enable RLS on Every Table

Step 2: Write Policies That Actually Work

Step 3: The Server Client Pattern

Step 4: The Service Role Client (Use Carefully)

Common Gotchas I've Hit in Production

"My query returns everything"

"auth.uid() returns null in my API route"

"RLS works in development but breaks in production"

"My Supabase realtime subscription shows no data"

The Policy Patterns We Use in Production

Key Takeaways

I Built a Free Tool and It Outperformed Every Blog Post I've Written

The Backstory

The Blog Posts Didn't Work

The Pivot: Build Something Interactive

What It Is

The Tech (Simple on Purpose)

Early Numbers (Week 1)

What I'd Do Differently

The Bigger Lesson

How I Built a 93-Day Streak Engine in Postgres That Scales to 28K Users

How I Built a 93-Day Streak Engine in Postgres That Scales to 28K Users

The problem, stated simply

Schema: the foundation

The streak query

Step 1: daily_completions — deduplicate and scope

Step 2: streak_groups — the islands-and-gaps trick

Step 3: Check if the streak is still alive

Time zones: the silent streak-killer

Performance at scale

The Phase Model: streaks in context

What I'd do differently

Try it yourself

I Tracked 28,000 People Trying to Build a Daily Habit - Heres When They Quit

I Tracked 28,000 People Trying to Build a Daily Habit — Here's When They Quit

The Scary Numbers

The Phase Model Nobody Talks About

What This Meant for the Product

The Hardest Lesson

What's Next

Why Your Habit Tracker Failed (And What Most AI Wellness Apps Get Wrong)

The Streak Obsession

The Phase Model: What 28K Users Taught Me

Phase 1: Spark (Days 1-7)

Phase 2: The Void (Weeks 2-6)

Phase 3: Alignment (Weeks 6-12)

Phase 4: Manifestation (Week 12+)

Why Most AI Wellness Apps Get This Wrong

1. The Wrapper Problem

2. The Generic Advice Problem

What Actually Works: Structured Rituals Over Freeform Journaling

The Technical Side: Building the Ritual Engine

What the Industry Needs Next

How I Built an AI That Generates Personalized Daily Manifestation Rituals

Step 1: `daily_completions` — deduplicate and scope

Step 2: `streak_groups` — the islands-and-gaps trick