I've always kept a running list of app ideas I wish existed, just little tools to make my life easier. Every so often, I'll pick one and spend a weekend building a rough version, usually as an excuse to try a new framework or tech stack. I've used these weekend projects to try out new frameworks like Remix or to explore new features in some of my favorite languages: C#, C++, JavaScript, and Python. Most of these projects end up half-finished by design, I timebox them to the weekend, then move on.

This time was different.

After hearing about vibe coding at Google, a concept where you act as the guide and let an LLMs generate all the code, I decided to try it on a five-hour flight to a wedding in LA. With no prior experience in Swift or Xcode, I opened my laptop, gave Gemini a high-level vision, and tried to stay hands-off. Surprisingly, by the time we landed, 90% of the app was functional. After the wedding, I gave it some finishing touches. The result: ReviewGenie.

As an avid traveler and Google Maps Local Guide (Level 8!!), I've collected countless experiences. But after moving my photos from Google Photos to iCloud, I hit a roadblock. Apple made it tough for Google Maps to access and use my photos for reviews. What was once a simple process became frustrating, and as a result, my reviews dwindled. That's when I decided to build an app to automatically draft Google Maps reviews using photos and location data, making it quick and easy to write and post reviews without hassle.

What Is Vibe Coding?

Originally coined by Kapharty, vibe coding is the act of coding alongside an LLM like Gemini. But here's the twist: you're not writing the code yourself. You give directions, review results, and nudge when necessary. You're the conductor, not the violinist.

To maximize the "vibe," I chose to build a macOS app, something I'd never done before. My Swift and Xcode knowledge was limited, which meant I couldn't rely on myself to fill in gaps. I had to depend on Gemini to write nearly everything.

Building ReviewGenie

The vision was clear: I wanted an app that helps me write Google Maps reviews using photos, location metadata, and a bit of AI-powered magic. The name "ReviewGenie" is a nod to the idea that large language models (LLMs) could act like a digital genie, taking my inputs and conjuring up polished, context-aware review drafts almost instantly.

I prompted Gemini with the overall plan and kicked off with a clear MVP breakdown:

Photo selection
Place search via Google Places
Ratings input (Food, Service, Atmosphere)
Review generation via LLM
Editable drafts and clipboard copy
Local storage with SwiftData

I set up CursorAI to use Gemini 2.5 Pro. Initially, performance was sluggish (likely due to high demand on the free tier) so I upgraded to the MAX plan. From there, I manually scaffolded the project and created the first plan prompt:

"Help me implement a review journaling macOS app using SwiftUI and SwiftData."

Gemini helped lay down the data model (VisitRecord) and scaffolded the core views:

HomeView: List of past visits
NewEntryView: Step-by-step form
VisitDetailView: Editable review view

The step-by-step experience felt natural: photo picker → place search → rating → review generation → editing. When build errors cropped up, Gemini helped debug and iterate quickly.

Getting Feedback Loops Right

Switching between Gemini and Xcode was painful. I asked Gemini for a way to streamline development, and it helped me create a terminal script:

alias runit='find . -name "*.swift" | entr -c sh -c "xcodebuild -scheme "ReviewGenie" -configuration Debug build | xcbeautify"'

This gave me a much faster feedback loop for catching build errors and made the whole process feel more fluid.

Surprising Wins

Efficient Code Creation with Swift Service Interfaces

Gemini handled the boilerplate like a champ. I asked for protocols and stubs for future LLM integrations (Gemini, Claude, and others), and it created clean Swift service interfaces. At one point, I refactored the review generation to show all drafts non-interactively and only load the editor on selection, Gemini adapted fast.

Location Suggestions via AI-Powered Image Analysis

Another neat feature: when photos were added, I wanted Gemini (in VertexAI) to suggest a location. We built a GeminiVisionService to analyze the images. That led to an error debugging rabbit hole (MIME types, UTTypes), but eventually we got Gemini to return useful location suggestions. Even reverse geocoding was integrated to improve hints.

Fun Roadblocks

Too Much Context Can Slow Things Down

A natural thought after a few iterations, is to combine all the code within a single file, and that's what I did, I called it Everything.swift. My theory was that if the model had full context, it would break the code less often. But XCode didn't like this, compilation got painfully slow. Apparently, building massive SwiftUI views in one file is a recipe for sluggish builds. Lesson learned: full context can be too much context.

Granular Refactor Creates More Problems

Then came the opposite extreme. Gemini proposed a refactor that split everything into highly granular files and protocols. It followed DRY principles aggressively, but the tradeoff was a mess of interdependent files that kept breaking each other. Fixing one error would cause another down the line. I realized LLMs thrive more when code is isolated and redundant than when it's beautifully abstract. Duplication might be pragmatic for LLMs.

Leveraging Different Models to Solve Stubborn Bugs

Finally, during one frustrating bug loop, Gemini kept suggesting the same fix that wasn't working. I gave Claude a single shot and surprisingly it solved the problem in one go. A thought came to mind, sometimes, a different model with a different approach can break through where others fail.

Reflection

Vibe coding wasn't about stepping back. It was about stepping into a different role: guiding, debugging, shaping. I learned that Gemini can accelerate development, but only when the vibe is clear. You need to know what you want, spot what's broken, and keep the feedback loop alive. I think vibing can be very frustrating if you don't build a relationship with the flow.

I definitely wrote less boilerplate and spent more time thinking about flow, design, and architecture. For rapid prototyping or building a complete MVP, vibe coding with Gemini 2.5 Pro was a massive win.

Codebase

You can explore the full codebase here, everything from models to services to SwiftUI views is documented and versioned. My goal is to review all the places I haven't reviewed in the last year :). I genuinely think we'll see a drastic change in the way that people build apps in the near future, and I can't wait to see this happening.

Scaling the Codebase

Once the foundation of ReviewGenie was in place, expanding the app became surprisingly smooth. One great example of this was improving the performance of the photo carousel. Initially, the app was loading full-resolution images, which slowed things down noticeably. To speed things up, I implemented logic to prioritize optimized image versions for display within the app, while still keeping the original images available for drag-and-drop to external targets like Google Maps.

Gemini helped me walk through the analysis and changes across the PhotoCarouselWithRemoveView, FinalSummaryView, and VisitDetailView. Here's how the process looked in action: Code inspection, Refactoring and performance discussion, Updated logic for optimized loading, follow up about format conversion.

These small changes had a huge impact on perceived performance. With optimized JPEGs loading in the UI and original files preserved for export, the carousel now feels snappy and production-ready.

Code: https://github.com/nramirez/ReviewGenie

Features

Photo Location with New Places APIs: Accurately identify and tag photo locations using Google's latest Places API.

Contextual Review Generation with Gemini: Generate insightful and relevant reviews by leveraging the context from previous reviews, powered by Gemini.

AI-Assisted Image Descriptions with Gemini Vision: Automatically generate descriptive text for images, making it easier to understand their content, thanks to Gemini Vision.

Photo History Index: Keep track of all visited places with an organized photo history, simplifying the process of writing reviews for past experiences.

Easy Google Maps Integration: Seamlessly post your reviews and photos directly to Google Maps.