Pawmise · Founder · 0→1 · AI-Augmented iOS
Founded Pawmise: idea to production iOS app in two weeks, solo.
Not a prototype — a working two-sided product with a live backend, built in personal time by one person directing AI through a docs-as-law pipeline.
2 wks
Idea → working product
Founded and built in personal time: design system → native app → live backend → running on iPhones. QA ongoing.
1
Founder, five disciplines
Product, design, iOS, backend, web — solo, directing Claude Code
3 days
First code → app on iPhones
The entire app generated from the docs that drove the design; in Apple's beta channel by day three
Shipped: running on iPhones
The real app, running on device — not a prototype. Live Firebase sync between owner and watcher accounts.
One calm timeline, no completion theater
No progress bars, no "2 of 9 done." The single test applied to every screen: does it answer "is my pet being cared for?" or "how many tasks are left?" Only one confirmation mechanic survived that test — the watcher-only confirm circle, kept because it's how the owner knows.
Amber is earned, not decorative
Medication is the only amber in the entire system — no red, pink, blue, or purple anywhere. Every color has a stated functional role written into the design law, so critical tasks stand out because nothing competes with them.
Two-sided by design
Owners author the routine; watchers confirm the day. Both see the same plan, synced live through Firestore with deployed security rules and a capability-token invite handshake.
The founder bet
Pet-care handoffs live in group texts: feeding instructions scroll away, medication doses get retyped, and the owner abroad refreshes a chat thread hoping someone answers. Pawmise replaces that with an operational handoff tool that happens to be about pets — a calm care guide, deliberately not a task manager.
I founded it and built it in my personal time, as a deliberate test of a working thesis: a designer who can author a design system precisely enough for machines to build from it no longer needs a team to ship. Not AI as autocomplete — AI as the production team, with the designer supplying direction, taste, and QA.
The bar I set was a working product, not a portfolio prototype: real authentication, a live backend with security rules, two-sided sync between real accounts, and a distribution pipeline pointed at the App Store. That's what 'production' means in the title — the infrastructure is live and production-grade; the App Store listing is the last mile, and QA is still running.
The pipeline: docs → design → code
Write the law before the pixels
DESIGN.md defines the visual system — palette with functional roles, a fixed control scale, tier system, anti-pattern bans. CONTENT_GUIDE.md defines the voice. Both written to be read by humans and machines alike; both are the single source every later artifact is generated from.
Design in Figma, driven by Claude Code over MCP
14 canonical screens, a component library, and variable-bound design tokens — built through AI-augmented iteration with the exploration boards and 13 palette versions preserved on canvas as the decision record.
Generate the app from the same docs
The SwiftUI codebase was produced from DESIGN.md and the Figma file — 14 components mapped 1:1 by name, tokens mirrored as code constants, terminology enforced from the content guide down to identifier names. Screenshot-compare against Figma before anything counts as done.
QA as legislation, then ship
Every visual fix found in QA was codified as a rule in the design law the same turn — roughly 40 fixes became permanent system rules instead of one-off patches. Six beta releases later, the app runs live sync between real owner and watcher accounts.
“The moment the design system became precise enough for a machine to build from, 'solo designer' stopped meaning 'small scope.'”
One law, three surfaces
The medication tier, traced end to end: written as law in DESIGN.md, componentized in Figma, shipped in SwiftUI. Amber is the only alarm color in the system — nothing else carries hue — so the one task that can't be missed is the only thing that stands out.
Open each artifact — the rule, the component master, and the shipped screen carry the same geometry.
Key decisions
Stripped completion theater — then let exactly one mechanic earn its way back
Care apps drift into checklist UI: progress bars, '2 of 9 done,' streaks. My early drafts did too. But completion theater reframes caring for a loved animal as chore-clearing — and an owner abroad doesn't need a score, they need to know their pet is okay. Strip every confirmation, though, and the owner has no signal at all.
Every screen had to pass a single test: does it answer 'is my pet being cared for?' — or 'how many tasks are left?' Progress bars and counts were removed; one mechanic returned. The watcher-only confirm circle stayed because its purpose is the owner's peace of mind, not gamification. The affordance rule took four iterations to land (active circle → flat tick → soft wash → none) and became law: if you can see a circle, you are the one who acts. Owner surfaces carry no status glyphs at all.
One alarm color in the entire system — and medication owns it
Every task type lobbies for emphasis, and color-coding by category is the default answer. It's the wrong one: when everything is highlighted, nothing is. The other obvious move — pinning medication to the top of the list — broke the chronological, location-grouped model the whole day view is built on.
Amber appears exclusively on medication; red, pink, blue, and purple are banned outright. The critical card burned through rejected treatments on the way — a left accent bar (displaces the grid), a 2px border (reads as a selected state) — before landing on the docked badge, with every rejection reasoned and written into the law so it can't quietly return. Prominence comes from the container, never from moving content: a med row shares the exact left edge of its siblings.
The day belongs to today's caregiver
Whose surface is Today — the owner's oversight dashboard or the watcher's plan? Splitting the home screen by role produces two half-products; merging them turns pet care into surveillance.
Today belongs to whoever is caring today. Watchers see the pets they're watching; owners see their own pets only when no one else is covering. When a watcher is on duty, the owner gets exception-based monitoring instead: reassurance first, a needs-attention block only when something is real, history collapsed to a single line. The law that fell out — exceptions surface, routine disappears — shaped every owner screen in the app.
The two-sided journey
Owner authors the care plan; watcher lives the day. Five screens, one shared source of truth.
Swipe to explore
Where the machine needed a designer
The pipeline isn't autopilot. Three moments made that concrete. A task chip kept rendering the wrong color, and every automated sweep of the codebase insisted it was fixed. The cause was a two-line variant hiding in the one code path the string searches never touched. The fix was judgment, not prompting: stop sweeping, open the rendered surface, and read its actual code path. That lesson is now codified in the project's working rules. The palette went through thirteen versions — evergreen to maritime to plum to coral, and back to the original evergreen. AI made the exploration nearly free; it could not make the call to come home to version one. Taste doesn't automate. And nothing shipped on the machine's word alone: every screen was screenshot-compared against its Figma frame before it counted as done. Measured beats derived, every time.
What a team of one shipped
- Native SwiftUI app (iOS 17), XcodeGen project, 14-component design system with hand-drawn vector iconography — no SF Symbols, no icon fonts
- Firebase Auth with Sign in with Apple and Google, Firestore data model, and deployed security rules
- Two-sided invite handshake: capability-token links → personalized landing page at pawmise.pet → passwordless email sign-in → live roster sync
- Branded transactional email service and web landing, deployed on Vercel
- Apple code-signing, beta distribution, and the App Store submission checklist — the unglamorous last mile most portfolios skip
Impact
0
Handoffs
Designer, engineer, and PM are the same person — nothing was lost in translation, because there was no translation
14
Components, Figma = SwiftUI
Every component exists twice under the same name — once in the design file, once in code
Every
QA fix became a rule
Each finding rewrote the design law the same turn it was caught — no one-off patches, no drift
5
Releases in one afternoon
Device finding → fix → rebuild → re-upload, five times between 2:50 and 4:25 pm
What I'd Do Differently
The same-turn law covered the docs, but not the Figma file.
Every QA fix updated DESIGN.md in the same turn it was found — but during the sprint to TestFlight, the canonical Figma frames fell behind the shipped app in five places. The catch-up sweep is scheduled before App Store submission. Next time, the same-turn rule covers every source of truth, not just the ones code is generated from.
The principle I carried forward
The skill that scaled here wasn't pixels or Swift — it was authoring the source of truth precisely enough that both humans and machines could build from it without drift. When the design system is written as executable law, AI becomes a reliable production team, and the designer's job distills to what it always should have been: judgment. What to build, what counts as done, and which rules the system must never break.