# How to Vibe Code Your Own Capture (and Stop Paying for It)

> Quick notes. Zero friction.

- Site: https://capture.sir.studio
- Category: Productivity / Utility
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 4-6 weeks of part-time native development

## Verdict

Build a single-platform subset for personal use, but expect weeks of native UI and shortcut plumbing frustration.

Replicating Capture means building a truly native multi-platform Apple application suite in Swift, utilizing system-wide global hotkeys on macOS, watchOS dictation complications, and local-first CoreData/SwiftData syncing over CloudKit. While AI coding agents can easily generate SwiftUI boilerplate and basic views, getting low-level system hooks, global key listeners to behave correctly without losing focus, and managing audio recording sessions on watchOS requires deep manual debugging. Furthermore, maintaining 54 external app integrations is a massive trap; you will inevitably narrow your personal clone to just the 3 or 4 apps you actually use daily, rendering the integration surface area a perpetual maintenance headache.

### What you can't replicate

- The massive maintenance effort of supporting 54 live outbound app integrations
- Seamless App Store distribution and native user trust

## What it does

A quick-capture scratchpad and note-to-self app designed to minimize cognitive friction with a single universally accessible input box and local iCloud syncing.

### Core features

- Global Spotlight-style keyboard shortcut panel on macOS
- Always-open single field capture view on iOS/iPadOS
- watchOS dictation complications and double-tap trigger
- On-device offline voice-to-text transcription
- Natural language date and structure extraction
- Centralized local inbox with daily triage/archiving
- Outbound routing handlers for 54 third-party app destinations and URL schemes
- Share sheet and Safari extension integration
- Zero-backend CloudKit/iCloud synchronization

## The business

### Pricing

- Free Tier: Free — Free download with capture limits.
- Pro Tier: Lifetime purchase / IAP — Paid upgrade for unlimited captures.
Team size: Indie solo.

## The hard parts

- Writing performant native macOS AppKit panels that trigger globally without stealing focus abnormally
- Handling low-level watchOS audio session lifecycles for instant dictation
- Maintaining 54 distinct app integrations, URL schemes, and Apple Shortcuts parameter mappings that break when target apps update
- Implementing resilient zero-backend local-first CoreData/SwiftData synchronization over CloudKit

## How to vibe code Capture

### Prerequisites

- Mac: Required for macOS development and compiling Apple target binaries
- Xcode (free): Required IDE for building Swift, SwiftUI, and Apple ecosystem applications
- Apple Developer account ($99/yr): Required to test push notifications, extensions, CloudKit sync, and device builds

### Recommended AI tools

- Cursor: AI code editor ideal for iterative SwiftUI layout work and viewing every native file change as a clear diff
- Claude Code: Terminal coding agent for handling multi-file Swift architecture scaffolding and debugging complex system event loops

### Stack

- Frontend: Swift / SwiftUI / AppKit
- Backend: Local-first SwiftData / CloudKit
- Database: Local SQLite (via SwiftData)
- Auth: Apple iCloud Account (No custom auth)
- Payments: StoreKit 2 (Optional for lifetime unlock)
- Other: Apple Speech Framework (SFSpeechRecognizer) for on-device voice transcription, WidgetKit for Home Screen / Control Center widgets, App Intents & Shortcuts for system actions

### Hosting

- CloudKit / iCloud (Zero-backend private user data synchronization across devices): $0/mo

### Build guide

1. **Project Scaffolding & SwiftData Model** — Initialize a multi-platform Swift/SwiftUI application project supporting macOS and iOS, establishing the core data schema for local inbox entries.

```
Create a new multi-platform SwiftUI app architecture targeting macOS and iOS. Define a SwiftData model named `CaptureItem` with the following attributes: id (UUID), text (String), createdAt (Date), destination (String optional), isArchived (Bool), and tags ([String]). Set up the model container with automatic CloudKit synchronization enabled for private database containers. Implement a lightweight local repository pattern to insert, query unarchived inbox items, and update items cleanly without blocking the main thread. Ensure the project structure cleanly separates views, models, and service utilities.
```

2. **macOS Global Quick-Capture Floating Panel** — Implement a Spotlight-style global floating text input window on macOS triggered via a global hotkey.

```
Write an AppKit and SwiftUI implementation for a macOS global quick-capture panel. Register a global keyboard shortcut (e.g., Option+Space) using Carbon event hotkeys or modern EventMonitor APIs. When triggered, present a borderless, floating floating window centered horizontally near the top of the active screen, styled with a blurred visual effect view (NSVisualEffectView). The window must host a focused SwiftUI text field (`TextField`) that captures user input immediately upon opening, submits and saves the text to SwiftData on the return key, and hides the panel instantly. Ensure the panel correctly manages app activation policy (`NSApp.setActivationPolicy`) so it does not permanently steal focus from the user's primary application.
```

3. **iOS Always-Open Inbox & Capture View** — Build the primary mobile interface featuring an instant input box and a scrollable list of recent fleeting thoughts for daily triage.

```
Create an iOS SwiftUI view representing the core Capture interface. The screen should feature a pinned, always-focused multi-line text input field at the top or bottom for instant note entry, followed by a list view displaying unarchived `CaptureItem` objects sorted by date descending. Support swipe-to-archive and tap-to-edit interactions. Implement natural language processing utilities using `NSDataDetector` to extract dates and links automatically from the raw text string during typing. Ensure the UI responds instantly with zero layout jank and clean dark/light mode adaptations.
```

4. **On-Device Voice Transcription Service** — Integrate Apple's native speech recognition framework to provide offline voice-to-text recording within the capture field.

```
Implement a native audio recording and speech recognition service using AVFoundation and `SFSpeechRecognizer`. Create an observable view model that handles microphone permissions, starts/stops an `AVAudioEngine` audio capture session, and streams real-time transcription updates from `SFSpeechAudioBufferRecognitionRequest`. Ensure audio session configurations properly handle ambient playback interruptions and run entirely on-device (`requiresOnDeviceRecognition = true`) to maintain privacy and offline capability. Connect this service to a microphone button UI component in the capture box.
```

5. **Outbound Routing & URL Scheme Handlers** — Build export handlers that push captured notes out to selected external destinations via deep links and custom URL schemes.

```
Implement an outbound routing manager in Swift that takes a `CaptureItem` and formats it for external productivity apps using their official URL schemes or Apple Shortcuts parameters. Support custom handlers for at least 4 key destinations: Apple Reminders (using `reminders://`), Obsidian (using `obsidian://new?vault=...&file=...`), Things 3 (using `things:///add?...`), and a generic fallback URL scheme builder. Save the user's last-selected destination choice to `AppStorage` so it defaults correctly on the next capture export action.
```

6. **Widgets, Share Extensions & Polish** — Add system widgets, a Share Extension for capturing web links, and polish the app bundle for personal distribution.

```
Add a WidgetKit extension providing a home screen widget and a Control Center control tile that deep-links directly into the capture input state. Implement an iOS Share Extension target that parses incoming URLs, plain text, or image files from Safari or other apps and writes them directly into the shared SwiftData/CloudKit container. Perform a comprehensive code audit to handle edge cases like empty inputs, network loss during CloudKit sync, and memory leaks in background transcription loops.
```

### Cost vs paying

**Starting costs (one-time):**

- Apple Developer Account: $99/yr
- Total: ~$99 one-time/annual

**Ongoing costs (monthly):**

- AI Coding Assistant: $20/mo
- Total: ~$20/mo (optional during build phase)

- Paying for the SaaS instead: Paid Pro option (lifetime or subscription)
- Build time: 40-60 hours
- AI tool credits: ~$20/mo (Cursor or Claude Pro)
- Break-even: N/A (Personal utility build)

## Sources

- [Capture Official Website](https://capture.sir.studio)
- [Apple App Store - Quick Notes: Capture](https://apps.apple.com/us/app/quick-notes-capture/id...)