For the next 18 months, my analytics looked like this: sales numbers. That’s it. Some days zero, some days one or two. No idea where they came from. No idea who was downloading it or why.

I assumed it was just how small apps work. You ship, you hope.

The Marketing Push I Couldn’t Measure

Last August I decided to actually try. I wrote blog posts, posted on Reddit, shared on Instagram and Twitter. Downloads ticked up a little. But I had no way to connect any of it. Did the Reddit post help? Which country responded? Was anyone even landing on the App Store page?

I just didn’t know. I moved on.

What I Didn’t Realize About Watch-Only Apps

When I started building an iOS companion for ChantFlow — dashboards, streaks, health data from Apple Watch — I wasn’t thinking about analytics. I just wanted to make the app more useful.

The iOS version got approved a few days ago.

Within 24 hours, my App Store Connect analytics tab came alive. Impressions, page views, conversion rates, sources, territories. All of it suddenly there.

And then I noticed the dates. The data went all the way back to launch day — August 2024.

Apple had been collecting everything. It just wasn’t showing it to me because I didn’t have an iOS app.

Looking Back at August

I went back to August 2025 — my marketing month — and finally saw what actually happened.

There was a real spike. Product page views jumped — people were landing on the App Store page.

And when I looked at impressions by territory, it was almost entirely India.

India is my #1 market by a wide margin — more than double the US. The app is a mantra counter, of course it resonates there. But I had no idea. I was writing Reddit posts without knowing who was actually reading them.

UAE, Singapore, Malaysia all show up too. The South Asian diaspora found this app and I didn’t even know to lean into it.

The other thing I noticed: nearly half my downloads come from App Store Browse, not Search. People stumble onto it while browsing Health & Fitness. If I’d known that earlier I would have focused more on my screenshots and less on obsessing over keywords.

If You Have a Watch-Only App

You are probably missing all of this. Not because the data doesn’t exist — Apple is collecting it — but because it won’t surface until you have an iOS app in the store.

It doesn’t have to be complex. Even a simple companion with a settings screen would unlock it.

I wish I’d known this at launch. Eighteen months of marketing in the dark. Though finally seeing it all laid out was a pretty good feeling.

ChantFlow is the app I built. It’s on the App Store if you’re curious.

Instead of manually digging through traces, I tried something different. I asked Claude Code to analyze my Instruments trace file directly. What followed was a systematic debugging session that not only fixed the issues but taught me patterns I’ll watch for in every SwiftUI app going forward.

The Starting Point

Here’s what Instruments showed before any fixes:

The SwiftUI template in Instruments revealed:

• 76,645 total SwiftUI updates in 28 seconds
• 1.82 seconds of total update duration
• Multiple visible “Hang” blocks in the Hangs track
• Red markers indicating “Long View Body Updates”

AI-Assisted Analysis

Claude Code can read Instruments trace files programmatically using xcrun xctrace export. This extracts hang data, SwiftUI update counts, and timing information into XML that can be analyzed without clicking through the Instruments UI.

xcrun xctrace export --input trace.trace \
  --xpath '//trace-toc[1]/run[1]/data[1]/table[9]' \
  --output hangs.xml

From the trace analysis, we identified five root causes.

Root Cause 1: @StateObject for Shared Singletons

Almost every view in my app had this pattern:

// WRONG
@StateObject private var themeManager = ThemeManager.shared

This was in 30+ views. The problem? @StateObject is meant for objects the view owns and creates. For shared singletons, every view was independently subscribing to changes, causing cascading redraws across the entire view hierarchy.

The fix:

// RIGHT
@ObservedObject private var themeManager = ThemeManager.shared

@ObservedObject tells SwiftUI “I’m observing this, but I don’t own it.” The subscription is shared, not duplicated.

Root Cause 2: DateFormatter in Computed Properties

My timeline view grouped items by date:

// WRONG - runs on EVERY body evaluation
private var groupedItems: [String: [Item]] {
    let formatter = DateFormatter()  // Created every render!
    formatter.dateStyle = .medium
    // ... grouping logic using formatter
}

DateFormatter is expensive to create. And computed properties in SwiftUI views run every time body is evaluated. With frequent updates, this was creating hundreds of formatters per second.

The fix:

// Cache the result in @State
@State private var cachedSections: [TimelineSection] = []

var body: some View {
    // Use cachedSections instead of computed property
}
.task(id: items.count) {
    cachedSections = Self.groupItemsIntoSections(items)
}

// Static method with formatter created once
private static func groupItemsIntoSections(_ items: [Item]) -> [TimelineSection] {
    let formatter = DateFormatter()
    formatter.dateStyle = .medium
    // ... grouping logic
}

Root Cause 3: VStack Instead of LazyVStack

// WRONG - renders ALL items immediately
ScrollView {
    VStack(spacing: 24) {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

With 100+ items, VStack forces SwiftUI to render every single row upfront, even those far off-screen.

The fix:

// RIGHT - only renders visible items
ScrollView {
    LazyVStack(spacing: 24) {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

Root Cause 4: Unstable ForEach Identity

// WRONG - String identity is unstable when array changes
ForEach(item.tags, id: \.self) { tag in
    TagView(tag: tag)
}

When using id: \.self with strings, SwiftUI struggles to track identity if the array is reordered or modified. This causes unnecessary view recreation.

The fix:

// RIGHT - stable identity using offset
ForEach(Array(item.tags.enumerated()), id: \.offset) { _, tag in
    TagView(tag: tag)
}

Root Cause 5: Array Mutation During Scroll

In my Wishlist screen, voting on an item would immediately re-sort the array:

// WRONG - sorting during user interaction
func voteFor(row: RowData) {
    rows[index].votes += 1
    rows.sort { $0.votes > $1.votes }  // Crash risk!
}

Mutating an array while SwiftUI is diffing the view hierarchy (during scroll) can cause crashes or visual glitches.

The fix:

// RIGHT - defer the sort
func voteFor(row: RowData) {
    rows[index].votes += 1

    DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
        self?.rows.sort { $0.votes > $1.votes }
    }
}

The Result

After applying all fixes:

The Hangs track went from showing multiple orange blocks to being nearly clean. The app feels noticeably smoother.

Lessons Learned

Using AI to fix code is fast, but it doesn’t teach you anything unless you ask why. Here are the patterns I’ll now watch for in every SwiftUI project:

Quick Checklist

When to Run Instruments

Don’t wait until the app feels slow. Run the SwiftUI template in Instruments:

• After implementing a new list view
• When adding new data sources
• Before any release
• When you see “View body took too long” warnings in Xcode

Using AI as a Learning Partner

The real value of AI-assisted debugging isn’t the fix—it’s the explanation. Instead of asking “fix this,” ask:

• “Why is this causing a hang?”
• “Explain what’s wrong with this pattern”
• “What should I look for in this Instruments trace?”

That way you build intuition, not dependency.

Summary

SwiftUI performance issues often come from a few common patterns: wrong property wrappers, expensive computed properties, eager view loading, and unstable identities. Tools like Instruments show you where the problems are; understanding why they happen helps you avoid them in the first place.

The code that runs on every render must be cheap. Everything else should be cached and computed in the background.

I’m not a video editor. I don’t have a budget for agencies or stock footage subscriptions. But I already pay for Claude Code Max ($100/month) for development work. What if I could use it for marketing too?

Here’s what happened.

Table of Contents

• The Goal
• The Tools
• Generating Video Clips
• Using Real Screenshots
• Generating Voiceover
• Adding Music
• Creating Vertical Versions
• Adding End Card
• Final Result
• Key Learnings
• Would I Do It Again?

The Goal

A 30-second ad that shows the problem (endless screen time) and the solution (EaseEyes). Something I could post on YouTube, Twitter, and Instagram Reels.

I wrote a simple script:

We spend our days in meetings.
Hour after hour.
Our eyes pay the price.

But what if your screen could be... kinder?

EaseEyes.
It knows when you're in a call.
It reminds you when you're not.

Your eyes deserve a break.

Now I needed visuals to match.

The Tools

Here’s what I used:

Total additional cost: $0

This is the beauty of the free tiers—if you’re strategic, you can create real marketing assets without new expenses.

Generating Video Clips

I used Google Veo to generate 8 short clips:

Shot List:
1. Close-up of tired eyes
2. Person at desk with Zoom calls
3. Clock showing time passing
4. Person rubbing their eyes
5. EaseEyes notification appearing
6. Person looking out window
7. Back to video call, notification pauses
8. Person smiling, refreshed

For each one, I wrote a prompt like:

Professional home office, person sitting at desk with multiple monitors
showing video call grid, afternoon light through window, cinematic

Veo generated 8-second clips for each. But here’s where things got interesting.

What Went Wrong #1: Different People in Every Shot

Each time Veo generated a clip, it created a different person. My “tired office worker” was a different human in every single shot.

The fix for next time: Use a tool like Google Nano or Banana to generate a reference person first, then pass that reference to each video prompt. This keeps the same “actor” throughout.

For this video, I decided to lean into it—framing it as “different people, same problem.”

What Went Wrong #2: The Clock Didn’t Work

My prompt said “time-lapse of clock.” Veo gave me a clock where only the second hand moved. The hour and minute hands stayed frozen.

The lesson: AI prompts need to be specific about what should animate.

❌ Bad prompt:
Time-lapse of analog clock on wall

✅ Better prompt:
Time-lapse of analog clock, hour hand and minute hand visibly moving
clockwise showing passage of several hours, light transitioning from
afternoon to evening

What Went Wrong #3: Veo Watermark

Every Veo clip had a watermark in the bottom-right corner. Not ideal for a polished ad.

The fix: I used ffmpeg to crop 60 pixels from the bottom and right edges, then scaled back to 1080p. Watermark gone.

ffmpeg -i input.mp4 \
  -vf "crop=1860:1020:0:0,scale=1920:1080" \
  output.mp4

Using Real Screenshots

For shots 5 and 7 (showing the actual EaseEyes notification), I didn’t use AI. I took real screenshots of my app.

Why? Because AI mockups of your own UI never look right. Real screenshots are more authentic and show exactly what users will get.

I used a Ken Burns effect (slow zoom) to add motion:

ffmpeg -loop 1 -i screenshot.png \
  -vf "zoompan=z='1+0.15*on/100':x='iw-iw/zoom':y='0':d=100:s=1920x1080" \
  -t 4 output.mp4

This zooms slowly into the top-right corner where the notification appears.

Recommendation: Always use real screenshots for your actual product UI. Let AI handle the conceptual/emotional shots.

Generating Voiceover

I used ElevenLabs to generate the narration. But here’s a key learning:

Don’t generate one long voiceover clip.

Instead, generate each line separately:

• “We spend our days in meetings.”
• “Hour after hour.”
• “Our eyes pay the price.”
• etc.

This lets you place each line at exactly the right moment to sync with the visuals.

What Went Wrong #4: Voiceover Timing

My first attempt had the voiceover starting at shot boundaries. “Hour after hour” played during the home office shot, not the clock.

The fix: Map voiceover to visual meaning, not timing.

Now “hour after hour” plays when you see the clock. Much better.

Adding Music

I found a relaxing ambient track and mixed it at about 12% volume—loud enough to set the mood, quiet enough to not compete with the voiceover.

Key settings:
- Fade in over 2 seconds at the start
- Fade out over 2 seconds at the end
- Keep it low when voiceover is playing
- Use copyright-free music (YouTube Audio Library, Epidemic Sound)

Creating Vertical Versions

Here’s something I wish I’d planned from the start: vertical video matters more than horizontal.

YouTube Shorts, Instagram Reels, TikTok—they’re all 9:16 vertical. That’s where the eyeballs are.

I had to convert my horizontal videos to vertical after the fact. For most shots, center crop worked fine. But for the notification screenshots, I needed a “smart crop” that kept the right side of the frame where the UI appears.

Lesson for next time: Plan for vertical first. Frame your AI prompts so subjects are centered.

# Convert horizontal to vertical (center crop)
ffmpeg -i horizontal.mp4 \
  -vf "crop=1080:1920" \
  vertical.mp4

# Smart crop (keep specific area)
ffmpeg -i horizontal.mp4 \
  -vf "crop=1080:1920:840:0" \
  vertical-right.mp4

Adding End Card

Every marketing video needs a call-to-action. I created a simple end card with the App Store badge and added it as the final 4 seconds.

Made sure to create both:

• Horizontal version (1920x1080)
• Vertical version (1080x1920)

Final Result

Four videos ready to post:

Total time: About 3 hours Additional cost: $0 (used existing Claude Code Max subscription)

Watch the final result on YouTube Shorts

Key Learnings

1. Generate a reference person first
   → Keep the same "actor" across all shots

2. Be specific in AI prompts
   → Say exactly what should move and how

3. Use real screenshots for your UI
   → More authentic than AI mockups

4. Generate voiceover per line
   → Enables precise timing

5. Map voiceover to visual meaning
   → Not just shot boundaries

6. Plan for vertical first
   → Shorts/Reels are where the audience is

7. Crop out watermarks
   → Simple ffmpeg fix

8. First shot can be music-only
   → Lets the visual hook establish

Cost Breakdown

Compare this to hiring a video agency ($2,000-5,000) or stock footage subscriptions ($30-50/month).

Would I Do It Again?

Absolutely. The process wasn’t perfect, but I ended up with a real marketing video that I can use across all platforms.

The AI tools aren’t magic—you still need to direct them carefully and fix their mistakes. But for an indie developer with no video budget, this workflow is a game changer.

When this approach makes sense:

• Solo developer with limited budget
• Need quick marketing assets
• Willing to iterate and fix AI mistakes
• Have basic command-line skills (ffmpeg)
• Already using AI tools for development

When to hire a professional:

• Brand video for funding pitch
• High-stakes product launch
• Need perfect execution first time
• Budget allows it (revenue > $5k/month)

Further Reading

• Essential Tools for Indie Developers
• Real Cost of Being an Indie iOS Developer
• MVP Mindset: Ship Fast

EaseEyes is a free Mac app that reminds you to take eye breaks. Download on the Mac App Store

The best marketing video is the one you actually ship.

There’s a better way. Build fallbacks so your app works with reduced functionality instead of failing completely. This is called graceful degradation.

A flowchart showing two paths from “HealthKit Permission?” - “Yes” leads to “Automatic Tracking”, “No” leads to “Manual Entry”. Both paths converge to “Same Core Value”.

The Problem: All or Nothing

Many apps do this:

if hasHealthKitPermission {
    MainAppView()
} else {
    PermissionDeniedView() // Dead end
}

User sees a wall. User uninstalls.

The Fix: Provide an Alternative

Instead of blocking users, adapt based on what’s available:

enum DataSource {
    case healthKit
    case manual
}

class DataManager: ObservableObject {
    @Published var dataSource: DataSource = .healthKit

    func checkPermission() {
        healthKitManager.requestPermission { granted in
            self.dataSource = granted ? .healthKit : .manual
        }
    }
}

Now both paths lead somewhere useful.

Example: Sleep Tracker

A sleep tracking app could work like this:

With HealthKit: Automatic sleep data from Apple Watch or iPhone.

Without HealthKit: Manual entry form with bed time, wake time, and optional quality rating.

The core value (tracking sleep patterns over time) works either way. HealthKit just makes it automatic.

Tiered Features

Structure your app in tiers based on available permissions:

Basic (no HealthKit):

• Manual data entry
• Goals and reminders
• Basic statistics

Standard (partial HealthKit):

• Automatic tracking
• Quality scores
• Trends over time

Premium (full HealthKit):

• Heart rate analysis
• Activity correlation
• Health insights

Users without permissions get the basic tier. They can still use the app. When they’re ready, they can unlock more.

Gentle Upsells

Don’t nag about permissions. Show the value contextually:

“See how your daily steps affect your sleep. Enable activity tracking to unlock this feature.”

Users understand why the permission matters because they’re already interested in that feature.

When They Change Their Mind

If a user grants permission later, offer to import their manual entries. Keep their history intact.

The Principle

Before requiring any permission, ask yourself:

• What’s the core value of this app?
• Can users get that value without this permission?
• What’s a reasonable fallback?

For a sleep tracker, the core value is understanding sleep patterns. Manual entry works. HealthKit makes it easier, but it’s not required.

For a step counter, you probably do need motion permission. But you could still show goals, history from manual entry, or educational content.

Why This Matters

Users who deny permissions aren’t lost causes. They might:

• Be privacy-conscious but still interested
• Want to try the app before granting access
• Have had bad experiences with other apps

Give them a path forward. Some will grant permissions later after seeing the app’s value. Others will stay on manual mode and still leave good reviews.

Build for the users who say no. They might become your best advocates.

I can build complex iOS apps with Core Data, CloudKit, HealthKit integration—the whole nine yards. But when it comes to simple tasks like writing launch checklists or social media captions, I freeze.

It’s not lack of skill. It’s decision fatigue.

By the time I’ve coded all day, designed UI, debugged edge cases, the thought of also planning a launch strategy or crafting marketing copy feels insurmountable.

So I built tools to handle it. Three AI micro-services in three days. No backend setup. No server management. Just clear problems and fast solutions.

If you’re an indie maker who’s great at building but struggles with everything around it, this is what I learned.

The Challenge: Building ≠ Shipping

I’ve shipped over a dozen iOS apps. Some did well. Some flopped. The pattern I’ve noticed?

The apps that succeeded weren’t necessarily better code.

They succeeded because I:

• Launched at the right time with the right messaging
• Stayed consistent with updates and social posts
• Tracked health metrics and iterated based on data
• Maintained momentum post-launch

All the “non-coding” parts.

But here’s the thing: I’m an iOS developer. I love Swift, SwiftUI, solving technical problems. Marketing? Launch planning? Social media? Those feel like context-switching tax.

The realization:

What if I could build tiny AI tools that handle these tasks for me?

Not generic ChatGPT prompts. Custom micro-services designed exactly for my workflow.

That’s what I set out to build this week.

Why Google AI Studio + Cloud Run?

Coming from iOS development, I had specific criteria:

• ✅ Fast iteration: I wanted to build and test ideas in hours, not days
• ✅ No infrastructure headache: I don’t want to manage servers or databases
• ✅ Instant deployment: TestFlight takes days; I wanted to go live in minutes
• ✅ Cheap: These are experiments, not revenue-generating products yet
• ✅ Shareable: I wanted to send links to beta testers immediately

Google AI Studio + Cloud Run hit all five.

The workflow:

1. Build the service in AI Studio (browser-based)
2. Define input/output JSON schema
3. Deploy to Cloud Run (one click)
4. Get a live URL instantly
5. Iterate based on real usage

No Docker. No backend frameworks. No database migrations.

Just pure focus on the problem I’m solving.

Tool #1: AI Fitness Coach (Built in 10 Minutes)

The Problem

I’ve been building a fitness app for Apple Watch. Users track daily steps, set goals, receive motivational messages.

The challenge: Writing personalized coaching messages for different scenarios.

• 3,500 steps at 9 AM → “Great start! Keep it up!”
• 3,500 steps at 9 PM → “Late push needed! You can still hit your goal!”
• 9,000 steps at 2 PM → “You’re crushing it today!”

Writing these variations manually is tedious. I needed dynamic, context-aware messaging.

The Solution

I built a web service that takes:

Yesterday I built an AI image generator using @GoogleAIStudio.

Today I tried something different - an AI Fitness Coach web service 🏃‍♂️

It takes your step count, goal, and time of day… then replies like a real coach. pic.twitter.com/image

— Ravi Shankar (@rshankra) November 4, 2025

Input:

{
  "current_steps": 3500,
  "goal_steps": 10000,
  "time_of_day": "evening",
  "coaching_tone": "coach"
}

Output:

{
  "headline_text": "3.5K",
  "message_short": "Late push needed!",
  "message_long": "It's evening, and you've logged 3,500 steps. That's solid effort, but you've got work to do. Your goal is 10,000—time to lace up and close the gap. Let's finish strong!"
}

How I Built It

Step 1: Defined the schema in Google AI Studio

Instead of building forms and UI first (my iOS instinct), I started with the data contract. What goes in? What comes out?

This shift in thinking—from UI-first to data-first—was surprisingly freeing.

Step 2: Prompted the AI with context

I gave Gemini 2.5 Pro this context:

“You’re a fitness coach. Based on someone’s current steps, goal, and time of day, generate motivational messages. Adjust tone: if it’s morning and they’re ahead, celebrate. If it’s evening and they’re behind, motivate urgency without guilt.”

Step 3: Tested with different scenarios

• Morning + low steps = “Get moving early!”
• Afternoon + high steps = “You’re crushing it!”
• Evening + behind = “Late push, you’ve got this!”

Step 4: Deployed to Cloud Run

One click. Live in 30 seconds.

Total time: ~10 minutes.

The Apple Watch Connection

Here’s where it gets interesting.

I previewed how these messages would look on Apple Watch and iPhone. Same data, different screen layouts, consistent motivational tone.

The preview shows how the message would look on an Apple Watch and iPhone.

Same data → different screen layouts → same motivational tone.

— Ravi Shankar (@rshankra) November 4, 2025

This is the bridge I’ve been looking for: AI-generated content + native Apple experiences.

My SwiftUI app can call this Cloud Run endpoint, get contextual messages, and display them beautifully on Apple Watch complications or iPhone widgets.

Rookie mistake #1:

I initially tried to generate the UI in AI Studio too. Bad idea. The web preview looked fine, but translating HTML/CSS to SwiftUI was messy.

The fix: Use AI Studio for logic and content. Use SwiftUI for native UI. They’re perfect partners.

What I Learned

1. Tiny services are powerful

This isn’t a full-featured fitness app. It’s one micro-service: steps + context → motivational message.

But that’s all I needed. By keeping scope small, I shipped fast.

2. Context matters more than cleverness

The AI doesn’t need complex prompts. It needs context: time of day, progress percentage, user’s goal.

Give good context, get good output.

3. JSON schemas force clarity

Defining input/output upfront made me think through edge cases:

• What if current_steps > goal_steps?
• What if time_of_day is invalid?
• Should coaching_tone be “friendly” or “coach” or “blunt”?

This upfront thinking saved debugging time later.

Tool #2: Launch Checklist Generator (Built in 10 Minutes)

The Problem

Every indie dev I know (myself included) has experienced this:

You finish building the app… and then freeze at the launch step.

• What do I post?
• In what order should things happen?
• Did I forget something important?
• Is 2 hours enough to launch, or do I need 2 weeks?

I’ve launched apps both ways: rushed 2-hour sprints and meticulously planned 2-week campaigns. Both can work. The key is having a plan.

But making the plan? That’s where I procrastinate.

The Solution

I built LaunchPad AI: a launch checklist generator for indie devs.

I built a Launch Checklist Generator for #indiedevs in @GoogleAIStudio.

You type your app + how soon you want to launch, and it creates a clear step-by-step launch plan.

Took me ~10 minutes.

Here's how I did it 👇 pic.twitter.com/image

— Ravi Shankar (@rshankra) November 5, 2025

You enter:

• Your app name
• App category
• Launch timeline (2 hours / 1 week / 2 weeks)

It returns a structured, time-based checklist:

Example output (2-hour sprint):

Pre-launch Readiness (T-0 to T-0)

• ✅ Finalize app name and tagline
• ✅ Prepare App Store screenshots
• ✅ Write compelling app description

Launch Hour (T-0 to T+1)

• ✅ Submit to Product Hunt
• ✅ Post on X/Twitter with demo video
• ✅ Share in relevant Slack/Discord communities

Post-Launch (T+1 to T+3 days)

• ✅ Respond to all comments and feedback
• ✅ Monitor crash reports and fix critical bugs
• ✅ Share user testimonials

For a 2-week timeline, it adds:

• Pre-launch landing page
• Email list building
• Beta tester recruitment
• Teaser campaign

How I Built It

Step 1: Interviewed myself

I listed every launch I’d done: what worked, what I forgot, what I’d do differently.

Then I turned that into prompt context.

Step 2: Structured the output

I didn’t just want a blob of text. I wanted:

• Grouped tasks (Product / Social / App Store / Post-launch)
• Time-based phases
• Actionable items, not vague suggestions

Step 3: Added interactivity

The tool lets you:

• Add custom tasks
• Edit existing tasks
• Delete irrelevant tasks
• Export the final checklist to PDF

This took the longest—maybe 40 of the 60 total minutes.

Step 4: Deployed and tested

I used it for a real launch (the fitness app). It worked.

Instead of thinking “What do I do next?”, I just followed the list.

Rookie mistake #2:

I initially generated checklists that were too generic.

“Promote on social media” → Okay, but which platforms? What content?

The fix: I refined prompts to generate specific, actionable tasks:

• ❌ “Promote on social media”
• ✅ “Post demo video on X/Twitter with 3 key features highlighted”

Specificity beats generality every time.

What I Learned

1. Decision fatigue is real

Even simple decisions (“Should I post on Reddit first or Twitter?”) compound when you’re doing 20 things at once.

Pre-made checklists eliminate those micro-decisions.

2. Templates reduce stress

Knowing I can generate a launch plan in 30 seconds removes the “I don’t know where to start” paralysis.

Now launching feels: clear, doable, repeatable.

3. Export matters

Being able to export to PDF means I can print it, check it off physically, or share it with collaborators.

This small feature made the tool 10x more useful.

Tool #3: Caption Generator (Built in 15 Minutes)

The Problem

I’m terrible at social media.

Not the technical side—I can record videos, edit screenshots, use scheduling tools. But the writing?

Every time I sit down to write a post about my app, I stare at a blank screen for 20 minutes.

The inner monologue:

• Is this too salesy?
• Should I be more casual?
• Do I sound like every other indie dev?
• What hashtags actually work?

By the time I’ve written something, I’ve lost momentum.

The Solution

I built a caption generator designed specifically for indie app developers.

Built another small mini tool today with @GoogleAIStudio

This one writes scroll-friendly social captions for your app.

No more staring at a blank screen.

Here's how it works 👇 pic.twitter.com/image

— Ravi Shankar (@rshankra) November 7, 2025

Input:

• App name
• What it does
• Target audience
• Tone (friendly / calm / energetic / professional)
• Auto-generate hashtags: Yes/No

Output:

• 5 different caption variations
• Hashtag set
• Call-to-action line

Example:

App: Expense Split What it does: Splits expenses among roommates, couples, friends Audience: Roommates, couples, friends Tone: Friendly

Generated captions:

1. “Splitting expenses shouldn’t mean splitting friendships. Expense Split makes it easy to track who owes what—no awkward conversations needed. Perfect for roommates, couples, and friend groups.”

2. “Ever had that moment where someone says ‘I’ll Venmo you later’ and… never does? Expense Split keeps everyone honest (and friendly). Track shared costs, settle up fast.”

3. “Money + relationships = complicated. Expense Split keeps it simple. Add expenses, split them fairly, done. Built for roommates who want to stay friends.”

4. “Stop doing mental math every time you grab dinner with friends. Expense Split handles the math, you handle the fun.”

5. “Because ‘I’ll pay you back’ shouldn’t require a spreadsheet. Expense Split: fair splits, zero stress.”

Hashtags: #ExpenseTracking #PersonalFinance #IndieApp #RoommateLife #SplitBills

CTA: “Try it free → [link]”

How I Built It

Step 1: Analyzed what works

I looked at successful indie dev posts on X/Twitter and Product Hunt. Common patterns:

• Start with a relatable pain point
• Show the solution concisely
• End with clear CTA
• Friendly, conversational tone
• 1-3 sentences max

Step 2: Turned patterns into prompts

I gave Gemini these guidelines:

“Write scroll-friendly social media captions for indie apps. Start with a pain point or relatable moment. Keep it under 3 sentences. Avoid buzzwords like ‘game-changer’ or ‘revolutionary.’ Be specific, not generic.”

Step 3: Added variety

One caption isn’t enough. Sometimes I need playful, sometimes urgent, sometimes calm.

The tool generates 5 variations so I can pick what fits my mood (or A/B test).

Step 4: Made it fast

Fill out the form, hit generate, get 5 captions in 3 seconds.

No more staring at blank screens.

Rookie mistake #3:

The first version generated captions that all sounded the same. Boring.

The fix: I added explicit instructions for variety:

• Caption 1: Pain-point focused
• Caption 2: Benefit-focused
• Caption 3: Scenario-based
• Caption 4: Question hook
• Caption 5: Bold statement

Now the outputs feel distinct.

What I Learned

1. Good prompts = good outputs

The difference between “write a caption” and “write a scroll-friendly caption starting with a relatable pain point” is huge.

Specificity in prompts = quality in results.

2. Options reduce perfectionism

When I write manually, I agonize over every word. Is this the perfect caption?

With 5 variations, I just pick one and move on. Good enough is good enough.

3. This works for me because I built it

Generic caption generators exist. But they don’t know my audience (indie devs, iOS users, people who appreciate authenticity).

Custom tools tuned to your niche > one-size-fits-all.

Deploying to Cloud Run: The 30-Second Workflow

Here’s the deployment process for all three tools:

In Google AI Studio:

1. Click “Deploy”
2. Select “Cloud Run”
3. Choose region (I use us-central1)
4. Click “Deploy”

That’s it.

Built completely inside Gemini 2.5 Pro using Google AI Studio's web service mode.

No backend setup, no extra code - just define input/output and deploy. pic.twitter.com/videolink

— Ravi Shankar (@rshankra) November 4, 2025

30 seconds later, I get a live URL:

https://fitness-coach-abc123-uc.a.run.app

No configuration. No servers. No DevOps.

For someone who’s used to:

• TestFlight provisioning
• App Store review wait times
• Backend server setup (EC2, Docker, etc.)

This feels like magic.

Cost:

Cloud Run has a generous free tier. All three of these tools combined cost me $0.00 so far because usage is low.

When they scale, pricing is pay-per-request. For micro-tools like these, that’s perfect.

What These Tools Taught Me

1. Micro-tools > Mega-platforms

I used to think tools had to be comprehensive to be useful.

“If I’m building a launch planner, it should also handle marketing analytics, email campaigns, social scheduling…”

No.

A tool that does one thing really well beats a tool that does ten things poorly.

These three tools are tiny. Single-purpose. And that’s why they work.

2. Speed Unlocks Experimentation

In iOS development, the feedback loop is long:

• Code → Compile → Test → Debug → Repeat

With Google AI Studio + Cloud Run:

• Prompt → Test → Deploy → Share

The cycle is minutes.

This changes how I think about ideas. Instead of “Is this worth building?”, I just build it and find out.

3. AI for Content, Native for Experience

Here’s my new mental model:

Use AI Studio for:

• Backend logic
• Content generation
• Data transformation
• Quick prototypes

Use Swift/SwiftUI for:

• Native UI
• Offline features
• Platform-specific integrations (HealthKit, Widgets, Complications)
• Performance-critical code

Use them together for:

• SwiftUI app → calls Cloud Run endpoint → displays AI-generated content in beautiful native UI

This hybrid approach gives me the best of both worlds.

4. Context Switching Is Expensive

Before these tools, my workflow looked like this:

1. Code for 2 hours
2. Switch to marketing mode (write captions, plan launch)
3. Lose momentum
4. Struggle to get back into coding flow

Now:

1. Code for 2 hours
2. Open caption generator, get 5 options in 10 seconds
3. Back to coding in 30 seconds

Minimizing context switches keeps me in flow longer.

5. Tiny Tools Compound

One micro-tool is nice. Three micro-tools start to feel like a workflow.

I can imagine a future where I have:

• 10 tiny AI tools
• Each solving one specific problem
• All integrated into my daily routine

That’s more powerful than one big monolithic platform.

Rookie Mistakes Summary

Here’s what I learned the hard way:

Mistake #1: Trying to generate UI in AI Studio

Problem: Web UI doesn’t translate well to native SwiftUI.

Fix: Use AI Studio for logic/content. Use Swift for UI.

Mistake #2: Generic outputs

Problem: First versions generated bland, generic text.

Fix: Add specificity to prompts. Show examples of what “good” looks like.

Mistake #3: Overcomplicating input schemas

Problem: I added too many optional fields, making the tool confusing.

Fix: Start with the minimum viable schema. Add complexity only when needed.

Mistake #4: Not testing edge cases

Problem: Tools broke when users entered unexpected input (negative steps, invalid dates, etc.).

Fix: Test thoroughly before deploying. Add validation.

Mistake #5: Forgetting to add export/share features

Problem: Generated great content but no way to save or share it.

Fix: Always include export (PDF, JSON, clipboard) from day one.

What’s Next

I’m participating in the #CloudRunHackathon and building one useful mini-tool every day.

Coming up:

• Screenshot to alt-text generator (for accessibility)
• Changelog writer (turns commit messages into user-friendly release notes)
• Pricing calculator (helps indie devs decide on pricing tiers)

All built with the same stack: Google AI Studio + Cloud Run.

Why?

Because these are problems I actually have. And building solutions for myself means they’ll be genuinely useful for other indie devs too.

Try It Yourself

If you’re an indie maker and you’ve been curious about AI but intimidated by the complexity, here’s my advice:

Start with one annoying task in your workflow.

For me, it was:

• Writing motivational messages for my fitness app
• Planning launches
• Writing social captions

For you, it might be:

• Generating app descriptions
• Writing support emails
• Summarizing user feedback

Then build the tiniest possible tool to solve it.

Don’t aim for perfection. Aim for “works well enough that I’d use it tomorrow.”

Google AI Studio makes this trivial. You can have a working prototype in 10 minutes.

Deploy it. Use it. Iterate.

If it saves you 10 minutes a day, that’s 60 hours a year. Worth it.

Final Thoughts

I’ve been an iOS developer for years. I love the craft of building native apps—the elegance of SwiftUI, the satisfaction of pixel-perfect animations, the joy of seeing someone use my app in the wild.

But I’m also a solo indie developer. I wear all the hats: coder, designer, marketer, support, finance.

These AI micro-tools let me offload the parts I’m not great at (or don’t enjoy) without hiring a team.

• Need motivational messaging? Tool handles it.
• Need a launch plan? Tool generates it.
• Need social captions? Tool writes them.

I’m still doing the hard work—building the app, solving real user problems, iterating based on feedback.

But the surrounding tasks? Automated.

This is the future I’m excited about:

Not AI replacing developers. But AI augmenting indie makers so we can focus on what we do best.

And tools like Google AI Studio + Cloud Run make it accessible to anyone willing to experiment.

So go build something tiny. Ship it today. See what happens.

You might surprise yourself.

If you want to try the working versions of these tools (deployed on Cloud Run), let me know! I’m sharing access as I build in public.

Follow along for daily updates as I build more micro-tools for indie developers: @rshankra

Resources:

• Google AI Studio
• Cloud Run Documentation
• Cloud Run Hackathon
• Gemini API Reference

Related posts:

• From Xcode to No Code: Building AI Apps with Google AI Studio (platform overview and getting started)
• My Learnings as Indie App Developer: Building Identity Habits (on indie dev workflows and habits)
• Building TwAIst: An AI Twitter Assistant (more on AI integration strategies)

Last week, I built an AI image generator in 3 minutes. Not 3 hours. Not 3 days. Three minutes.

As someone deeply rooted in the Apple ecosystem, this felt surreal. No Xcode project. No backend server setup. No deployment headaches. Just prompts becoming code, instantly.

If you’re an iOS developer curious about AI, or an indie maker who wants to build fast, this is what I learned exploring Google AI Studio.

Why I Explored Google AI Studio

Here’s the honest truth: I was skeptical.

I’ve built dozens of iOS apps. I know SwiftUI, UIKit, Core Data, CloudKit. I understand the rhythm of native development—design, code, test, debug, repeat. It’s methodical. It’s structured. It works.

But it’s also slow.

When you have an idea at 10 PM and want to validate it before midnight, spinning up a new Xcode project feels like overkill. You need models, view controllers, networking layers, error handling. By the time you’re done scaffolding, the excitement has worn off.

That’s where Google AI Studio caught my attention.

The promise: Prompts are becoming code. If you can think clearly, you can build quickly.

As someone who’s been thinking about adding AI features to my apps—and procrastinating because of the complexity—I decided to give it a shot.

What Is Google AI Studio?

Google AI Studio is a browser-based development environment for building AI-powered applications using Gemini models. Think of it as a playground that turns into production code.

You describe what you want your app to do, and AI Studio generates a working web service. No backend setup. No infrastructure management. Just input, output, and logic.

Key features I discovered:

• Annotation tool: Capture screenshots of what you want to build and add them directly to your conversation with the AI
• Rollback checkpoints: Made a mistake? Easily restore to a previous version with the “Restore Check Point” feature
• Built-in code editor: Fix code or add features directly in the browser
• Deployment options: Download code, publish to GitHub, deploy to Cloud Run, or share your work instantly

It’s designed for rapid iteration. Build, test, tweak, deploy—all in one place.

My First Project: Image Generator in 3 Minutes

I started simple. An AI image generator seemed like a good test.

Here’s what I did:

Step 1: Opened Google AI Studio

No installation. No setup. Just opened the browser and landed in the studio.

Step 2: Described what I wanted

“Build an image generator that takes a text prompt and returns an AI-generated image.”

Step 3: Configured input and output

The studio prompted me to define:

• Input: Text prompt (string)
• Output: Generated image (URL or base64)

Step 4: Tested it

Hit “run” and got back a working image from my prompt.

Total time: 3 minutes.

For context, building this in Swift would have involved:

1. Setting up an Xcode project
2. Creating UI in SwiftUI
3. Adding networking with URLSession or Alamofire
4. Handling image decoding and display
5. Managing error states
6. Testing on simulator/device

Even if you’re fast, that’s 30-60 minutes minimum.

The Annotation Tool: Screenshot → Code

This feature blew my mind.

As an iOS developer, I’m used to sketching UI in Figma or Sketch, then manually translating it into SwiftUI code. There’s always that gap between design and implementation.

In Google AI Studio, you can:

1. Capture a screenshot of an interface you want to replicate
2. Add it directly to your conversation
3. The AI generates code matching that visual

Google AI Studio provides an annotation tool that can be used to capture the screen where you want to make changes and add it to the conversation.

— Ravi Shankar (@rshankra) November 3, 2025

I tested this with a fitness app dashboard I’d been sketching. Dropped in the screenshot, described the functionality, and got back working HTML/CSS/JavaScript that looked remarkably similar.

Rookie mistake #1: I initially tried to describe complex layouts in text. It was clunky. Once I switched to screenshots + brief descriptions, the results improved dramatically.

The takeaway: Show, don’t just tell. If you have a visual in mind, screenshot it.

Rollback Checkpoints: Time Travel for Code

Anyone who’s worked on a complex app knows the fear of breaking something.

You make one change. Then another. Suddenly nothing works, and you’re not sure which edit caused the problem.

Google AI Studio has a brilliant solution: restore checkpoints.

It automatically saves states as you work. If something breaks, you can jump back to a previous working version with one click.

You can easily rollback the previous changes using the Restore Check Point' feature. pic.twitter.com/videolink

— Ravi Shankar (@rshankra) November 3, 2025

This is like Git’s version control, but without the ceremony of commits and branches. It’s instant.

When I used it:

I was building the fitness coach tool (more on this in my next article) and accidentally overwrote the JSON schema. Instead of panicking or manually reconstructing it, I hit “Restore Check Point” and went back 3 steps.

Problem solved in 10 seconds.

Comparison to iOS development:

In Xcode, I rely heavily on Git for this. But Git requires discipline—commit often, write good messages, manage branches. Here, it’s automatic and frictionless.

The Code Editor: When You Need More Control

Google AI Studio isn’t purely no-code. It’s low-code with an escape hatch.

When the AI generates something close but not quite right, you can drop into the built-in code editor and make changes yourself.

If you are a developer and want to make code changes, you can use the code editor to fix the code or add features. pic.twitter.com/videolink

— Ravi Shankar (@rshankra) November 3, 2025

I used this when:

• Tweaking UI styling: The AI gave me a working layout, but I wanted custom colors matching my brand
• Adding validation: I wanted stricter input validation than what was generated
• Optimizing logic: The generated code worked but wasn’t as efficient as I’d like

As someone who writes code daily, this felt like the best of both worlds:

• Speed of AI generation
• Precision of manual editing

The learning curve:

If you know HTML/CSS/JavaScript, you’ll feel at home. If you’re coming from pure Swift/iOS development like me, there’s a small adjustment period. But the code is clean and readable—no weird abstractions.

Deployment: From Prototype to Production

This is where Google AI Studio really shines for indie developers.

Once you’ve built something, you have four options:

Like any other popular vibe coding tool, this allows users to:
- download the code
- publish to GitHub
- deploy it in the cloud
- share your work. pic.twitter.com/videolink

— Ravi Shankar (@rshankra) November 3, 2025

1. Download the Code

Get a zip file with all your HTML, CSS, and JavaScript. Host it anywhere.

2. Publish to GitHub

One-click push to a GitHub repository. Great for version control and collaboration.

3. Deploy to Cloud Run

This is the killer feature. Click “Deploy to Cloud Run,” and your app goes live on Google Cloud infrastructure.

No server configuration. No Docker knowledge required. Just deployed, scalable web service.

For iOS developers used to TestFlight and App Store review, this instant deployment feels like cheating.

4. Share Your Work

Get a shareable link immediately. Perfect for user testing or showing stakeholders.

My workflow:

1. Build in AI Studio
2. Test with the preview
3. Deploy to Cloud Run
4. Share the link for feedback
5. Iterate based on responses

This cycle takes minutes, not days.

Key Lessons Learned

1. Start Stupidly Simple

Problem: My first instinct was to build something complex to “test the limits.”

Solution: I started with the image generator—one input, one output, minimal logic. Once that worked, I built up complexity.

Lesson: Validate the workflow before attempting ambitious projects.

2. Screenshots > Long Descriptions

Problem: I spent 10 minutes typing out detailed UI specifications for a form layout.

Solution: I sketched it on paper, took a photo, and uploaded it. Got better results in 30 seconds.

Lesson: The annotation tool is powerful. Use it liberally.

3. Think in Input/Output, Not Screens

Problem: Coming from iOS development, I was thinking in terms of view controllers and navigation flows.

Solution: Google AI Studio works best when you think in terms of services: “Given this input, return this output.”

Lesson: Shift your mental model from “app with screens” to “service with endpoints.”

4. Not a Replacement, But a Complement

Problem: I initially wondered if this made native iOS development obsolete.

Solution: No. Google AI Studio is brilliant for web services, APIs, and rapid prototyping. But for native features—Face ID, HealthKit, Apple Watch complications—you still need Swift and Xcode.

Lesson: Use AI Studio for backend logic and web interfaces. Use Swift for native experiences. They complement each other perfectly.

5. Deployment Simplicity Lowers the Bar for Experimentation

Problem: In iOS development, deploying means TestFlight at minimum, App Store at maximum. Both take time.

Solution: Cloud Run deployment is instant. This changes the psychology of experimentation.

Lesson: When deployment is friction-free, you’re more willing to try weird ideas. Some of my best discoveries came from “what if I just…” moments that would’ve been too much hassle in Xcode.

When to Use Google AI Studio vs. Native iOS Development

After a week of building, here’s my framework:

Use Google AI Studio when:

• ✅ You need to validate an idea quickly
• ✅ You’re building a web service or API
• ✅ The UI is browser-based
• ✅ You want instant deployment and sharing
• ✅ Backend logic is more important than native features
• ✅ You’re prototyping before committing to native development

Use Xcode/Swift when:

• ✅ You need native iOS/macOS features (HealthKit, Core Motion, etc.)
• ✅ Offline functionality is critical
• ✅ You’re building for App Store distribution
• ✅ Performance is paramount (games, complex animations)
• ✅ You want deep integration with Apple ecosystem
• ✅ You need platform-specific UI patterns (SwiftUI, UIKit)

Use Both when:

• ✅ Your app has a native frontend + cloud backend
• ✅ You want to prototype backend logic in AI Studio, then integrate via API
• ✅ You’re building multi-platform (iOS app + web dashboard)

My current approach:

I use Google AI Studio to build and deploy backend services quickly. Then I connect my SwiftUI apps to those services via standard HTTP requests.

This gives me:

• Speed of AI Studio for backend iteration
• Quality of native Swift for user experience

Best of both worlds.

What I’m Building Next

Google AI Studio has changed how I think about side projects.

Ideas that seemed too time-consuming to validate are now afternoon experiments. I’m less precious about code and more focused on outcomes.

Coming up:

• Fitness Coach: A web service that takes step count and goal, returns personalized coaching messages (perfect for Apple Watch complications)
• Launch Checklist Generator: Helps indie devs overcome launch paralysis
• Caption Generator: Writes scroll-friendly social media captions for apps

I’ll share the full build process for all three in my next article, including rookie mistakes, architecture decisions, and Cloud Run deployment.

Getting Started

If you’re an iOS developer curious about AI, here’s my recommendation:

1. Pick one simple idea: Something with clear input/output
2. Open Google AI Studio: google.ai/aistudio (no installation needed)
3. Build it in one session: Don’t overthink. Just start.
4. Deploy to Cloud Run: Experience the instant gratification
5. Reflect: What could you build with this speed?

The learning curve is gentle. If you understand basic programming concepts, you’ll be productive in an hour.

Final Thoughts

I’m not abandoning Xcode. SwiftUI is still my favorite way to build iOS apps.

But Google AI Studio has given me a new superpower: rapid validation.

When I have an idea now, I can:

• Build a working prototype in minutes
• Deploy it live
• Get real user feedback
• Decide if it’s worth the investment of a full native app

That cycle used to take weeks. Now it takes an evening.

For indie developers, this is a game-changer.

We’re already stretched thin—coding, designing, marketing, supporting users. Any tool that accelerates the build phase gives us more time for everything else.

And honestly? It’s just fun. The immediacy of seeing prompts become working code reignites the joy of building.

If you’ve been curious about AI but intimidated by the complexity, Google AI Studio is the most approachable entry point I’ve found.

Try it. Build something weird. Ship it. See what happens.

Next up: I’ll walk through building 3 AI mini tools for indie developers in 3 days, including full code examples, architecture decisions, and lessons learned. Follow along for the full build-in-public journey.

Resources:

• Google AI Studio
• Cloud Run Documentation
• Gemini API Reference

Related posts:

• My Learnings as Indie App Developer: Building Identity Habits (lessons on rapid iteration and validation)
• Building TwAIst: An AI Twitter Assistant (more on AI integration for apps)

I built TwAIst for the Google Chrome Built-in AI Hackathon, and honestly? It started from pure frustration. I was spending way too much time staring at empty tweet boxes, trying to craft the “perfect” reply, watching my productivity disappear into the Twitter void.

But here’s what got me excited: Chrome’s new Prompt API with Gemini Nano means you can run AI completely on-device. No external API calls. No data leaving your machine. No rate limits. Just pure, privacy-first AI that works offline.

This post is for anyone wanting to get started with Chrome’s built-in AI or build Chrome extensions. I’ll walk through what I built, how the Prompt API actually works, and the lessons I learned the hard way.

Watch the demo: TwAIst Demo Video

What TwAIst Does

TwAIst is a Chrome extension that helps you create better Twitter/X content using AI - completely privately on your device.

TwAIst’s welcome screen showing the main features

Core Features

1. Multi-Step Tweet Composer

This is where things get interesting. Instead of just “generate a tweet,” TwAIst uses a workflow:

• Generate ideas for any topic
• Create attention-grabbing hooks from your chosen idea
• Compose full tweets using your selected hook
• Choose from 5 different tones (casual, witty, storytelling, educational, motivational)

The multi-step composer showing the Ideas → Hooks → Tweet workflow

2. Smart Reply Generator

• Paste any tweet, get contextual replies in 6 different tones
• Upload images and AI analyzes them for image-aware replies
• Refine replies iteratively until they’re perfect
• Tones: friendly, humorous, personal story, thought-provoking, add insight, quick help

Smart reply generator with tone selection

3. Template Generator

Six proven tweet formats that go viral:

• Contrast (before/after)
• Transformation story
• Unpopular opinion
• Choose your hard
• Hook+list+question
• Struggle→solution

Credit: Template inspiration from Stijn Noorman’s viral tweet formats (@stijnnoorman)

Template generator showing different viral tweet formats

4. Advanced Features

• Multimodal support: Upload images, AI understands them for contextual content
• Conversation context: Multi-step workflow remembers previous choices
• AI parameter tuning: Adjust temperature (0.0-1.0) and top-K (1-100) for creativity control
• Device-optimal defaults: Loads hardware-specific AI parameters automatically
• Work-in-progress saving: Auto-saves your drafts locally
• Refine anything: Iteratively improve any generated content

Settings panel with AI creativity controls

Getting Started with Chrome’s Built-in AI

Before you can use Chrome’s Prompt API, you need to enable it. Here’s how:

1. Enable Chrome Built-in AI

1. Open Chrome and go to chrome://flags
2. Search for “Prompt API for Gemini Nano”
3. Enable the flag
4. Restart Chrome
5. Verify Gemini Nano is available by checking chrome://components and ensuring “Optimization Guide On Device Model” is present

Resources:

• Chrome AI Documentation
• Prompt API Guide
• Chrome AI Hackathon Resources

2. Basic Prompt API Usage

The simplest way to use the Prompt API:

// Check if the API is available
if (!window.ai || !window.ai.languageModel) {
  console.error('Prompt API not available');
  return;
}

// Create a session
const session = await window.ai.languageModel.create();

// Generate text
const result = await session.prompt('Write a tweet about Chrome AI');

console.log(result);

// Clean up
session.destroy();

That’s it! But for real applications, you need more control.

The Architecture: How I Built TwAIst

Modular Design

I structured TwAIst to be modular from day one. Each feature lives in its own module:

TwAIst/
├── popup.js              # Main orchestrator
├── modules/
│   ├── composer.js       # Multi-step tweet composer
│   ├── reply-generator.js # Smart reply generator
│   ├── template-generator.js # Template system
│   └── image-handler.js  # Multimodal image processing
└── utils/
    └── ai-manager.js     # Central AI session manager

The AI Manager Pattern

Instead of creating AI sessions everywhere, I built a central ai-manager.js that handles all AI interactions. This became the single source of truth for AI operations.

// utils/ai-manager.js
class AIManager {
  constructor() {
    this.currentSession = null;
    this.abortController = null;
  }

  async initPrompt(systemPrompt, options = {}) {
    try {
      // Check API availability
      if (!window.ai || !window.ai.languageModel) {
        throw new Error('Prompt API not available');
      }

      // Clean up any existing session
      this.cleanup();

      // Create abort controller for cancellation
      this.abortController = new AbortController();

      // Create session with parameters
      const session = await window.ai.languageModel.create({
        systemPrompt,
        temperature: options.temperature || 0.7,
        topK: options.topK || 40,
        signal: this.abortController.signal
      });

      this.currentSession = session;

      return { session, abortController: this.abortController };
    } catch (error) {
      console.error('Failed to init AI session:', error);
      throw error;
    }
  }

  async initPromptWithContext(options = {}) {
    try {
      if (!window.ai || !window.ai.languageModel) {
        throw new Error('Prompt API not available');
      }

      this.cleanup();
      this.abortController = new AbortController();

      // Create session with conversation history
      const session = await window.ai.languageModel.create({
        systemPrompt: options.systemPrompt || '',
        initialPrompts: options.conversationHistory || [],
        temperature: options.temperature || 0.7,
        topK: options.topK || 40,
        signal: this.abortController.signal
      });

      this.currentSession = session;

      return { session, abortController: this.abortController };
    } catch (error) {
      console.error('Failed to init AI with context:', error);
      throw error;
    }
  }

  cancel() {
    if (this.abortController) {
      this.abortController.abort();
    }
  }

  cleanup() {
    if (this.currentSession) {
      this.currentSession.destroy();
      this.currentSession = null;
    }
    if (this.abortController) {
      this.abortController = null;
    }
  }
}

export const aiManager = new AIManager();

Why this matters:

• Single place to manage session lifecycle
• Easy cancellation with AbortSignals
• Proper cleanup to avoid memory leaks
• Centralized error handling

The Killer Feature: Multi-Step AI Workflow

The multi-step composer is what makes TwAIst feel like collaborating with AI rather than just one-shot generation. Here’s how it works:

Step 1: Generate Ideas

async function generateIdeas(topic) {
  const systemPrompt = `You are a creative brainstorming assistant.
Generate 5 unique tweet ideas about the given topic.
Each idea should be specific, interesting, and tweetable.`;

  const { session } = await aiManager.initPrompt(systemPrompt, {
    temperature: 0.8, // Higher creativity for ideation
    topK: 50
  });

  const result = await session.prompt(`Topic: ${topic}`);

  return result;
}

Step 2: Generate Hooks WITH Context

This is where conversation context becomes crucial. The AI needs to “remember” which idea the user selected:

async function generateHooks(selectedIdea) {
  // Build conversation history
  const conversationHistory = [
    {
      role: 'system',
      content: 'You are a hook-writing expert for social media.'
    },
    {
      role: 'user',
      content: `I want to write about: ${selectedIdea}`
    }
  ];

  const { session } = await aiManager.initPromptWithContext({
    conversationHistory,
    temperature: 0.7,
    topK: 40
  });

  const hooks = await session.prompt(
    'Generate 5 attention-grabbing hooks for this idea'
  );

  return hooks;
}

Step 3: Compose Tweet

Same pattern - carry the context forward:

async function composeTweet(selectedIdea, selectedHook, tone) {
  const conversationHistory = [
    {
      role: 'system',
      content: `You are a tweet composer. Write in ${tone} tone.`
    },
    {
      role: 'user',
      content: `Idea: ${selectedIdea}`
    },
    {
      role: 'assistant',
      content: `Hook: ${selectedHook}`
    }
  ];

  const { session } = await aiManager.initPromptWithContext({
    conversationHistory,
    temperature: 0.6,
    topK: 30
  });

  const tweet = await session.prompt(
    'Write a complete tweet using this hook and idea'
  );

  return tweet;
}

The magic: Each step builds on the last. The AI “remembers” the context, creating a coherent workflow that feels natural.

Multimodal AI: Working with Images

Getting image analysis working was genuinely challenging, but the results are worth it. You can upload a screenshot and TwAIst generates contextual tweets about it.

How to Process Images

async function analyzeImage(imageFile, prompt) {
  // Read image as Blob
  const imageBlob = await readFileAsBlob(imageFile);

  const systemPrompt = 'You are an image analysis expert who creates engaging social media content.';

  const { session } = await aiManager.initPrompt(systemPrompt, {
    temperature: 0.7
  });

  // Send multimodal prompt
  const result = await session.prompt([
    {
      role: 'user',
      content: [
        { type: 'text', value: prompt },
        { type: 'image', value: imageBlob }
      ]
    }
  ]);

  return result;
}

function readFileAsBlob(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = (e) => resolve(new Blob([e.target.result]));
    reader.onerror = reject;
    reader.readAsArrayBuffer(file);
  });
}

Important notes:

• Image processing takes 5-10 seconds - always show loading indicators
• Set user expectations: “Analyzing image… (this may take 5-10 seconds)”
• The Prompt API accepts images as Blobs
• Works best with clear, high-contrast images

Prompt Engineering: Making AI Sound Human

My first attempts at AI-generated tweets were… painful. They screamed “I WAS WRITTEN BY AI!” - lots of “Haha, okay so…” and “Bold move!” everywhere.

What Didn’t Work

❌ Longer prompts: Made it worse ❌ Asking for “casual tone”: Still sounded formal ❌ Positive instructions only: Too vague

What Actually Worked

✅ Explicit AVOID lists: Tell AI what NOT to do

const systemPrompt = `You are a friendly reply generator.

WRITING STYLE:
- Reply naturally like texting a friend
- Jump straight to your reaction
- Lowercase is OK
- Sentence fragments are OK
- Be specific, not vague

AVOID THESE PHRASES:
- "totally"
- "this is so true"
- "I agree"
- "haha okay"
- "bold move"
- "interesting take"
- "fair point"

Keep it under 280 characters.`;

The insight: Telling AI what NOT to do is more effective than telling it what TO do.

Tone-Specific Prompts

Each tone needs its own carefully crafted system prompt:

const tonePrompts = {
  friendly: `Reply warmly and supportively.
AVOID: "totally", "so true", "I agree"
Jump straight to reaction.`,

  humorous: `Reply with wit and humor.
AVOID: "haha", "lol", forced puns
Be clever, not try-hard.`,

  personal_story: `Share a brief relevant personal experience.
AVOID: "this reminds me", "funny story"
Start with the story.`,

  thought_provoking: `Ask an insightful follow-up question.
AVOID: "interesting point", "makes you think"
Go straight to the question.`,

  add_insight: `Add a valuable new perspective.
AVOID: "also", "additionally", "another thing"
State the insight directly.`,

  quick_help: `Offer practical advice or resources.
AVOID: "you should", "try this"
Give direct help.`
};

Chrome Extension Setup

TwAIst is built as a Manifest V3 Chrome extension. Here’s the basic structure:

manifest.json

{
  "manifest_version": 3,
  "name": "TwAIst - AI Twitter Assistant",
  "version": "1.0.0",
  "description": "AI-powered Twitter assistant running 100% on-device",
  "permissions": [
    "storage",
    "activeTab"
  ],
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "icons/icon16.png",
      "48": "icons/icon48.png",
      "128": "icons/icon128.png"
    }
  },
  "icons": {
    "16": "icons/icon16.png",
    "48": "icons/icon48.png",
    "128": "icons/icon128.png"
  }
}

Project Structure

TwAIst/
├── manifest.json
├── popup.html          # Main UI
├── popup.js           # Main orchestrator
├── styles.css         # Styles
├── modules/
│   ├── composer.js
│   ├── reply-generator.js
│   ├── template-generator.js
│   └── image-handler.js
├── utils/
│   └── ai-manager.js
└── icons/
    ├── icon16.png
    ├── icon48.png
    └── icon128.png

Key Lessons Learned

1. User Activation Requirement

Problem: Chrome requires user interaction before creating AI sessions.

// ❌ This will FAIL
async function init() {
  // Trying to create session on page load
  const session = await window.ai.languageModel.create();
}

init(); // Error: requires user activation

Solution: Always create sessions inside click handlers:

// ✅ This works
button.addEventListener('click', async () => {
  const session = await window.ai.languageModel.create();
  // Use session...
});

2. Set User Expectations

Image processing takes time. Don’t make users guess:

async function analyzeImage(imageBlob) {
  // Show specific loading message
  showStatus('Analyzing image... (this may take 5-10 seconds)');

  const result = await session.prompt([...]);

  hideStatus();
  return result;
}

3. Temperature and Top-K Matter

Different tasks need different parameters:

// Ideation: high creativity
{ temperature: 0.8, topK: 50 }

// Hook writing: moderate creativity
{ temperature: 0.7, topK: 40 }

// Final composition: more focused
{ temperature: 0.6, topK: 30 }

// Analytical tasks: low creativity
{ temperature: 0.3, topK: 20 }

4. Conversation Context is Powerful

The initialPrompts parameter makes multi-step workflows feel natural:

const session = await window.ai.languageModel.create({
  systemPrompt: 'You are a helpful assistant',
  initialPrompts: [
    { role: 'user', content: 'Previous step context here' },
    { role: 'assistant', content: 'AI response from previous step' }
  ]
});

5. Always Clean Up Sessions

Memory leaks are real:

class ComponentWithAI {
  async generateContent() {
    let session = null;
    try {
      session = await window.ai.languageModel.create();
      const result = await session.prompt('...');
      return result;
    } finally {
      // ALWAYS clean up, even on errors
      if (session) {
        session.destroy();
      }
    }
  }
}

The Privacy-First Advantage

Running AI on-device isn’t just about privacy - it unlocks better UX:

Benefits:

• ✅ No API roundtrips = instant responses
• ✅ No rate limits = unlimited usage
• ✅ Works offline
• ✅ No external API costs
• ✅ User data never leaves their machine

The insight: Privacy-first architecture actually creates better user experiences. In a world of constant API calls and loading spinners, on-device AI feels genuinely fast.

What’s Next for TwAIst

I’m actively developing new features:

Short-term:

• Thread unroller: paste thread URL, get intelligent summary
• Sentiment analysis: suggest optimal reply tone
• Custom tone training: analyze user’s tweets to create personalized tone
• A/B testing: generate variations, predict performance

When APIs Stabilize:

• Translation API: auto-translate while preserving tone
• Summarizer API: better thread summarization
• Rewriter API: nuanced style transformations

Long-term:

• Voice input: Speech Recognition API + Prompt API
• Analytics dashboard: track AI-generated tweet performance
• Engagement predictor: score tweets before posting

Try TwAIst

Ready to transform your Twitter workflow with privacy-first AI?

GitHub Repository: TwAIst

Installation:

1. Clone the repository
2. Enable Chrome Built-in AI flags (see instructions above)
3. Load unpacked extension in Chrome
4. Start creating better content!

For Developers: Getting Started with Chrome Built-in AI

If you’re new to Chrome’s built-in AI, here’s your roadmap:

1. Read the docs: Chrome AI Documentation
2. Enable the flags: chrome://flags → “Prompt API for Gemini Nano”
3. Start simple: Basic prompt/response before complex workflows
4. Experiment with parameters: Temperature and top-K dramatically change outputs
5. Handle errors gracefully: Not all devices support Gemini Nano yet
6. Join the community: Chrome AI Hackathon

Resources

• Chrome Built-in AI Documentation
• Prompt API Guide
• Chrome AI Hackathon Resources
• TwAIst GitHub Repository
• TwAIst Demo Video

Built With AI Assistance

Full transparency: I built TwAIst using Claude Code, Anthropic’s AI-powered development tool.

This was actually a fascinating meta-experience - using AI to build an AI-powered application. Claude Code helped with:

• Architecture decisions and modular design patterns
• Writing the AI Manager abstraction layer
• Implementing the multi-step workflow with conversation context
• Debugging tricky session lifecycle issues
• Crafting effective system prompts and prompt engineering

The irony isn’t lost on me: I used an AI coding assistant to build a tool that helps people create better AI-generated content. AI building AI tools. We’re living in interesting times.

If you’re building Chrome extensions or working with new APIs, I highly recommend trying Claude Code. It significantly accelerated development and helped me navigate the Prompt API documentation more effectively.

Acknowledgments

• Template inspiration: Stijn Noorman for his excellent viral tweet formats video
• Chrome AI Team: For building the Prompt API and making on-device AI accessible
• Devpost: For hosting the Chrome Built-in AI Hackathon

Conclusion

Building TwAIst taught me that Chrome’s Prompt API is legitimately production-ready. It’s not just a toy - it enables real applications with great UX that respect user privacy.

The key lessons:

• On-device AI is faster and better for users
• Prompt engineering is 80% of the work
• Conversation context makes multi-step workflows feel natural
• Explicit AVOID lists help AI sound human
• Temperature/top-K parameters matter more than you think

Chrome’s built-in AI represents a fundamental shift: bringing AI inference to the edge, making it private, fast, and accessible. TwAIst is just the beginning.

What will you build with Chrome’s built-in AI?

Built for the Google Chrome Built-in AI Hackathon. Check out TwAIst on GitHub and let me know what you think!

See the app here: ChantFlow and on the App Store: ChantFlow — Daily Om Practice.

The Sacred 108: A Digital Revolution in Spiritual Practice

In the ancient tradition of mala (prayer bead) practice, 108 holds profound spiritual significance. But in our modern, fast-paced world, maintaining this sacred practice can be challenging. Enter ChantFlow - an Apple Watch app that transforms your wrist into a digital mala, making the sacred 108 practice accessible, consistent, and deeply meaningful.

What Makes ChantFlow Special?

ChantFlow isn’t just another meditation app. It’s a spiritual technology that honors tradition while embracing innovation. The app transforms your Apple Watch into a digital mala, allowing you to count your 108 mantras with the same reverence and intention as traditional prayer beads, but with the convenience that modern life demands.

Apple Watch Complications: Your Sacred Progress at a Glance

ChantFlow’s Apple Watch complications are where the magic happens. These tiny widgets on your watch face serve as gentle reminders of your spiritual journey, showing your progress toward the sacred 108 without requiring you to open the app or interrupt your day.

ChantFlow’s Apple Watch complication displays the current time (10:13), a bed icon indicating sleep/rest mode, and shows +138 extras completed beyond the daily 108 practice.

What You See on Your Wrist:

• Current Mantra Count: “67 of 108” - showing your progress toward the daily goal
• Sacred Progress Circle: A visual representation of your journey through the 108 mantras
• Completion Status: Whether you’ve reached your daily goal
• Practice Streak: How many consecutive days you’ve maintained your practice
• Extra Merit: Mantras completed beyond the daily 108 for additional spiritual benefit

Real-World Impact: From Glance to Practice

Imagine this scenario: You’re in a busy meeting, feeling stressed and disconnected. You glance at your Apple Watch and see “45 of 108” on your ChantFlow complication. In that moment, you’re reminded of your spiritual practice, your connection to something greater than the immediate stress. That simple glance becomes a moment of mindfulness, a gentle nudge back to your center.

The Technical Magic Behind Sacred Complications

ChantFlow’s complications are built using Apple’s WidgetKit framework, ensuring they update seamlessly in the background and provide real-time information about your spiritual practice.

Key Technical Features:

• Real-Time Updates: Complications refresh automatically as you progress through your mantras
• Background Processing: Updates happen even when the app isn’t actively open
• Data Persistence: Your progress is saved and shared between the main app and complications
• Battery Optimization: Efficient updates that don’t drain your Apple Watch battery

The User Experience: From First Glance to Deep Practice

1. The Gentle Reminder

Your ChantFlow complication sits quietly on your watch face, showing your current progress. Unlike push notifications that demand attention, it’s there when you need it, offering gentle guidance without interruption.

2. The Moment of Awareness

When you glance at your wrist and see “23 of 108,” you’re reminded of your spiritual practice. This isn’t a demand to practice right now - it’s a gentle invitation to remember your connection to the sacred.

3. The Practice Experience

ChantFlow’s main interface features a sacred progress circle that fills as you count your mantras. Each tap provides haptic feedback, simulating the tactile experience of traditional mala beads. The visual progress and tactile feedback create a deeply immersive spiritual experience.

The Psychology of Sacred Complications

The psychology behind ChantFlow’s complications is simple yet profound: what you see regularly becomes part of your consciousness. When your spiritual progress is always visible on your wrist, it becomes a natural part of your daily awareness.

The Habit Loop:

1. Cue: You glance at your watch and see your mantra progress
2. Craving: You feel the desire to continue your spiritual practice
3. Response: You open ChantFlow and engage in your practice
4. Reward: You experience the satisfaction of spiritual connection and progress

Getting Started with ChantFlow Complications

Setting Up Your Sacred Dashboard

1. Download ChantFlow: Available on the App Store for Apple Watch
2. Choose Your Watch Face: Select a face that supports complications
3. Add ChantFlow Complications: Long-press your watch face and add ChantFlow widgets
4. Customize Your Layout: Arrange complications so your spiritual progress is easily visible
5. Begin Your Practice: Start with your first 108 mantras

The Impact: Real Stories from ChantFlow Users

Sarah’s Story: Finding Peace in Chaos

“I work in a high-stress environment, and I was struggling to maintain my spiritual practice. ChantFlow’s complications changed everything. I can glance at my watch and immediately remember my connection to something greater. It’s like having a gentle spiritual guide on my wrist.”

Michael’s Journey: Building Consistency

“I’ve tried many meditation apps, but I always fell off track. With ChantFlow, seeing my progress on my watch face keeps me motivated. I’ve maintained my 108 practice for 47 consecutive days - something I never thought possible.”

Conclusion: Where Technology Meets Tradition

ChantFlow’s Apple Watch complications represent more than just convenient widgets - they’re a bridge between ancient spiritual wisdom and modern technology. By making the sacred 108 practice glanceable, accessible, and consistent, the app is helping people maintain their spiritual connection in a world that often pulls us away from it.

The key insight is that complications don’t demand spiritual practice - they gently remind us of our spiritual nature. In a world of constant notifications and digital noise, this subtle approach to spiritual technology might be exactly what we need to maintain our connection to the sacred.

Whether you’re a long-time practitioner of mala meditation or someone just beginning their spiritual journey, ChantFlow’s complications offer a gentle, non-intrusive way to keep your spiritual practice alive throughout the day. Your sacred journey starts with a single glance at your wrist.

Ready to transform your Apple Watch into a sacred digital mala? Download ChantFlow and begin your journey with the sacred 108. Your spiritual practice is just a glance away.

Ever spent hours searching for the perfect stock photo, only to settle for something “close enough” and pay $50 for the privilege? I did this for months while marketing my Apple Watch app ChantFlow until I discovered something that changed everything.

What if you could generate exactly the image you want, in seconds, for less than a dollar?

That’s exactly what I built using Runware’s AI API—a simple iOS app that creates unlimited marketing visuals on demand. Here’s how you can do the same.

The Problem: Stock Photos Are Expensive and Generic

ChantFlow is an Apple Watch meditation app that helps users perform traditional chanting practices. Marketing this required very specific imagery—people using Apple Watch during meditation, serene spiritual scenes, the blend of ancient practices with modern tech.

Stock photo sites couldn’t deliver what I needed:

• Generic meditation photos (another person sitting cross-legged in a white room)
• Expensive licenses ($20-50 per image)
• Limited selection for niche concepts
• No way to create variations or test different styles

The Solution: Runware AI API

I discovered Runware AI—an API that generates high-quality images in under a second. No machine learning expertise required, just simple API calls.

What makes Runware special:

• 312,464+ AI models to choose from
• Lightning-fast generation (0.6-4 seconds depending on model)
• Affordable pricing (pennies per image vs. $50 stock photos)
• Easy integration with any programming language

I built “Mindful Creator,” a simple iOS app that uses Runware’s API to generate marketing content on demand. The complete source code is on GitHub.

Why Runware Over Other AI Services?

1. Speed

While other services take 10-30 seconds, Runware generates images in 0.6-4 seconds depending on the model. Perfect for testing multiple ideas quickly.

2. Model Variety

Access to 312,464+ models from platforms like CivitAI. Just copy any model’s “AIR ID” and use it in your app.

3. Simple Integration

No complex setup. Just make HTTP requests with your API key—works with any programming language.

4. Affordable

Generate hundreds of images for what you’d pay for a single stock photo.

Start Here: The Runware Playground

Before writing any code, use the Runware Playground. It’s a web-based tool where you can:

1. Test different AI models without coding
2. Adjust parameters and see results instantly
3. Copy model IDs to use in your app
4. Learn what prompts work best

The Runware Playground interface allows you to test different AI models, adjust parameters, and see results instantly. Notice the “Copy AI ID” button that lets you easily copy model IDs for use in your app.

Key Tip: Copy AI ID Feature

When you find a model you like, click “Copy AI ID” and paste it into your app. For example, civitai:4384@128713 gives dreamy, artistic results perfect for wellness apps.

Writing Good Prompts

Be specific. Instead of “meditation,” try:

“person wearing Apple Watch, meditating peacefully, soft lighting, minimalist room, serene expression”

Add negative prompts to avoid unwanted elements:

“cluttered, dark, aggressive, scary”

See It In Action

Here’s a simple prompt I used for ChantFlow marketing:

Prompt: “person wearing Apple Watch, peaceful meditation pose, soft morning light, minimalist room, serene expression”

AI-generated image of a person wearing an Apple Watch while meditating peacefully in a minimalist room with soft morning light - exactly what I needed for ChantFlow marketing.

Cost: $0.0273 per image

Compare that to spending hours searching stock photo sites and paying $50 for something that’s only “close enough.”

The App I Built

The Mindful Creator app is a simple iOS app with these features:

• Easy prompting: Text input with helpful suggestions
• Multiple models: Switch between different AI styles
• Batch generation: Create 1-4 images at once
• Various sizes: Square, portrait, landscape, story formats
• Save to Photos: Export directly to your photo library
• Cost tracking: See how much you’re spending

Input your prompt and choose content series

Select visual style and add negative prompts

View and save your generated image

The complete Mindful Creator workflow: from input to style selection to final generated image with metadata.

The Basic API Call

Here’s the core of how it works:

let request = RunwareImageRequest(
    prompt: "person using Apple Watch for meditation",
    aspectRatio: .square,
    aiModel: .dreamShaper,
    numberResults: 4
)

That’s it. No complex machine learning setup required.

The Results: Before vs After

Before Runware:

• Hours searching stock photos
• $20-50 per image
• Settling for “close enough”
• Limited to existing photos

After Runware:

• Generate exactly what I need in 30 seconds
• $0.50 for 4 variations
• Perfect match to my vision
• Unlimited iterations

Quick Tips for Better Results

1. Be specific: “person using Apple Watch during morning meditation” vs “meditation”
2. Use negative prompts: Exclude unwanted elements like “cluttered, dark, aggressive”
3. Try different models: Each has its own style—experiment in the playground first
4. Generate multiple variations: Create 3-4 options and pick the best

Why This Matters

As an indie developer, I can now compete visually with big companies. No more $1000+ design budgets or settling for generic stock photos. I generate exactly what ChantFlow needs to stand out.

Get Started Today

Ready to stop paying $50 per stock photo?

1. Try the Runware Playground - Test models without coding
2. Get your API key at runware.ai
3. Check out the documentation for technical details
4. Download the source code - Mindful Creator on GitHub shows you exactly how to build your own

Your Turn

Whether you’re building an app, running a business, or just tired of expensive stock photos, Runware’s API can transform how you create visual content.

The playground is free to try. The API costs pennies per image. The creative freedom? Priceless.

Check out ChantFlow to see how AI-generated visuals help market a unique Apple Watch meditation app, and grab the complete source code to build your own content creator.

What’s new

• Heart rate insights: See your BPM during and after sessions — today and across the week.
• Mindful Minutes in Health: Your sessions are logged to Apple Health as Mindfulness.
• HRV (experimental): Heart Rate Variability appears after a session when conditions are right.
• Simple Health Insights screen: Big, readable numbers. Built for quick glances.

Why this matters

• Feel it, then see it: A calm heart rate trend is a gentle nudge to keep going.
• HRV as a signal, not a score: It can reflect resilience. We show it when it’s reliable.

How it works

• When you chant, the app quietly starts a health session.
• We read heart rate during the session, summarize after.
• HRV usually becomes available after ending the session and needs 3–5+ minutes of stillness and good sensor contact.
• Your Mindful Minutes are saved to Apple Health (with your permission).

Tiny code you can use

Request Health permissions (read HR/HRV, write Mindfulness + Workout)

import HealthKit

let healthStore = HKHealthStore()

func requestHealthPermissions(completion: @escaping (Bool) -> Void) {
    let toShare: Set = [
        HKObjectType.categoryType(forIdentifier: .mindfulSession)!,
        HKObjectType.workoutType()
    ]
    let toRead: Set = [
        HKObjectType.quantityType(forIdentifier: .heartRate)!,
        HKObjectType.quantityType(forIdentifier: .heartRateVariabilitySDNN)!
    ]
    healthStore.requestAuthorization(toShare: toShare, read: toRead) { ok, _ in
        completion(ok)
    }
}

Log a Mindfulness session to Apple Health

import HealthKit

func saveMindfulMinutes(start: Date, end: Date, completion: @escaping (Bool) -> Void) {
    let mindful = HKObjectType.categoryType(forIdentifier: .mindfulSession)!
    let sample = HKCategorySample(type: mindful, value: 0, start: start, end: end)
    HKHealthStore().save(sample) { ok, _ in
        completion(ok)
    }
}

(Optional) Start a lightweight workout for live heart rate on watchOS

import HealthKit

final class LiveHRSession: NSObject, HKWorkoutSessionDelegate {
    private let store = HKHealthStore()
    private var session: HKWorkoutSession?
    private var builder: HKLiveWorkoutBuilder?

    func start() throws {
        let cfg = HKWorkoutConfiguration()
        cfg.activityType = .mindAndBody
        cfg.locationType = .unknown
        let session = try HKWorkoutSession(healthStore: store, configuration: cfg)
        let builder = session.associatedWorkoutBuilder()
        builder.dataSource = HKLiveWorkoutDataSource(healthStore: store, workoutConfiguration: cfg)
        self.session = session
        self.builder = builder
        session.delegate = self
        session.startActivity(with: Date())
        builder.beginCollection(withStart: Date()) { _, _ in }
    }

    func stop(completion: @escaping () -> Void) {
        builder?.endCollection(withEnd: Date()) { _, _ in
            self.session?.end()
            self.builder?.finishWorkout { _, _ in completion() }
        }
    }

    func workoutSession(_ workoutSession: HKWorkoutSession, didChangeTo toState: HKWorkoutSessionState, from fromState: HKWorkoutSessionState, date: Date) {}
    func workoutSession(_ workoutSession: HKWorkoutSession, didFailWithError error: Error) {}
}

Privacy, always

• You’re in control: Permissions are requested clearly during onboarding (new users) or at launch (existing users).
• Minimal data: We read only what’s needed. We don’t write HRV to Health. We don’t sell or share your data.
• On‑device first: Data is handled with care for speed and privacy.

Accessibility and design

• Big text, clean layout, VoiceOver‑friendly.
• Built for short sessions and quick checks, not deep dives.

HRV: set the right expectation

• HRV is experimental. It often appears after you end a session, and only with steady, still wear for several minutes. Heart rate will show up almost every time — HRV will show up some of the time. That’s normal.

Tips for better readings

• Wear the watch snugly, above the wrist bone.
• Keep your wrist still during the session.
• Aim for at least 5 minutes if you’re hoping to see HRV.

What’s next

• Gentle trends over weeks and months.
• Clear, friendly insights like “Your average heart rate during chanting dropped this week.”
• Continued focus on privacy and accessibility.

Start a session, breathe, and take a peek at your Health Insights afterward. Calm feels good — and now you can see it, too.