# How to Vibe Code Your Own GPTZero (and Stop Paying for It) > AI Content Detection and Writing Verification Platform - Site: https://gptzero.me - Category: AI Content Verification & Compliance - Platforms: Web app, Browser extension, Google Docs add-on - Verdict: **Solid side project** (65/100 vibecodeable) - Estimated effort: 3-4 weeks of focused development ## Verdict Build a personal subset for your own document screening, but keep paying if you need enterprise LMS integrations or courtroom-grade accuracy. Replicating a personal-use text classifier with sentence-level highlighting is straightforward using heuristic statistical analysis (perplexity/burstiness via open LLM tokenizers) or proxying calls to frontier APIs. However, matching GPTZero's multi-million document proprietary training pipeline, ESL de-biasing, and resilient paraphraser shielding requires immense data engineering that a solo developer cannot match. Build this as a fun side project to analyze your own drafts, but do not expect to rival a $30M ARR platform. ### What you can't replicate - Proprietary training corpus spanning 17+ million user documents - Extensive fine-tuning datasets specifically de-biased for ESL and diverse academic prose - Official partnerships with educational institutions and LMS platforms (Canvas, Moodle) ## What it does GPTZero identifies whether text or documents were generated by large language models, offering sentence-level highlights, writing process playback, hallucination checks, and plagiarism detection. ### Core features - Text scanning interface with character limit validation - Statistical heuristic calculation engine (perplexity and burstiness scoring) - Sentence-level probabilistic text segmentation and color-coded highlighting - Document classification (Human, AI, Mixed) with confidence categories - Writing playback / keystroke verification tracking replay system - Basic plagiarism and external source matching scanner - REST API endpoint for programmatic text classification - User authentication, plan quota tracking, and usage metering ## The business ### Pricing - Free Plan: Free — Basic detection for casual checking - Essential / Premium Plan: ~$12.99/mo — For individual writers and educators - Professional Plan: ~$24.99/mo — For heavy users and small teams - Enterprise / API: Custom — For institutions and developers ### Funding $13.5M raised. - Seed Round ($3.5M, May 2023) - Series A Round (June 2024) Investors: Footwork, Uncork Capital Founded 2023. Team size: 140+. ## The hard parts - Training and fine-tuning custom classification models to maintain <1% false positive rates on ESL prose - Building robust adversarial shielding against paraphrasing and word-substitution humanizers - Designing client-side event tracking pipelines for real-time keystroke/edit history recording - Achieving sub-second API inference latency across massive documents under public load ## How to vibe code GPTZero ### Prerequisites - Node.js (free): Required runtime for the Next.js full-stack framework and TypeScript backend execution. - GitHub (free): Source code repository hosting and continuous deployment integration. - Supabase Account (free): Managed Postgres database for storing user accounts, scan quotas, and usage logs. ### Recommended AI tools - Claude Code: Best-in-class terminal coding agent for scaffolding full-stack applications, handling multi-file migrations, and writing complex statistical processing utilities. - Cursor: AI-native code editor ideal for reviewing diffs, tweaking UI layouts, and fine-tuning React components. ### Stack - Frontend: Next.js with Tailwind CSS and shadcn/ui components - Backend: Next.js Server Actions and API Routes with Python/FastAPI microservice for text heuristic calculations - Database: Supabase (PostgreSQL 17) - Auth: better-auth - Payments: none - Other: Transformers / PyTorch (for running local perplexity calculations), Resend (for optional transactional login emails), PostHog (for product analytics) ### Hosting - Vercel (Hosting the Next.js frontend and serverless API endpoints): $0/mo (Hobby tier) - Supabase (Managed Postgres database and authentication storage): $0/mo (Free tier) - Render (Hosting the Python FastAPI heuristic calculation service): $0-7/mo ### Build guide 1. **Project Scaffolding and Database Schema** — Initialize the Next.js full-stack repository with Tailwind CSS, configure shadcn/ui primitives, set up better-auth connected to Supabase PostgreSQL, and define tables for users, scan_history, and usage_quotas. ``` Create a new Next.js TypeScript project with Tailwind CSS and configure connection to Supabase PostgreSQL using Drizzle ORM or Prisma. Set up better-auth with email/password authentication. Create database migrations for a 'users' table, a 'scans' table storing document text, overall classification scores (human, ai, mixed), sentence-level highlight JSON arrays, and a 'quotas' table tracking monthly character usage per user. Ensure all environment variables are properly typed and validated on startup. ``` 2. **Core Text Scanner Dashboard UI** — Build the main web dashboard featuring a large text input textarea with real-time character counting, upgrade prompts, file upload dropzone, and scan action buttons matching the GPTZero layout. ``` Build a responsive dashboard page in Next.js resembling the GPTZero main text checker interface. Include a resizable textarea with a live character counter up to 10,000 characters, a clear button, an example selector dropdown (ChatGPT, Claude, Human texts), and a prominent 'Scan' action button. Add a file upload dropzone supporting .txt, .pdf, and .docx documents. Include a sidebar navigation linking to dashboard views, history, and settings. ``` 3. **Statistical Heuristic and Text Analysis Engine** — Develop a backend microservice (Python FastAPI) that ingests text, tokenizes it, computes statistical perplexity and burstiness metrics using a lightweight open-source language model, and returns sentence-level probabilistic scores. ``` Write a Python FastAPI microservice that exposes a POST /api/v1/predict endpoint. The endpoint should accept a JSON body containing a document string, tokenize the text, and calculate sentence-level perplexity and burstiness metrics using a small open-source Hugging Face transformer model. Return a JSON structure containing overall document classification ('HUMAN_ONLY', 'MIXED', 'AI_ONLY'), class probabilities, confidence category, and an array of sentence objects tagged with ai_probability and highlight flags for sentences exceeding threshold scores. ``` 4. **Sentence-Level Highlighting and Results View** — Integrate the frontend text inspection results view to render color-coded background highlights on individual sentences based on the scanning API payload, along with summary metric cards for perplexity and burstiness. ``` Create a React component that renders scan results with sentence-level color-coded highlights. Sentences classified as highly likely AI should render with a yellow/orange background highlight, while human sentences remain clean. Include a summary metrics panel showing overall document classification badge, average perplexity score, burstiness score, and a breakdown of AI vs. human probability percentages. Ensure clicking a highlighted sentence displays a tooltip explaining the scoring rationale. ``` 5. **Writing Replay and Keystroke Verification Tracker** — Implement a client-side writing activity recorder that captures typing velocity, paste events, and edit timelines within a dedicated document drafting view to simulate authorship verification reports. ``` Build an authorship verification drafting component in Next.js that acts as a secure writing editor. Track client-side keystroke events, timestamps, backspace counts, and paste actions in real time. Save session history snapshots to Supabase. Create a playback review screen with a timeline scrubber that visually replays the writing process session like a video, displaying metrics on total typing duration, paste percentages, and authenticity score. ``` 6. **Public REST API and Rate Limiting** — Expose a public REST API endpoint allowing programmatic text submission with API key authentication, request origin validation, and strict rate limiting per user plan. ``` Implement a secure public REST API endpoint at /api/v2/predict/text in Next.js that validates an 'x-api-key' header against stored API keys in the database. Enforce rate limiting based on the user's subscription tier. The endpoint should forward the document payload to the detection engine and return a structured JSON response matching the core classification schema without storing raw document text for privacy compliance. ``` 7. **Polish, Usage Quotas, and Error Handling** — Add usage quota tracking middleware to deduct character limits per scan, implement graceful error handling for oversized files, and polish loading states and mobile responsiveness. ``` Add middleware and database checks to enforce monthly word and character quotas for free vs. registered users. If a user exceeds their 10,000 character free limit, present a modal prompting them to upgrade or sign in. Add robust error handling for failed API requests, malformed file uploads, and network timeouts. Polish UI transitions, loading skeletons, and mobile responsiveness across all views. ``` ### Cost vs paying **Starting costs (one-time):** - Domain name (optional): $12 one-time - Total: ~$12 one-time **Ongoing costs (monthly):** - Hosting (Vercel & Supabase free tiers): $0/mo - Total: $0/mo - Paying for the SaaS instead: $14.99/mo (Essential Plan) - Build time: 35-45 hours - AI tool credits: $20/mo (Claude Pro / Cursor) - Break-even: Free forever (personal self-hosted build) ## Sources - [GPTZero Official Website & Pricing](https://gptzero.me) - [Superhuman Acquires GPTZero ($30M ARR) - TechCrunch via StrictlyVC](https://vertexaisearch.cloud.google.com/grounding-api-redirect/AUZIYQHRtdTzReXpZ6xORBExgWW2GFngd0MzMB2t2jHkzRFStesjuByeaUcCR_XW2xAn_2GDnZqFYFNBFmdF6mFFAMV0cEBLpvUVM2ACC9Wc6JuKpn1FXTRphq5AazLsDgWzVxyfHANHsyfj-uYJQ5_h0QeoS9L1Sz-L_KWDVnEEjh6HNn9bg_OX0nD8rFJB1fmqryxMxRidrA0) - [GPTZero ArXiv Research Paper on Robust Detection](https://arxiv.org/abs/2602.13042)