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

> AI-powered short-form video operations platform for social media growth

- Site: https://ghostfeed.ai
- Category: SaaS / AI Content Automation
- Verdict: **Serious undertaking** (42/100 vibecodeable)
- Estimated effort: 6+ weeks of full-time engineering

## Verdict

Build a simplified personal video generation dashboard with local media queues, or keep paying if you need production-scale UGC automation.

Ghostfeed combines heavy asynchronous media generation pipelines, human approval checkpoints, and an MCP server that lets coding agents drive workspaces natively. While you can stitch together Next.js, Turso, and Fal.ai or Luma for the core video generation loop, building a resilient state machine that handles multi-step AI model orchestration, video frame stitching, and an MCP auth bridge requires substantial backend plumbing.

### What you can't replicate

- The proprietary reaction library and verified high-performing content templates
- The managed infrastructure running real US devices and warmed accounts

## What it does

An automated platform for generating short-form video content at scale—specializing in UGC reactions, slideshow carousels, AI avatar creation, and agentic workflows via a Model Context Protocol (MCP) server.

### Core features

- UGC reaction video cloner with split-scene frame analysis
- Product slideshow and image carousel automatic generator
- AI influencer face and character swap pipeline
- Streamable HTTP MCP (Model Context Protocol) server for coding agent workspace control
- Durable multi-step job state machine with backpressure and failure classification
- Timeline editing canvas for fine-tuning video frames and slides
- Multi-account content scheduling and distribution calendar

## The business

### Pricing

- Free: $0/mo
- Starter: $29/mo
- Growth: $49/mo
- Agency: $99/mo
Team size: Small bootstrap team (~2 engineers).

## The hard parts

- Orchestrating multi-step async video generation pipelines (Kling, Grok, vision frames) with robust retries and idempotency
- Implementing an MCP server with OAuth 2.1 / PKCE auth supporting dynamic agent interaction
- Handling human-in-the-loop approval gates before expensive video animation runs
- Managing complex media storage, video rendering concurrency, and rate-limiting

## How to vibe code Ghostfeed

### Prerequisites

- Node.js (free): Required for running the Next.js framework and backend workers.
- GitHub (free): Code repository hosting and deployment pipelines.
- Fal.ai Account (Usage-based): API access for fast image generation and video model inference.

### Recommended AI tools

- Claude Code: Best-in-class multi-file agentic coding tool for scaffolding complex full-stack pipelines and MCP endpoints.
- Cursor: Ideal for iterative UI work on the timeline editing canvas and interactive components.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui components
- Backend: Next.js API routes paired with a durable background worker queue (Inngest)
- Database: Turso (SQLite at the edge) for relational data and job states
- Auth: better-auth for self-hosted TypeScript authentication
- Payments: Stripe (optional for local personal clones)
- Other: Vercel AI SDK for LLM orchestration, fal.ai API for video/image generation, Cloudflare R2 for asset storage

### Hosting

- Vercel (Hosting the Next.js web application and API routes): $0-20/mo
- Fly.io (Running long-lived background job workers and the custom MCP server daemon): $5-10/mo
- Cloudflare (R2 Object Storage for rendered video clips and image assets): $0-5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS, configure better-auth with SQLite via Turso, and set up core tables for workspaces, projects, generation jobs, and asset lineages.

```
Scaffold a new Next.js project configured with TypeScript, Tailwind CSS, and better-auth. Set up Turso database connectivity using libSQL. Create database migrations and models for: workspaces, projects, jobs (with state machine fields: status, input_version, model_settings, cost, error_reason), assets, and lineage (parent-child relationships). Ensure robust error logging and environment configuration are in place.
```

2. **Durable Job Queue & State Machine** — Implement a durable background worker engine using Inngest or a custom worker state machine to manage multi-step generation pipelines with retry logic and idempotency.

```
Build a durable background job execution framework using Inngest or a reliable state machine. Implement explicit state transitions for video and slideshow generation: brief -> scripted -> frame_generating -> frame_review -> approved_for_animation -> animating -> motion_qc -> assembly -> final_review. Ensure every transition records job ID, asset IDs, provider request payloads, timestamps, and failure reasons to prevent double-billing or duplicate asset processing.
```

3. **AI Media Generation & Approval Gates** — Integrate third-party frontier media APIs (fal.ai / Luma) to handle image creation, frame generation, and video animation, incorporating a mandatory human-in-the-loop review gate.

```
Integrate fal.ai and Luma video generation APIs into the backend pipeline. Build a modular service layer that submits generation requests, polls job statuses, handles webhooks or retries, and stores output files directly into Cloudflare R2 storage. Implement a review gate workflow where frame generation pauses for manual user approval before triggering the expensive animation step.
```

4. **Model Context Protocol (MCP) Server Integration** — Build a Streamable HTTP MCP server supporting OAuth 2.1 and PKCE to expose workspace controls and generation pipelines to external AI agents like Claude Code and Cursor.

```
Implement a Streamable HTTP Model Context Protocol (MCP) server endpoint at /api/v2/mcp within the Next.js backend. Add support for OAuth 2.1 with PKCE authentication connected to user workspace grants. Expose MCP tools allowing external coding agents (such as Claude Code and Cursor) to list workspaces, create generation jobs, check job statuses, and retrieve asset URLs programmatically.
```

5. **Dashboard UI & Timeline Editing Canvas** — Create the frontend dashboard, workspace switcher, slideshow project creator, and a timeline canvas for fine-tuning video frames and text overlays.

```
Build a responsive Next.js dashboard using shadcn/ui. Implement workspace management, a slideshow carousel generator view, a reaction library browser, and an interactive timeline canvas component for fine-tuning slides and video frames. Connect the UI components to backend API routes with real-time status updates reflecting job queue progression.
```

6. **Scheduling & Distribution Pipeline** — Implement content scheduling calendar views and platform integration hooks for publishing approved video assets.

```
Build a calendar-based scheduling interface within the dashboard allowing users to queue approved video assets for distribution. Implement backend cron tasks or scheduled jobs that track posting times and simulate distribution workflows, preparing assets for multi-platform export with proper compliance and safety checks.
```

### Cost vs paying

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

- Domain registration: $12 one-time
- Initial API credits (fal.ai / Luma): $25 one-time
- Total: ~$37 one-time

**Ongoing costs (monthly):**

- Hosting & Infrastructure (Vercel + Fly.io + Cloudflare R2): $15/mo
- AI Model Generation Usage (fal.ai / LLM APIs): $20/mo
- Total: ~$35/mo

- Paying for the SaaS instead: $49/mo (Growth tier)
- Build time: 45-60 hours
- AI tool credits: $20/mo (Claude Pro)
- Break-even: Comparable to paid tiers, but built for learning and personal customization rather than cost savings.

## Sources

- [Ghostfeed Homepage & Pricing Structure](https://ghostfeed.ai)
- [Ghostfeed Documentation: Quickstart & MCP API v5.17.1](https://ghostfeed.ai)
- [Ghostfeed Blog: How to Scale AI UGC Without Making 500 Videos of Garbage](https://ghostfeed.ai)