Building GitaWisdom: A Learning Journey

This post reflects personal learning and experimentation. It does not represent commercial offerings or services.

There's a lot of talk about AI-assisted development these days. Folks building apps quickly with AI tools. "Just describe what you want and the AI writes the code." It sounded interesting enough to explore.

Working at the junction of product and engineering, it had been a while since any production code was written — but AI tools changed everything. Armed with this new arsenal, the question emerged: could something real actually be built? And not just any app — mobile development for two platforms. Phew.

The exploration started with ChatGPT for general questions. Then Claude became the go-to for anything code-related.

But here's the thing about building apps: you need an idea worth building. Not just a demo. Something people would actually use.

The Idea: Decision Framework as an App

The Bhagavad Gita is a 5,000-year-old text about a warrior stuck between what his heart wants and what duty demands. It's basically a decision-making framework - every career choice, family conflict, or ethical dilemma maps to this tension.

The vision: an app that helps with real-life decisions. Not verse lookup, but "I'm stuck between X and Y - show me both perspectives."

Here's an example. Take a scenario like: "My coworker took credit for my work."

That's the core product: real scenarios, dual perspectives, connected to source material. The existing apps were all verse browsers. PDF viewers. Audio recitations. None of them mapped real-life situations to actionable guidance.

The idea was solid. Now to figure out if AI-assisted development could actually make it real.

Starting from Zero: Swift and Xcode

The goal was to keep costs minimal. No expensive infrastructure. No monthly bills for a side project that might go nowhere.

That meant starting with iOS native - everything runs on-device, no backend needed initially. Downloaded Xcode. First time touching Swift.

The prompt to Claude: "Build a simple iOS app that displays a list of scenarios. Each scenario has a title and description. How do I start?"

Twenty minutes later, a basic list view appeared on the simulator. It crashed if you scrolled too fast, but it existed. Something on screen that wasn't there before.

This was the moment of realization: AI development is fundamentally different from traditional development. Not "AI will replace developers" - but "AI can get non-developers past the blank page."

Before AI vs After AI

To put it in perspective:

The transformation was real. But as I'd soon learn, acceleration has limits.

The Content Challenge

The code was actually the easy part. The hard part was the content.

The dilemmas started getting categorized at a high level. Career conflicts. Family expectations. Relationship challenges. Ethical gray areas. Each category needed specific scenarios that real people actually face.

"My coworker took credit for my work."
"My parents want me to pursue a career I don't want."
"I said something hurtful and don't know how to apologize."

For each scenario, two perspectives were needed: what the Heart says (emotional, intuitive) and what Duty says (logical, principled). Plus connections to relevant Gita verses.

It started with about 100 scenarios, all hardcoded directly in Swift. Just arrays of strings. It worked.

Then 200 scenarios. Then 500. The code files became unmanageable. Every time a scenario needed editing, the entire app had to be rebuilt.

This is where learning hit its first wall: scale. AI can help you write code, but it can't design systems. A backend was needed.

From Paper to Pixels

The UI started as sketches on paper. Rough boxes. Arrows showing navigation. Labels for buttons.

Then a photo uploaded to Claude: "Here's the app design. Can you create the SwiftUI views for this?"

It generated actual UI code from napkin sketches. Not perfect, but close enough to iterate on. This was AI-assisted development in action - describe or show what you want, let the AI translate it to code.

For the backend, Supabase was the choice. Hosted Postgres, authentication built-in, and a generous free tier. The data model described in plain English, and Claude produced the SQL schema and the Swift code to query it.

From there, it was a rollercoaster. And honestly? A blindfolded rollercoaster.

The Blindfolded Rollercoaster

Here's what nobody tells you about AI-assisted development: the AI gives you code that works... until it doesn't. And when it breaks, you don't always understand why.

Authentication took two weeks. The AI-generated OAuth code worked in the simulator but failed on real devices. Race conditions that weren't understood. Deep links that went nowhere. Copying and pasting errors into Claude, getting fixes, applying them, finding new errors.

Some days it felt like debugging with eyes closed. "Try this." Didn't work. "Okay, try this instead." Still broken. "Interesting, the issue might be..."

But here's the thing: learning was happening. Slowly. Each debug session taught a little more about how iOS apps actually work. The AI wasn't just writing code - it was explaining code.

Five Unexpected Lessons

Looking back, here's what was most surprising about this learning process:

1. Debugging takes longer than coding. AI writes code fast. Understanding why it broke? That's on you.
2. AI-generated UIs need refactoring. First pass looks great. Second week, it's spaghetti.
3. Authentication is 90% of the pain. OAuth, session management, token refresh - weeks of work for something users never see.
4. AI hallucinations feel real until they break. This was a hard lesson. The SQL looked perfect. The function names made sense. The code ran without errors. Then three days later, it was discovered to be silently inserting data into the wrong table. AI-generated code has a dangerous quality: it looks right. Trust comes because there are no obvious red flags. The bugs aren't syntax errors - they're logic errors hidden behind confident-looking code.
5. App Store compliance teaches product rigor. Every rejection was a lesson in what users actually expect.

After four months, a working iOS app existed. SwiftUI, CoreData for local storage, Supabase for sync. About 50 people were using it.

Then someone asked: "When's it coming to Android?"

The Rewrite Decision

Half the potential users couldn't use what was built. And maintaining two native codebases as a solo developer with a day job? Not sustainable.

Claude was consulted about Flutter. Cross-platform. One codebase. Both app stores.

Six weeks later, everything was rewritten in Flutter . The concepts translated. The knowledge carried over. And now every feature reaches iOS and Android with the same effort.

Six Rejections from Apple

The app was ready. Time to ship.

Apple rejected it. Missing account deletion feature.

Fixed. Submitted again. Rejected. OAuth race condition they found.

Fixed. Submitted. Rejected. Privacy manifest incomplete.

Six rejections total. Each one a 24-48 hour wait, then another issue to fix. By the fifth rejection, questions arose about whether this was worth it.

Each rejection taught something about what users actually expect from apps they trust with their data. The app that finally shipped was genuinely better than what was originally submitted.

What AI-Assisted Development Actually Is

Here's the key lesson: AI-assisted development isn't magic. It's acceleration.

The AI helps get past the blank page. It translates rough ideas into working code. It explains concepts when you're stuck. It debugs issues faster than working alone.

But it doesn't replace the need to understand what's being built. Every time the AI's output is blindly trusted without understanding it, there's a cost later. The code that works best is code that can be explained back.

Those "2-3 day app" stories on Twitter? They're real - for demos. For something production-ready, with authentication, offline support, store compliance, real content? Plan on months. The AI makes months feel like weeks, but it's still months.

The Numbers

Where the app stands today:

What I Learned

This project taught me that building software is now accessible to domain experts who understand user problems. The technical barriers that once existed are falling.

Want to read more about the technical details? Check out the GitaWisdom case study.

And for anyone thinking about building their own idea with AI assistance - do it. The tools are real. The acceleration is real. Just know that the rollercoaster is also real.

The Future of Building

Here's the takeaway: the future of building isn't "developers vs AI." It's domain experts + AI tools.

Product thinkers understand user problems. They can design solutions. What they couldn't do was translate those ideas into working software - until now.

AI-assisted development closes that gap. Not perfectly. Not easily. But enough to ship something real.

The best products will come from people who deeply understand a problem space and can now build solutions themselves. That combination - domain expertise + AI acceleration - creates products that couldn't exist before.

Buckle up. It's worth the ride.

* * *

Related reading:

More articles coming soon.