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

> Automatic time tracking for Mac. No timers needed.

- Site: https://timingapp.com
- Category: Productivity
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 2-3 months of part-time native development

## Verdict

Build a basic local prototype with Tauri and Swift hooks, but keep paying for Timing if you need rock-solid background tracking that survives macOS updates.

Timing's core value is not a CRUD web dashboard; it is a bulletproof native background daemon that polls macOS window states every second while keeping CPU usage under 0.5% and respecting strict OS permission sandboxes. Building a personal clone requires writing native Swift helpers for Accessibility and CGWindow APIs, piping data into local SQLite, and managing constant Apple security permission changes across macOS releases.

### What you can't replicate

- Decade-long edge-case hardening against macOS system updates
- Zero-latency native memory footprint (<0.5% CPU background usage)

## What it does

An automatic time-tracker and productivity analyzer for macOS that passively records active application windows, visited web URLs, document file paths, and calendar events with AI summaries and privacy-first local storage.

### Core features

- Passive background macOS activity tracking (App windows, URLs, document paths)
- Interactive visual timeline with drag-and-drop categorization
- Rule-based auto-categorization via option-drag
- AI activity summarization and natural language insights
- Calendar and meeting detection integration
- Idle time detection and exclusion
- Local SQLite data storage with optional sync
- Exportable timesheets (PDF, CSV, XLSX)

## The business

### Pricing

- Professional: $12/mo — For individuals tracking time on 1 Mac.
- Expert: $16.50/mo — For heavy power users across 2 Macs.
- Connect: $22.50/mo — For AI-powered workflows, APIs, and teams.

Founded 2011.
Team size: Boutique indie team.

## The hard parts

- Low-level macOS Accessibility API and CGWindow API polling without draining CPU or battery
- Handling fragile macOS permissions (Screen Recording and Accessibility prompts)
- Querying exact document file paths from native browsers and office apps via AppleScript/JXA
- Maintaining second-by-second timeline state in a local SQLite database without disk bloat

## How to vibe code Timing

### Prerequisites

- Mac computer: Required to compile and run native macOS accessibility daemons
- Xcode (Free): Required for Swift development and native macOS app compilation
- Node.js (Free): Required for frontend web dashboard tooling if building a Tauri/web hybrid

### Recommended AI tools

- Cursor: Ideal for iterating on the frontend dashboard and reviewing Swift/TypeScript code diffs
- Claude Code: Best for scaffolding complex multi-file Tauri desktop bridges and SQLite data models

### Stack

- Frontend: Tailwind CSS + React (via Tauri web view)
- Backend: Rust (Tauri core background daemon + macOS Accessibility hooks)
- Database: SQLite (local application support directory)
- Auth: None (single-user personal local app)
- Payments: None (personal use)
- Other: Swift / AppleScript helper scripts for window polling, Anthropic API for AI activity summaries

### Hosting

- Cloudflare (Hosting optional web dashboard or sync backend if needed): $0/mo

### Build guide

1. **Scaffold Tauri macOS Desktop Shell** — Initialize a Tauri v2 project configured as a native macOS menubar and window utility, establishing the TypeScript frontend and Rust backend bridge.

```
Initialize a Tauri v2 project with a React and Tailwind CSS frontend template. Configure the project window to run as a macOS menubar utility app with a hidden dock icon. Set up the Rust backend entry point in `src-tauri/src/lib.rs` with basic Tauri command plumbing to communicate between the Swift/Rust layer and the React frontend. Ensure the build configuration targets macOS desktop distribution and includes necessary permissions for system tray management.
```

2. **Implement Native macOS Activity Polling Daemon** — Build a background Rust and Swift helper routine using the macOS Accessibility API and CGWindow API to capture active application names, window titles, and file paths every second.

```
Implement a background activity-polling daemon in Rust within the Tauri backend that executes every 1 second. Use macOS CoreGraphics APIs (CGWindowListCopyWindowInfo) and Accessibility APIs to query the currently active application bundle identifier, active window title, and document file path. Handle permission request flows gracefully when Accessibility access is not yet granted by the user. Ensure CPU consumption remains negligible (<0.5%) by throttling checks and caching unchanged window states.
```

3. **Local SQLite Storage & Idle Detection** — Configure a local SQLite database in the application support directory to persist second-by-second activity logs, alongside idle time detection based on user input inactivity.

```
Integrate rusqlite into the Tauri Rust backend to manage a local SQLite database stored in the macOS Application Support directory. Create tables for `activities` (id, app_name, window_title, file_path, url, start_time, end_time, duration, is_idle). Implement an idle-detection watcher using CGEventSourceSecondsSinceLastEventType to detect when the user steps away from the Mac, automatically closing active intervals and marking subsequent periods as idle time.
```

4. **Interactive Timeline & Project Categorization UI** — Build a React-based interactive visual timeline displaying 24-hour activity blocks, supporting drag-and-drop project assignment and option-drag rule creation.

```
Build a React component representing an interactive 24-hour visual timeline view. Render activity blocks grouped by application and project color codes. Implement drag-and-drop functionality to assign time blocks to custom projects. Add an option-drag modifier interaction that saves a matching rule (e.g., 'if window title contains X, assign to Project Y') into a `rules` table in SQLite so future activities auto-categorize.
```

5. **AI Activity Summaries & Exporting** — Connect the Anthropic API to generate natural language summaries of daily work patterns, and add report generation for CSV and JSON export.

```
Implement an AI summary feature in the Rust backend that aggregates the day's activity logs from SQLite, formats them into a structured text prompt, and calls the Anthropic API to generate a concise summary of what was accomplished and key productivity patterns. Build a reporting screen in React that displays total hours per project and provides export options for CSV and JSON format.
```

### Cost vs paying

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

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

**Ongoing costs (monthly):**

- Anthropic API usage for AI summaries: ~$2.00/mo
- Total: ~$2.00/mo

- Paying for the SaaS instead: $12.00/mo
- Build time: 40-60 hours
- AI tool credits: $20.00 (one-month Cursor/Claude subscription)
- Break-even: 2 months

## Sources

- [Timing App - Home Page](https://timingapp.com)
- [Timing App - Pricing Page](https://timingapp.com/pricing)
- [Timing App - Features Page](https://timingapp.com/features)