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

> Save recipes from anywhere

- Site: https://pestlechef.app
- Category: Productivity
- Platforms: iOS app, iPadOS app, macOS app, watchOS app, visionOS app
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 3-6 months of focused part-time work

## Verdict

Build a simplified web or single-platform subset, or keep paying for Pestle; replicating a polished 5-platform native Apple app suite with offline ML parsing and real-time household sync requires months of platform-specific engineering.

Pestle is an exquisite indie masterclass in SwiftUI and Apple ecosystem integration. While a solo developer can build a single-platform web clone or a rudimentary SwiftUI wrapper in a few weeks using AI coding tools, recreating the seamless cross-device CloudKit sync, watchOS companion apps, Dynamic Island live activities, and resilient recipe extraction from chaotic web pages across five Apple form factors is a massive multi-month undertaking. AI coding agents struggle heavily with SwiftUI layout bugs, native concurrency edge cases in CloudKit, and brittle DOM scrapers.

### What you can't replicate

- The exact zero-latency native feel across iPhone, iPad, Mac, Apple Watch, and Vision Pro
- Pestle's organic app-store presence and active user base

## What it does

An AI-powered digital recipe manager and cooking assistant designed to clean up modern cooking websites, social media videos, and paper cards.

### Core features

- Universal recipe extraction from web URLs and social media captions
- Portion scaling engine with fraction and qualitative unit handling
- Metric and Imperial unit conversion
- Weekly meal planning calendar grid
- Consolidated shopping list with ingredient deduplication
- Guided hands-free cooking mode with timers
- Multi-device sync via CloudKit
- Household sharing and collaborative recipe edits

## The business

### Pricing

- Free: Free
- Pestle Pro: $24.99/yr

Founded 2021.
Team size: 1.

## The hard parts

- Parsing brittle, non-standard recipe web layouts and unstructured social media captions locally
- Synchronizing recipe and meal plan edits across multiple Apple ecosystem devices with CloudKit conflict resolution
- Implementing native Apple features like Dynamic Island, Live Activities, and WatchOS complications in SwiftUI
- Handling fuzzy scaling math for non-linear ingredients ('pinch', 'to taste', qualitative ranges)

## How to vibe code Pestle

### Prerequisites

- Mac: Required for compiling and running Xcode and SwiftUI target builds.
- Xcode (Free): Integrated development environment for building native Apple ecosystem applications.
- Apple Developer Account ($99/yr): Required to test on physical devices, enable CloudKit capabilities, and distribute native apps.
- Cursor (Free tier): AI-native code editor for writing SwiftUI views and Swift backend parsing logic.

### Recommended AI tools

- Cursor: Best code editor for iterative SwiftUI component construction and multi-file Swift project management.
- Claude Code: Terminal agent excellent for scaffolding data models, setting up Swift parser structs, and refactoring project architecture.

### Stack

- Frontend: Swift / SwiftUI (Native iOS, iPadOS, macOS, watchOS)
- Backend: Local SwiftData persistence with CloudKit container sync
- Database: SwiftData (Local SQLite abstraction)
- Auth: Apple Sign-In / iCloud Account ID
- Payments: StoreKit 2 (In-App Purchases)
- Other: NaturalLanguage / CoreML framework for text processing, Gemini API for web recipe scraping fallback parsing

### Hosting

- CloudKit (Native Apple cloud storage and database backend for syncing user recipes and households across devices with zero server management.): $0/mo

### Build guide

1. **Project Scaffolding & Data Model Architecture** — Initialize a multi-platform SwiftUI project in Xcode and define the core SwiftData models for Recipes, Ingredients, Steps, and MealPlans.

```
Create a new multiplatform SwiftUI app structure supporting iOS, iPadOS, and macOS. Set up SwiftData models for Recipe (title, sourceURL, prepTime, cookTime, servings, notes), Ingredient (name, amount, unit, category), InstructionStep (stepNumber, text), and MealPlanItem (date, mealType, recipeID). Ensure all models conform to PersistentModel with appropriate relationships. Write robust unit tests for fraction scaling logic on ingredients, ensuring qualitative units like 'pinch' or 'to taste' do not break multiplier arithmetic when scaling servings up or down.
```

2. **Recipe URL Scraper & Parsing Engine** — Implement a web scraper that fetches recipe page HTML, extracts JSON-LD recipe schema data, and falls back to an AI API parser for unstructured pages.

```
Build a Swift service class called `RecipeParserService` that takes a URL string, fetches the page HTML using URLSession, and parses it. First, look for `<script type="application/ld+json">` blocks containing schema.org/Recipe data to extract title, ingredients, and instructions reliably. If JSON-LD is missing or fails, extract the raw article text and send it to the Gemini API using structured JSON output mode to extract the exact same recipe schema. Return a fully populated Recipe model object ready for local storage insertion.
```

3. **Recipe Library & Detailed SwiftUI Views** — Build the main recipe list interface, card views, search filtering, and a clean reading view with unit conversion toggles.

```
Design and implement the SwiftUI views for the recipe library. Create a responsive Grid/List layout with search filtering by title and ingredient. Build a dedicated RecipeDetailView featuring an ingredient scaling stepper (dynamically recalculating amounts from base servings), a unit conversion toggle button (switching between Metric grams/ml and Imperial ounces/cups on the fly), and a clean instruction checklist view where completed steps can be ticked off.
```

4. **Guided Hands-Free Cooking & Timer Integration** — Create an immersive cooking mode view with large text, voice command placeholders, and interactive timer chips parsed from step text.

```
Build a full-screen SwiftUI `CookingModeView` optimized for tablets and phones in the kitchen. The view should present one step at a time in large, legible typography with prominent Next/Previous controls. Implement a regex parser inside instruction text that automatically detects time durations (e.g., 'simmer for 20 minutes', 'bake for 15 mins') and renders interactive countdown timer pills that users can tap to start live system notifications and Live Activities.
```

5. **Meal Planner & Automated Shopping List Aggregator** — Develop a weekly calendar grid for meal planning and an aggregator engine that compiles and deduplicates shopping list items.

```
Implement a weekly calendar grid view (`MealPlannerView`) allowing users to assign recipes to breakfast, lunch, or dinner slots for any day of the week. Build an accompanying `ShoppingListService` that aggregates all ingredients from recipes scheduled in the current week's meal plan, intelligently deduplicates identical ingredients (e.g., combining '2 cloves garlic' and '3 cloves garlic' into '5 cloves garlic'), groups them by supermarket category (Produce, Pantry, Dairy), and presents them in a checkable shopping list view.
```

6. **CloudKit Sync & Household Sharing** — Configure CloudKit container entitlements and background sync so recipes and meal plans sync seamlessly across user devices and shared household accounts.

```
Configure SwiftData to use a CloudKit container sharing setup for multi-device synchronization. Implement a `HouseholdSharingService` that allows users to share a CloudKit share record via Apple's standard UIActivityViewController or ShareSheet. Handle incoming share invitations so that invited family members can read, edit, and add recipes and meal plans to the shared household database in real time with proper conflict resolution.
```

7. **StoreKit 2 Monetization & Paywall** — Integrate StoreKit 2 subscriptions and lifetime purchases to gate unlimited recipe storage and household features behind a paywall.

```
Implement an in-app purchase manager using StoreKit 2 (`StoreKitManager`) supporting an annual subscription ($24.99/yr) and a lifetime buyout ($59.99). Build a clean SwiftUI PaywallView that triggers when free users attempt to save their 16th recipe or create a household. Handle purchase verification, trial periods, restoration of purchases, and expose an `@Observable` entitlement status across the app to unlock Pro features.
```

### Cost vs paying

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

- Apple Developer Program Membership: $99/yr
- AI Coding Assistant Subscription: $20
- Total: $119 one-time/annual

**Ongoing costs (monthly):**

- Gemini API credits for fallback recipe web scraping: ~$2/mo
- Total: ~$2/mo

- Paying for the SaaS instead: $2.08/mo ($24.99/yr)
- Build time: 80-120 hours
- AI tool credits: $20 (1 month of Cursor/Claude Pro)
- Break-even: Never (paying $24.99/yr is vastly cheaper than the $99 Apple developer fee and 100+ hours of development time)

## Sources

- [Pestle Official Website & Pricing](https://pestlechef.app)
- [9to5Mac Indie App Spotlight on Pestle 2.0](https://9to5mac.com)