One designer, zero engineers, three weekends

Every health app gives you more numbers. Vera gives you one. Your biological age, revealed every Sunday morning like a weekly letter from your body. I designed and built the entire thing, 18 calculation models, 11 screens, a cinematic reveal system, across three weekends by assembling a team of AI agents and directing them like an engineering org.

Currently in public beta. App Store launch incoming.

The bet

Most fitness apps treat you like a day trader of your own body. Steps today. Heart rate now. Sleep last night. The data is noisy, the signals conflict, and nobody gets healthier from staring at dashboards.

Vera's bet: one number, once a week, with one thing to do about it is worth more than all the dashboards in the world.

The studio I built to build the app

I'm a designer. I'd never shipped a production iOS app. The traditional path was clear: learn Swift for six months, or find an engineer and split equity. I did neither. I built an engineering team from scratch, hired them in an afternoon, and they never missed a deadline.

The agent roster

I created custom AI agents in Codex, each specialized like a senior engineer who only owns one domain:

• Scoring Agent owned the 18 calculation models: hazard scoring, confidence math, uncertainty ranges, cardio overlap correction. This agent thought in formulas and edge cases. When I said "stale metrics should be neutralized, not penalized," it knew what that meant for every downstream calculation.
• HealthKit Agent owned the Apple Health integration: the 11-metric data pipeline, staleness detection, recency contracts, workout taxonomy. It knew that "7 days without a VO2 Max reading" means something very different from "7 days without step data," and it built the logic to handle both correctly.
• UI Agent owned the SwiftUI layer: every screen, the animation system (five distinct timing curves), the haptic map, Reduce Motion support. It didn't just build screens. It built screens that matched a 12-token spacing grid, a semantic color system, and a 44dp touch target contract across every interactive element.
• Data Model Agent owned the structural backbone: domain models, threshold definitions, profile configurations, telemetry schema. The unglamorous work that makes everything else possible.

The head agent

Then I built the agent that changed everything.

The Head Agent sat above the four domain agents and ran the build the way a staff engineer runs a complex project. It wasn't just a coordinator. It was the system that let one designer operate at the output of a full engineering team.

• Context routing. Every task needed the right agent with the right context. The Head Agent decided which agent owned which task, what prior decisions that agent needed to know about, and what constraints from other agents' work applied.
• Consistency enforcement. Four agents working in parallel will drift. The Head Agent caught when the UI Agent's animation timing didn't match the spec, when the Scoring Agent's output format diverged from what the Data Model Agent expected, when a color token was hardcoded instead of pulling from the theme system.
• Dependency sequencing. A scoring engine is useless without the data pipeline. A reveal animation is meaningless without the score. The Head Agent mapped the dependency graph and sequenced the build so nothing was assembled out of order.
• Conflict resolution. When two agents made assumptions that clashed, the Head Agent didn't guess. It escalated to me with the exact conflict, the options, and what each choice would affect downstream.

I wasn't writing Swift. I was running a studio. The deliverables I gave the agents were the same things I'd give any engineering team: clear specs, prioritized decisions, and a design system tight enough to build from. The difference is that this team executed in hours, not sprints. Three weekends, not three months.

The documentation layer

The real unlock wasn't the agents. It was what I fed them.

I wrote structured markdown specs for every screen, every model, every edge case. Token-level design system definitions. State diagrams for every view. Calculation contracts with exact formulas, clamp ranges, and fallback behavior. Not rough briefs. Not "make it feel premium." Exact specs.

The docs weren't afterthoughts or handoff artifacts. They were the management API. An agent with a perfect spec produces perfect output. An agent with a vague brief produces garbage. I learned this on day one of the first weekend and never made that mistake again.

The quality of my documentation was the quality of my app.

The product

11 signals in, 1 number out

Vera reads sleep duration, sleep consistency, steps, active days, heart rate zones, strength training, training load, VO2 max, resting heart rate, HRV, and lean body mass from Apple Watch. 18 models work together: adaptive hazard scoring, cardio overlap correction, staleness neutralization, on-device ML ranking. All on-device. No health data leaves the phone.

The confidence gate

New users don't have enough data for a real score. Instead of showing a shaky number, Vera shows a "Building your baseline" card with a progress bar. Bio Age unlocks at 75% confidence. That restraint costs first-day wow factor. It earns trust.

The Sunday reveal

Every Sunday at 10:00 AM, full-screen cinematic reveal. The number counts up over 3.2 seconds with haptic pulses. Stats fade in with staggered timing. If your bio age improved: confetti, color flash, heavy haptic hit. The reveal turns a data point into an event. Health behavior change starts with feeling something, not reading a chart.

The explainer

Biological age is something most people misinterpret. I explored four visual concepts. The "Time Decoupling" concept won: two parallel timelines showing calendar age marching steadily while bio age jumps around. Users got the core idea in under two seconds.

The action bridge

After the reveal, Vera generates a Weekly Focus Plan around your strongest headwind. A what-if engine shows honest confidence intervals for behavior changes. An on-device logistic ranker personalizes suggestions and suppresses bad recommendations during fatigue or low-data contexts.

The design system

Space Grotesk. 4pt grid. Age-band colors that tint the entire home screen: purple, blue, green, orange. Informational, not decorative. 44dp touch targets. Five animation curves collapsing to 10ms under Reduce Motion. Haptics per event type.

Where it stands

Public beta, heading to the App Store. The metrics I'm watching:

• Week-2 return rate: Do users come back for their second Sunday reveal?
• Baseline completion rate: Does withholding the score build trust or cause drop-off?
• Focus plan engagement: Does the number-to-action bridge work?
• What-if exploration rate: Is the counterfactual tool discoverable?

The lesson

I used to think the gap between designing a product and shipping a product was engineering talent. It's not. The gap is clarity. If you can spec it down to the staleness thresholds, the animation curves, and the edge cases, the building follows. The agents didn't replace an engineering team. They made me realize that what a great engineering team actually needs from a designer is exactly what these agents demanded: perfect specs, zero ambiguity, and decisions made before the build starts.

Three weekends. One designer. A custom AI agent team. An app with 18 models and a cinematic reveal that makes people feel something about their health data for the first time.