# How to Vibe Code Your Own 100 Questions (and Stop Paying for It) > AI visibility audit and benchmarking tool - Site: https://100questionsai.com - Category: SaaS / AI Marketing - Platforms: Web app - Verdict: **Weekend build** (85/100 vibecodeable) - Estimated effort: 1-2 weekends ## Verdict You can build this personal clone over a weekend using Next.js and LLM APIs, making the paid reports unnecessary unless you want pre-configured agency templates. The core engineering challenge is writing robust async orchestration scripts that call four separate LLM providers with web search enabled, parsing their responses to verify valid web citations, and computing basic mathematical ratios for share of voice and visibility. An AI coding agent can scaffold the database models, dashboard UI, and API orchestration loops in an afternoon. The primary friction points are handling upstream API rate limits and ensuring your regex/parsing logic correctly extracts grounding URLs from varying provider response payloads. ### What you can't replicate - The exact commercial dataset and brand positioning of the original tool ## What it does An AI visibility audit and benchmarking tool that analyzes how businesses appear in web-grounded LLM responses across OpenAI, Claude, Gemini, and Grok. ### Core features - Multi-provider API orchestration (OpenAI, Anthropic, Google, xAI) - Parameterized question template generation (20 neutral + 5 diagnostic prompts) - Web grounding verification (filtering out ungrounded model outputs) - Share of voice and competitor comparison analytics - Citation domain matching and occurrence tracking - Prioritized AI visibility action plan generation - 30-day rolling report snapshots and evidence retention - PDF and CSV data export engine ## The business ### Pricing - First Benchmark: $9 — Introductory rate for your first audit - Single Benchmark: $15 — Standard single run after introductory purchase - Three Benchmarks Pack: $39 — Best value for baseline and measurement loop - Ten Benchmarks Pack: $99 — Flexible capacity for agencies and consultants Founded 2025. Team size: Solo-founder. ## The hard parts - Handling concurrent API rate limits and structural JSON schema variances across 4 providers - Reliably parsing and validating web search grounding URLs returned inside model responses - Aggregating deterministic scoring metrics from unstructured LLM text blocks ## How to vibe code 100 Questions ### Prerequisites - Node.js (free): Runtime environment for Next.js and TypeScript orchestration scripts - GitHub (free): Source code repository and deployment integration - API Keys (Pay-as-you-go): Access keys for OpenAI, Anthropic, Gemini, and xAI model endpoints ### Recommended AI tools - Cursor: AI-native code editor ideal for rapid full-stack scaffolding and UI iteration - Claude Code: Terminal agent capable of executing multi-file scaffolding and test loops autonomously ### Stack - Frontend: Next.js with Tailwind CSS - Backend: Next.js App Router API Routes - Database: Turso (SQLite at the edge) - Auth: better-auth - Payments: None needed for personal use - Other: Vercel AI SDK, Lucide React ### Hosting - Vercel (Hosting the Next.js frontend and serverless API execution routes): $0/mo (Hobby tier) - Turso (Storing user audits, frozen question sets, and 30-day response evidence): $0/mo (Free tier) ### Build guide 1. **Scaffold Project and Database Schema** — Initialize a Next.js project with Tailwind CSS and configure Turso with Drizzle ORM to store audits, questions, model responses, and citation evidence. ``` Create a new Next.js TypeScript project using App Router and Tailwind CSS. Configure Drizzle ORM to connect to a Turso SQLite database. Set up database tables for 'audits' (id, target_name, domain, category, competitors, created_at), 'questions' (id, audit_id, prompt_text, type), and 'provider_responses' (id, audit_id, question_id, provider, raw_text, citations_json, is_grounded, brand_mentioned, prominence_score). Ensure all foreign keys and indexes are correctly defined for fast aggregation queries. ``` 2. **Implement Multi-Provider LLM Orchestration Engine** — Build an asynchronous service layer that dispatches prompt sets concurrently across OpenAI, Anthropic, Gemini, and xAI with web grounding enabled. ``` Create a TypeScript orchestration service that accepts a list of 25 questions (20 neutral discovery, 5 diagnostic) and executes them concurrently across OpenAI (GPT-4o/5 mini), Anthropic (Claude Sonnet), Gemini (Flash Lite with search grounding), and xAI (Grok). Ensure each provider request enables native web search tooling or grounding parameters. Catch request timeouts and API errors gracefully without failing the entire batch, returning structured payloads containing raw response text and raw citation URLs. ``` 3. **Build Grounding Verification and Scoring Algorithm** — Write deterministic parsing functions to verify citation URLs, filter ungrounded responses, and calculate visibility, prominence, and share of voice. ``` Implement scoring and validation logic in TypeScript. For each model response, verify that at least one valid HTTP/HTTPS URL is returned in the citation payload; flag 'is_grounded = false' otherwise. Analyze the response text using target brand aliases and competitor lists to compute: (1) visibility percentage (mentions in neutral discovery answers), (2) prominence weighting (headline vs body mention), (3) competitor share of voice ratios, and (4) claimed domain citation frequency. Save these computed metrics to the database. ``` 4. **Construct Audit Configuration and Trigger UI** — Develop the front-end form allowing users to submit their target brand, canonical domain, category description, market locale, and competitors. ``` Build a clean Next.js dashboard page with a form to initiate a new audit run. The form must accept: Subject Name, Canonical Domain, Category/Use-case Description, Market/Locale, and a comma-separated list of Competitors. On submission, show a loading state with progress indicators while calling the backend orchestration API. Store the input parameters and frozen timestamp in the audit record. ``` 5. **Build Report Dashboard and Evidence Inspector** — Design a client-ready audit dashboard displaying overall metrics, model breakdown charts, missed questions, and source citation evidence. ``` Create a comprehensive audit report view in Next.js displaying summary KPI cards (Discovery Visibility, Owned Citations, Model Breakdown across OpenAI, Claude, Gemini, Grok). Include an expandable evidence inspector table showing each of the 25 questions, what each model answered, whether citations matched the claimed domain, and which competitor appeared instead. Ensure the UI matches a professional, clean SaaS aesthetic using Tailwind CSS and Lucide icons. ``` 6. **Implement Action Plan Generator and Export Tools** — Synthesize missed citation evidence into five prioritized GEO/AEO recommendations and add JSON/CSV export capabilities. ``` Add an action plan generation module that analyzes low-visibility questions and missing competitor citations to output five prioritized technical or content recommendations for GEO optimization. Implement client-side export functions that serialize the audit report and retained evidence into clean CSV and downloadable PDF-ready formats. ``` ### Cost vs paying **Starting costs (one-time):** - AI Provider API Credits: ~$5 (OpenAI/Anthropic/Google/xAI test calls) - Total: ~$25 one-time **Ongoing costs (monthly):** - API usage per audit run: ~$0.10 - $0.50 per run depending on model calls - Total: Usage-based (~$2-5/mo) - Paying for the SaaS instead: $9 - $15 per run - Build time: 10-15 hours - AI tool credits: $20 (Cursor Pro or Claude Code usage) - Break-even: Immediate if running multiple audits ## Sources - [100 Questions Homepage & FAQ Data](https://100questionsai.com)