Show HN：Viberuler——衡量你的 AI 编程上下文流向何处

Vibe 编程者的基准测试。
你的 vibe 到底有多猛？只有一种办法可以知道：

---

viberuler 会在几秒内于本地扫描你的机器，并计算你的 VIBE SCORE：

信号	来源	可炫耀数据
🧠 消耗的 token	Claude Code + Codex 会话日志（以及你的 LiteLLM 网关，需主动启用）	1.2B tokens
💸 每美元 token 数	token ÷ 花费（内置价格表）	6.5M tok/$ — TOP 3%
⚡ 已交付 LoC	你在自己的提交中新增的代码行，减去生成内容	312K LoC
⚙️ 机器噪声	你提交的生成代码行，以及它们在 diff 中的占比	163K · 33% of diff
📦 项目	你曾提交代码的仓库	47 projects
🔥 连续记录 · 节奏	连续提交天数，以及每个活跃日的提交次数	212-day streak · 8.4/day
🏆 成就	见下文	Token Billionaire
🤖 设备中的 Agent	你 home 目录中已知编程 Agent 的标记目录	4 agents · Claude Code · Codex · Antigravity
⏳ Codex 套餐余量	Codex 已写入会话日志的 rate_limits 记录——不计分、不上传	5h 12% used · resets in 45m · week 2% used

接着，它会打印一份你还没来得及克制自己就想截图的计分卡。

tokens per dollar 是最核心的统计指标。 任何人都能烧 token；高效地烧 token 才是这场游戏的关键。

Token 是赌场筹码。 它们以这样的单位计价，让你感觉不到自己是在花钱；而每一种新的工作方式（vibe 一下、长篇大论地交代一下、让 Agent 自己琢磨）都降低了操作成本、提高了消耗。viberuler 就像赌场的兑款窗口：在你重新坐回赌桌前，它会把筹码换算回美元——按 API 等价价格计算总额，并按平台分类。

LoC 计算的是你写过什么，而不是你拥有什么。 以前它按仓库目录树的大小计算——这会把你从未碰过的第三方代码，以及编译器生成的每一行代码，都算作你的功劳。现在，它统计你自己提交中新增的代码行，并排除生成内容。这让作者原先的头部数字下降了 17%，但我们发布的是更小、也更真实的数字。详细原因 →

被排除的代码行仍会展示。 作者 diff 的三分之一原来是机器输出——重新生成的类型、bundle、lockfile。它们不参与计分，也永远不会离开你的机器；它是一个需要缩小的基线。看不见的数字，就无法减少。

这是一面镜子，不是绩效评估。 这里的每一个数字都只针对一台机器和一个人：你自己。按消耗的 token 给初级开发者评分，你得到的只会是一个拼命烧 token 的初级开发者——古德哈特定律一周内就会应验，而 token 账单由你来付。截图、炫耀、与自愿参与的人比较都可以；但一旦它进入某人的绩效评估，它就不再衡量任何东西。

Prompt Peasant → Vibe Apprentice → Token Burner → Context Goblin → Ship Machine → GIGACHAD SHIPPER → Singularity Adjacent

（没有数据？你会获得 NPC (no vibes detected)。我们很抱歉。并不抱歉。）

| |
---|---|---
💰 Token Billionaire — ≥10 亿 token | 🪦 Free Tier Martyr — 在不足 1 美元的花费下使用 ≥100 万 token | 🗄️ Cache Whisperer — 缓存读取占比 >90%
🌐 Polyglot — 使用 5 种以上语言 | 🐘 Monorepo Menace — 在一个仓库中创作 10 万行以上代码 | 🔥 Streak Freak — 连续提交 100 天
🌙 3AM Committer — 深夜提交 10 次以上 | 💥 YOLO Force Pusher — 改写历史 20 次 | 🎰 High Roller — 消耗 1,000 美元以上的 API 等价值
🎲 Table Hopper — 在 3 个以上平台各消耗超过 1 美元 | |

通过 GitHub 设备流登录后，你的分数会发布到 viberuler.dev/u/<you>，成为一张用于炫耀的 Vibe 测量证书（LoC · tok/$ · 连续记录 · Agent · 排名 · 称号）。提供全球排名、效率百分位，以及预填充的分享链接——X · LinkedIn · Facebook · Bluesky。

分享到 Stories ——证书页面还会渲染一张竖版 9:16 的 故事卡片（类似 Spotify Wrapped 的数据揭晓），并提供 Share to Stories 按钮。在移动端，它会将卡片直接交给手机的原生分享面板——Instagram、WhatsApp、Facebook、Messenger；在桌面端则会下载卡片供你发布。（Stories 仅限 App 内使用，因此这是唯一可行方式——Spotify Wrapped 采用的也是同一机制。）

• 默认运行会发起零网络请求。零。
• --submit 仅发送汇总数据——共 14 个字段：聚合统计、成就 ID、你的编程 Agent 名称、提交连续记录和交付结果（已交付功能数 / 已合并 PR 数）。不发送路径、仓库名称、提示词或代码。绝不发送。
• 在发送任何内容之前，CLI 会打印精确的 JSON 载荷并征求确认。
• --share 同样不会发送任何数据：它只会打印一个包含展示数字的 URL。是否打开或发布该链接由你决定，而它渲染的卡片会标记为未经验证。
• 时间指标来自你转录记录中已有的时间戳。它不会监控你的屏幕，也不会读取、存储或发送窗口标题、路径或文件名。
• 不要相信我们——阅读大约 140 行代码：packages/cli/src/payload.ts 和 packages/cli/src/submit.ts。详情见：PRIVACY.md。

完整公式、价格表、归一化方式和坦诚的免责声明位于 METHODOLOGY.md。简版如下：

VIBE = 1000·log₁₀(1 + LoC/1000)          # shipping volume
     +  500·log₁₀(1 + tokens/1M)         # AI leverage
     +  800·efficiency_percentile        # tokens/$ vs the world
     +  300·log₁₀(1 + projects·10)       # breadth
     +  min(streak, 365) + 50·achievements

到处都使用对数——大户会被压缩，新手仍有上升空间。

npx viberuler wrapped --month 2026-06

你当月的 Vibe Wrapped——提交记录、最繁忙的一天、连续记录、主要语言，以及该时间段内的 Claude Code token/成本。100% 本地运行；截图并炫耀。

npx viberuler                # scan + scorecard (100% local)
npx viberuler audit          # audit your rig — see below
npx viberuler --submit       # push to the global leaderboard
npx viberuler payload        # show exactly what --submit WOULD send
npx viberuler --json         # machine-readable
npx viberuler --scan-dir ~/code --since 2026-01-01
npx viberuler --scan-dir ~/work --scan-dir ~/oss   # repeatable — scans ALL repos under each root
npx viberuler --github <handle>   # add your stars (the only other network call)
npx viberuler --share        # print a shareable card URL (nothing is sent)
npx viberuler audit --idle-gap 5             # pause (minutes) that stops counting as attention
npx viberuler audit --compare 2026-06-01..2026-07-01   # that window vs the equally long one after it
npx viberuler audit --market   # reprice your mix at live market rates (one catalog GET, opt-in)

一次不带参数的运行会扫描你 home 目录下的每一个 Git 仓库。如果你的代码位于其他位置（或分布在多个位置），请为每个根目录指定 --scan-dir——这个参数可重复使用，且所有指标（LoC、提交数、功能数、PR 数）都会在找到的全部仓库中累加，因此你的证书反映的是完整工作成果，而非单个项目。

你的 每美元 token 数分数说明你烧 token 的效率。audit 则说明你的 设备环境 配置得有多高效。它 100% 在本地运行，并读取你的 Claude Code 转录记录：

• Token 经济性 ——缓存命中率，以及提示词缓存实际为你节省了多少 API 等价美元。
• 上下文放大 ——你允许进入上下文的平均每个 token，在后续轮次中被重复读取了多少次。仅在主线程中测量：将内容汇集到短生命周期子 Agent 上下文中，会令这一数字减半，并低估你日常所在主线程中 token 的真实成本。（在一台真实设备上：1088×。）
• 子 Agent ——衡量它们压缩得有多厉害：子 Agent 内部获取的工作量，与返回摘要的比率。它们并非免费（存在真实开销），但在 1000 倍放大的情况下，让 token 留在主线程之外就是全部游戏规则。
• 🧊 冷上下文 ——在你输入一个字之前，一个会话的成本：系统提示词、工具名称、Agent 与技能描述、记忆。每次启动子 Agent 都要重新支付这笔成本。（在一台真实设备上：会话启动时为 50.2K tokens，每次 3,234 次启动中均重新支付 33.1K。）
• 👻 幽灵 token ——某个输出重写插件承诺为你节省的 token；这里不接受承诺，而是进行测量。超大结果（>4KB）占全部纳入内容的 54%；著名的“去重重复读取”技巧只值 2%。
• 主要工具 ——哪些工具真正填满了你的上下文，按调用次数和 token 数排序。
• ☠️ 无效负担 ——每个会话都加载、启动一个进程、注入其工具 schema……但调用次数为零的 MCP 服务器与插件。

最后一项才是重点。作者的设备上发现了两个 MCP 服务器：它们在 76 个进程中占用 1.5 GB RAM，却在 10,700 多个会话中获得 0 次调用。移除它们后，中位冷上下文从 49.9K 降至 41.1K token——此后每个会话都有 17.5% 的折扣，也证明延迟加载工具 schema 并不能让未使用的服务器变成免费。

测量胜过猜测——对于一个按 vibe 给你打分的工具来说，这个结论有点尴尬。

上下文浪费——呈现规模与改善手段，绝不宣称节省额

许多工具都承诺能将你的 token “最多减少 90%”。它们都是真实项目；但没有一个公开其数字背后的方法论。audit 采取另一种立场：依据你自己的转录记录，说明上下文流向了何处。

CONTEXT WASTE
  5.7M tok · 2,555 calls   oversized single results          → slice / grep before read
  2.2M tok · 4,068 calls   subagent-returned tokens          → tighter subagent contracts
  1.9M tok · 3,394 calls   whole-file reads never edited     → outline-first / symbol reads

以下三条规则保证诚实性；它们不只是写在文档中，也会在输出中强制执行：

• 不说“你本可以节省 N%”。 反事实无法得知——一次没有导致改动的读取，可能恰恰是告诉你 不应该 改动的那次读取。
• 不提供总计。 这些分类在设计上存在重叠（一次超大读取也可能属于探索性读取），因此将它们相加会重复计算，并人为制造一个吸引眼球的数字。
• audit --compare A..B 会将两个时间窗口并排展示——安装一个优化器，比较安装前后——并将差异标记为一种_观察结果，而非因果关系_，因为两个窗口中的工作负载不同。没有会话的窗口会显示“数据不足”，而不是打印一个看似好看的零。

按市场价格计算你的组合（audit --market）

将“筹码换美元”的视角扩展到整个交易市场：根据你测量到的 token 使用组合，按一组精选现有模型的标价重新计价——包括开放权重旗舰模型（Kimi K3、DeepSeek、GLM、Qwen、Llama、MiniMax）和闭源梯队。费率来自对 OpenRouter 公共目录发起的一次匿名 GET 请求（与 --github 一样，这个标志需要主动选择联网），在本地缓存一天；同时提供内置快照的离线后备，输出会标明使用了哪个数据源。这是算术，不是建议：tokenizer、质量和缓存机制各不相同，因此表格只说明你的使用量在不同柜台需要多少成本，绝不声称你能节省多少。

同一张表还回答了每美元可获得的最大 AI 性能：在目录提供 Artificial Analysis intelligence index 的情况下，每个柜台都会显示基于_你的_使用组合计算的每一个指数点成本（$/pt），并按这一指标排名，最便宜者会获得 🏆——最初的统计方式是每美元积分，但当使用组合达到数十亿 token 时，它会让每一行都显示 0.00；而 $12.77/pt vs $688.51/pt 在任何规模下都清晰可读（排序相同，只是倒过来表示）。没有公开评分的模型会显示 s

The benchmark for vibe coders.
How hard do you actually vibe? There's only one way to find out:

---

viberuler scans your machine — locally, in seconds — and computes your VIBE SCORE :

Signal	Source	Flex
🧠 tokens burned	Claude Code + Codex session logs (+ your LiteLLM gateway, opt-in)	1.2B tokens
💸 tokens per dollar	tokens ÷ spend (bundled price table)	6.5M tok/$ — TOP 3%
⚡ LoC shipped	lines you added, in your commits, minus generated output	312K LoC
⚙️ machine noise	generated lines you committed, and their share of your diff	163K · 33% of diff
📦 projects	repos where you authored commits	47 projects
🔥 streak · cadence	consecutive commit days, and commits per active day	212-day streak · 8.4/day
🏆 achievements	see below	Token Billionaire
🤖 agents in the stable	marker dirs of known coding agents in your home	4 agents · Claude Code · Codex · Antigravity
⏳ Codex plan headroom	the rate_limits records Codex already writes to its session logs — not scored, not sent	5h 12% used · resets in 45m · week 2% used

Then it prints a scorecard you'll screenshot before you can stop yourself.

tokens per dollar is the headline stat. Anyone can burn tokens. Burning them efficiently is the game.

Tokens are casino chips. They're denominated the way they are so spending them doesn't feel like spending money — and every new way of working (vibe it, ramble it, let the agent figure it out) lowers the effort and raises the burn. viberuler is the cashier's window: it converts the chips back into dollars — API-equivalent, total and per platform — before you sit back down at the table.

LoC counts what you wrote, not what you have. It used to be the size of your repo trees — which credited you with vendored code you never touched and with every line a compiler emitted. Now it's the lines you added in your own commits, generated output excluded. That cut the author's own headline number by 17%, and we shipped the smaller true one. Why, in detail →

The excluded lines are still shown. A third of the author's diff turned out to be machine output — regenerated types, bundles, lockfiles. It isn't scored and never leaves your machine; it's a baseline to shrink. A number you can't see is a number you can't reduce.

It's a mirror, not a performance review. Every number here is scoped to one machine and one person: yours. Score a junior on tokens burned and you'll get a junior who burns tokens — Goodhart shows up inside a week, and you paid for the tokens. Screenshot it, flex it, compare it with people who opted in; the moment it lands in someone's perf review it stops measuring anything at all.

Prompt Peasant → Vibe Apprentice → Token Burner → Context Goblin → Ship Machine → GIGACHAD SHIPPER → Singularity Adjacent

(No data? You get NPC (no vibes detected). We're sorry. We're not sorry.)

| |
---|---|---
💰 Token Billionaire — ≥1B tokens | 🪦 Free Tier Martyr — ≥1M tokens under $1 | 🗄️ Cache Whisperer — >90% cache reads
🌐 Polyglot — 5+ languages | 🐘 Monorepo Menace — 100K+ lines authored in one repo | 🔥 Streak Freak — 100-day streak
🌙 3AM Committer — 10+ night commits | 💥 YOLO Force Pusher — 20+ history rewrites | 🎰 High Roller — $1,000+ API-equivalent burned
🎲 Table Hopper — $1+ of burn on 3+ platforms | |

GitHub device-flow login → your score goes live at viberuler.dev/u/<you> as a Certificate of Vibe Measurement (LoC · tok/$ · streak · agents · rank · title), built for flexing. Global rank. Efficiency percentile. Prefilled share links — X · LinkedIn · Facebook · Bluesky.

Share to Stories — the certificate page also renders a vertical 9:16 story card (Spotify-Wrapped-style stat reveal) and a Share to Stories button. On mobile it hands the card straight to your phone's native share sheet — Instagram, WhatsApp, Facebook, Messenger; on desktop it downloads the card to post. (Stories are app-only, so this is the only way in — same mechanism Wrapped uses.)

• The default run makes zero network calls. Zero.
• --submit sends aggregates only — fourteen fields: aggregate stats, achievement ids, your coding-agent names, commit streak, and ship outcomes (features shipped / PRs merged). No paths, no repo names, no prompts, no code. Ever.
• Before anything is sent, the CLI prints the exact JSON payload and asks.
• --share also sends nothing: it prints a URL carrying your display numbers. Opening or posting that link is your choice, and the card it renders is marked unverified.
• Time metrics come from timestamps already inside your transcripts. Nothing watches your screen, and no window titles, paths, or filenames are read, stored, or sent.
• Don't trust us — read the ~140 lines: packages/cli/src/payload.ts and packages/cli/src/submit.ts. Details: PRIVACY.md.

Full formula, price table, normalization and honest disclaimers in METHODOLOGY.md. Short version:

VIBE = 1000·log₁₀(1 + LoC/1000)          # shipping volume
     +  500·log₁₀(1 + tokens/1M)         # AI leverage
     +  800·efficiency_percentile        # tokens/$ vs the world
     +  300·log₁₀(1 + projects·10)       # breadth
     +  min(streak, 365) + 50·achievements

Logarithms everywhere — whales get compressed, newcomers have room to climb.

npx viberuler wrapped --month 2026-06

Your Vibe Wrapped for the month — commits, busiest day, streak, top language, and Claude Code tokens/cost for that window. 100% local; screenshot and flex.

npx viberuler                # scan + scorecard (100% local)
npx viberuler audit          # audit your rig — see below
npx viberuler --submit       # push to the global leaderboard
npx viberuler payload        # show exactly what --submit WOULD send
npx viberuler --json         # machine-readable
npx viberuler --scan-dir ~/code --since 2026-01-01
npx viberuler --scan-dir ~/work --scan-dir ~/oss   # repeatable — scans ALL repos under each root
npx viberuler --github <handle>   # add your stars (the only other network call)
npx viberuler --share        # print a shareable card URL (nothing is sent)
npx viberuler audit --idle-gap 5             # pause (minutes) that stops counting as attention
npx viberuler audit --compare 2026-06-01..2026-07-01   # that window vs the equally long one after it
npx viberuler audit --market   # reprice your mix at live market rates (one catalog GET, opt-in)

A bare run scans every git repo under your home dir. If your code lives elsewhere (or in several places), point --scan-dir at each root — it's repeatable, and every metric (LoC, commits, features, PRs) is summed across all repos found, so your certificate reflects your whole body of work, not one project.

Your tokens per dollar score says how efficiently you burn tokens. audit says how efficiently your rig is set up. 100% local, reads your Claude Code transcripts:

• Token economy — cache-hit rate, and what prompt caching actually saved you in API-equivalent dollars.
• Context amplification — how many times the average token you admit gets re-read on later turns. Measured on the main thread alone : pooling in short-lived subagent contexts halves the number and understates what a token really costs in the thread you live in. (On a real rig: 1088×.)
• Subagents — how hard they compress: work pulled in inside a subagent vs the summary handed back. They aren't free (they cost real overhead), but at 1000× amplification, keeping tokens out of the main thread is the whole game.
• 🧊 Cold context — what a session costs before you type a word : system prompt, tool names, agent and skill descriptions, memory. Every subagent spawn re-pays it. (On a real rig: 50.2K tokens at session start, 33.1K re-paid on each of 3,234 spawns.)
• 👻 Ghost tokens — the tokens an output-rewriting plugin promises to save you, measured instead of promised. Oversized results (>4KB) were 54% of everything admitted; the famous "dedupe repeat reads" trick was worth 2%.
• Top tools — which tools are actually filling your context, ranked by calls and by tokens.
• ☠️ Dead weight — MCP servers and plugins that load on every session, spawn a process, inject their tool schemas… and get called zero times.

That last one is the point. On the author's rig it found two MCP servers burning 1.5 GB of RAM across 76 processes for 0 calls in 10,700+ sessions. Removing them dropped the median cold context from 49.9K to 41.1K tokens — a 17.5% discount on every session since, and proof that deferred tool schemas do not make an unused server free.

Measuring beats guessing, which is an awkward conclusion for a tool that scores you on vibes.

Context waste — sizes and levers, never a savings claim

A crowded genre of tools promises to cut your tokens "by up to 90%". They're real projects; none of them publishes a methodology behind the number. audit takes the other side: it names where context went, on your own transcripts.

CONTEXT WASTE
  5.7M tok · 2,555 calls   oversized single results          → slice / grep before read
  2.2M tok · 4,068 calls   subagent-returned tokens          → tighter subagent contracts
  1.9M tok · 3,394 calls   whole-file reads never edited     → outline-first / symbol reads

Three rules hold this honest, and they are enforced in the output, not just in docs:

• No "you would save N%". The counterfactual is unknowable — a read that changed nothing may be the read that told you not to change something.
• No total. The classes overlap by construction (an oversized read can also be exploratory), so summing them would double-count and manufacture a headline.
• audit --compare A..B puts two windows side by side — install an optimizer, compare before and after — and labels the delta an observation, not causation , because workload differs between windows. A window with no sessions says "not enough data" instead of printing a flattering zero.

Your mix at market rates (audit --market)

The chips-to-dollars view, extended to the whole exchange: your measured token mix, repriced at the list rates of a curated set of current models — open-weight flagships (Kimi K3, DeepSeek, GLM, Qwen, Llama, MiniMax) and the closed tiers. Rates come from one anonymous GET to the OpenRouter public catalog (this flag is opt-in network, like --github), cached locally for a day, with an offline fallback to a bundled snapshot — the output labels which source answered. Arithmetic, not advice: tokenizers, quality, and cache mechanics differ, so the table says what your volume costs per counter, never what you would save.

The same table answers maximum AI performance per dollar : where the catalog carries an Artificial Analysis intelligence index, each counter shows what one index point costs on your mix ($/pt), the ranking is by that, and the cheapest wears 🏆 — points-per-dollar was the first cut, but it reads 0.00 on every row once a mix gets into the billions of tokens, while $12.77/pt vs $688.51/pt stays legible at any scale (same ordering, upside down). Models without a published score say so and trail the list — an unknown is not a zero. The index is a third-party benchmark of the model, not of your workload; the crown marks the cheapest intelligence, not the most of it.

Self-hosted models get the same honesty: set VIBERULER_LOCAL_RATE=<USD/Mtok> (and optionally VIBERULER_LOCAL_MODELS=local,mlx prefixes) to price your gateway's local models at your own electricity + hardware rate instead of $0. You compute the rate; viberuler applies it and marks it self-reported.

Prints a card URL you can post anywhere. The image renders from the data in the link — no account, no submit, nothing written to the database — and is branded SELF-REPORTED · UNVERIFIED with no rank on it. The GitHub-verified certificate at /u/:login stays the only ranked surface.

The card and audit also report time derived from transcript timestamps — attention time (gaps longer than --idle-gap don't count) against wall-clock. No daemon, no window tracking, nothing watching your screen.

Put your score where your ego lives — ready-to-paste snippets for Claude Code , Starship , oh-my-posh , tmux , and raw shell prompts in integrations/statusline/. One cache file, sub-millisecond reads:

Fable 5 · ⚡3982 Context Goblin · 481.5K tok/$

Want your agent on the board? A collector is ~70 lines and a test: two methods, is this agent here and what did it burn. CONTRIBUTING.md walks through it, including the two parsing traps that already bit us. Draft PRs are fine — you don't have to finish it before asking.

If your agents don't live in your home directory, point at them — every extra root is searched, and mounting the same logs twice never double-counts:

npx viberuler --agent-home C:\agents\Claude --agent-home C:\agents\codex

CODEX_HOME and CLAUDE_CONFIG_DIR are honoured automatically, so if you already relocate your agents the normal way, there is nothing to pass.

Several subscriptions? Normal. A Claude plan plus a ChatGPT/Codex one plus Cursor all land on the same card: each platform is its own collector, and the per-agent legend prices each platform's traffic separately — that dollar figure is what that subscription was worth in API-equivalent terms. Two accounts of the same platform (work + personal Claude) merge into one line; to split them, run once per account with VIBERULER_AGENT_HOMES pointing at a single home (details in METHODOLOGY).

TypeScript CLI (one runtime dep: picocolors). Backend: Cloudflare Worker + D1, OG images rendered in-worker by satori — packages/worker. Font: JetBrains Mono (OFL). MIT.

---

Your prompts never leave your machine. Your score never leaves the group chat.