DEV Community: henry

How I Built a Contract Review Chrome Extension That Grounds AI in Real Statutes

henry — Thu, 11 Jun 2026 06:38:04 +0000

I signed a contract I didn't read. The auto-renewal cost me money I didn't have. So I built PactLens.

The hard part wasn't the AI. It was preventing hallucinations.

The Hallucination Problem

Ask an LLM "review this contract clause" and it will confidently cite laws that don't exist. I tested this — GPT-4 invented a "Fair Contract
Terms Act 2024" and gave it a fake section number.

The Solution: Statute Grounding

PactLens pre-loads 1,700+ real statutes across 8 jurisdictions. Before the AI generates any analysis, we:

Extract clause semantics from the contract text
Run keyword matching against the statute database
Inject the top N matching statutes as context into the prompt
Force the AI to cite ONLY from the provided statutes

Result: zero hallucinated laws. Every citation is verifiable.

Why Not a Vector Database?

Embedding 1,700+ statutes would make sense architecturally. But CF Workers doesn't have great vector support, and the statutes are stable
enough for keyword matching + TF-IDF. The simpler approach works better at this scale.

Stack

WXT + TypeScript for the extension. Hono + CF Workers for the backend. DeepSeek for AI inference. The entire statute database lives in CF KV
as JSON.

What I Learned

Chrome Web Store review takes 2-3 weeks. Submit early.
The statute grounding is what makes users trust the output. Without it, it's just another GPT wrapper.
Freelancers don't search for "contract review AI." They search for "is this NDA clause normal?" Meet them where they are.

Try it: pactlens.net/contract

How I Shipped 3 Chrome Extensions as a Solo Developer in 3 Months

henry — Thu, 11 Jun 2026 06:33:05 +0000

Three months ago I had zero Chrome Extensions. Last week, my third one got approved.

Here's the honest timeline, technical stack, and what I'd do differently.

Month 1: The Contract That Started Everything

I signed a SaaS contract without reading the auto-renewal clause. Cost me money I didn't have. So I built PactLens — a Chrome extension that reviews contracts before you sign.

Key decisions that saved weeks:

WXT framework over raw Chrome APIs (hot reload, TypeScript, manifest generation)
Hono + Cloudflare Workers for the backend (zero cold start, global edge)
DeepSeek for AI inference (20x cheaper than GPT-4 for the same quality)

Month 2: Pivot to Problems, Not Features

I almost made the classic mistake: building features nobody asked for. Instead, I watched what freelancers were complaining about on Reddit
and Twitter.

That's how DocuVox (document OCR & chat) and JobPilot (1-click job autofill) were born — not from brainstorming, but from real complaints.

Month 3: The Chrome Web Store Is Not Your Friend

I got rejected twice. Here's what the review team flagged:

No remote code — eval() anywhere = instant rejection
Every host permission must be justified in your description
Description must be under 132 characters (yes, that tiny)
Remove all console.log before submitting
Privacy policy MUST be linked in the manifest

What Worked for Getting Users

Not Product Hunt. Not Hacker News. Reddit comments. Finding people with the exact problem and giving them a helpful answer. One well-placed
comment brought more users than any launch post.

Stack Summary

WXT + TypeScript for extensions
Hono + Cloudflare Workers for backend
DeepSeek for AI
Lemon Squeezy for payments
Zero servers, zero databases, zero DevOps

What I'd Do Differently

Submit to the Chrome Web Store on DAY ONE. Review takes 2-3 weeks.
Don't optimize before you have users. My first extension had 500 lines of unused code.
Talk to users before writing code. Every successful feature came from a Reddit complaint.

AMA in the comments about Chrome Extensions, solo dev, or the Chrome Web Store review process.

How I Built a Chrome Extension That Analyzes Contracts Using 1,700+ Real Statutes as RAG Grounding

henry — Wed, 10 Jun 2026 05:48:24 +0000

Two months ago I signed a contract with an auto-renewal clause I didn't notice. When I tried to cancel, I owed another year. That $1,200
mistake turned into PactLens — a Chrome extension that reviews contracts before you sign.

The core problem: LLMs hallucinate. You can't just ask an AI "is this clause risky" — it'll confidently make up laws that don't exist. So I
needed real statutes as a source of truth.

The RAG Pipeline

Here's how it works:

User selects contract text on any page → right-clicks → "Review with PactLens"
The text hits our Cloudflare Worker backend, which extracts clause-level semantics
We run semantic search against 1,700+ pre-loaded statutes using keyword matching + TF-IDF similarity
The top N most relevant statutes are injected into the prompt as context
The AI generates analysis grounded in those actual statutes, not hallucinations

The key insight: ground first, generate second. The AI doesn't need to know every law — it just needs to know how to apply the specific
statutes we feed it.

Why Static Pre-Loading Over a Vector Database

A vector DB would be "cleaner" architecturally. But:

Embedding 1,700+ statutes costs money and adds latency
Cloudflare Workers don't have great vector DB support
The statutes don't change daily — they're stable enough for pre-loading

So I went with plain text matching + TF-IDF stored in KV. Simple, fast, and surprisingly effective.

## What I'd Do Differently

Start with the Chrome Web Store review guidelines FIRST, not last
Use a lighter embedding model for better semantic search
Add a feedback loop — let users flag incorrect analysis

Stack

Hono + Cloudflare Workers (backend)
WXT + TypeScript (extension)
KV for statute storage
DeepSeek for AI inference

Links

Chrome Store: [link]
Web App: https://pactlens.net/contract

Would love feedback from anyone who's worked on RAG systems — especially on making semantic search fast at the edge.