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

> Private AI workspace for Mac power users

- Site: https://boltai.com
- Category: AI Productivity
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 2-3 months of focused part-time work

## Verdict

Build a personal clone only if you want to spend months wrestling with native macOS APIs, global hotkey overlays, and multi-provider LLM streaming.

Replicating BoltAI means building a polished native macOS application in Swift rather than an Electron wrapper. While an AI coding agent can scaffold the basic SwiftUI chat interface and API connectors quickly, the real engineering friction lies in global window management, accessibility permissions, Keychain credential syncing, and sandboxed MCP tool execution. If you just want a unified AI client on your Mac, paying for the real product saves you dozens of hours of system-level debugging.

### What you can't replicate

- The exact polish and low CPU overhead of a native Swift/AppKit macOS codebase
- The author's 3 years of continuous iteration across 160+ rapid updates
- Seamless BoltAI Cloud syncing infrastructure across macOS and mobile

## What it does

Instantly switch between 300+ AI models from a single native macOS app with global shortcuts, screen capture resolution, local models, and MCP tools.

### Core features

- Native macOS app shell with SwiftUI and AppKit performance
- Global shortcut overlay window and system-wide hotkeys
- Unified multi-model streaming client (OpenAI, Anthropic, Gemini, Ollama)
- Screenshot capture and analysis (ShotSolve)
- Persistent chat history and local encrypted storage via Keychain
- Model Context Protocol (MCP) tool execution loop
- Voice dictation and inline text editing over active apps

## The business

### Pricing

- Essential: $79 — For students and hobbyists.
- Pro: $199 — For freelancers & professionals.
- Team Perpetual: $99/seat — For small teams.

### Funding

$0 raised.

Founded 2023.
Team size: Solo developer.

## The hard parts

- Low-latency native global overlay window and accessibility permissions integration in SwiftUI
- Reliable multi-provider streaming abstraction with interrupt, retry, and token parameter tuning
- Sandbox-safe client-side execution loops for MCP servers and shell subprocesses
- Secure credential management interfacing directly with the macOS Keychain

## How to vibe code BoltAI

### Prerequisites

- Mac with Apple Silicon: Required to run Xcode and build native macOS SwiftUI applications locally
- Xcode (Free): Required IDE for compiling and debugging Swift and AppKit native code
- Anthropic / OpenAI API Keys (Pay-as-you-go): Required to test multi-model chat streaming inside your custom native client

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding and debugging complex multi-file Swift codebases
- Cursor: Excellent AI editor for reviewing file diffs and tweaking UI components interactively

### Stack

- Frontend: SwiftUI + AppKit (Native macOS)
- Backend: Swift Concurrency (Local Async/Await)
- Database: GRDB.swift (Local SQLite)
- Auth: macOS Keychain (Local Secure Credentials)
- Payments: None (Personal clone)
- Other: Vercel AI SDK (reference patterns), Ollama (local model runner)

### Hosting

- GitHub (Source code repository and version control): $0/mo

### Build guide

1. **Scaffold Native macOS App & Core Window Layout** — Initialize a native macOS SwiftUI application with a split-view sidebar layout, chat history navigation, and support for macOS 13+.

```
Create a new SwiftUI macOS app project structure named BoltAIPersonal. Configure the app lifecycle to support a multi-window interface with a persistent sidebar for chat organization (Projects, Folders, Chats) and a detail pane for active conversations. Implement a clean, modern Mac-style aesthetic using native materials and styling. Ensure support for macOS 13+ and Apple Silicon optimization.
```

2. **Implement Local SQLite Storage with GRDB** — Set up a local-first SQLite database using GRDB.swift to store chats, messages, settings, and encrypted API credentials.

```
Integrate GRDB.swift into the project for local-first persistence. Define Swift models for Chats, Messages, and ProviderCredentials. Create a database manager that handles migrations, background queue execution, and atomic writes. Implement secure credential storage that interfaces with the macOS Keychain for API keys, ensuring keys never clear-text save to disk.
```

3. **Build Multi-Provider LLM Streaming Client** — Develop an abstraction layer supporting streaming responses from OpenAI, Anthropic, and local Ollama endpoints with parameter tuning.

```
Build an LLM client service in Swift using AsyncStream that handles streaming responses from OpenAI, Anthropic, and local Ollama API endpoints. Implement request payload construction supporting custom system instructions, temperature, top-p, and max tokens. Add robust error handling for rate limits, connection drops, and partial response recovery with interrupt and retry controls.
```

4. **Global Shortcut Overlay Window** — Implement a global hotkey listener using AppKit and Carbon events to trigger a floating instant-chat overlay window over any active app.

```
Implement global keyboard shortcut registration in AppKit (e.g., Command+Shift+Space) to toggle a floating, borderless panel overlay window anywhere on the macOS screen. Ensure the panel acts as an independent accessory window that does not steal focus from other apps permanently, supports quick prompt entry, and disappears on blur or escape key.
```

5. **Screenshot Capture & Vision Analysis (ShotSolve)** — Add screen capture functionality to capture a region of the screen and send it instantly to vision-enabled LLMs.

```
Implement a screen capture utility using CoreGraphics / CGWindowListCreateImage that allows users to select a screen region via an interactive overlay. Compress the resulting image into JPEG/PNG data and wire it directly into the active chat model payload as a multimodal attachment for instant vision-based question answering.
```

6. **MCP Tool Execution & Refinement** — Add support for Model Context Protocol (MCP) tool configuration and local client execution loops.

```
Build a Model Context Protocol (MCP) configuration parser that reads local JSON manifests (e.g., ~/.boltai/mcp.json). Implement a client-side execution loop allowing the LLM to request tool execution (such as filesystem access or local shell commands), execute the subprocess safely within a background task, and feed the tool output back into the conversation stream.
```

### Cost vs paying

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

- AI coding tool subscription: $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- API usage (Bring your own keys): Variable (~$10-30/mo)
- Total: Variable API costs

- Paying for the SaaS instead: $199 one-time ($69 promo)
- Build time: 40 hours
- AI tool credits: $20 (Claude Code / Cursor)
- Break-even: N/A (Personal build for learning)

## Sources

- [BoltAI Official Website](https://boltai.com)
- [BoltAI Pricing](https://boltai.com/pricing)
- [BoltAI Documentation](https://boltai.com/docs)
- [BoltAI Changelog](https://boltai.com/changelog)