Building a Sanskrit Dictionary App: An AI-Powered Retrospective

My experience building a Sanskrit Dictionary app showed me how LLMs and Python empowered me, a Swift developer, to work with unfamiliar tools, languages, and systems I once thought were out of reach.

Instead of participating in WWDC this year, I decided to take the “quiet” time to power through and release an app I’ve been working on slowly over the past year, when I graduated the MA Sanskrit Studies program from Manipal University in India. This post won’t go into the details of Sanskrit dictionary design or user experience (I’ve covered those here, if you’re interested). Instead, I’ll focus on the technical and AI-specific challenges behind building the app: what worked, what didn’t, and what I learned along the way.

Python is All You Need

So why use Python if I’m a Swift developer? The answer is simple: most Swift apps need a backend, and in my case, I was using Supabase. To process and prepare that backend data, Python when paired with LLMs, is by far the easiest and most efficient tool. Could it be done in Swift? Probably. But the developer experience would be painful, and LLM support for Swift just isn’t there yet. Python, on the other hand, works beautifully.

While there is a ton of hype around AI Agents - if you build fully agentic systems using LLMs for all tasks in the pipeline, you’ll quickly run into surprisingly unreliable and unpredictable results. While these systems have potential (I’m sure they’ll really stand out for certain futuristic use cases I haven’t thought about), the real strength of LLMs today lies in their ability to write solid, reliable Python code that simply gets the job done.

Most of the work I did for my Sanskrit Dictionary app was writing a ton of Python scripts with the help of LLMs. I pushed as much of the data processing as possible to the backend, so the frontend app could stay lightweight and simply display everything instantly and efficiently.

Now here’s the magical part: I barely know Python. I only dabbled with it briefly over a decade ago when I first started learning to code. As I was finishing my MA in Sanskrit Studies and beginning to imagine this app, I assumed I’d need to spend at least six months head-down, learning Python from scratch before I could even get started. But then LLMs came along and suddenly, I could write working Python code without needing to formally study it. It just worked. I’m convinced that without LLMs + Python - I wouldn’t have been able to build this app!

The takeaway? Any Swift developer can now pick up Python on the fly - and that’s the real superpower of LLMs. Even agentic systems, like OpenAI’s o models, often rely on generating and executing Python scripts behind the scenes to produce accurate results. Right now, that’s the most reliable way to get meaningful output from LLMs. So before getting swept up in the agent hype, see if a well-crafted Python script can solve your problem. More often than not, it will.

Learning New Tools

While building the Sanskrit Dictionary app, I had to dive into two platforms I’d never used before: Supabase and Railway. Both are relatively easy to get started with, but using their more advanced features would’ve felt overwhelming if not for LLMs. With AI guiding me, the learning curve became not just easy, but honestly kind of addictive.

Take Supabase edge functions, for example. I was initially intimidated as I’ve never written a line of TypeScript, and I had no idea what Deno even was. But with LLMs helping me adapt and generate the right code, it felt like gaining a superpower!!

And did you know you can deploy a standalone Python script to Railway and call it via API?!!! That’s the kind of mind-blowing capability I wouldn’t even have found out about with LLMs guiding me.

Again - the takeaway here is that even if you’re a Swift developer, LLMs have opened up a whole new world of powerful tools and platforms - with almost no traditional learning curve. You don’t need to master every new language or framework from scratch anymore. You just need to know what you want to build.

Understanding Open Source Libraries

Some of the Sanskrit resources I had to use to build my app were written in Python that was just not accessible for me. My hope while I was in academia was always to work with the library creators to try to understand how these libraries work.

But now there is no need! By using uithub.com to extract the library into LLM-readable format + the 1M+ token window of Google Gemini Pro, I was able to get Gemini Pro to explain what the library did and write Python scripts exactly for my use case to use this library. Wow!!

Again - this is a game-changer for working with any open source library in any language!

Using LLMs for Swift

Unfortunately, LLMs are just not there in the same way when it comes to working with Swift / iOS / macOS apps. My favorite tool was Alex Sidebar, which I highly recommend. But just like any AI solution for Xcode, it is limited by the lack of training data in the models it uses.

For Swift - the best model is Claude Sonnet (Opus uses up all the rate limited tokens in one question, so not going to include it here). And Alex Sidebar does everything in it’s power to embed it with context, including documentation. But it will still write super verbose duplicate unmanageable code.

I use Alex Sidebar + Claude Sonnet in two way. First - if I have a very clear idea of a small coding task I need, I give it clear instructions, then I look carefully through the code and refactor it. Make sure to do this!! Claude Sonnet will take shortcuts and provide weird solutions that are very subtle and can go undetected without careful inspection. I really love the Diff viewer in Alex Sidebar to see exactly what changes were made - many times it’ll change something completely unrelated that you specifically have in your code for a purpose…

The other way I love using Alex Sidebar is for prototyping a feature I’m not exactly sure about. I would commit all my working code, then accept everything Alex Sidebar says (VIBE CODING ALERT!!!) to visually see what it builds. Once I have a better idea of what I want and how to architect properly, I will delete all this code, and go step-by-step as above, slowly and double checking the work as I recode the same feature.

The takeaway? Don’t trust the hype! While these code assistant models are amazing. I’m not going to argue with that! And do increase my productivity 10x, I’m always skeptical and refactor the code to make sure I understand the code and can work with my own codebase in the future. This is critical!

Conclusion

As Swift developers, we’re no longer locked into Swift. And that’s incredibly empowering! With the help of LLMs, we can now tap into the vast ecosystem of tools, languages, and platforms that were once too time-consuming or intimidating to learn. Whether it’s writing Python scripts, deploying backend functions, or understanding open source libraries in unfamiliar languages, we now have the ability to move fast and build things that would have taken months or been out of reach entirely! not too long ago.

What has once been impossible is not possible beyond our wildest imaginations!! My mind was completely blown with every step I took to make the “impossible” Sanskrit Dictionary app and this is only the starting point.

At the same time, we have to stay grounded. AI is a tool, not a shortcut. It can supercharge productivity, but it still requires judgment, refactoring, and a solid understanding of what you’re building. The real magic happens when you combine your developer intuition with the power of these tools.

So build boldly, but refactor carefully. Learn just enough, trust selectively, and let LLMs open doors, not create blind spots.

Happy Building 🚀