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

> AI search visibility and Generative Engine Optimization (GEO) platform

- Site: https://amicited.com
- Category: Marketing SaaS / AI SEO
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

You can build a personal-use clone of the tracking and analytics loop, but expect 2 weeks of engineering frustration wrestling with multi-engine API orchestration and MCP server plumbing.

AmICited relies on automated prompt runners querying 8 distinct AI search engines, parsing citations, and computing visibility indices. While you can replicate the database schema, frontend dashboard, and basic AI API callers using a Next.js and Supabase stack, you will hit real friction handling changing API contracts across multiple LLM providers, maintaining reliable daily cron jobs for 42,000+ daily prompts at scale, and writing a clean Model Context Protocol (MCP) server to pipe live data into Claude Code. For personal use, scoping it down to 2 or 3 engines and a single target domain makes this a fantastic learning project.

### What you can't replicate

- The massive proprietary historical citation dataset built across 500+ active agency and brand portfolios
- Deep infrastructural backing from QualityUnit and the pre-existing FlowHunt automation ecosystem

## What it does

AmICited monitors how major AI search engines describe, recommend, and cite a brand, running scheduled prompt checks, tracking Share of Voice, analyzing source domain trust, and providing AI SEO agents to optimize content.

### Core features

- Multi-Engine Prompt Execution across ChatGPT, Perplexity, Gemini, Claude, Copilot, AI Overviews, AI Mode, and Grok
- Visibility Score and Share of Voice calculation against competitors
- Full Answer Archiving and day-over-day diffing
- Source Domain Intelligence (tracking which sites like Reddit or G2 get cited)
- Prompt Discovery engine mining Search Console / PAA data
- SEO AI Agents for automated GEO content drafting and optimization
- Model Context Protocol (MCP) server for local IDE integration (Claude Code, Cursor)
- Multi-tenant team workspaces and scheduled email/Slack report digests

## The business

### Pricing

- Starter: €50/mo — For a single brand getting its first read on AI visibility.
- Pro: €120/mo — For marketing teams that want to win prompts, not just watch them.
- Premium: €500/mo — For agencies running AI visibility across client portfolios.
- Enterprise: from €1,500/mo — For global brands running AI visibility at scale.

Founded 2026.
Team size: 1-10.

## The hard parts

- Coordinating stable automated queries across 8 heterogeneous AI engines without getting blocked by rate limits or changing DOM structures
- Parsing markdown and citation payloads from unstructured AI responses into structured relational entities
- Designing a robust agentic publishing loop that scores articles against GEO metrics and pushes updates directly to CMS platforms
- Exposing secure, real-time database query capabilities via a custom Model Context Protocol (MCP) server for external editor harnesses

## How to vibe code AmICited

### Prerequisites

- Node.js (free): Required runtime for executing the Next.js full-stack application and MCP server tooling.
- GitHub (free): Source control and seamless deployment integration for your hosting provider.
- Supabase Account (free): Provides PostgreSQL database hosting, row-level security, and authentication primitives.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex multi-file Next.js apps, writing database migrations, and building custom MCP servers.
- Cursor: Ideal AI code editor for inspecting UI components, reviewing git diffs, and tuning Tailwind layouts interactively.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui components
- Backend: Next.js API routes / Server Actions
- Database: Supabase (PostgreSQL with pgvector for semantic prompt clustering)
- Auth: better-auth
- Payments: None (Personal use clone)
- Other: Vercel AI SDK for multi-model LLM calls, Model Context Protocol (MCP) SDK for local IDE integration, Resend for weekly report digests, Inngest for reliable daily cron prompt execution

### Hosting

- Vercel (Hosting the Next.js frontend, API endpoints, and scheduled cron functions.): $0-20/mo
- Supabase (Managed PostgreSQL database storage for prompt archives and brand visibility scores.): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Supabase with better-auth, and set up relational tables for domains, prompts, engine_runs, and citations.

```
Scaffold a new Next.js 16 project using TypeScript, Tailwind CSS, and App Router. Set up better-auth for email/password authentication connected to Supabase PostgreSQL. Create a robust database schema using Prisma or Supabase migrations with the following tables: `domains` (id, user_id, domain_name, created_at), `prompts` (id, domain_id, query_text, tags, active), `engine_runs` (id, prompt_id, engine_name, raw_response, sentiment, cited_domains, created_at), and `competitors` (id, domain_id, competitor_name). Ensure proper foreign key constraints, indexes on prompt timestamps, and a clean folder structure with shared UI primitives.
```

2. **Multi-Engine Prompt Orchestration Engine** — Build server actions and cron handlers that query OpenAI, Anthropic, Gemini, and Perplexity APIs simultaneously to evaluate tracked prompts.

```
Implement a robust multi-engine prompt execution pipeline using the Vercel AI SDK. Create an API route `/api/cron/run-prompts` that fetches active prompts for all domains and dispatches queries in parallel to OpenAI (ChatGPT), Anthropic (Claude), Google (Gemini), and Perplexity (Sonar API). Wrap each engine call in a resilient retry/backoff wrapper with error catching to handle rate limits gracefully. Each execution must record the raw response string, extract mentioning brand entities, parse out referenced citation URLs, and calculate a baseline sentiment score (positive/neutral/negative) before saving the record into the `engine_runs` table.
```

3. **Visibility Score & Analytics Dashboard** — Construct the main dashboard UI visualizing Visibility Scores, Share of Voice, and engine-by-engine performance comparisons.

```
Build a responsive Next.js dashboard under `/dashboard` using Tailwind CSS and shadcn/ui components. Create summary metric cards displaying the composite Visibility Score, Share of Voice percentage against tracked competitors, and average citation ranking. Implement a multi-platform breakdown view showing side-by-side performance across ChatGPT, Perplexity, Gemini, and Claude. Include an interactive historical trend chart using Recharts to visualize visibility deltas over 30 and 90 days, drawing live data from the `engine_runs` and `citations` tables.
```

4. **Full Answer Archive & Diff Viewer** — Build an archive viewer that lets users inspect raw LLM responses and diff day-over-day changes in brand citations.

```
Create a detailed prompt view page at `/dashboard/prompts/[id]` that displays the full chronological history of LLM answers for a specific query. Implement a diff viewer component that compares yesterday's answer text against today's response, highlighting changes in brand mention position, wording, and newly acquired or lost citation links. Include source domain filters so users can instantly inspect which third-party domains (e.g. reddit.com, g2.com) the search engines relied upon for each run.
```

5. **SEO AI Agent & Content Optimization Module** — Develop an AI assistant interface that detects visibility gaps, evaluates competing URLs, and drafts GEO-scored optimization guidelines.

```
Build an SEO AI Agent module under `/dashboard/articles` that identifies prompts where competitors are cited and the user's domain is absent. Using the Vercel AI SDK and Claude Sonnet, create a server action that analyzes winning competitor URLs, extracts missing semantic entities, and auto-drafts a GEO-optimized markdown article. The output must adhere to GEO best practices (direct answer in first 80 words, structured FAQ schema, and competitor comparison tables) and display a live calculated GEO readiness score before allowing export or markdown download.
```

6. **Model Context Protocol (MCP) Server Integration** — Implement a custom Model Context Protocol (MCP) server so local development agents like Claude Code can query your citation database directly.

```
Build a standalone Model Context Protocol (MCP) server script in TypeScript (using `@modelcontextprotocol/sdk`) that securely connects to your Supabase PostgreSQL database. Expose custom tools such as `get_brand_visibility_summary`, `list_prompt_gaps`, and `get_competitor_share_of_voice`. Configure transport over stdio so that external coding agents like Claude Code and Cursor can run local queries against your tracked brand data during code refactoring and content creation workflows. Document the setup instructions in a project `README.md`.
```

### Cost vs paying

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

- Domain name (optional): $12 one-time
- AI API starting credits (OpenAI/Anthropic/Perplexity): $15 one-time
- Total: ~$27 one-time

**Ongoing costs (monthly):**

- Vercel Hosting & Cron Jobs: $0-5/mo
- Supabase Database & Auth: $0/mo
- LLM & Search API Usage (Evaluating 42k prompts/mo scaled down for personal use): $5-15/mo
- Total: ~$10-20/mo

- Paying for the SaaS instead: €50/mo to €120/mo
- Build time: 35-50 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Immediate if replacing Pro plan

## Sources

- [AmICited Official Website & Documentation](https://amicited.com)