Hussein Taha
Writeups
ENGINEERING•
2026-01-10
•
12 min read

Shipping a 30-Screen App in 24 Hours with AI

How DevOps Pilot turned a single Telegram message into a deployed 30+ screen mobile app — and what I learned about the line between AI-generated code and shipping a real product.

HT
Hussein Taha
Author

Shipping a 30-Screen App in 24 Hours with AI

Tadwerak — a dual-role recycling and e-commerce mobile app with over 30 screens — was built, tested, and deployed to a client in under 24 hours.

I didn't type every line of code myself. I used DevOps Pilot, my AI-orchestrated development framework, to generate the scaffolding. But the AI didn't build the product; it just wrote the boilerplate. Understanding the exact boundary between where the AI stopped and I started is the key to modern engineering.

Here is the honest breakdown of how I shipped an impossible deadline.

The Generation Pipeline

DevOps Pilot isn't a simple chat interface. It's an autonomous loop that generates code, attempts to build it, and fixes its own errors.

At Hour 0, I sent a single Telegram command:

/expo Tadwerak Build a recycling app with wallet and e-commerce

Behind the scenes:

  1. The Orchestrator selected my pre-configured Expo Pro template (React Native, Navigation, Firebase boilerplate).
  2. The Engine prompted Claude 3 to generate the 30+ requested screens based on the natural language specification.
  3. The Tester ran npx expo export to validate the build.
  4. When the build failed due to a missing import in CartScreen.tsx, the Tester fed the error back to the AI.
  5. The AI generated a patch, applied it, and the build passed.

Total time: ~25 minutes.

What the AI Actually Delivered

After 25 minutes, I had a working app skeleton. It was genuinely impressive, but it was nowhere near a product.

The AI is exceptionally good at:

  • Boilerplate: Setting up React Navigation stacks, creating the directory structure, wiring up context providers.
  • Standard UI patterns: Generating login forms with validation, list views, card layouts, and bottom tab navigation.
  • CRUD operations: Writing basic Firebase Firestore reads/writes for standard entities like "Users" and "Products".

It generated about 60% of the total codebase lines. It saved me roughly a week of typing repetitive boilerplate.

What the AI Could NOT Do (The Human Element)

The remaining 23 hours were entirely manual engineering. This is where "AI coding" breaks down and real software development begins.

1. Product Architecture Decisions

The AI generated a "Wallet" screen, but it didn't understand the reconciliation logic. A wallet isn't just a number in a database; it's a ledger. I had to design the transaction flow: when a user recycles, credit the wallet; when they buy a product, debit the wallet; when they withdraw via InstaPay, create a pending withdrawal request for admin approval. The AI cannot architect business logic.

2. RTL Arabic Layout Engineering

React Native's RTL (Right-to-Left) support is notoriously tricky. While calling I18nManager.forceRTL(true) flips the layout direction, the AI generated the UI assuming Left-to-Right (LTR). I had to manually audit all 30 screens:

  • Fixing hardcoded marginLeft and marginRight values to use marginStart and marginEnd.
  • Reversing custom navigation gestures.
  • Fixing bidirectional text rendering where Arabic and English numbers mixed (e.g., "150 نقطة").

3. Firebase Security Rules & Schema Design

The AI generated flat Firestore collections. I had to restructure the database for security and performance:

  • Creating subcollections for user-specific data to optimize read costs.
  • Writing complex Firebase Security Rules so users could only read their own wallet balance, while admins could read everything.
  • Implementing atomic batch writes to ensure that when an order is placed, the inventory decreases and the wallet balance updates in a single transaction. If one fails, both fail. The AI didn't consider race conditions.

4. Edge Cases and State Management

What happens if the network drops mid-checkout? What if a user with 0 points tries to withdraw? What if the admin approves a pickup request, but the user's account was deleted 5 minutes prior? The AI builds for the "happy path." I spent hours writing error boundaries, offline fallbacks, and input validation to handle the chaotic reality of mobile users.

The Honest Takeaway

AI did not build Tadwerak. AI generated 60% of the boilerplate, and I spent 23 hours making product decisions, fixing RTL layout, enforcing database consistency, handling edge cases, and testing on real devices.

The value of AI isn't replacing the engineer; it's removing the friction of the blank page. It allowed me to skip the tedious setup phase and immediately start solving the hard domain problems.

The real skill of the future engineer isn't prompting. It's reading AI-generated code, knowing what to keep, knowing what to throw away, and having the architectural vision to turn a skeleton into a production-ready system.