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

> AI-powered photo post-processing and delivery platform for professional photographers

- Site: https://aftershoot.com
- Category: Photography SaaS
- Platforms: macOS app, Windows app, Web app
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 6+ months of full-time work

## Verdict

Build a simplified web-based prototype or keep paying, because local RAW multi-threaded rendering and offline vision models are a massive engineering hurdle for a solo dev.

Replicating Aftershoot requires writing a high-performance desktop wrapper that handles heavy proprietary RAW files (CR3, NEF, ARW) and executes local computer vision models without crashing the user's GPU. While a web-based MVP can process standard JPEGs, matching the local offline speed, non-destructive XMP sidecar generation, and complex AI style-transfer training pipeline of Aftershoot is an immense undertaking that will consume months of painful low-level debugging.

### What you can't replicate

- The years of model fine-tuning on billions of professional RAW photos
- Optimized native cross-platform rendering pipelines for massive image libraries
- Instant hardware-accelerated batch inference across varied GPU architectures

## What it does

Aftershoot is an end-to-end desktop and web platform that automates photo culling, batch editing using AI profiles, portrait retouching, and branded client gallery delivery.

### Core features

- Local multi-threaded RAW image decoding (CR3, NEF, ARW)
- Offline local computer vision inference (blur, blink, face detection)
- Non-destructive XMP sidecar rating and tagging engine
- AI style-transfer regression pipeline mapping presets to photo batches
- Batch portrait retouching on raw image data
- Branded client delivery web gallery with face search

## The business

### Pricing

- Aftershoot Complete: $45/mo
- Select: $10/mo
- Edit: $30/mo
- Retouch: $20/mo

### Funding

$240K raised.
- Pre-Seed (April 2021)
- Seed (May 2021)
Investors: Techstars, TDV Partners

Founded 2020.
Team size: 130+.

## The hard parts

- Parsing 30–60MB proprietary RAW files locally without memory bloat or crashing
- Packaging and running hardware-accelerated computer vision models (Metal/CUDA) offline
- Writing accurate non-destructive XMP sidecars compatible with Lightroom
- Training custom regression weights locally to mimic arbitrary Lightroom presets

## How to vibe code Aftershoot

### Prerequisites

- Node.js (free): Required for running the Tauri/Electron desktop wrapper and build tooling
- Rust (free): Required for Tauri desktop backend and fast RAW image parsing bindings
- GitHub (free): Source control and repository hosting

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding complex desktop application architecture and debugging native bindings.
- Cursor: Ideal for fine-tuning UI components and managing multi-file desktop frontend states.

### Stack

- Frontend: React with Tailwind CSS inside a Tauri desktop container
- Backend: Rust (Tauri core) + Python sidecar for computer vision inference
- Database: SQLite (local embedded database for photo metadata and ratings)
- Auth: None (local-first personal application)
- Payments: None (personal use clone)
- Other: OpenCV / ONNX Runtime for local computer vision inference, LibRaw for multi-threaded RAW image decoding

### Hosting

- Cloudflare (Hosting optional web client gallery components and update manifests): $0/mo

### Build guide

1. **Desktop Shell & RAW Ingestion Pipeline** — Initialize a Tauri desktop application with a React and Tailwind CSS frontend. Implement a local file-system ingestion pipeline utilizing Rust bindings and LibRaw to parse 30-60MB proprietary RAW files (CR3, NEF, ARW) and generate low-res proxy previews asynchronously without locking the UI main thread.

```
Initialize a Tauri v2 desktop project using React, Vite, and Tailwind CSS. Create a native file-system importer component that accepts folders of raw image files. Write a robust Rust command module using LibRaw or equivalent fast decoding bindings to parse camera metadata (EXIF) and render low-resolution JPEG previews into a local application cache directory. Ensure the UI remains responsive during batch imports of 500+ raw files, displaying a real-time progress bar and memory usage metrics.
```

2. **Local Computer Vision Culling Engine** — Bundle an embedded Python runtime or ONNX Runtime executing lightweight computer vision models locally to evaluate images for blur, closed eyes, and exact duplicate framing.

```
Build an offline computer vision module using ONNX Runtime and lightweight models packaged inside the Tauri app bundle. Implement functions to analyze decoded image frames for sharpness (Laplacian variance), face detection with eye closure classification, and structural similarity (SSIM) grouping for duplicate sequence detection. Expose these functions to the frontend via Tauri IPC commands so users can trigger an automated culling pass across imported photo batches.
```

3. **Non-Destructive XMP Sidecar Manager** — Implement rating, color labeling, and metadata modification logic that writes directly to XMP sidecar files alongside original RAW assets without altering source files.

```
Develop a metadata management service in Rust/TypeScript that reads and writes XMP sidecar files matching professional photography standards (compatible with Lightroom). When a user applies ratings, rejects, or color labels in the grid or loupe view, atomically update or create the corresponding .xmp file in the source directory. Ensure original RAW files remain strictly untouched (non-destructive workflow).
```

4. **Grid, Loupe, and Survey Review UI** — Build high-performance photo review interfaces including a virtualized grid view, a loupe zoom inspector, a spray-can rating tool, and a multi-image survey comparison mode.

```
Create a high-performance photo review workspace in React. Implement a virtualized grid view capable of rendering thousands of cached proxy thumbnails smoothly. Build a Loupe view with pan/zoom inspection, a Survey mode for side-by-side duplicate comparison, and a Spray Can tool that applies batch ratings instantly on keystroke. Handle keyboard shortcuts for fast culling workflows (1-5 stars, pick/reject flags).
```

5. **AI Style-Transfer and Preset Mapping Pipeline** — Construct a local parameter adjustment engine that parses user-imported Lightroom presets or reference edits, mapping exposure, contrast, and color curves across batch image arrays.

```
Implement an AI editing module that reads user-imported Lightroom XMP presets or paired folders of unedited RAWs and final edited JPEGs. Build a lightweight regression or style-mapping pipeline that calculates delta adjustments for exposure, white balance, tone curves, and HSL parameters, applying consistent adjustments across an entire photo batch while maintaining local offline execution.
```

6. **Batch Portrait Retouching Engine** — Integrate local image processing routines for skin smoothing, stray hair reduction, and background touch-ups directly on raw raster data prior to export.

```
Integrate an offline portrait retouching routine using local image processing libraries (OpenCV / custom segmentation weights). Detect faces and skin regions to perform automated blemish removal, skin smoothing, and stray hair cleanup. Provide a master sync toggle allowing adjustments made to a reference portrait to intelligently scale across an entire event batch.
```

7. **Export and Delivery Preparation Module** — Build a flexible export engine supporting custom naming conventions, resizing, watermarking, and color space conversions (sRGB, AdobeRGB) directly to local storage.

```
Build an export dialog and pipeline supporting custom file naming templates, destination folder selection, sizing constraints, format conversion (JPEG/TIFF/PNG), color space embedding (sRGB/AdobeRGB), and optional text/image watermarking. Process exports in a multi-threaded worker queue to maximize CPU/GPU utilization without blocking the application UI.
```

### Cost vs paying

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

- AI Coding Assistant Subscriptions (Claude Pro / Cursor): $40
- Total: $40 one-time

**Ongoing costs (monthly):**

- Total: $0/mo

- Paying for the SaaS instead: $45/mo
- Build time: 120-160 hours
- AI tool credits: $40
- Break-even: 1 month of Aftershoot Complete

## Sources

- [Aftershoot Official Website](https://aftershoot.com)
- [Aftershoot Pricing & Modular Plan Breakdown](https://aftershoot.com/blog/aftershoot-pricing-built-for-how-you-work)