I’ve just launched Kitchen Sink on the App Store, and the development journey offers fascinating insights into AI-assisted coding. The project took 33 builds to progress from initial concept to App Store approval, with every line of code written by Claude Code whilst I provided direction and prompts.
What Kitchen Sink Does
Kitchen Sink is a multi-purpose utility app combining several practical tools in one package. The flagship feature is its Golden Hour calculator, which uses GPS location data to determine optimal photography lighting times—those magical periods shortly after sunrise and before sunset when natural light is softest.
The app also includes Blue Hour times for twilight photography, sun position tracking with altitude and azimuth data, GPS coverage tracking with map visualisation of your travels, and a Carbon Sequestration Tracker that logs actions and calculates environmental impact using AI.
With its clean, dark-themed interface, the app works offline after initial location fetch and requires no account creation—just location access to get started.
The Development Approach
What made this project particularly interesting was the collaborative dynamic between human guidance and AI implementation. I focused on conceptual direction and decision-making, whilst Claude Code handled the technical execution—from writing code to debugging issues and preparing App Store submission materials.
The project demonstrated both the capabilities and limitations of AI-assisted development, particularly when working with mobile platforms and their specific constraints.
The iOS Crash Challenge (Builds 1-26)
The most significant obstacle emerged early: the app crashed immediately on iOS startup, providing no useful error messages to guide debugging efforts. This created a frustrating cycle of attempted fixes without clear direction.
Our troubleshooting attempts included:
- Removing Sentry integrations that might interfere with startup
- Systematically disabling features to isolate the problem
- Adding comprehensive error handlers throughout the codebase
None of these approaches resolved the issue. The breakthrough came when Claude suggested stripping the application to a minimal “Hello World” implementation and rebuilding functionality systematically.
The Root Cause
After 26 builds, we identified the culprit: React 19.2.3 proved incompatible with React Native 0.81.5 in Expo SDK 54. The version difference between 19.2.3 and 19.1.0—seemingly minor—caused a native crash before any JavaScript could execute.
This particular issue highlighted a key challenge in AI-assisted development: dependency compatibility problems that occur at the native layer often lack the clear error messages that help guide troubleshooting.
Systematic Rebuilding (Builds 27-31)
Once we’d identified the compatibility issue, Claude Code approached the rebuild methodically:
The navigation system received attention first, with expo-router implementation providing the app’s structural foundation. The Golden Hour feature—the app’s primary functionality—was then restored and tested thoroughly.
Dependency conflicts required careful resolution, ensuring all packages worked together without introducing new issues. Each step received verification on iOS before proceeding to the next feature addition.
App Store Preparation (Builds 32-33)
Claude Code managed the entire App Store submission preparation:
Visual Assets: The system generated custom app icons programmatically, creating a golden sun design on a dark background. Screenshots for all required device sizes were produced automatically.
Documentation: All App Store metadata and descriptions were written and optimised for discoverability. A privacy policy was created and hosted appropriately.
Technical Requirements: An alpha channel issue with iOS icons emerged during this phase—iOS icons cannot contain transparency. Claude identified and resolved this requirement.
Successful Approaches
Several strategies proved particularly effective:
Systematic Debugging: Stripping the application to its minimum viable state, then rebuilding incrementally, isolated the actual problem from suspected issues. This methodical approach prevented wasted effort on tangential concerns.
AI-Handled Repetitive Tasks: Icon generation, screenshot creation, and metadata writing suited AI capabilities well, freeing human attention for decision-making and oversight.
Parallel Investigation: Claude could research documentation whilst explaining its reasoning, accelerating the learning process for both parties.
EAS Build Workflow: The ability to run 33 builds with automatic TestFlight submission enabled rapid iteration without manual deployment overhead.
Areas for Improvement
The project highlighted several opportunities for enhanced efficiency:
Dependency Compatibility: Better upfront checking of package versions and their compatibility could prevent issues like our React version conflict. Automated compatibility verification tools would prove valuable.
Incremental Development: Adding features one at a time, with builds between each addition, would help isolate problems more quickly when they occur.
Native Debugging Tools: Better tools for debugging native crashes would significantly reduce troubleshooting time when issues occur at the platform level rather than in JavaScript code.
The Outcome
Kitchen Sink is now available on the App Store: Download Kitchen Sink
The project demonstrates that AI-assisted development can handle complex tasks including native mobile app creation and App Store submission. Success requires clear human direction, systematic troubleshooting approaches, and understanding both AI capabilities and limitations.
The 33-build journey from concept to approval revealed that whilst AI excels at implementation and repetitive tasks, complex debugging—particularly of native platform issues—still benefits significantly from systematic human-guided approaches and methodical problem isolation strategies.
Have you experimented with AI-assisted development for mobile applications? The tools are developing rapidly, and understanding their effective use patterns helps both individual developers and the broader development community.