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

> AI Content Detection Platform and API

- Site: https://wasitaigenerated.com
- Category: AI / Security / Developer Tools
- Platforms: Web app, iOS app, RESTful API
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

You can build a functional personal clone of the wrapper, dashboard, and API gateway in a couple of weeks, but you will need to rely on third-party foundation APIs rather than custom-trained detection networks.

The real product's primary barrier is its underlying ML infrastructure—training proprietary models that reliably detect audio deepfakes and advanced video diffusion artifacts is a massive engineering undertaking. However, for a personal-use clone, you can easily proxy requests to Hugging Face inference endpoints, OpenAI models, or specialized open-source checkpoints behind your own Next.js API gateway. The credit system, API key management, and multi-modal UI are standard SaaS patterns that AI coding agents generate quickly.

### What you can't replicate

- Proprietary model weights trained on millions of proprietary synthetic data samples
- Real enterprise contracts and 99.9% guaranteed uptime SLAs

## What it does

An enterprise-ready AI content detection platform and REST API for identifying synthetic text, images, audio, and video.

### Core features

- Multi-modal dashboard for text, image, audio, and video submission
- RESTful API gateway with Bearer token authentication
- Credit ledger and wallet balance enforcement per request type
- Text AI detection with per-sentence confidence scores
- Image synthetic artifact and cryptographic content credentials checker
- Audio acoustic deepfake detection analyzer
- Frame-by-frame video AI manipulation screener
- User authentication and API key management dashboard

## The business

### Pricing

- Free Starter: Free
- Unlimited (Website Only): $9.99/mo
- Starter Pack: $5.00 one-time
- Credit Package: $19.99 one-time
- Enterprise: Custom

Founded 2022.
Team size: Solo-led.

## The hard parts

- Training and maintaining custom low-level deepfake and audio-visual neural networks that outpace modern generative models
- Achieving low-latency (<3s) frame-by-frame video processing over standard HTTP connections
- Balancing false-positive rates on academic and professional text detection classifiers
- Handling multipart uploads and asynchronous processing queues for large video and audio files

## How to vibe code wasitaigenerated

### Prerequisites

- Node.js (free): Required runtime for the Next.js full-stack application.
- GitHub (free): Source control and integration for deployment platforms.
- Hugging Face account (free tier): Provides inference APIs for text classification and media artifact screening.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding the entire multi-modal API and dashboard end-to-end.
- Cursor: Ideal for fine-tuning React frontend components, dashboard layouts, and Tailwind styles.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui components
- Backend: Next.js App Router API endpoints with Bearer token middleware
- Database: Turso (SQLite at the edge for users, API keys, and credit ledger)
- Auth: better-auth for self-hosted secure email/password and session management
- Payments: Skipped for personal use (credit balance managed locally in DB)
- Other: Vercel AI SDK for prompt handling, Hugging Face Inference API / OpenAI API for detection models, UploadThing for handling temporary media uploads

### Hosting

- Vercel (Hosting the Next.js frontend, web dashboard, and serverless API endpoints.): $0-20/mo
- Turso (Serverless SQLite database storing user accounts, API keys, and credit balances.): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js application with Tailwind CSS, configure Turso SQLite via Drizzle ORM, and set up the schema for users, API keys, credit balances, and scan logs.

```
Scaffold a new Next.js project using App Router and TypeScript. Install Tailwind CSS and set up Drizzle ORM configured with Turso (SQLite). Create database tables for 'users' (id, email, passwordHash, credits), 'api_keys' (id, userId, keyHash, name, createdAt), and 'scan_logs' (id, userId, type, contentHash, resultJson, cost, createdAt). Ensure proper foreign key constraints and indexes on keyHash and userId. Write migration scripts and test database connection locally.
```

2. **Authentication & Dashboard Layout** — Implement authentication with better-auth and build the main user dashboard layout showing credit balances, recent scans, and navigation tabs.

```
Implement authentication in the Next.js app using better-auth with email and password support. Create signup, login, and logout routes. Build a responsive dashboard layout with a sidebar (Overview, Detectors, API Keys, Documentation, Pricing) and a top navigation bar showing the user's current credit balance. Protect dashboard routes with authentication middleware and render user profile data dynamically.
```

3. **API Key Management & Gateway Middleware** — Build the API key generation interface in the dashboard and create a secure middleware layer to validate Bearer tokens and deduct credits.

```
Create an API key management page in the dashboard allowing users to generate, view (once), and revoke API keys stored as secure hashes in Turso. Implement a Next.js middleware or utility function for incoming API routes at `/api/v1/*` that validates the `Authorization: Bearer <key>` header, checks if the user has sufficient credits, deducts the appropriate credit amount based on detection type, and returns 401 Unauthorized or 402 Payment Required errors appropriately.
```

4. **Multi-Modal Detection UI & Web Scanners** — Build the interactive web demo interface supporting text input, document upload, image uploads, and audio/video files, calling internal detection handlers.

```
Build a multi-modal detection interface on the web dashboard with tabs for Text, Document, Image, Audio, and Video. For text, provide a textarea with a word counter and real-time credit estimator. For files (images, audio, video), provide drag-and-drop file upload zones with size validation (max 10MB). When submitted, send the payload to internal API routes, display a loading state, and render results with confidence scores, visual progress bars, and breakdown metrics matching the specified UI design.
```

5. **Detection Engine Integration (Text & Image)** — Implement backend processing for text and image detection endpoints, integrating external AI inference APIs or heuristic classifiers.

```
Implement the backend detection logic for text (`POST /api/v1/detect/text`) and images (`POST /api/v1/detect/image`). For text, analyze perplexity/burstiness heuristics or call an external LLM classification endpoint via Vercel AI SDK to return `isAI`, `confidence`, `patterns`, and per-sentence scoring. For images, accept multipart form-data, check file headers, and run a lightweight computer vision classification check or mock confidence score with synthetic artifact tags. Return structured JSON matching the documented API response format.
```

6. **Detection Engine Integration (Audio & Video)** — Implement processing endpoints for audio and video deepfake analysis, completing the full multi-modal detection suite.

```
Implement the backend detection endpoints for audio (`POST /api/v1/detect/audio`) and video (`POST /api/v1/detect/video`). Handle multipart file uploads using UploadThing or local temporary storage. Process audio chunks for acoustic synthetic patterns and video files for frame-by-frame artifact tracking. Return JSON response payloads including `isAI`, `confidence`, `patterns`, and analysis reasoning. Add comprehensive error handling for unsupported file formats and oversized uploads.
```

7. **API Documentation & Polish** — Create a clean, interactive API documentation page with cURL examples and test responses, and perform end-to-end testing.

```
Build an API documentation page within the app that outlines endpoints (`POST /api/v1/detect/text`, `POST /api/v1/detect/image`, etc.), authentication requirements, request bodies with JSON examples, response schemas, and error codes (400, 401, 402, 403, 500). Add copy-to-clipboard code blocks for cURL requests. Perform an end-to-end test verifying that dashboard scans deduct credits correctly and API requests with valid Bearer tokens succeed.
```

### Cost vs paying

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

- Domain name (optional): $12/yr
- AI coding tools subscription: $20 one-time
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Turso / UploadThing: $0/mo
- Hugging Face / LLM API inference credits: ~$5/mo
- Total: ~$5/mo

- Paying for the SaaS instead: $9.99/mo (Website) + Pay-as-you-go API credits
- Build time: 25-35 hours
- AI tool credits: $20 (Claude Pro / Cursor)
- Break-even: N/A (Personal clone)

## Sources

- [wasitaigenerated Home Page](https://www.wasitaigenerated.com)
- [wasitaigenerated About Page](https://www.wasitaigenerated.com/about)
- [wasitaigenerated API Documentation](https://www.wasitaigenerated.com/docs)
- [wasitaigenerated Enterprise Landing Page](https://www.wasitaigenerated.com/enterprise)