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

> Secure, simple & beautiful diary app

- Site: https://diarly.app
- Category: Productivity
- Platforms: macOS app, iOS app, iPadOS app, watchOS app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 3-5 weeks of focused coding

## Verdict

Build a simplified single-platform desktop/mobile subset or keep paying; the multi-device iCloud sync and native Apple polish across four form factors represent a significant engineering hurdle.

Replicating Diarly as a personal clone means committing to Swift and SwiftUI. While an AI coding agent can scaffold SwiftUI views and Markdown editors rapidly, you will burn significant time wrestling with CloudKit conflict resolution, local SQLite/SwiftData encryption layers, and matching the native feel of AppKit/UIKit across macOS and iOS. If you just want a journal, paying $2/mo is vastly more efficient; build this only if you want a deep Swift learning project.

### What you can't replicate

- The exact multi-device seamlessness of CloudKit out of the box without edge-case sync bugs
- First-party watchOS companion app integration
- Ecosystem hooks like Apple Journaling Suggestions and HealthKit without deep platform entitlements

## What it does

Secure, personal digital journaling and daily reflection application featuring a distraction-free Markdown editor, multimedia attachments, mood tracking, and cross-device sync via iCloud.

### Core features

- Distraction-free Markdown editor with custom typography and formatting
- Timeline, calendar, map, gallery, and table views for journal navigation
- Multimedia attachments (photos, videos, voice recordings, sketches)
- End-to-end encryption and biometric security (FaceID/TouchID)
- Mood tracking, habit streaks, and writing goals
- Templates, custom tags, and slash commands
- Cross-device synchronization

## The business

### Pricing

- Free: Free — Basic journaling with unlimited daily entries in a single journal, calendar/map views, and streaks.
- Diarly Premium (Annual): Less than $2/mo — Billed annually at less than $24/year with a 7-day free trial.

Founded 2018.
Team size: Small indie team.

## The hard parts

- Building a buttery-smooth native multi-platform Apple UI (Mac, iPad, iPhone, Apple Watch) using SwiftUI
- Implementing conflict-free, local-first data synchronization across devices via CloudKit/iCloud
- Client-side zero-knowledge end-to-end encryption combined with local search indexing
- Audio recording pipeline with transcription and multimedia asset management

## How to vibe code Diarly

### Prerequisites

- Mac: Required to run Xcode and build native Apple platform binaries
- Xcode (Free): The official IDE and compiler toolchain for SwiftUI and SwiftData development
- Apple Developer Account ($99/yr): Needed only if testing CloudKit container sync and iCloud capabilities on real physical devices
- Claude Code ($20/mo): Primary AI agentic coding assistant for scaffolding SwiftUI components and data layers

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for generating multi-file Swift and SwiftUI architectures from prompts
- Cursor: Ideal for fine-tuning individual SwiftUI views and reviewing code diffs interactively

### Stack

- Frontend: SwiftUI (Native macOS and iOS)
- Backend: Local-first SwiftData / CloudKit
- Database: SQLite via SwiftData (Local)
- Auth: Local Biometrics (LocalAuthentication framework / FaceID / TouchID)
- Payments: None (Personal use clone)
- Other: CloudKit for device synchronization, CoreLocation for map view, AVFoundation for audio recording

### Hosting

- CloudKit (Native zero-server cloud persistence and sync leveraging user's personal iCloud storage): $0/mo

### Build guide

1. **Project Scaffolding & SwiftData Local Schema** — Initialize a multiplatform SwiftUI app project in Xcode and define the core SwiftData models for Journal, Entry, Tag, and Mood.

```
Create a new multiplatform SwiftUI app structure supporting macOS and iOS. Define a SwiftData schema with Model classes: Journal (id, title, createdAt, themeColor), Entry (id, content, date, moodScore, journalId, tags), and Tag (id, name, color). Set up the main App lifecycle container to inject the ModelContainer with encryption configurations enabled. Ensure the models support clean JSON encoding and local persistence.
```

2. **Markdown Editor & Distraction-Free UI** — Build the core writing interface using SwiftUI TextEditor combined with a Markdown formatting toolbar and typewriting mode.

```
Build a SwiftUI writing view featuring a distraction-free TextEditor for Markdown composition. Implement a bottom formatting toolbar for quick markdown insertions (bold, lists, headings, timestamps, checklists). Add a toggleable 'zen mode' that hides sidebar navigation and maximizes text canvas width. Include auto-save debouncing logic so entries persist to SwiftData instantaneously as the user types.
```

3. **Timeline & Calendar Navigation Views** — Implement multiple organizational views allowing users to navigate entries by calendar dates, timeline scrolls, and tag filters.

```
Create a navigation sidebar in SwiftUI with views for Timeline, Calendar, and Gallery. The Timeline view should group entries chronologically by day with custom time separators. The Calendar view should use UICalendarView or custom grid representations highlighting dates that contain journal entries. Implement tag-based filtering logic and a search bar that queries entry content matching search strings.
```

4. **Multimedia & Voice Recording Integration** — Add support for attaching images from the photo library and recording audio notes using AVFoundation.

```
Implement multimedia attachment capabilities within entries. Allow users to pick photos from the photo library and display them in a responsive thumbnail grid. Integrate AVFoundation to build an audio recorder view that records voice notes, saves audio files to the local app documents directory, and embeds playback controllers directly inside the journal entry view.
```

5. **Biometric Security & End-to-End Encryption** — Secure the application with LocalAuthentication (FaceID/TouchID) and encrypt local database fields.

```
Implement app lock functionality using the LocalAuthentication framework for FaceID and TouchID biometric verification upon app launch and backgrounding. Implement a secure encryption wrapper for sensitive entry text fields using Keychain-backed keys and AES-GCM encryption before storing strings into SwiftData storage.
```

6. **CloudKit Synchronization Setup** — Configure iCloud and CloudKit container settings to synchronize SwiftData models across user devices.

```
Configure the SwiftData ModelConfiguration to leverage CloudKit sync for multiplatform targets. Handle CloudKit container entitlements, persistent history tracking, and merge conflict resolution policies. Add a status indicator in the UI displaying sync state (synced, syncing, offline).
```

### Cost vs paying

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

- Apple Developer Account (required for CloudKit testing): $99/yr
- AI Coding Subscriptions: $20
- Total: ~$119 one-time (optional developer account)

**Ongoing costs (monthly):**

- iCloud Storage (User's own storage): $0/mo
- Total: $0/mo

- Paying for the SaaS instead: $2/mo (<$24/yr)
- Build time: 40-60 hours
- AI tool credits: $20 (Claude Code / Cursor 1-month subscription)
- Break-even: Never (paying $2/mo is much cheaper than the $99 developer fee and your time, build only for learning)

## Sources

- [Diarly Official Website](https://diarly.app)
- [Diarly Pricing Page](https://diarly.app/pricing)
- [Descargatic - Diarly App Technical Overview](https://descargatic.com/en/diarly/)