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

> Create Studio-Quality Visuals with AI

- Site: https://pixelcut.ai
- Category: AI Photo & Video Editor
- Platforms: Web app, iOS app, Android app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 4-6 weeks of part-time work

## Verdict

Build a personal web-based studio subset with direct API wrappers, but keep paying if you need the mobile apps and multi-model video router.

Cloning Pixelcut for personal use means deciding whether to rebuild proprietary background removal models or wrap APIs like fal.ai and Runway. A solo developer can assemble a Next.js web application that calls fal.ai for image generation, Flux for background swapping, and a server-side queue for batch processing. However, maintaining parity with native iOS/Android camera workflows, handling dozens of third-party video generation webhooks, and implementing a robust credit accounting system represents a substantial engineering load that will take weeks of frustrating integration work.

### What you can't replicate

- Proprietary low-latency computer vision models for instant background cutting
- Deep cross-platform ecosystem across iOS, Android, and Web
- Enterprise agreements and volume pricing tiers with frontier video model providers

## What it does

An AI-powered photo and video editing platform tailored for e-commerce sellers, creators, and marketers, featuring instant background removal, generative fill, AI product showcase scenes, and video generation.

### Core features

- Instant background removal for images and videos
- AI background generation and Product Showcase framing
- Image upscaling and uncropping
- Magic eraser and generative fill retouching
- Batch editing pipeline for multiple files
- Model router connecting to frontier image and video generators
- Cross-platform sync (Web, iOS, Android)

## The business

### Pricing

- Free: $0/mo
- Pro: $10/mo
- Business: $30/mo

Founded 2020.
Team size: Unknown.

## The hard parts

- Orchestrating dozens of third-party video and image generation APIs under a unified credit ledger
- Building a responsive cross-platform canvas UI with touch and mouse support for cropping and masking
- Handling asynchronous webhooks and polling queues for heavy video generation models (Sora, Kling, Veo)
- Processing bulk background removal and transformations asynchronously at scale

## How to vibe code Pixelcut

### Prerequisites

- Node.js (Free): Runtime for building the Next.js full-stack web application.
- GitHub (Free): Source code repository and CI/CD integration.
- fal.ai API Account (Pay-as-you-go (~$10 starting credit)): Provides fast, low-cost image generation and background removal model endpoints.

### Recommended AI tools

- Claude Code: Best-in-class coding agent for scaffolding multi-file Next.js apps, setting up API routes, and wiring model integrations.
- Cursor: Ideal for fine-tuning the interactive canvas UI and styling components with Tailwind CSS.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions & API Routes
- Database: Turso
- Auth: better-auth
- Payments: Stripe
- Other: Vercel AI SDK, fal.ai API, Cloudflare R2

### Hosting

- Vercel (Hosting the Next.js web application and serverless endpoints.): $0-20/mo
- Cloudflare (Using R2 object storage for storing uploaded product images and exported visuals.): $0-5/mo

### Build guide

1. **Project Scaffolding & Database Setup** — Initialize the Next.js project with Tailwind CSS, configure Turso for database storage, and set up better-auth.

```
Create a new Next.js project with Tailwind CSS, TypeScript, and App Router. Set up better-auth using Turso as the database provider with tables for users, projects, and asset generations. Include environment variable configurations for database connection strings and auth secrets. Implement a clean layout with a sidebar navigation shell for Dashboard, Studio, Batch Editor, and Settings.
```

2. **Image Upload & Storage Pipeline** — Build an image upload interface connected to Cloudflare R2 object storage for handling product photos.

```
Build an image upload component and API route in Next.js that accepts product photos (PNG/JPG up to 20MB) and securely uploads them to Cloudflare R2 using S3-compatible credentials. Store the resulting asset URLs in Turso linked to the authenticated user ID. Add client-side drag-and-drop support, upload progress indicators, and an asset gallery view displaying uploaded product shots.
```

3. **Background Removal & AI Editing Integration** — Integrate fal.ai endpoints for background removal and image generation tasks.

```
Implement server-side API routes that integrate with fal.ai models for background removal and image generation (Flux). Build a Studio canvas page where users can select an uploaded product image, trigger background removal, input a text prompt for a custom AI background scene, and execute the generation. Handle API errors gracefully, track credit usage per user in the Turso database, and display processing states with loading spinners.
```

4. **Canvas & Retouching Tools** — Add interactive canvas controls for positioning, shadow adjustments, and magic eraser features.

```
Develop an interactive editor canvas component using HTML5 Canvas or fabric.js inside the Next.js app. Allow users to reposition the isolated product cutout over generated background scenes, adjust drop shadows (blur, opacity, offset controls), and apply simple erase masks. Provide download functionality to export the final composed image in high resolution without watermarks.
```

5. **Batch Processing Pipeline** — Build a batch editing interface allowing users to apply background removal across multiple files simultaneously.

```
Build a batch editing workflow page where users can upload up to 20 images at once. Implement a background job queue using Next.js background execution or serverless triggers that iterates through the files, sends each to the background removal API, and packages the resulting transparent PNGs into a downloadable ZIP archive. Display real-time progress bars for each file item in the batch queue.
```

6. **Polish & Deployment** — Finalize UI polish, configure error tracking, and deploy to Vercel.

```
Perform a comprehensive code review and UI polish pass using Tailwind CSS to match a clean, dark-mode-capable professional SaaS aesthetic. Add Sentry error tracking for API failure monitoring. Verify all environment variables and build scripts, ensuring successful deployment to Vercel with Cloudflare R2 and Turso properly linked.
```

### Cost vs paying

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

- Domain name: $12 one-time
- fal.ai starting credits: $10 one-time
- Total: ~$22 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Cloudflare R2: $0-5/mo
- fal.ai API usage (personal volume): ~$5-15/mo
- Total: ~$10-20/mo

- Paying for the SaaS instead: $10/mo (Pro Plan)
- Build time: 35-50 hours
- AI tool credits: $20 (Claude Pro / Cursor)
- Break-even: Not applicable (build is for learning; paid SaaS is cheaper relative to build time)

## Sources

- [Pixelcut Homepage Content](https://www.pixelcut.ai)
- [Pixelcut Pricing Page](https://www.pixelcut.ai/pricing)
- [Pixelcut Product Showcase](https://www.pixelcut.ai/product-showcase)
- [Pixelcut About Us & FAQs](https://www.pixelcut.ai/about)