Ayush Soni

Stop Over Coding - A Story About Building Desktop App with AI

|
15 min read

Building File Studio: 3 Days Struggling with Cursor

There are a few moments in your life where something quietly shifts from “this would be cool one day” to “oh, this is real now.”

For me, one of those moments was watching a fully working Mac and Windows app appear on my screen with installers, icons, features and all after less than ten minutes of chatting with an AI.

This is the story of how I tried (and failed) to build my app the “smart” way with Claude and Cursor… and how switching to the new tool turned the whole thing into a one-shot, ship-ready product.

Quick note before we dive in: I’m not affiliated with this tools mentioned here in any way. No sponsorship, no referral deal. This is just an honest write-up of what actually happened when I tried to ship a desktop app in 2025.

What I Wanted to Build

The app I had in mind was simple on paper, but surprisingly fiddly to build.

File Studio is an offline toolkit for everyday file tasks on Mac and Windows:

  • Drag and drop files to get started
  • Convert files (images/videos/docs) between formats (HEIC, JPG, PNG, WebP, AVIF, TIFF, ICO, and more)
  • Resize and compress files so they’re small but still look good
  • Work with PDFs:
    • Remove passwords
    • Split a PDF into separate pages
    • Merge multiple PDFs
    • Turn PDF pages into images

All of this runs completely on your device. No uploads, no accounts, no servers. Just a simple, fast app that respects your privacy.

For a normal user, it’s just: open app → drop files → done.

For a builder, it’s: “okay, now I need a cross-platform desktop UI, file handling, image conversion, PDF tools, packaging, signing, updates…”

You can see where this is going.

Round 1: Vibing with Claude and Cursor (and Stalling at 80%)

My first attempt at File Studio was the “builder-brain” route:

  • Use Cursor as my AI-powered editor
  • Use Claude as my coding co-pilot
  • Ship a custom Mac and Windows app like a “proper” engineer

And to be fair: it kind of worked.

Within a few days of back-and-forth prompts, Cursor and Claude helped me:

  • Scaffold a cross-platform desktop app
  • Wire up some basic UI screens
  • Add rough image conversion and PDF handling
  • Get to something that looked like a real app, at least in screenshots

If I had to put a number on it, I’d say I got to about 80%.

But here’s the problem with that last 20%:

  • That’s where all the edge cases live
  • That’s where packaging, signing, and distribution show up
  • That’s where “works on my machine” turns into “works on a stranger’s computer”

I found myself sinking time into:

  • Tooling and config instead of product
  • Debugging little cross-platform issues
  • Trying to remember how to package and sign installers properly

After about three days of vibing (and not shipping), I hit the “ugh” wall.

Cursor and Claude are powerful, but I was still manually steering the entire build: choosing frameworks, fixing build errors, wiring everything together. I didn’t want to be a full-time desktop engineer. I just wanted File Studio to exist.

So I did what most solo builders quietly do.

I closed the repo. And I walked away.

The Switch: Discovering Vibingbase

A little later, I stumbled across Vibingbase, a platform that lets you build production-grade desktop apps for Mac and Windows just by chatting with an AI. No traditional coding required.

On paper, that sounded like marketing fluff.

It was still in waitlist when I found it through Twitter/X, and then a few weeks later I become the lucky first person to use it.

And to my surprise, in practice, it turned out to be the missing piece I didn’t know I needed.

Vibingbase does a few important things:

  • Handles the desktop framework and plumbing for you
  • Builds lightweight native apps (based on Tauri) instead of bloated bundles
  • Gives you a Mac and Windows build from the same conversation
  • Focuses on getting you to a shareable app, not just a codebase

At this point I thought, “Okay, worst case, I waste an hour. Best case, I finally ship File Studio.”

So I opened Vibingbase and started chatting.

One Chat, One App: Shipping in Under 10 Minutes

Here’s roughly how it went.

I didn’t write a spec. I didn’t architect anything. I just described what I wanted, like I was talking to a human developer:

“I want to build an offline Mac and Windows app called File Studio. Users can drag and drop files to: convert between image formats, resize and compress images, and handle PDFs (split, merge, remove password when they already know it, export pages as images). Everything should run on-device with no uploads or accounts. I want the UI to be rounded and use blue as the primary color and the whole app should be in dark mode.” (It was a slightly more detailed prompt about how I want the UI to look)

But, within minutes, I was looking at:

  • A real desktop app UI
  • Drag-and-drop file handling
  • Image conversion and resizing wired up
  • PDF operations connected to buttons and flows
  • Mac and Windows installers (DMG and EXE) ready to download

No config hell. No debugging build scripts. No wrestling with cross-platform quirks.

It honestly felt like cheating.

That first moment of double-clicking the installer, opening File Studio, dragging in a test PDF, and watching it just… work?

That was the “magical moment.”

The dream of “I wish I could just describe an app and have it exist” suddenly didn’t feel like a dream anymore. It felt like a product I could sell.

Turning a Prototype into a Product (Features, Licensing, Money)

Once the core app existed, everything else got easier.

Instead of touching code, I treated Vibingbase like a product teammate:

  • “Let people choose output folders and remember their choice.”
  • “Show a friendly progress indicator when processing big PDFs.”
  • “Make errors human-readable: no scary technical messages.”

Each small prompt turned into another slice of polish.

Then came the business side: how do I sell this thing?

For licensing and payments, I plugged in Polar - platform that handles payments, license keys, and automated delivery for software products.

With Polar I could:

  • Sell license keys for File Studio
  • Let users buy, get a key, and unlock the app
  • Offload all the annoying tax and compliance details

Hooking that into the app was straightforward:

  • Add a “License” or “Activate Pro” screen
  • Prompt for a key
  • Call Polar’s license validation endpoint from the app

And suddenly, File Studio wasn’t just a cool personal tool.

It was a product:

  • A Mac and Windows app
  • Downloadable via DMG and EXE
  • With licensing and payments wired in
  • Actually ready to make money

All in a fraction of the time I’d already burned trying to brute-force it with Cursor.

Why Cursor Wasn’t Enough (For This Project)

I don’t hate Cursor. It’s an impressive editor, and pairing it with Claude can be powerful.

But for this project, I realised something important:

  • Cursor is still code-first. It accelerates coding, but you’re still choosing frameworks, managing folders, and owning the build.
  • Vibingbase is app-first. You describe the product, and the platform worries about how to turn that into a Mac and Windows app.

If you love tinkering with code, Cursor is fantastic.

If you mainly care about “Can a user download this app and use it today?”, something like Vibingbase is simply closer to where you want to end up.

For File Studio, I didn’t need another editor.

I needed a shortcut to the finish line.

How I Plan to Leverage AI From Here

File Studio was the first “this changed everything” moment for me. It won’t be the last.

Here’s how I plan to lean into AI going forward:

1. Use AI as my default “first draft” of any product

Instead of opening a blank repo, I’ll:

  • Start in an AI-first tool like Vibingbase for desktop apps, or Cursor for web apps
  • Let it generate the first usable version
  • Then refine based on real user feedback, not hypothetical ideas

Getting to version 0.1 in minutes is a superpower.

2. Let AI handle the “boring but important” stuff

Things like:

  • Installers and packaging
  • Cross-platform quirks
  • Licensing screens and basic integrations
  • UI scaffolding and simple components

I’d rather spend my energy on:

  • Positioning
  • Pricing
  • Onboarding
  • Talking to users

AI can babysit the plumbing.

3. Stack AI tools together like LEGO

For File Studio, the stack looked like:

  • Vibingbase: Build the Mac & Windows app
  • Polar: Handle payments and license keys
  • Claude / other models: Help with copy, documentation, FAQs, onboarding emails

I expect future projects to look similar: pick a few AI-native tools, glue them together (while adding my taste and product sense in it), ship a beautiful product that feels good to use.

4. Keep everything grounded in real products

The temptation with AI is to stay stuck in “idea land.”

My rule for myself:

If an idea survives the first conversation, it should have a landing page, a prototype, or a preorder within 24-48 hours.

AI makes that possible. The only bottleneck now is my willingness to ship.

A Small, Honest Disclaimer

Just to repeat it clearly:

  • I’m not affiliated with Vibingbase.
  • I’m not affiliated with Polar.
  • There are no referral links hidden in this post.

If You’re Sitting on an App Idea…

If you’ve been:

  • Staring at a blank repo
  • Over-engineering your stack
  • Or quietly judging tools like Cursor because all you want is a finished app, not an AI IDE…

Here’s my honest suggestion:

  1. Write down what your app should do in plain language.
  2. Paste that into an AI-native builder.
  3. See how far you can get in a single evening.

The worst case? You learn something and throw it away.

The best case?

You have your own “magical moment” where an app that used to only exist in your head turns into a real app you can send to someone… and charge for.

We’re at a point where “I want to build a Mac and Windows app” is no longer a multi-month dream.

Sometimes, it’s just one good prompt away.