prism0x2a 0.7.2 → 0.11.0

package/.next/standalone/docs/marketing/launch-materials.md

@@ -0,0 +1,696 @@
+# HN Launch Materials — prism0x2A
+
+> Drafted 2026-05-18 for HN Show-HN launch.
+> Status: drafts for review, refinement, then dispatch.
+
+---
+
+## Strategic Recap
+
+**Hero positioning:** Local-first code intelligence dashboard. Understands what AI just generated.
+
+**Primary persona:** Developer using Cursor / Claude Code / Copilot, generating large amounts of code, drowning in unfamiliar codebase.
+
+**Brand pillars:**
+1. **Local-first** — no telemetry, no data leaves the machine
+2. **AI-augmented intent** — "Cursor writes it, prism0x2A makes you own it"
+3. **42-narrative** — founding-day on 42nd birthday, "the answer to your codebase"
+4. **Pair-product story** — `prism0x2A` discovers, `forge0x2B` tells the story
+
+**Anti-positioning** (what we are NOT):
+- Not another AI code generator (we're complementary)
+- Not a SaaS cloud product (local-first is the point)
+- Not for non-TypeScript projects (initially TS/React focused)
+
+---
+
+## HN Show-HN Title Variants
+
+The title is **the single most important launch decision** — 80% of click-through depends on it.
+
+### Variant A — Direct positioning
+> **Show HN: prism0x2A – Local-first code intelligence for AI-generated codebases**
+
+Rationale: clear what + clear value-prop. "Local-first" signals trust. "AI-generated" hooks the target persona. Length: 78 chars.
+
+### Variant B — Provocative pitch
+> **Show HN: prism0x2A – Cursor writes the code. prism0x2A makes you own it.**
+
+Rationale: directly references competitor without attacking. Frames complement-not-compete. Memorable. Length: 80 chars.
+
+### Variant C — Personal narrative
+> **Show HN: prism0x2A – Built on my 42nd birthday to make sense of my codebase**
+
+Rationale: HN loves personal stories + birthday twist creates curiosity hook. Emotionally resonant. Hex "0x2A" payoff revealed inside. Length: 86 chars.
+
+### Variant D — Technical specificity
+> **Show HN: prism0x2A – TypeScript code analysis dashboard, runs locally, free up to 50k LOC**
+
+Rationale: dev-tool-classified positioning. Numbers signal seriousness. Free-tier hook. Length: 95 chars.
+
+### Variant E — Bundle teaser
+> **Show HN: prism0x2A + forge0x2B – Architect AND marketing department in your repo**
+
+Rationale: full ecosystem story. Higher curiosity-quotient. Risk: pair-product narrative is novel. Length: 91 chars.
+
+### Recommendation: **Variant B**
+
+Reasoning:
+- Provocative without being aggressive
+- Directly addresses the target persona's pain (Cursor user with code they don't understand)
+- "Makes you own it" is unique copy, not generic dev-tool speak
+- Short enough for mobile preview
+- Sets up clear value-prop in <80 chars
+
+**Backup: Variant C** if you want the personal narrative angle.
+
+---
+
+## HN Show-HN Post Body
+
+```markdown
+Hi HN,
+
+prism0x2A is a local-first dashboard that helps you understand code
+your AI tools just wrote. Or any code, really — but the trigger for
+building this was watching teams generate thousands of lines with
+Cursor/Claude/Copilot, then struggle to navigate, review, or take
+ownership of what was generated.
+
+What it does:
+- Scan your TypeScript/React codebase (cycles, imports, file metadata,
+  test coverage, registry of "capabilities")
+- Generate LLM-driven recommendations with your own Anthropic API key
+- Persist everything locally in .prism/ — no telemetry, no cloud, no
+  data leaves your machine
+- Optional: detect monorepos (pnpm/npm/yarn workspaces, Nx, Lerna,
+  Turborepo) and aggregate insights across packages
+
+How it works:
+  npm install --save-dev prism0x2a
+  npx prism init
+  npm run prism
+  → Dashboard at http://localhost:3001
+
+Why "0x2A":
+  Hex for 42 — the answer. Project started on my 42nd birthday.
+  Some coincidences write themselves.
+
+Why local-first:
+  Your codebase is your most sensitive asset. Most AI dev-tools today
+  send your code to someone else's servers for "analysis". prism0x2A
+  runs entirely on your machine. The only network calls are: (a) your
+  own LLM API key calls (you choose the provider), and (b) license
+  validation if you upgrade to Pro (once every 30 days).
+
+What's already shipped:
+- v0.8.0 — Dashboard with BLUE (sessions/recommendations), AMBER
+  (coverage/registry/files), GREEN (insights/cross-layer/queries),
+  Settings, Pricing
+- Free tier: up to 50,000 lines of source code per project, static
+  analysis only
+- Pro tier (€39/m): unlimited LOC, monorepo support, all LLM features,
+  custom queries
+- Team tier (€99/dev/m): shared state, CI integration
+
+Cross-sell hint:
+  There's a sister product called forge0x2B (just released, early
+  access) that takes prism's analysis and generates release notes,
+  blog posts, social copy. "0x2B" is hex for 43 — and yes, "2B or not
+  2B" was intentional. Bundle Spectrum 0x55 (49€/m) gets you both.
+  forge0x2B is here: https://github.com/dadenjo/forge0x2B
+
+Tech stack:
+- Next.js 16 (App Router)
+- TypeScript strict mode
+- Tailwind v4
+- prismlens (the engine library, MIT-licensed, also on npm)
+- File-system persistence (no DB)
+- Anthropic SDK (bring your own key)
+- Lemonsqueezy for subscriptions (handles EU VAT compliance for me)
+
+Repo: https://github.com/dadenjo/prism0x2A
+npm: https://www.npmjs.com/package/prism0x2a
+Engine: https://github.com/dadenjo/prismlens
+Brand: https://github.com/prism0x2A (org with full ecosystem map)
+
+Architecture diagram:
+  prismlens (engine) → prism0x2A (dashboard) → your .prism/ folder
+  forgesmith (engine) → forge0x2B (dashboard) → reads sibling .prism/
+
+The whole brand-family is open in the org. Engines are MIT. Dashboards
+are source-available with commercial license (free for personal use +
+OSS projects + below 50k LOC).
+
+I'd love feedback. Especially curious:
+- Is the local-first positioning resonant for HN's audience?
+- Anyone here using Cursor/Claude Max who'd see value in the
+  pair-product story (analysis + content-generation)?
+- For monorepo users: is auto-detection of pnpm/npm/yarn/Lerna/Nx/Turbo
+  enough, or are there other patterns I should support?
+
+Open to questions. Happy to deep-dive any technical or product
+decisions.
+
+— Joachim
+```
+
+Word count: ~520 words. Sweet spot for HN show-hn (not too long, not too short).
+
+---
+
+## Tweet / X Thread
+
+Optimized for tag-of-launch-day. 10 tweets max.
+
+### Tweet 1 (Hook)
+```
+Just launched prism0x2A on @ycombinator HN.
+
+It's a local-first code intelligence dashboard built for the AI-coding
+era. Free up to 50k LOC.
+
+Cursor writes the code. prism0x2A makes you understand it.
+
+Link in next tweet 👇
+```
+
+### Tweet 2 (Link + Visual)
+```
+HN post here: https://news.ycombinator.com/show
+
+[attach hero screenshot]
+
+It scans your TypeScript/React codebase locally — no cloud, no
+telemetry, no data leaves your machine.
+
+Free for personal. Pro at €39/m unlocks unlimited LOC + LLM features.
+```
+
+### Tweet 3 (Why this matters)
+```
+The reality for AI-augmented devs:
+
+→ You generate 1000s of lines with Cursor/Claude
+→ You scroll through, hit "looks good"
+→ Three weeks later: "wait, who wrote this? what does it actually do?"
+
+prism0x2A is the answer.
+```
+
+### Tweet 4 (Tech detail — for dev audience)
+```
+What's under the hood:
+
+- Static analysis (cycles, imports, registry)
+- Coverage hot-spots
+- LLM-driven recommendations (your own Anthropic key)
+- Monorepo auto-detection (pnpm/npm/yarn/Nx/Lerna/Turbo)
+- File-system persistence — .prism/ folder
+
+No DB. No server. Pure local.
+```
+
+### Tweet 5 (Brand-Story / 42-narrative)
+```
+Why "0x2A"?
+
+Hex for 42. The answer to everything.
+
+I started building this on my 42nd birthday. Some coincidences
+write themselves.
+
+(There's also a sister product called forge0x2B — 0x2B = 43.
+ Hint: "2B or not 2B")
+```
+
+### Tweet 6 (Bundle pitch)
+```
+The pair-product story:
+
+🔵 prism0x2A — Discover and understand
+🟠 forge0x2B — Forge the message from the code (release notes,
+   blog posts, social copy, internal updates)
+
+Bundle "Spectrum 0x55" gets you both at €49/m.
+
+It's an architect AND a marketing department in your repo.
+```
+
+### Tweet 7 (Use case demonstration)
+```
+A workflow that's now possible:
+
+1. Cursor writes 2000 lines for a new feature
+2. prism0x2A scans → identifies test gaps + cycle risks
+3. forge0x2B turns the prism session into a release note
+4. You ship + tweet about it without writing the release post yourself
+
+All local. All your data.
+```
+
+### Tweet 8 (Architecture transparency)
+```
+For the curious — the architecture:
+
+prismlens (MIT engine) → prism0x2A (source-available dashboard)
+forgesmith (MIT engine) → forge0x2B (source-available dashboard)
+
+Engines are fully open. Dashboards are source-available with
+commercial license. License keys via @lmsqueezy (handles EU VAT
+properly, which raw Stripe doesn't).
+```
+
+### Tweet 9 (Story / encouragement)
+```
+Built this in ~6 weeks of focused work. Solo. AI-augmented
+development.
+
+Yes, I used Cursor + Claude Code to build the tool that helps
+you understand Cursor + Claude Code output. The irony is the
+feature, not the bug.
+```
+
+### Tweet 10 (CTA)
+```
+→ Try it: npm install --save-dev prism0x2a
+→ HN post (please upvote if useful): [link]
+→ Repo: github.com/dadenjo/prism0x2A
+→ Org with full ecosystem: github.com/prism0x2A
+
+Questions/feedback super welcome.
+
+🔮 = prism. 0x2A = 42.
+```
+
+---
+
+## LinkedIn Founder Post
+
+Optimized for founder voice + professional audience. ~250 words.
+
+```
+Today I launched prism0x2A on Hacker News.
+
+It's a local-first code intelligence dashboard built for an era
+where most of us generate code with AI tools (Cursor, Claude, Copilot)
+faster than we can understand what was generated.
+
+The premise is simple: your codebase is your most sensitive asset.
+Most "AI code analysis" tools today send your code to someone else's
+servers. prism0x2A runs entirely on your machine — your code never
+leaves it.
+
+What it does:
+• Scans TypeScript/React projects (cycles, imports, coverage, files)
+• Generates LLM-driven recommendations using YOUR API key
+• Persists everything in a local .prism/ folder — no cloud, no
+  telemetry
+
+Free up to 50,000 lines of source code per project. Pro tier (€39/m)
+unlocks unlimited LOC, monorepo support (pnpm/npm/yarn/Nx/Lerna/
+Turborepo all auto-detected), and full LLM features.
+
+Built solo, AI-augmented, in ~6 weeks of focused work.
+
+The "0x2A" in the name is hex for 42. Project started on my 42nd
+birthday — felt too poetic to ignore.
+
+There's also a sister product called forge0x2B (yes, "2B or not 2B")
+that takes prism's analysis and generates release notes, blog posts,
+marketing copy. Bundle pricing at €49/m for both.
+
+If you're a TypeScript/React dev using AI coding tools, I'd love
+your feedback.
+
+Repo: github.com/dadenjo/prism0x2A
+HN post: [link]
+
+DM if you want to chat about the build or the local-first philosophy.
+
+— Joachim
+```
+
+---
+
+## Email Template (Early Supporters)
+
+For people who've been following the journey. Personal tone.
+
+```
+Subject: prism0x2A is live (and yes, the 42 thing is real)
+
+Hi [Name],
+
+Quick one — prism0x2A launched on HN this morning.
+
+You've heard me ramble about this for weeks (or months). Here it is,
+finally shipped:
+
+https://news.ycombinator.com/show/...
+
+Live npm install:
+  npm install --save-dev prism0x2a
+  npx prism init
+  npm run prism
+
+Free up to 50k LOC. Pro at €39/m unlocks everything (unlimited,
+monorepo, LLM features).
+
+If you have 2 minutes and find it useful:
+  → Upvote on HN: [link]
+  → Star the repo: github.com/dadenjo/prism0x2A
+
+If you find a bug:
+  → Issue: github.com/dadenjo/prism0x2A/issues
+  → Or just text me
+
+Also, sister-product forge0x2B is live (early access) for content
+generation from prism data: github.com/dadenjo/forge0x2B
+
+Today is a day. Thanks for being part of it.
+
+— J
+
+PS: 0x2A = 42 (yes, started on my 42nd birthday, no it wasn't
+intentional planning, yes I'm leaning into it)
+PPS: 0x2B = 43 ("2B or not 2B")
+```
+
+---
+
+## HN Comment FAQ — Predicted Questions + Answers
+
+Pre-drafted responses for common HN-comment questions. Use as cheat-sheet during launch-day.
+
+### Q: "Why not just use Sourcegraph / Codeium / [competitor]?"
+
+A:
+```
+Fair question. The differences:
+
+Sourcegraph is enterprise-positioned, requires a server, and most
+of their dev-focused features moved to paid tiers. prism0x2A is
+local-first by design — your code never leaves your machine.
+
+Codeium/Cursor focus on code generation. prism0x2A focuses on
+understanding code that already exists (much of which is now
+AI-generated and unfamiliar to the dev who "wrote" it).
+
+We're complementary to code-generation tools, not replacement.
+```
+
+### Q: "What's your moat? Anyone could rebuild this in a weekend."
+
+A:
+```
+You're right that the static-analysis parts (cycle detection, import
+graphs) aren't novel — the algorithms are decades old. The value-add
+is:
+
+1. The orchestration: combining static analysis + LLM-driven insights
+   + recommendations workflow in a polished dev-tool UX.
+
+2. The local-first commitment. Most competitors phone home. We don't.
+
+3. The pair-product story with forge0x2B for content generation.
+
+4. The bundle pricing makes the "architect + marketing department"
+   story compelling for solo devs and small teams.
+
+Could someone fork prismlens (MIT-licensed engine) and rebuild the
+dashboard? Sure. License is source-available + trademark for the
+brand. We rely on speed of iteration, community, and brand for moat.
+```
+
+### Q: "Pricing seems high vs Cursor ($20)"
+
+A:
+```
+Different product. Cursor is an IDE — coded for an individual writing
+code. prism0x2A is a dashboard for understanding codebases (yours,
+your team's, or AI-generated). Different value-prop, different
+audience.
+
+€39/m is mid-market for dev tools (cheaper than Sentry, similar to
+Linear). For an individual dev: 1 hour saved per month equals the
+subscription cost at typical loaded dev-rate.
+
+For OSS projects + personal use: it's free up to 50k LOC.
+```
+
+### Q: "Why TypeScript/React only? When will you support Python/Go/Rust?"
+
+A:
+```
+Honest answer: I work primarily in TS/React, so it's where I have the
+strongest opinions about what "good code intelligence" looks like.
+
+Architecturally, prismlens (the engine) is language-agnostic for
+static analysis (graph algorithms work on any AST). The LLM-driven
+features just need different prompts per language.
+
+Python support is the most-requested next-language. Realistic timeline:
+3-6 months after launch, once we have signal that the TS/React product
+works well enough to expand.
+
+If you're a Python/Go/Rust dev and want to be a design partner: DM me.
+```
+
+### Q: "Open source the dashboard?"
+
+A:
+```
+The engine (prismlens) IS open source — MIT licensed. You can build
+your own dashboards on top.
+
+The prism0x2A dashboard is source-available (you can read the code in
+the GitHub repo). It's licensed for free personal use + free OSS use,
+with a commercial license for companies above 50k LOC. Same model as
+Sentry's Functional Source License, Sourcegraph's Community License,
+or Cursor's freemium model.
+
+This lets us capture some revenue to sustain development while keeping
+the engine truly open.
+```
+
+### Q: "Why local-first? Cloud would be more convenient"
+
+A:
+```
+Three reasons:
+
+1. Your codebase is your most sensitive IP. Sending it to an external
+   service is a real risk most teams underestimate.
+
+2. Local = offline-capable. Works on the plane, in air-gapped envs,
+   in compliance-heavy industries.
+
+3. Local = no per-call SaaS costs. Your LLM key, your costs, your
+   data residency.
+
+The tradeoff is no automatic team-sync (Team tier addresses this via
+git-based shared state). For a solo or small-team use-case, local-first
+is almost always better.
+```
+
+### Q: "How do you make money?"
+
+A:
+```
+Subscriptions. Three paid tiers:
+
+- Pro €39/m or €390/y (single dev, commercial use, unlimited LOC,
+  LLM features, monorepo)
+- Team €99/dev/m (multi-developer, shared state, CI)
+- Spectrum Bundle €49/m (prism0x2A + forge0x2B together)
+- Enterprise: contact for custom (self-hosted, SLA, revenue-share for
+  $10M+ ARR companies)
+
+Free tier is genuinely useful (50k LOC, static analysis), not crippled.
+The conversion happens when users hit LOC limit or want LLM features.
+
+Payments handled by Lemon Squeezy (Merchant of Record) so I don't have
+to deal with EU VAT or US sales tax compliance.
+```
+
+### Q: "Why hex names?"
+
+A:
+```
+0x2A = 42 (the answer). 0x2B = 43 (the next answer / "to be or not
+to be" 🎭).
+
+Started building prism0x2A on my 42nd birthday. The hex was already
+a working title to differentiate from generic "prism" projects (and
+there are many — wheel-alignment machinery, journalism YouTube
+channels, etc.).
+
+Some coincidences are too good to refactor away.
+```
+
+### Q: "What's the AI cost story for users?"
+
+A:
+```
+Users bring their own LLM API key (Anthropic supported now, OpenAI/
+others coming). You control your costs. Typical workflows cost
+€2-15/month in Anthropic API calls depending on usage.
+
+We don't markup or charge for LLM tokens. The subscription is for the
+dashboard + license, not for inference.
+```
+
+### Q: "Will you accept contributions?"
+
+A:
+```
+On prismlens (MIT engine): absolutely. PRs welcome.
+
+On the dashboards: source-available, but currently no contribution
+model. Plans to open this up once the product matures and contribution
+guidelines are clear. For now: bug reports + feature requests via
+GitHub issues are super valuable.
+```
+
+### Q: "Are you VC backed?"
+
+A:
+```
+No. Solo founder, bootstrapped, self-funded.
+
+Revenue from subscriptions covers development. If it grows enough,
+I might raise; for now, the model works as-is.
+```
+
+---
+
+## Bundle 0x55 — Spectrum Copy
+
+For dedicated Bundle-marketing in tweets/posts:
+
+```
+Introducing Spectrum 0x55.
+
+prism0x2A + forge0x2B in one bundle. €49/month (save €19 vs separate).
+
+→ prism0x2A discovers what's in your code
+→ forge0x2B turns those discoveries into release notes, blog posts,
+  social copy
+
+It's an architect AND a marketing department, in a box.
+
+0x55 = 0x2A + 0x2B = "U" in ASCII. For U.
+
+Available at: github.com/prism0x2A
+```
+
+---
+
+## Launch-Day Timeline
+
+US East Coast morning + EU evening for max HN visibility.
+
+```
+06:00 EU time (06:00 UTC = 02:00 EST = night for US)
+  → Final pre-launch checks (Lighthouse, domain DNS, repo READMEs)
+
+09:00 EU time (= 04:00 EST = pre-work for US)
+  → Light social warmup tweet ("today is a day, more soon")
+
+13:00 EU time (= 08:00 EST = pre-work US morning)
+  → HN Show-HN submitted
+  → LinkedIn post published
+  → Tweet 1 of thread
+
+13:30 EU time (= 08:30 EST)
+  → Email to early-supporters list
+  → Discord/Slack outreach to known supporters
+  → Tweet 2-10 in sequence
+
+14:00 EU time (= 09:00 EST)
+  → Monitor HN front-page-rank
+  → Reply to first comments quickly (HN algorithm rewards engagement)
+
+15:00 EU time (= 10:00 EST = US morning peak)
+  → All hands on HN comments
+  → Watch for spikes in npm install counts
+  → Engage every meaningful comment
+
+20:00 EU time (= 15:00 EST = US afternoon)
+  → Reply round 2
+  → Re-tweet first round to keep momentum
+
+24:00 EU time (= 19:00 EST = US evening)
+  → Wrap, sleep, recover
+
+Next day:
+  → Email/note follow-ups
+  → Issue triage
+  → npm install + GitHub star metrics
+```
+
+---
+
+## Anti-Patterns to Avoid on Launch Day
+
+- ❌ Don't repost on HN if it doesn't fly (frowned upon)
+- ❌ Don't reply with "thanks!" or low-effort to every comment
+- ❌ Don't disable comments anywhere
+- ❌ Don't argue with critical comments — engage thoughtfully
+- ❌ Don't oversell — let the product speak
+- ❌ Don't ghost mid-launch — be present for 8h after submission
+- ❌ Don't post on Tuesday/Wednesday tech-blog-overload days (we'll target Thu/Fri)
+
+---
+
+## Metrics to Watch
+
+```
+HN-specific:
+- Front-page-rank within 1h (target: top 30)
+- Total upvotes (target: 100+ for "decent launch")
+- Comments-count + engagement (more important than upvotes)
+
+Product-specific:
+- npm install count (target day-1: 50+)
+- GitHub stars (target day-1: 30+)
+- Pro tier sign-ups (target week-1: 3-5)
+- /pricing visits (target: 200+ unique)
+
+Brand-specific:
+- prism0x2a.dev visits (target: 500+ day-1)
+- @ mentions on X/Twitter (target: 5+ organic)
+- Bookmarked/saved (HN saves count)
+```
+
+---
+
+## After-Launch Roadmap
+
+```
+Week 1:
+- Respond to all feedback
+- Triage GitHub issues
+- Quick bug-fix releases as needed
+- forge0x2B GA push (if Phase 2 done by launch)
+
+Week 2:
+- Blog post recap "Launching prism0x2A: lessons learned"
+- Engage successful HN-comment-questions as follow-up content
+- LinkedIn long-form post (~800 words)
+
+Week 4:
+- Decide: Python support / what's next based on user signal
+- forge0x2B full marketing push for Spectrum bundle
+- Domain-specific features based on early user feedback
+
+Month 2:
+- Public roadmap published
+- Open source contribution-model decision
+- Eval: VC/angel-funding or full bootstrap continue
+```
+
+---
+
+*All material drafted for review. Refine per personal voice, factor in latest forge0x2B Phase 2 status before final launch-day text.*