Clarion

Product management is broken at the signal-to-spec boundary. Customer feedback lives scattered across support tickets, sales calls, Slack threads, GitHub issues, analytics events, and product reviews. Product managers manually synthesize this chaos into PRDs. Engineers guess at vague requirements like "make it fast" or "ensure it's responsive." Coding agents operate without context, generating code that doesn't reflect actual user needs. Every handoff loses fidelity.

No platform closes the full loop from raw customer feedback to shipped code. Competitors solve 2-3 stages each — Productboard takes signals to insights, Aha! handles roadmapping, Linear tracks specs, Cursor generates code — but nothing connects them natively. Teams stitch these together with spreadsheets, Notion pages, and Slack threads. Context decays at every boundary. Coding agents start from scratch every sprint. The data that should drive product decisions stays locked in silos.

The real opportunity isn't another point tool. It's the full pipeline: ingest → process → synthesize → decide → specify → ship → measure — as one system with shared identity, shared taxonomy, and shared scoring.

Building what is effectively seven enterprise products as one cohesive platform, with every stage natively connected to the next.

Signal Collector — 15+ source types with 7 native integrations (Zendesk, Intercom, Gong, GitHub, Jira, Linear, Amplitude), CSV import, webhooks with HMAC signing, manual entry, email-to-signal, Slack ingestion, app reviews. Incremental sync with cursor-based pagination, per-API rate limiting, content-hash duplicate detection, async processing via BullMQ.

Intelligence Engine — 7-stage AI pipeline: classification into 6 categories with confidence scoring → theme & entity extraction → sentiment (-1 to +1) and urgency (1-5) scoring → importance scoring (urgency × ARR × frequency × impact) → 1024-dim Voyage AI embeddings with pgvector HNSW → adaptive taxonomy classification with auto-evolution → anomaly detection (volume spikes, sentiment drops, theme emergence, churn risk clustering).

Knowledge Explorer — Multi-turn conversational RAG with hybrid search (70% semantic + 30% keyword via Reciprocal Rank Fusion) across signals, insights, opportunities, specs, and competitors simultaneously. Every answer cites source signals with exact customer quotes.

Opportunity Canvas — When 3+ signals from different customers describe the same need, Clarion auto-generates an opportunity with AI-written title, description, and priority score. The "What to Build?" engine synthesizes evidence and ranks recommendations with HIGH/MEDIUM/EMERGING confidence based on signal volume. Framework scoring via RICE, ICE, MoSCoW, or Value-Effort — calculated from real signal data, not PM intuition.

Spec Studio — The core differentiator. Every vague requirement becomes quantified: "fast" → "<200ms p95 latency," "responsive" → "layout adapts at 640px, 768px, 1024px, 1440px," "secure" → "OWASP Top 10, bcrypt(12), 100 req/min rate limit, CSRF tokens." Generates 5 machine-verifiable artifacts per spec: SPEC.md (60K+ tokens with numbered requirements REQ-001 through REQ-032+, data models, full API contracts, UI state machines, acceptance tests), tasks.json (22-78 dependency-sorted tasks with hour estimates), agents.md (5-agent workflow: Architect, Backend, Frontend, Testing, Review), .cursorrules (Cursor IDE context), and acceptance_tests.spec.ts (80+ test cases mapped TEST-001 to TEST-080).

Agent Bridge — Native Model Context Protocol server exposing 7 tools so coding agents query Clarion directly while building: query_opportunities, get_specification, search_feedback, get_customer_context, what_to_build, get_cursorrules, get_tasks. HMAC-authenticated API keys, every tool call logged for usage analytics.

Validation Campaigns — 5 campaign types (Smart Email, Micro-Survey, Combination, High-Touch, Concept Testing). AI drafts personalized outreach from the PM's identity, generates 5-question surveys, selects participants based on signal recency + ARR + engagement + segment diversity, and auto-generates reports with 5 recommendation verdicts (Proceed, Pivot, Investigate More, Deprioritize, Split Opportunity).

Autonomous Research Agents — Tavily for analyst-grade web search + Jina for content extraction. Plans research queries → searches competitor features → extracts content → synthesizes findings → correlates with internal customer signals. Detects when customers are asking for features competitors already have.

Auto-Calibration Learning — Scoring weights learn from shipped features' outcomes. If predicted impact ≠ actual impact, the system recalibrates future recommendations automatically. Post-ship signal analysis detects whether sentiment improved and theme volume decreased.

Multi-Tenant SaaS Foundation — 55 Prisma models with UUID v7, pgvector HNSW indexes, soft deletes. 4-role RBAC + custom org roles for approval workflows. AES-256-GCM encryption. CSP + HSTS (preload) + X-Frame-Options DENY. Redis-backed rate limiting with Lua atomicity across 4 tiers. Razorpay billing across 4 plan tiers (Starter free, Essentials $39, Pro $59, Enterprise custom).

All of this as one cohesive product — 119,039 lines of TypeScript across 932 files, 194 API routes across 12 feature domains, 217 React components, 63 pages, 39 versioned AI prompts, 49 distinct AI modules, 534+ test cases.

Built as a Next.js 15 monorepo with Prisma + PostgreSQL + pgvector + Redis + BullMQ. All 4 plan tiers live with Razorpay billing.

Unified LLM Client — automatic retry with exponential backoff, rate-limit detection with longer backoff, structured output validation via Zod on every response, cost tracking per call in AiProcessingLog. 3 Claude model tiers used strategically: Sonnet 4.6 default (99% of operations), Opus 4.6 for reasoning-heavy tasks (PRD critique, learning calibration), Haiku 4.5 for lightweight operations. Voyage AI voyage-4 for embeddings. Vercel AI SDK abstracts provider swapping.

39 versioned markdown prompts organized by function: core signal processing (3), PRD and spec generation (8), machine spec and artifact generation (9), opportunity recommendations (4), validation campaigns (4), taxonomy and learning (5), competitive research (3), knowledge chat (1). Each prompt is composable, testable, and has its own Zod schema for structured output.

Spec Studio Flow — Human PRD generated with real customer quotes → Machine Spec translates every vague term into quantified requirements → Validation scans for remaining ambiguity → 5 artifacts generated and bundled. Export formats include individual files, ZIP bundle, agent-specific formats (Cursor, Claude Code, v0, Bolt, Lovable), or direct push to GitHub as a PR.

MCP Server — packages/mcp-server implements Model Context Protocol over stdio transport. Cursor and Claude Code connect via `.cursor/mcp.json` or `claude_desktop_config.json` and query Clarion live — asking "what are the requirements for the auto-save feature?" and getting complete spec context without leaving the IDE.

Validation Campaign Infrastructure — Resend for email delivery with unsubscribe tokens. Public survey pages at `/validate/[slug]` (no auth required), branded with org logo and color, one-question-at-a-time Typeform-style UX. Responses auto-populate as VALIDATION_SURVEY signals, feeding back into the intelligence engine.

Spec Translator — Public tool at `/translate` (no auth). Paste any PRD → AI translates to machine-verifiable SPEC.md → download for Cursor, Claude Code, or Bolt. The free acquisition funnel — users who try the translator often upgrade for the full pipeline.

Full Traceability Chain — Every decision traceable: customer quote → insight → opportunity → spec → GitHub PR → shipped feature → outcome measurement → auto-calibration feedback. Interactive flow diagram on the Feature Detail page.

Closed-Loop Learning — Shipped features tracked against predicted success metrics. Post-ship signal analysis detects whether sentiment improved and theme volume decreased. Scoring calibration runs continuously, adjusting weights so future recommendations improve automatically.

Infrastructure — Docker Compose production deployment (PostgreSQL 16 + pgvector + Redis 7 + Next.js + BullMQ + Caddy). 3 GitHub Actions workflows: PR validation, weekly security scan, dev-to-prod sync. Health check endpoint verifying DB + Redis. Pino structured JSON logging.

The only platform generating machine-verifiable specifications directly from customer feedback for coding agents. Other products (Productboard, Aha!, Linear) stop at human PRDs; Clarion continues to the machine spec and hands it to agents via a native MCP server.

30 users onboarded in the first 15 days with zero paid marketing. Product-led growth entirely via the free Spec Translator at `/translate` — a genuinely useful standalone tool that serves as the top-of-funnel acquisition engine.

Technical depth: 119,039 lines of production TypeScript across 932 files. 194 API routes across 12 feature domains. 55 database models. 217 React components (50+ shadcn/ui primitives + 167 custom). 63 pages in Next.js 15 App Router. 39 versioned AI prompts. 49 distinct AI/research modules totaling 14,793 LOC. 534+ test cases. 123 git commits.

Integration breadth: 7 native integrations, 7 MCP tools for coding agents, 5 artifact types per spec, 5 validation campaign types, 4 RBAC roles, 4 plan tiers live with Razorpay, 3 Claude model tiers used strategically, 3 GitHub Actions CI/CD workflows.

Security: AES-256-GCM encryption, CSP + HSTS (preload) + X-Frame-Options DENY headers, Zod validation on all API boundaries, multi-tenant with org-scoped data isolation, Redis-backed rate limiting with Lua atomicity across 4 tiers (10/60/300/1000 req/min), comprehensive audit logging.

Live pricing: Starter (free, 5 PRDs/month), Essentials ($39/editor/month), Pro ($59/editor/month), Enterprise (custom). Annual billing at ~17% discount. Product audit rated 8.5/10 for MVP maturity.

AI-assisted development can 10x velocity when the architecture is right. The key insight was treating CLAUDE.md as the single source of truth — when your AI coding assistant has perfect context about conventions, patterns, constraints, and the domain model, it produces production-quality code consistently. Clarion was built with Claude Code as the primary pair programmer; that workflow became the product.

The full-loop is the moat. Every competitor solves 2-3 stages; none connect all 7 (signals → intelligence → opportunities → specs → agents → validation → outcomes) with auto-calibration feedback closing the loop. Building the full pipeline as one platform is a structural advantage integrations can't replicate — the data flows natively between stages with shared identity, shared taxonomy, and shared scoring.

Machine specs are the unlock for agent-native development. "Fast" and "responsive" are the enemy of reliable AI code generation. When every vague term becomes quantified, agents produce working code on the first attempt instead of the fifth. The Machine Spec format is a contract between product intent and implementation.

The Spec Translator was the highest-leverage feature for growth. Free, no-auth conversion of any PRD to machine-verifiable spec — a genuinely useful tool standalone that became the top-of-funnel acquisition engine. Product-led growth works when the free tool is better than paid alternatives in its narrow scope.

MCP is the right protocol for agent-native products. Building a native MCP server instead of requiring users to copy-paste specs makes agents feel like they have complete product context. The shift from "copy-paste workflows" to "live context protocol" is as big as the shift from FTP to API.

Structured output + retries + cost tracking is table stakes for AI infrastructure. The Unified LLM Client — with Zod validation, exponential backoff, rate-limit detection, and per-call cost logging — was the single most-used abstraction across 49 AI modules.