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

> AI for scientific research

- Site: https://elicit.com
- Category: AI Research Assistant
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 6-8 weeks of intensive development

## Verdict

You can build a personal AI research assistant wrapper, but matching Elicit's scale of 138 million indexed papers and rigorous systematic review pipelines is a serious undertaking.

While spinning up a Next.js frontend that queries an LLM over a few dozen uploaded PDFs is straightforward, recreating Elicit's core value—massive hybrid search over millions of academic records, multi-column PDF layout parsing, and high-recall data extraction workflows—requires deep vector infrastructure, complex agentic orchestration, and substantial engineering hours. You will spend weeks wrestling with token limits, vector search relevance, and citation grounding accuracy.

### What you can't replicate

- The 138 million academic paper index and real-time ingestion pipelines
- PRISMA 2020-compliant audit trails and enterprise-grade screening accuracy
- Proprietary multi-step agentic 'factored cognition' fine-tuned over years

## What it does

Elicit is an AI-powered research assistant designed to automate literature reviews, semantic paper searches, and data extractions for scientific and academic research across millions of papers.

### Core features

- Semantic search across academic paper corpora
- Automated literature review synthesis
- Structured table data extraction with citations
- Interactive full-text chat with documents
- Systematic literature review screening workflows (PRISMA framework)
- Customizable research reports

## The business

### Pricing

- Basic: Free — For casual exploration
- Pro: $49/mo — For systematic reviews
- Scale: $169/mo — For collaboration

### Funding

$31M raised.
- Seed Round (September 2023) - $9M
- Series A - $22M
Investors: Fifty Years, Andreessen Horowitz, General Catalyst, Craft Ventures, Afore Capital

Founded 2021.
Team size: 50-55.

## The hard parts

- Indexing, chunking, and maintaining vector and hybrid search across 138 million+ papers
- Multi-step agentic reasoning ('factored cognition') with 95%+ extraction recall and rigorous citation verification
- Complex layout and figure parsing for multi-column academic PDFs and mathematical notation
- Deterministic audit trails for systematic reviews and compliance frameworks

## How to vibe code Elicit

### Prerequisites

- Node.js (Free): Required runtime for Next.js and backend scripts.
- GitHub (Free): Source control and deployment pipeline integration.
- Anthropic API Key (Pay-as-you-go): Powers advanced paper synthesis and extraction using Claude models.

### Recommended AI tools

- Claude Code: Agentic coding tool ideal for scaffolding complex multi-file Next.js and vector search architectures.
- Cursor: AI code editor for iterative UI adjustments on data tables and search dashboards.

### Stack

- Frontend: Next.js (App Router, Tailwind CSS, shadcn/ui)
- Backend: Next.js API Routes / Server Actions
- Database: Neon (Serverless Postgres with pgvector extension)
- Auth: better-auth
- Payments: Stripe
- Other: Anthropic API for extraction and reasoning, OpenAlex or Semantic Scholar API for paper metadata, PDF.js / Unstructured for document parsing

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints.): $0-20/mo
- Neon (Serverless Postgres database with pgvector for storing paper metadata and embeddings.): $0-19/mo

### Build guide

1. **Project Initialization & Database Schema** — Initialize a Next.js project with Tailwind CSS, configure shadcn/ui components, and set up Neon Postgres with the pgvector extension for storing paper embeddings and extraction tables.

```
Initialize a new Next.js 16 app with TypeScript, Tailwind CSS 4, and App Router. Set up Drizzle ORM to connect to Neon Postgres. Create database schemas for users, projects, papers (storing title, abstract, DOI, year, full_text_url), embeddings using pgvector, and extraction_tables with dynamic columns. Ensure proper indexes for vector similarity search.
```

2. **Authentication & User Dashboard** — Implement authentication using better-auth and build the main research dashboard layout with project management capabilities.

```
Configure better-auth in the Next.js app supporting email/password and magic links, storing session data in Neon Postgres. Build a clean, responsive dashboard layout using shadcn/ui featuring a sidebar for navigation (Search, Reports, Library, Systematic Review) and a main workspace area for active research queries.
```

3. **Academic Search & Metadata Integration** — Integrate external academic APIs (such as OpenAlex or Semantic Scholar) to allow users to search and import paper metadata into their personal workspace.

```
Build a backend service that queries the OpenAlex API for academic papers based on user search queries. Implement semantic search by generating embeddings for search queries via Anthropic or OpenAI models and querying the pgvector database. Display search results in a responsive, sortable data table showing title, authors, year, citation count, and abstract.
```

4. **PDF Ingestion & Text Extraction Pipeline** — Create a document upload and parsing pipeline to extract text and structure from scientific PDFs.

```
Implement a file upload endpoint for scientific PDFs using Cloudflare R2 or direct storage. Build a background ingestion worker that parses uploaded PDF text, chunks the content with overlapping windows, generates vector embeddings for each chunk, and stores them in Neon Postgres with foreign keys linked to the paper record.
```

5. **Data Extraction & Synthesis Tables** — Build agentic workflows that extract custom structured data points from multiple papers into interactive comparison tables with sentence-level citations.

```
Develop a multi-step extraction engine using the Anthropic API. Given a user-defined research question and a list of selected papers, prompt Claude to extract structured values for user-defined columns (e.g., sample size, methodology, findings) with exact sentence-level citations pointing back to source text chunks. Render the results in an interactive, editable table component.
```

6. **Research Report Generation** — Synthesize extracted findings across multiple sources into a comprehensive, citation-backed research brief.

```
Implement a report generation feature that aggregates data from selected papers and extraction tables, passes them through a structured synthesis prompt using Claude Opus/Sonnet, and generates a formatted research brief with inline citation tags and a bibliography. Allow users to export the report as markdown, PDF, or DOCX.
```

### Cost vs paying

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

- AI Coding Subscriptions: $40 one-time
- Total: ~$40 one-time

**Ongoing costs (monthly):**

- Vercel / Neon Hosting: $0-10/mo
- Anthropic API Usage: $15-30/mo
- Total: ~$25-40/mo

- Paying for the SaaS instead: $49/mo (Pro)
- Build time: 45-60 hours
- AI tool credits: $40 (Claude Pro / Cursor Pro)
- Break-even: 1 month of Pro tier equivalent

## Sources

- [Elicit Official Website](https://elicit.com)
- [Elicit Pricing Page](https://elicit.com/welcome#Pricing)