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

> Your inbox for reading, watching and listening

- Site: https://reederapp.com
- Category: Content Aggregator & Reader
- Platforms: macOS app, iOS app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 3-4 weeks of serious part-time development

## Verdict

Build a personal SwiftUI client if you want a native Mac/iOS weekend project, but you will spend weeks debugging CloudKit sync and feed parsing edge cases.

Reeder is an aggressively native Apple application. While an AI coding agent can scaffold SwiftUI views and feed parsers rapidly, syncing continuous scroll position state via CloudKit across devices without race conditions is a painful debugging sinkhole. Furthermore, parsing a sprawling variety of malformed RSS feeds, Atom formats, and YouTube endpoints locally on-device requires endless edge-case handling. Because it is a $10/year app with zero ads and pristine design, paying the developer is the rational choice unless building native Swift apps is your hobby.

### What you can't replicate

- The 15-year brand heritage and intuitive native feel
- Exact muscle memory of the original UI interactions

## What it does

A multi-source content aggregator and inbox for RSS feeds, YouTube channels, podcasts, and social media posts with timeline syncing and shared feeds.

### Core features

- Unified timeline aggregating RSS, YouTube, podcasts, and links
- Scroll-position synchronization across devices via CloudKit
- On-device feed parsing and sanitization
- Custom timeline filters by keywords, media types, and sources
- Native share extension for saving links from Safari and other apps
- Shared public JSON feeds hosted on custom infrastructure
- Fluid native SwiftUI list rendering and swipe gestures

## The business

### Pricing

- Monthly: $1.00 / mo — Full access across all Apple devices
- Annual: $10.00 / yr — Full access with annual discount

Founded 2009.
Team size: Solo developer.

## The hard parts

- Implementing fine-grained, continuous scroll-position sync over CloudKit without database bloat or conflict loops
- Robust client-side feed parsing handling broken RSS/Atom feeds, YouTube API quotas, and podcast enclosures
- Achieving buttery-smooth 120fps native SwiftUI performance across mixed-media timelines on macOS and iOS

## How to vibe code Reeder

### Prerequisites

- macOS & Xcode (Free): Required for compiling and running native SwiftUI applications for macOS and iOS
- Apple Developer Account ($99/yr): Required for configuring CloudKit containers and provisioning push notifications or device sync
- Cursor (Free tier / $20/mo Pro): AI-assisted Swift editor for iterating on SwiftUI views and data models

### Recommended AI tools

- Cursor: Best code editor for prompting and editing native Swift/SwiftUI multi-file architectures
- Claude Code: Terminal agent capable of running local builds, managing git, and debugging Swift compiler errors

### Stack

- Frontend: SwiftUI (Native macOS 14+ / iOS 17+)
- Backend: CloudKit / Local SQLite (SwiftData)
- Database: SwiftData (Local on-device persistence)
- Auth: Apple iCloud Account (CloudKit Identity)
- Payments: StoreKit 2 (In-App Purchases)
- Other: FeedKit (Swift RSS/Atom parsing library), Share Extension (System extension for link capture)

### Hosting

- Cloudflare (Hosts the lightweight reederapp.net JSON feed exporter and public tag endpoints): $0/mo

### Build guide

1. **Project Scaffolding & Core Data Models** — Initialize a multiplatform SwiftUI project structure for macOS and iOS using SwiftData for local persistence.

```
Create a new multiplatform SwiftUI project structure targeting macOS 14+ and iOS 17+. Set up SwiftData models for Feed, Article, MediaItem, and TimelinePosition. Define fields for item ID, title, URL, contentSnippet, publishedDate, mediaType (rss, youtube, podcast, link), readStatus, and continuousScrollOffset. Ensure models support CloudKit synchronization containers out of the box. Implement a clean MVVM or observable architecture where view models query SwiftData stores efficiently with predicate filtering for tags and sources.
```

2. **Feed Parser & On-Demand Fetching Engine** — Implement robust XML/JSON parsing for RSS, Atom, and JSON feeds using Swift concurrency.

```
Implement an asynchronous FeedParser service in Swift using URLSession and XMLParser (or SwiftSoup/FeedKit equivalent if allowed via SPM). The parser must gracefully handle malformed RSS 2.0 and Atom feeds, extract enclosures (podcasts, YouTube video links), sanitize HTML content strings, and handle network timeouts or HTTP error codes. Write background task triggers that periodically fetch new items for subscribed feeds, updating SwiftData asynchronously without blocking the main thread UI.
```

3. **Unified Timeline UI & Smooth Scrolling** — Build a responsive native timeline list supporting variable media types, thumbnails, and scroll position tracking.

```
Build a high-performance SwiftUI unified timeline view using LazyVStack or List optimized for both macOS sidebar navigation and iOS compact/split views. Each row must dynamically render content based on media type (article excerpt, YouTube thumbnail preview, podcast play button). Implement continuous scroll-position tracking that records the exact visible item ID and fractional offset, persisting it locally and queuing it for CloudKit sync on scroll deceleration.
```

4. **CloudKit Scroll Position & Metadata Sync** — Configure CloudKit record zones to synchronize timeline position, starred items, and subscriptions across devices.

```
Integrate CloudKit container syncing for user metadata. Synchronize feed subscriptions, tag mappings, favorites, and most importantly, the latest continuous scroll position markers across devices. Implement conflict resolution logic favoring the most recent timestamp to prevent sync loops when switching rapidly between an iPhone and Mac. Handle network disconnects gracefully with local queueing and automatic retries.
```

5. **Share Extension & External Link Capture** — Create a native share extension enabling users to send links from Safari and other apps directly into the reader.

```
Add an iOS and macOS Share Extension target to the project. The extension UI must allow users to select tags or folders, extract URLs and page titles from sharing context, and save them into the shared SwiftData container or push them directly to CloudKit so they appear instantly in the app's 'Links' timeline. Ensure app group containers are properly configured for data sharing between the main app and extension.
```

6. **Shared JSON Feeds & Edge Export** — Build a lightweight Cloudflare Worker endpoint to export public tag collections as JSON feeds.

```
Create a Cloudflare Worker project using TypeScript and Workers KV or D1 to handle public shared feeds. Implement an endpoint structure (/feed/[tagId]) that accepts exported tag structures from the client app and renders them as standard JSON Feeds (jsonfeed.org format) with proper CORS headers and caching rules. Write documentation and testing scripts to verify that external RSS readers can ingest these generated endpoints.
```

### Cost vs paying

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

- Apple Developer Account (required for CloudKit/Provisioning): $99/yr
- Total: $99 one-time/year

**Ongoing costs (monthly):**

- Cloudflare Workers (Shared feed hosting): $0/mo
- Total: $0/mo

- Paying for the SaaS instead: $1.00 / mo ($10/yr)
- Build time: 40-60 hours
- AI tool credits: $20 (Cursor Pro)
- Break-even: Never (paying $10/year is vastly cheaper than the Apple Developer fee)

## Sources

- [Reeder Official Website](https://reederapp.com)
- [Reeder Help & Documentation](https://reeder.app)