One designer. One AI. One full-stack app.
Shipped Sous Pantry solo across iOS (Swift) and Android (React Native) using light spec-driven development and rapid prototyping with Claude Code — research to multi-platform production in eight months, with zero rework between prototype and shipping.
Serves
2 platforms
iOS (Swift) + Android (React Native), one shared backend
Prep time
4 months
Research, ideation, competitor analysis & learning the tools
Cook time
6 weeks
Focused iOS implementation + 2 weeks QA, launched June 2025
Ready in
8 months
Concept to multi-platform — Android shipping July 2025
The problem
Meal planning apps solve the wrong friction.
Most meal planning apps either require tedious manual data entry, suggest meals with ingredients you don't have, or don't connect to your actual shopping workflow. Users want to reduce food waste and simplify meal decisions — but existing solutions create more friction, not less.
Manual entry, high abandonment
Tracking a pantry by hand is tedious enough that most people give up within a week.
Suggestions that ignore reality
Meal ideas built from a generic recipe database, not what's actually in your kitchen.
Disconnected from shopping
Meal planning and grocery shopping live in separate apps, so nothing carries over.
Research & discovery — Dec 2024 to April 2025
Four months before a line of production code.
User research. Interviewed potential users on their actual pain points:
- "I buy groceries then forget what I have. Things go bad." — food waste
- "Deciding what to cook takes 20+ minutes daily." — meal fatigue
- "I have to manually make lists or remember what I need." — shopping friction
Competitor analysis. Studied Yummly, BigOven, Mealie, and AnyList:
- Most require manual pantry entry — the exact friction users complained about
- AI features were superficial, bolted on rather than core to the experience
- None connected pantry → meals → shopping into one seamless loop
The rest of discovery went into learning what this build would require: modern mobile development in Swift and React Native, LLM integration with the Anthropic API, and rapid AI-assisted prototyping workflows with Claude Code.
Core hypothesis — validated before writing a single screen
Photo-based pantry scanning + AI reasoning removes the #1 friction point — manual entry. Get this right, and the rest follows.
The method
Light spec-driven development,
not vibe-coding from scratch.
Rather than jumping straight into code, I ran a structured seven-phase process before implementation began — treating architecture decisions with the same rigor as UX decisions.
-
Product clarity
Vision, pain points, and a single success metric: plan a week of meals in under 15 minutes. Key assumption to validate — photo-based scanning removes enough friction to make the whole idea work.
-
Architecture-first design
Mapped the data model (users → pantry inventory → meals → shopping lists), made Claude the core reasoning layer for inventory matching, meal suggestions and shopping automation, and settled on one backend API consumed by both iOS and Android.
-
Research & validation
Explored UX patterns for photo-based input, tested whether Claude should reason over a raw photo or an extracted inventory list, and de-risked the LLM integration with real API calls before committing.
-
Capability audit
Identified the specialised skills the build needed: Swift for uncompromising native iOS performance, React Native for Android with shared business logic, Anthropic API prompt design, native camera APIs, and a Node.js backend.
-
Options & recommendation
Weighed a web-only MVP, iOS-first, and parallel iOS + Android. Chose iOS-first, then scale to Android leveraging the same backend once the core product was validated.
-
Executable roadmap
Phase 1: iOS MVP — six weeks of implementation plus two weeks of QA covering pantry scanning, AI meal suggestions, shopping lists and preferences. Phase 2: Android in eight weeks, rebuilt in React Native with native patterns — not a direct port — reusing the backend and business logic.
-
Ship with quality
Interactive prototypes in Cursor validated UX before production code. Iterated with real early testers, then used Claude Code end-to-end across design, components, API integration and testing.
Technical architecture
One backend, two native clients.
iOS — Swift + Xcode
Native UI for photo capture and pantry management, a local SQLite cache for an offline-first experience, and real-time sync with the backend. Responsive across phone and tablet.
Android — React Native
Shared component architecture with iOS design patterns, native modules for the camera and performance-critical paths, and the same backend API. Feature parity from day one — not a later port.
Data
PostgreSQL, cloud-hosted, for user data, preferences and meal history — paired with an on-device SQLite cache for offline access, syncing in real time when back online.
AI — Anthropic API
Claude as the core reasoning engine with purpose-built prompts for inventory extraction, meal reasoning and shopping lists — plus semantic caching to control cost, since a pantry doesn't change every session.
Key features
Four features, one connected loop.
Pantry scanning
Photograph the shelf and Claude extracts the items, with manual entry as a fallback. Items are tracked with quantity and expiry, syncing instantly across iOS and Android.
AI-powered meal suggestions
Claude reasons over dietary preferences and current inventory to suggest 3–5 meals feasible right now — and explains why each one works.
Shopping list automation
Select meals for the week and the app works out exactly what's missing, organised by category — produce, proteins, pantry staples.
Multi-platform consistency
iOS and Android consume the same backend and design tokens. Meal reasoning lives once, on the server — never duplicated in client code.
The product
Pantry → meals → shopping,
in your pocket.
Development process
Built with Claude Code, end to end.
Thirty-minute interactive prototypes in Cursor validated UX decisions before a line of production code was written. From there, Claude Code drove rapid component and API integration loops, helped diagnose issues mid-build, and filled in Swift and React Native patterns as I needed them. The iOS prototype went to production in six weeks with no rework — and Android began the same week iOS entered testing, made possible by the backend and business logic already being shared.
Dec 2024 – Apr 2025 · 4 months
Research & planning
User research, competitor analysis, ideation, and learning the tools this build would require.
Apr – mid-May 2025 · 6 weeks
iOS implementation
Focused development against the roadmap from the spec-driven planning phase.
Mid-May – mid-June 2025 · 2 weeks
iOS testing & launch
QA, refinement, and launch — Sous Pantry went live on the App Store in June 2025.
End of May – end of July 2025 · parallel
Android build
Ran alongside iOS testing, reusing the backend and business logic already shipped.
Results & impact
Production quality, zero rework.
Early testers consistently called out the same three things: photo-based pantry scanning feels close to magic compared to manual entry in competitor apps; the AI meal suggestions feel genuinely useful rather than generic; and the shopping lists match exactly what's needed, cutting down on waste.
- Production-ready AI integration — Anthropic API with deliberate, transparent UX
- Multi-platform shipping, iOS and Android, from a solo contributor
- Zero external service dependencies — every infrastructure layer owned end-to-end
- Backend architecture designed for scale, with iOS and Android reusing the same API
What this proves
For design technologists.
For design teams
- Light spec-driven development works — one week of architecture planning prevented rework across eight-plus weeks of implementation
- AI integration needs design thinking first — not "add a Claude button," but architecture that considers how AI actually enhances the experience
- Multi-platform thinking from day one prevents regrets — Android was a re-platform of the same backend, not a port
- Rapid iteration and production quality aren't mutually exclusive with the right tools
For founders & individual contributors
- A solo contributor can move at small-team speed when infrastructure thinking — design systems, shared backend, reusable business logic — amplifies individual velocity
- Shipping beats perfection — a launched product beats an endlessly optimised prototype
- Systematic thinking removes decision friction — a spec-driven approach means faster, more confident shipping
What worked well
Five decisions that paid off.
-
Architecture-first
One week on the database schema and system design prevented rework across eight-plus weeks of implementation.
-
Photo-based input
The single biggest UX lever — manual entry took 3–5 minutes per session, photo capture dropped it to 20 seconds.
-
Transparent AI reasoning
Users trust a suggestion when they can see why — "you have chicken, rice, and soy sauce → fried rice" beats an unexplained recommendation.
-
Both platforms from day one
Android reused the API, business logic, and database schema, so the two builds could run in parallel.
-
Claude Code for prototyping
Thirty-minute interactive prototypes caught UX issues before implementation, saving weeks of rework.
What I'd do differently
Four things for next time.
-
Accessibility, earlier
Voice control, screen readers, and high-contrast support should have been researched during planning, not after launch.
-
Validate receipt import sooner
Receipt OCR and parsing turned out harder than expected — it needed building during iOS development, not deferring as a "future feature."
-
User testing before launch
Post-launch feedback revealed pantry UX friction that one or two rounds of testing before shipping would have surfaced.
-
A clearer offline-first strategy
Local-first sync works, but the approach evolved mid-build — deciding upfront would have simplified things.
Learnings for design technologists
Four takeaways.
Spec-driven development is still relevant
Fast-shipping teams still need architecture thinking. It isn't "spec vs. vibe-code" — it's a smart spec paired with rapid iteration.
AI integration needs design thinking
LLMs are powerful, but thoughtful UX is what turns that power into delight. Transparent reasoning plus user control drives adoption.
Multi-platform is one system, not three
iOS, Android, and backend aren't separate projects — they're one system with different client views. Architecture thinking from day one prevents rework.
Shipping removes assumptions
Feedback on a shipped product beats research on wireframes every time. Ship fast, then iterate on real usage.
What's next
Where Sous Pantry goes from here.
Code like an engineer, think like a designer, use AI to amplify both.
The operating model behind this build
