ghost.reviews

Inspiration

The domain ghost.reviews immediately suggested ghostwritten reviews: product reviews that look real, but may have been generated, copied, incentivized, or manipulated.

Fake reviews are a real consumer problem, and modern AI makes them cheap to produce at scale. I wanted to turn the domain into a useful product instead of just a clever name: a tool that helps shoppers see the “ghosts” hiding inside review pages.

What it does

ghost.reviews analyzes product reviews and returns an explainable Ghost Score.

Instead of giving a black-box accusation, it shows the evidence behind the score:

• suspicious timing bursts
• near-duplicate review text
• rating anomalies
• generic or template-like language
• incentivized review wording
• AI-like phrasing signals
• sentiment and star-rating mismatch
• per-review verdict reasons

The hosted demo uses bundled sample data so judges always get a fast, complete report without network failures or paid API dependencies. If someone searches outside the bundled examples, the app now shows a clean demo-only message instead of returning the wrong result.

How I built it

The app is built with Next.js, React, TypeScript, Tailwind CSS, and Vercel.

The scan flow goes through POST /api/scan, which can either load bundled demo fixtures or use the live-web architecture built around Nimble adapters. Reviews are normalized into a shared model, then scored by a pure TypeScript detection engine.

The frontend renders the result as a polished report: Ghost Score, verdict banner, signal meters, hauntings, duplicate evidence, review cards, and a generated share card.

The engine is intentionally evidence-first. Every signal is designed to produce human-readable support instead of a mysterious score.

Challenges I ran into

The biggest challenge was balancing hackathon reliability with a real live-web architecture.

Live crawling can be unpredictable during a timed demo, especially when depending on outside sites and credentials. To solve that, I built a judge-safe demo mode with bundled product examples while keeping the Nimble crawl/extract path in the architecture.

Another challenge was making the result trustworthy. A fake-review detector should not simply say “this is fake.” It needs to show what it found, why it matters, and which reviews contributed to the score.

Accomplishments that I’m proud of

• Built an end-to-end product scan experience from query to evidence report.
• Created a memorable product concept directly tied to the ghost.reviews domain.
• Added reliable bundled demo data for the hosted submission.
• Kept the detection engine pure, typed, and unit-tested.
• Built transparent scoring instead of a black-box verdict.
• Added generated share-card support.
• Stayed on a free stack with no required paid APIs.

What I learned

For trust tools, the user experience matters as much as the detection logic. A score only becomes useful when people can inspect the evidence behind it.

I also learned that hackathon demos need reliability by design. The app should be honest about what is live, what is bundled, and what judges can expect every time they open it.

What’s next

• Browser extension overlay for shopping pages.
• Product comparison mode.
• More marketplace/source adapters.
• Brand dashboard for monitoring suspicious review patterns over time.
• Public API for review-quality checks.

Built With

• framer-motion
• free-tier
• groq/gemini/runpod
• llm
• lucide-react
• next.js
• nimble-sdk-api
• optional
• react
• tailwind-css
• typescript
• vercel
• vitest
• zod