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

> Repurpose Audio or Video Content for Every Marketing Channel

- Site: https://swellai.com
- Category: Web app
- Verdict: **Solid side project** (62/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

You can build a solid personal-use clone of Swell AI for processing your own podcast episodes, but dealing with long-running media transcription queues and RAG chatbot pipelines will test your debugging patience.

Swell AI is a classic wrapper-plus-pipelines SaaS. The UI is straightforward dashboard CRUD, but the engineering meat is entirely asynchronous: accepting a massive podcast audio file, sending it to a transcription API, splitting the output, feeding chunks to LLMs with strict prompting templates, and building a vector search index for the episode chat. An AI coding agent will scaffold the Next.js frontend and basic database schema in an afternoon, but getting background job queues and the transcript clipping state management right requires careful iteration.

### What you can't replicate

- The exact user base and organic agency integrations
- Proprietary fine-tuned brand voice models accumulated over thousands of production runs

## What it does

AI-powered content repurposing platform that ingests long-form audio or video files and automatically generates transcripts, show notes, blog posts, newsletters, social assets, video clips, and RAG-powered episode chatbots.

### Core features

- Media ingestion via direct upload, YouTube links, and RSS feeds
- Automatic speech-to-text transcription with speaker diarization
- Interactive transcript viewer with clip selection and highlight timestamps
- AI text generation engine for show notes, blog posts, newsletters, and social copy
- Vector embeddings and RAG pipeline for conversational episode chat bots ('Swell Chat')
- Project dashboard to manage multi-episode catalogs and show branding
- Webhook and REST API system for automated content pipelines

## The business

### Pricing

- Hobby: $0/mo
- Studio: $29/mo
- Agency: $49/mo
- Pay-As-You-Go: $8.99

Founded 2023.
Team size: Very small team.

## The hard parts

- Handling large multi-gigabyte media uploads and managing background worker queues without timing out
- Synchronizing audio player playback states with precise timestamp highlights in a custom interactive text editor
- Chunking long transcripts, generating vector embeddings, and building a responsive RAG retrieval pipeline for episode chats
- Orchestrating multi-step LLM pipelines that format raw transcripts into structured templates (LinkedIn threads, long articles, show notes)

## How to vibe code Swell AI

### Prerequisites

- Node.js (free): Required runtime for Next.js development and package management
- GitHub (free): Source control and deployment pipeline integration
- OpenAI API Key (pay-as-you-go): Powers Whisper transcription and GPT-4o text generation pipelines

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding full-stack features, multi-file database models, and background processing logic
- Cursor: Ideal for fine-tuning the interactive transcript editor component and Tailwind UI layouts

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js App Router API routes with Inngest for background jobs
- Database: Supabase (PostgreSQL with pgvector for transcript embeddings)
- Auth: better-auth
- Payments: none
- Other: Vercel AI SDK, OpenAI API (Whisper + GPT), UploadThing

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints): $0-20/mo
- Supabase (Hosting PostgreSQL database, file storage buckets, and vector pgvector tables): $0/mo (Free tier)

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, shadcn/ui, better-auth, and Supabase client bindings including pgvector support.

```
Create a new Next.js project with App Router, TypeScript, and Tailwind CSS. Configure better-auth for local single-user or multi-user authentication using a Supabase PostgreSQL database. Write the database migration file using SQL to create tables for `podcasts`, `episodes` (with columns for title, audio_url, raw_transcript, duration, status), and `transcript_chunks` with a `vector(1536)` column for embeddings. Set up Drizzle ORM or Supabase JS client configuration in `lib/supabase.ts`. Ensure all environment variables are documented in `.env.example`. Test the database connection with a simple health check route.
```

2. **Media Ingestion & Transcription Pipeline** — Build file upload handling via UploadThing and a background transcription workflow using OpenAI Whisper API.

```
Implement a media upload component using UploadThing for handling audio and video files up to 500MB. When an upload completes, trigger an API route that creates an episode record with status `processing`. Call the OpenAI Whisper API (`v1/audio/transcriptions`) with timestamp granularities to retrieve verbatim speaker-labeled and timestamped transcript segments. Store the JSON transcript inside the `episodes` table and update the status to `completed`. Handle errors robustly with fallback retry states and display processing progress indicators in the UI.
```

3. **Interactive Transcript Editor & Clipping** — Create an interactive transcript dashboard where users can view timestamps, search text, and highlight clips.

```
Build a dashboard page in Next.js at `/episodes/[id]` featuring an HTML5 audio player on the left and a scrollable, synchronized transcript viewer on the right. Render transcript segments with speaker labels and timestamps. Clicking any transcript line must seek the audio player to that exact second. Add text selection functionality that lets users highlight a range of transcript text, click 'Create Clip', and save the snippet to a `clips` table linked to the episode. Include search filtering across transcript text.
```

4. **AI Content Generation Engine** — Implement automated generation of show notes, blog posts, newsletters, and social media posts using Vercel AI SDK and OpenAI.

```
Create a content generation panel within the episode view that includes a template selector (Show Notes, Blog Article, LinkedIn Post, Twitter Thread). Using the Vercel AI SDK (`ai` package) and OpenAI models, write server actions that take the episode's raw transcript, apply specific prompt engineering templates based on selected formats, and stream the generated markdown back to the UI. Provide an interface to edit the generated copy and export or copy it to the clipboard.
```

5. **RAG-Powered Episode Chat ('Swell Chat')** — Build a conversational vector search chatbot that answers questions based on individual episode content.

```
Implement the 'Swell Chat' feature for individual episodes. Upon episode transcription completion, chunk the transcript text, generate embeddings via OpenAI `text-embedding-3-small`, and store them in the `transcript_chunks` table linked to the episode ID. Build a chat interface component using `useChat` from the Vercel AI SDK. In the chat API route, take the user query, embed it, perform a vector similarity search (`cosine distance`) against the episode's chunks using Supabase pgvector, construct a prompt with the retrieved context, and stream the conversational answer back to the user interface.
```

6. **Dashboard Polish & RSS Import Support** — Add multi-show project management and podcast RSS feed ingestion support.

```
Build a multi-project dashboard where users can group episodes by podcast show. Implement an RSS feed parser utility using `rss-parser` that accepts a podcast RSS URL, lists recent episodes, and allows bulk importing of audio enclosure URLs into the database queue for automated transcription and content generation. Polish the overall Tailwind UI with consistent dark/light mode styling, loading skeletons, and notification toasts.
```

### Cost vs paying

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

- Domain name (optional): $12 one-time
- OpenAI API starting credits: $10 one-time
- Total: ~$22 one-time

**Ongoing costs (monthly):**

- Supabase DB & Storage: $0/mo
- Vercel Hosting: $0/mo
- OpenAI Whisper & GPT API usage (per uploaded hour): ~$0.15/hr
- Total: ~$3-10/mo depending on media volume

- Paying for the SaaS instead: $29/mo (Studio Plan)
- Build time: 25-35 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Pays for itself immediately if processing over 4 hours of audio per month compared to paid tiers, though built primarily for learning and personal customization.

## Sources

- [Swell AI Official Website](https://swellai.com)
- [Starter Story - How Cody Schneider Bootstrapped SwellAI](https://www.starterstory.com)