# How to Vibe Code Your Own Originality.ai (and Stop Paying for It)

> AI content integrity and quality assurance platform for publishers

- Site: https://originality.ai
- Category: SaaS / Developer Tools
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 2-3 months of focused part-time work

## Verdict

Build a personal subset with local heuristic checks and LLM evaluation prompts, or keep paying for the enterprise models.

While a solo developer can easily spin up a Next.js frontend that calls OpenAI or Anthropic to judge text perplexity and burstiness, building an accurate AI detection classifier that withstands adversarial prompt-spinning and maintaining an enterprise plagiarism index is a multi-month engineering marathon. The writing replay extension alone requires intricate DOM event tracking inside Google Docs that easily breaks upon Google's frequent internal updates.

### What you can't replicate

- Proprietary historical training checkpoints for every newly released LLM
- Index coverage across billions of live web pages for instantaneous plagiarism matching

## What it does

An all-in-one web SaaS and browser extension platform providing AI text detection, internet-wide plagiarism checking, content quality scoring, readability analysis, and character-by-character writing replay verification.

### Core features

- AI content classification probability scoring
- Internet-wide plagiarism checking index
- Bulk website scanner
- Content quality and readability metric calculator
- Grammar and spell checker
- Fact-checking assertion aid against source text
- Chrome extension with character-by-character Google Docs writing replay

## The business

### Pricing

- Pay As You Go: Custom bundles — One-time credit purchase expiring after 2 years.
- Pro Plan: $14.95/mo — For individuals and small teams.
- Enterprise Plan: $179.00/mo — Ideal for agencies and publishers.

Founded 2022.
Team size: 21 employees.

## The hard parts

- Maintaining ML classification accuracy against rapidly drifting LLMs and adversarial text rephrasing tools
- Crawling and indexing the live web to power a reliable plagiarism engine at scale
- Building a performant DOM observer extension that compresses and streams character keystrokes from Google Docs

## How to vibe code Originality.ai

### Prerequisites

- Node.js (free): Required runtime for building the Next.js full-stack application and CLI tools.
- GitHub (free): Source code repository hosting and CI/CD triggers.
- Google Chrome Developer Account (free): Required if you want to load and test the custom Chrome extension locally and package it.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding the full Next.js stack, database schema, and browser extension components.
- Cursor: Ideal for fine-tuning frontend UI dashboards, Tailwind styling, and complex React state hooks.

### Stack

- Frontend: Next.js (React) with Tailwind CSS and shadcn/ui
- Backend: Next.js API Routes / Server Actions
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: Stripe
- Other: Vercel AI SDK, Anthropic API, OpenAI API

### Hosting

- Vercel (Hosting the Next.js SaaS dashboard and API routes): $0-20/mo
- Cloudflare (Edge caching and static asset distribution): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Turso database connectivity, and establish core database models for users, scans, credits, and report history.

```
Initialize a new Next.js 16 project using TypeScript, App Router, and Tailwind CSS. Set up Turso database client bindings using libSQL. Create database migration files for tables: `users` (id, email, credits, created_at), `scans` (id, user_id, content_snippet, ai_score, plagiarism_score, readability_score, created_at), and `scan_history` (id, user_id, report_json, created_at). Implement environment validation using Zod and create a clean configuration structure.
```

2. **Authentication System Setup** — Configure better-auth with email/password and session management connected to the Turso database.

```
Integrate `better-auth` into the Next.js application. Configure email and password authentication providers backed by the Turso database. Create API routes for authentication endpoints, build secure React login and registration pages with Tailwind styling, and protect dashboard layouts so unauthenticated users are redirected cleanly.
```

3. **AI Text Detection Engine & Heuristics** — Implement server actions using the Vercel AI SDK and Anthropic API to analyze text perplexity, burstiness, and estimate probability of machine generation.

```
Create a server action that takes submitted text, validates a minimum length of 100 words, and queries the Anthropic API using structured JSON output. Instruct the model to evaluate the text for AI-generation characteristics (perplexity, burstiness, uniform sentence structure) and return an overall AI probability score along with sentence-level highlighting data. Store the completed scan record in the Turso database and deduct user credits.
```

4. **Content Quality, Readability, and Grammar Scoring** — Add algorithms and LLM prompt wrappers to calculate standard readability indices (Flesch-Kincaid) and grammar assessment.

```
Write utility functions in TypeScript to calculate standard readability metrics including the Flesch-Kincaid Grade Level and Gunning Fog index for input text. Implement a supplementary server action that checks grammar and spelling issues, returning line numbers, corrected suggestions, and a comprehensive content quality score (low, good, high).
```

5. **Dashboard UI & Shareable Reports** — Build the main user dashboard with text pasting interfaces, file upload parsing (PDF/DOCX), scan history tables, and public shareable reports.

```
Build a responsive SaaS dashboard using shadcn/ui components. Include a main editor view supporting text pasting, word count tracking, file upload handling for .docx and .pdf files, and trigger buttons for AI, Plagiarism, and Readability scans. Create a dedicated results view with sentence-level color-coded highlights and a shareable public report page accessible via a unique UUID slug.
```

6. **Chrome Extension & Writing Replay Scaffolding** — Develop a Manifest V3 Chrome extension that observes DOM mutations in Google Docs to record typing speed and character history.

```
Build a Chrome Extension (Manifest V3) containing a background service worker and content script tailored for Google Docs (`docs.google.com`). Implement a MutationObserver that tracks character additions, deletions, and typing timestamps in local storage buffers. Build a popup interface that allows users to view a sped-up playback graph of their document authoring history.
```

### Cost vs paying

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

- Custom domain name: $12/year
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Vercel Hosting & Turso Database: $0/mo (Hobby tier)
- Anthropic/OpenAI API usage for AI detection analysis: ~$10/mo
- Total: ~$10/mo

- Paying for the SaaS instead: $14.95/mo
- Build time: 45-60 hours
- AI tool credits: $20/mo (Claude Pro)
- Break-even: Never (built for learning and personal exploration)

## Sources

- [Originality.ai Official Website](https://originality.ai)
- [Originality.ai Pricing & Plans](https://originality.ai/pricing)
- [GetLatka Company Profile - Originality.ai](https://getlatka.com)