Inspiration
Friend groups rarely end in a fight. They fade. Someone gets busy, stops replying, and by the time anyone notices, it has been weeks. Group chats don't help much: they stay loud for the people already talking and silent for the one who isn't.
We started with a big idea: could your phone notice when you're drifting toward isolation and quietly get a friend to reach out, so nobody ever has to ask for help? Early on, we changed direction from rescue to prevention. We didn't want to diagnose who was lonely. We wanted to give friends a small, fun reason to connect every day, then create a few more chances to connect when someone starts engaging less than usual.
That gave us two goals: bring the group closer, and catch quiet drift. The second one only works if the first one is genuinely fun, so we built a cozy little app full of eggs.
What it does
Sunny Side Up is an iPhone app for small friend groups, called coops.
- Today's photo: Each day belongs to one person in the coop. They answer a prompt with a photo and everyone else reacts.
- Sunny Sunday: Every Sunday you're paired with one friend and send them a voice memo or video inside an egg you decorated. You can only crack theirs open after sending yours.
- Little things: Send an egg, photo, voice memo, or text to one person or the whole coop.
- Staying in sync: Birthdays, shout-outs for big days ("interview on Tuesday"), events with a temporary chat and shared album, a coop gallery, and AI hangout ideas for your area.
- Egg war: An opt-in game. If more than half the coop votes yes, everyone has three days to snap candid "snipes" of each other for a leaderboard. When the war ends, the snipes and their photos are deleted.
- Quiet nudges: When someone's activity falls well below their own normal, one friend gets a friendly prompt like "Ella would love a silly voice memo from the Sunny Side Up crew today, go say hi! 🍳". The quiet person isn't told, and the friend never learns why.
How we built it
Two developers, one contract. We wrote the plan before writing any code. One developer owned the mobile app and the other owned the backend, AI, and analytics. A shared /shared folder held the agreed types and API, and changes to it went in their own commits. Every screen gets data through a single typed @/api layer, which let us redesign the entire UI late without rewriting how data works. Both of us built with Claude Code, using a CLAUDE.md file that gave it each developer's role, the plan, and our privacy rules.
Tech stack
| Layer | What we used |
|---|---|
| Mobile | Expo SDK 58, React Native 0.88, TypeScript, Expo Router |
| Backend | Supabase: Postgres, row-level security, Storage, Realtime, Deno Edge Functions, pg_cron |
| AI | Claude, called only from Edge Functions |
| Analytics | Entrinsik Informer |
| Builds | Xcode on a Mac, signed with a free Apple ID |
The development process
- Foundation: We scaffolded the Expo app, installed every native module up front to avoid repeat phone installs, and created the full database schema and security policies.
- Accounts and coops: We added email sign-in, a plain-language consent screen, profiles, and invite links.
- Tiny interactions: We built a live feed with eggs, photos, voice memos, reactions, and notifications.
- Rhythm: We added the Sunday share, daily spotlight rotation, birthday and moment reminders, and AI hangout ideas.
- Quiet drift: We built on-device signal collection, nightly scoring, the nudge engine, privacy controls, Informer analytics, and a one-button demo reset.
- Design pass: Our design went through versions 0.3, 0.4, and 0.5, adding coops, events, galleries, profiles, and the egg war along the way. We then ported the interactive HTML prototype into the app.
How quiet drift works
Drift detection is deliberately rule-based, not a black-box model. It compares you only with yourself.
- On the phone: With consent, the phone reduces raw location and health data to a few daily numbers: hours away from home, places visited, sleep hours, and steps. Coordinates and raw health data stay on the phone.
- Nightly on the server: A cron job compares your last 3 days of activity with your previous 14. Activity is what you sent plus half your app opens. Message content is never read. If daily numbers are available, the score is 70% engagement and 30% signals.
- Flagging: You're marked quiet only with a score of at least 0.6, a full 3 recent days, at least 7 baseline days, and a baseline of at least one activity per day.
- Nudging: A daily job picks a friend, rotating so no one carries the load and skipping anyone nudged in the last 48 hours. Everyone else in the coop also has a 25% chance of being the subject of a cover nudge, so receiving a nudge never proves anything is wrong.
How we use Claude
Claude does three small jobs: writes nudges, suggests three hangout ideas, and suggests playful profile categories. Each call is server-side, defaults to Haiku for speed and cost, has an 8-second timeout, returns schema-validated output, and has a fallback, so a slow model can't break the app.
Claude never decides who is quiet and never sees scores or signals. The nudge function accepts only a first name and coop name. It has no parameter for the reason, so real and cover nudges use the same prompt by construction. A filter also rejects output containing words like "lonely" or "worried", along with gendered pronouns, and swaps in a fallback message.
How we use Entrinsik Informer
Informer gives whoever runs a community a view of coop health without exposing a single name.
- Locked-down connection: Informer connects to Postgres through Supabase's session pooler, over SSL, as a dedicated read-only role,
informer_ro. That role can read only a separateanalyticsschema. We confirmed it can't accesspublic, the schema that holds our app tables. - De-identified views: Seven SQL views expose aggregated counts, including daily coop engagement, alerts, nudge totals, daily photo participation, Sunday exchanges, and egg war summaries. Coops appear only as hashed keys. There are no names, user IDs, media, message bodies, or drift scores, and the nudge totals never separate real nudges from cover nudges.
- Coop health dashboard: Native SQL datasets feed a dashboard with a trend line of activity per member, a table of coops at least 20% below their own baseline, and a count of friendly nudges sent.
- Seeing the dip: In our seeded demo coop, one friend's fade takes the group from a baseline of 8.56 to 6.72, a 21.5% drop. Informer flags the coop without showing who caused it.
- Practical fixes: We pass each date as noon so UTC conversion doesn't shift chart labels back a day, and we leave out coops with under 7 days of history so brand-new test groups don't skew the average.
Challenges we ran into
- No paid Apple Developer account: We pivoted mid-build to a free Apple ID, which ruled out remote push and Sign in with Apple. The server now writes rows to a
notificationstable, and the open app listens over Supabase Realtime and shows them as local notifications. It catches up when reopened, but delivery while backgrounded is limited. We also cut our demo cast from four people to three because of the free team's phone limit. - Making the "why" impossible to leak: A policy wasn't enough, so we built it into the system. The reason for a nudge is server-only, clients read nudges through a view that hides it, and notifications look the same either way.
- Being honest about privacy: Our concept was on-device analysis, but in this build, scoring runs on the server. The consent screen says so.
- Security that doesn't recurse: Membership checks inside row-level security policies can cause infinite recursion, so they go through
SECURITY DEFINERhelpers. A 124-check script signs in as test users and tries to read what they shouldn't. - Matching the prototype exactly: Rebuilding animated egg drawings by hand would have lost their charm, and native changes meant reinstalling on every phone from the build Mac. Expo DOM components let us reuse the prototype's art, a WebGL egg-white spill, and a 3D egg carton with no native rebuild. Keeping those web views stable took some hard-won rules, like never unmounting one while it's waiting on a native callback.
- Demoing 17 days of history in a weekend: Drift needs a baseline nobody could have yet, so a one-button reset backfills realistic history for our real demo accounts. Rehearsing caught real bugs, including a nudge that said "Send ella7.ha a quick photo" because the name was still an email prefix.
Accomplishments that we're proud of
- The full loop works: In our rehearsal on the live backend, with seeded history, Ella scored 0.875 while everyone else scored 0.01 to 0.02. Jocelyn got one natural-sounding nudge about Ella, and Ella got nothing.
- It's actually delightful: Cracking an egg, decorating one, and sniping a friend are fun on their own, and that's what gives the drift detection meaningful activity to read.
- It fails gracefully: A missing key, timeout, or refusal still produces a sensible result.
- Late design changes held up: We replaced the look of the whole app in the final stretch, largely without rewriting how it gets its data.
What we learned
- Privacy is easier to keep when it's structural. Who can read which column, and which parameters a function accepts, are harder to get wrong than a written policy.
- A clear contract is what makes parallel work possible. Clear ownership kept two people moving fast, even as the scope grew.
- Simple and explainable can be the right kind of AI. A person's own baseline and a transparent rule suited this problem better than a model we had no data to train. The LLM's most important job is making real and cover nudges indistinguishable.
- Rehearse early. Our most embarrassing bugs only showed up when we ran the demo end to end.
What's next
- Test with real friend groups: Our drift demo runs on seeded history, so the next step is learning how real coops behave over several weeks, starting with college students on one campus.
- Measure whether nudges work: Friends can already mark a nudge as acted on, so we can use de-identified data to see whether nudges lead to people reconnecting.
- Tune cover nudges: Too few could give real nudges away, while too many could make people tune out.
- Move scoring onto the phone: This would keep even the daily numbers local, which was our original vision.
- Add real push notifications: A paid Apple Developer account would let notifications arrive reliably in the background, and the
notificationstable can stay the source of truth. - Strengthen analytics: We want Informer to send automatic alerts instead of only showing them on a dashboard, and to hide very small coops so that aggregate numbers stay truly anonymous.
- Expand beyond iPhone: We'd bring Sunny Side Up to Android and explore a free-time finder that reads only busy or free status, never event details, so hangout ideas arrive when people can actually go.
Built With
- anthropic
- claude
- deno
- entrinsik-informer
- expo.io
- postgresql
- react-native
- supabase
- typescript
- xcode
