Building a Mobile App with AI: Lessons from the Trenches

After 20 years of building software and leading technical teams, I decided to embark on an unusual experiment: Could I build an entire mobile application using nothing but AI-generated code? No Stack Overflow, no GitHub copilot, just pure LLM-generated code. Spoiler alert: I did it, and the journey was fascinating.

The Challenge

I set myself up with a fairly complex tech stack:

• React Native for the core application framework
• Expo for streamlined mobile development
• Redux and Redux Thunk for state management
• Claude 3.5 Sonnet for AI recommendations
• Tasty.co's API for recipes and metadata
• Firebase for authentication and data storage

The application itself? An AI-powered recipe recommendation engine that would make both Gordon Ramsay and a Silicon Valley engineer proud. Users input their food allergies, preferences (sorry, AI, not everyone loves cilantro), and dietary restrictions. The app then serves up personalized recipe recommendations, enables specific recipe searches, and helps users build comprehensive meal plans. It even automatically generates grocery shopping lists - because let's face it, nobody wants to manually count how many eggs they need across seven different recipes. Future features include a digital pantry that will let the AI play "Chopped" with your available ingredients, suggesting recipes based on what you already have at home.

As someone who's led digital transformations and built platforms from scratch, I'm no stranger to complex technical architectures. But this project was different - I was essentially partnering with an AI to build something from the ground up.

The Players: ChatGPT vs Claude

I decided to use both OpenAI's ChatGPT and Anthropic's Claude for this experiment. While both performed admirably, Claude (especially with their new Projects feature) emerged as the clear winner. The Projects feature is a game-changer - imagine having a pair programmer who can see your entire codebase at once, understanding all the context and relationships between files. More on that later.

Treating AI Like a Junior Developer

Here's where it gets interesting. After years of managing development teams, I instinctively started treating the AI like I would a junior developer. And you know what? It worked surprisingly well.

Like any junior dev, the AI makes mistakes. The difference? It's remarkably good at quickly acknowledging the error and fixing them right away. For instance, when it generated code using an outdated version of a packaged library, a quick correction was all it needed. No ego, no defensive explanations - just "Oh, you're right, here's the fix."

What really impressed me was its error-handling capabilities. When I'd copy and paste in the error messages from my console logs, about 90% of the time it would immediately provide working fixes. Usually, these were simple oversights - a missing import here, an unhandled null state there. You know, the kind of things that make you facepalm when you spot them in code review.

The Pleasant Surprises

The biggest shock? How incredibly competent the AI was at handling API interactions. I threw a complex JSON response at it, with no data schema inputs or explanations of the file, and it parsed it like a champ. When I needed to extract an array of directions from nested response data, it mapped over the structure perfectly even though the parameter was called instructions. No sweating the small stuff - it just worked.

The Not-So-Pleasant Surprises

Let's talk about SVGs. Or rather, let's not, because the AI was terrible at generating them. If you need custom vector graphics, you're better off sticking with human-created assets. That said, if you're using ChatGPT and need quick logos or image assets, DALL-E-2 or 3 (from OpenAI) does a decent job - good enough that you might not need to spring for a paid Midjourney subscription, depending on your requirements.

The Usage Limits Dance

Even after paying up for Claude Pro and access to their latest Sonnet model, I often hit usage limits that triggered five-hour timeouts. This was actually my biggest time bottleneck in development. However, through trial and error, I discovered some crucial optimizations that completely changed the game.

Lesson 1: Bundle Your Requests

My first approach was what I thought would be most helpful - making single requests at a time per screen, all in one continuous conversational thread. Big mistake. Here's why:

1. I assumed I was being considerate by not overwhelming the AI with multiple tasks.
2. I thought keeping everything in one thread would provide better context.
3. What actually happened? The AI had to process the entire conversation history with each new request, exponentially increasing compute usage. It was like forcing someone to re-read a novel before answering each new question.

Instead, I learned to bundle related requests together. The AI is surprisingly good at organizing multiple tasks into logical steps, and it even helps when some requests have interdependencies. As a bonus, it starts by explaining its approach, letting you course-correct before it dives into implementation - just like a good technical planning session.

Lesson 2: Fresh Conversations for Fresh Components

This was a game-changer, and couldn’t have worked without Claude's Projects feature. Instead of that one massive conversation, I started fresh chats for each new screen or component. Since the Projects feature provided full codebase context, the AI still understood the overall architecture while keeping individual conversations focused and efficient.

Tips for Success

1. Be Clear About Dependencies: When starting a new feature, explicitly state which libraries and versions you're using. The AI will adjust its code accordingly.
2. Provide Sample Data: When working with APIs or data structures, give the AI a sample of what you're working with. It's remarkably good at pattern matching and will generate more accurate code.
3. Use Error Messages: Don't waste time trying to debug AI-generated code yourself. Just paste the error message back to the AI - it's surprisingly efficient at fixing its own mistakes.
4. Think in Components: Bundle related tasks together, but start fresh conversations for new components or screens. This keeps the context focused while maintaining efficiency.
5. Trust But Verify: While the AI is impressive, always review the generated code. It's more like a very eager junior developer than a seasoned architect.

The Verdict

Could AI replace developers? No way. But can it be an incredibly powerful tool in the right hands? Absolutely. The key is understanding how to work with it effectively - treating it like a junior developer who's extremely knowledgeable but needs guidance and oversight.?

The experience has changed how I think about AI in development. It's not about replacement; it's about augmentation. Used properly, AI can significantly speed up development time while handling many of the routine aspects of coding. For a sense of timing, this project would have taken me about 2-3 weeks to complete without the AI assistant. With the AI assistant, about 3-4 days.

This leaves developers free to focus on architecture, optimization, usability and the more creative aspects of software development. It hammers home the point that we will not lose our jobs to AI, but rather another person who knows how to use AI.

For my next project, I won't be using AI exclusively - but I'll definitely be incorporating it into my workflow. The key is understanding its strengths and weaknesses, and leveraging it accordingly.

As a side note: I will update this post with a link to the applications when they are formally published to the Apple App Store and Google Play Store. It is currently in the Beta Testing phase with a few additional openings available. If interested in participating in the beta, please feel free to send me a Direct Message to lock in one of the remaining spots.

Looking Ahead

As these AI models continue to evolve, particularly with features like Claude's Projects that provide full codebase context, we're likely to see even more powerful development capabilities emerge. The key will be learning how to effectively collaborate with AI - treating it not as a replacement for human developers, but as a powerful tool in our development arsenal.

Remember: AI is not here to take your job; it's here to make your job more interesting by handling the routine stuff while you focus on the challenging, creative aspects of software development. And isn't that what we all got into this field for in the first place?

Daniel Cohen is a seasoned Operations and IT Executive with over 20 years of experience in scaling technical startups and leading digital transformations. When not experimenting with AI, he can be found advising technology companies and occasionally writing about his adventures in code.