Lykka is a private memory journal for iPhone. You capture good moments — a line of text, a photo, a voice note — and Lykka gives them back to you when they matter: a daily push with a memory worth re-reading, a home-screen widget, an on-demand boost for the bad days, On This Day, a Year in Memories. You can seal a Letter to the Future. You can share a memory with someone who was in it. The name is a whisper away from lycka, Swedish for happiness, and the app is fully bilingual — Swedish and English.
It is a diary that answers back, without ever reading your diary. That last part is a hard architectural constraint, not a marketing line, and it shaped the whole stack.
What it runs on
Two surfaces, one repo. The app is SwiftUI on iOS 18 with Swift 6 strict concurrency, a WidgetKit extension, and a share extension. The Xcode project is not even committed — it is generated from a project.yml via XcodeGen, which matters more than it sounds when agents are the ones editing targets and entitlements. Declarative project files are diffable; pbxproj conflicts are misery.
The backend is deliberately small: Hono on Cloud Run, TypeScript on Node 22, Firestore for state, Cloud Storage for media, Apple's App Store Server Library for subscription verification and webhooks. Its job is to be a gate, not a database of your life. It holds the AI keys, checks the subscription, and passes reflections through. It never stores and never logs memory content. Your memories live on your device; letters with media are envelope-encrypted; identity is a seed-recoverable keypair rather than an account with a password.
The AI layer is multi-vendor, same as Jobado and Lovio. Claude writes the reflections and affirmations — the daily lines that make a resurfaced memory land — with two-block prompt caching to keep the per-push cost sane. Gemini does image understanding when a photo is captured and the pronoun-sensitive rewriting when you share a memory with the person who is in it. Every prompt has a runnable eval with golden baselines checked into the repo, because 'the prompt feels better now' is not a regression test.
How it was built: agents that verify, not just generate
Lykka is the first app where I would say the agents built it and mean it literally. Claude Code did the overwhelming majority of the work, with Codex as a second pair of eyes. But the interesting part is not code generation — that is table stakes now. The interesting part is that the agents could verify their own work, end to end, without me in the loop.
The repo's CLAUDE.md is not documentation for humans. It is an operating manual for agents: how to resolve the simulator UUID (the display name xcodebuild rejects), how to build and launch the app on an iPhone 17 Pro simulator, how to dump the accessibility hierarchy and compute tap targets from the frames, how to swipe a sheet away reliably, which USB HID key-code is Return, and how to read the app's OSLog stream through simctl to confirm which API endpoints were actually hit. An agent that lands a feature does not tell me it probably works. It builds the app, taps through the flow, screenshots the result, greps the logs for the network calls, and shows me.
- Plan: each feature starts as a drilldown doc — an interview until the design has no open branches — checked into the repo.
- Build: Claude Code implements against that doc; parallel work runs in separate git worktrees so agents never trample each other.
- Verify: the agent boots the simulator, drives the real UI through the accessibility tree, reads the logs, and captures screenshots and GIFs as evidence.
- Review: a second agent reviews the diff cold — different model, different blind spots.
- Ship: the asc skills handle TestFlight, metadata in three locales, screenshots, and the App Store submission.
The verification loop looks like this in practice:
xcodebuildmcp simulator build-and-run --scheme Lykka --simulator-id $SIMxcodebuildmcp ui-automation snapshot-ui # accessibility tree → tap targetsxcodebuildmcp ui-automation tap --label "Spara minne"xcrun simctl spawn $SIM log show --predicate 'process == "Lykka"'xcodebuildmcp simulator screenshot # evidence, not vibesParallel worktrees deserve their own sentence. When two features are in flight, each agent gets its own checkout of the repo, works on its own branch, and merges when its verification passes. It is the same discipline you would demand from two human engineers, applied to two agents — and it is the difference between agents as a queue and agents as a team.
The unit of progress stopped being "code written" and became "behaviour demonstrated in the simulator". Everything about the workflow follows from that one change.
The release was agents too
I have written before about asc, the agent-native App Store Connect CLI. On Lykka that idea grew into a couple dozen small skills that run the whole commercial surface: metadata sync in Swedish and two English locales, the screenshot pipeline, subscription localization, TestFlight orchestration, release flow, ASO audits, even the Apple Search Ads weekly report. Shipping 1.0 was a prompt. Shipping 1.1 and 1.2 were smaller prompts.
What the human did
Nine weeks, 148 commits, version 1.2.0, build 71. My contribution was judgment: the drilldown interviews where every design decision got settled before code, the product taste calls, the privacy line that the backend never holds memory content, and the daily dogfooding that decided what a reflection should feel like. The agents did the typing, the testing, and the shipping. I decided what was worth building and whether it was actually good. That split — my judgment, their execution — keeps getting more productive, and Lykka is the cleanest demonstration of it I have shipped so far.
Lykka is live now at lykka.app and on the App Store — free to start, one subscription for the full experience, no ads, and a backend that could not read your diary even if it wanted to.