想让人帮你改代码，
又不能把代码给他 Get help with your code
without handing over your codebase

先说这不是什么What this is not

这不是共享、出借、合池或转售 AI 订阅额度。那违反 Anthropic 条款，做了就是等封号。 This is not a way to share, lend, pool, or resell AI subscription quota. That is against Anthropic's terms and gets accounts banned.

You may not share your Account login information, Anthropic API key, or Account credentials with anyone else. You also may not make your Account available to anyone else.

2026 年 2 月 Anthropic 进一步禁止把 Pro/Max 的 OAuth token 用在 Claude Code 和 claude.ai 之外，也禁止代表他人把请求路由过你的 seat——即使量很小，即使只是团队内部工具。 In February 2026 Anthropic went further, prohibiting Pro/Max OAuth tokens anywhere outside Claude Code and claude.ai, including routing other people's requests through your seat — even at low volume, even for an internal team tool.

所以这里没有额度池、没有 token 中转、没有代理、没有共享账号。有余力的人自己把活干了，交出去的是成果（一个 PR），不是账号访问权。那就是普通的外包，条款上是干净的。 So there are no quota pools, no token relays, no proxies, no shared accounts. People with spare capacity do the work themselves and hand over the result — a pull request — not access to their account. That is ordinary freelance work, and it is fine.

真正稀缺的东西从来不是 token，是有时间又愿意干活的人。 The scarce resource was never tokens. It was people with time and willingness.

四件可以自己动手核实的事Four things you can check yourself

下面每一条都不是形容词，是一条能跑的命令或者一行能读的代码。这也是唯一值得写在落地页上的那种卖点。 None of the following is an adjective. Each one is a command you can run or a line you can read — the only kind of claim worth putting on a landing page.

sparepack 做的事What sparepack does

你有个真实的 bug，任务不大，也有人愿意修。但那个文件里全是你的定价规则、客户数据，还有三年前谁留下的一个硬编码密钥。于是你不问了，bug 就一直在那。 You have a real bug. The task is small and there are people who would happily fix it. But the file is full of your pricing rules, your customers, and a hardcoded key someone left there three years ago. So you do not ask, and the bug stays.

// src/pricing.ts
export function quote(
  seats: number, tier: string
): Quote {
  const base = tier === "enterprise"
    ? 4900 : 1900
  const discount = seats > 50 ? 0.7
    : seats > 10 ? 0.85 : 1
  return { cents: Math.round(
    base * seats * discount), tier }
}

// Stripped by sparepack:
// signatures only.
export function quote(
  seats: number, tier: string
): Quote {
  throw new Error(
    'sparepack stub: not implemented'
  )
}

签名是契约，阈值是商业决策。只有前者需要离开这栋楼。 The signature is a contract. The thresholds are a business decision. Only one of those needs to leave the building.

# 三个命令Three commands
npx sparepack init     # 生成带注释的配置write a commented config
npx sparepack pack     # 构建、扫描、给你过目、再落盘build, scan, show you, then write
npx sparepack verify   # 从磁盘重新推导，独立复检re-derive from disk, check again

配置长这样The config

一份 sparepack.yaml，五个键，每个键决定一类文件怎么处理。 One sparepack.yaml, five keys, each deciding how a class of file is handled.

task: "Stream large CSV imports instead of loading the whole file"

include:                     # 逐字节原样发布published byte for byte
  - src/importer/types.ts

interfaces:                  # 留签名，函数体换成会抛错的桩signatures kept, bodies stubbed
  - src/importer/parser.ts

tests:                       # 这就是任务规约本身this is the specification
  - tests/importer/*.spec.ts

fixtures:                    # 真结构，假数据real structure, synthetic values
  data/orders.json: shape:5

redact:                      # 扫描器不可能知道的自家名字names the scanner cannot know
  - pattern: "acme-corp|ACME"
    replace: "example-org"

shape:n 读真实 JSON，按同样的键和嵌套重建一份假值，数组截到 n 条。rows:n 保留分隔文件的表头再造 n 行。生成是确定性的——同一份配置打两次包字节一致，所以两个包之间的 diff 一定意味着有东西真的变了。 shape:n reads the real JSON and rebuilds it with the same keys and nesting but fake values, capping arrays at n. rows:n keeps a delimited file's header and generates n fake rows. Generation is deterministic — packing twice gives byte-identical output, so a diff between two packs always means something real changed.

三条设计原则Three design rules

白名单制。没有 exclude 键，以后也不会有。「除了这些全发出去」意味着一个没人想过的文件会被发布，泄露就是这么发生的。而且匹配不到任何文件的 pattern 直接报错——打错一个字不该悄悄少发东西。 Allowlist only. There is no exclude key and there will not be one. "Publish everything except…" means a file nobody thought about gets published, which is how leaks happen. A pattern matching nothing is an error rather than a silent no-op, because a typo should not quietly ship less than you meant.

失败方向朝「少给」。接口剥离是解析后只输出能被明确识别为契约的东西，不是复制原文再删函数体。前者解析漏了等于 stub 缺东西、你会发现；后者漏了等于源码泄露。不支持的语言直接拒绝，绝不把一个 .py 原样放过还暗示它被剥离过了。 Failures point at giving less. Stripping parses your file and emits only what it positively recognised as contract. It does not copy the file and delete the bodies — under that design a parser gap publishes your source. Unsupported languages are refused outright, never passed through with the implication that they were stripped.

写盘在确认之后。整个包在内存里构建、扫描、打印清单，然后问你一句：这份文件清单你敢不敢公开贴出来。答案不是 publish 就一个字节都不写。 Nothing is written before you have seen it. The pack is built in memory, scanned, and printed as a manifest. Then it asks: would you be comfortable posting this file list in public? Answer anything other than publish and no file is created.

扫描器查什么What the scanner checks

各家厂商的 API key、私钥块、JWT、带真实密码的连接串、硬编码的密钥赋值、身份证与手机号、内网 IP 段、内部主机名。扫描发生在你的 redact 规则生效之后——扫之前只会报出你已经处理掉的东西，扫之后才能验证脱敏是否够用。 API keys from the major providers, private key blocks, JWTs, connection strings carrying real passwords, hardcoded secret assignments, national ID and mobile numbers, private IP ranges, internal hostnames. Scanning happens after your redactions are applied — scanning before would report findings you had already handled, and only scanning after can tell you the redactions were enough.

两件它不做的事：命中的内容永远不会被完整打印，报告只给掩码片段和长度——一份会泄露它检出的密钥的报告，比没有报告更糟。以及它努力不喊狼来了：example.com、127.0.0.1、${DB_PASSWORD}、<your-token-here> 是占位符，不算命中。一个被人学会忽略的检查已经不是检查了。 Two things it will not do. It never prints a finding in full — a report that leaks the secret it detected is worse than no report, so findings carry a masked excerpt and a length. And it works hard not to cry wolf: example.com, 127.0.0.1, ${DB_PASSWORD}, and <your-token-here> are placeholders, not findings. A check people learn to ignore has stopped being a check.

边界，先说清楚Limits, stated up front

• 接口剥离只支持 TypeScript 和 JavaScript。别的语言拒绝处理，不做「半处理」。Interface stripping is TypeScript and JavaScript only. Other languages are refused rather than half-handled.
• include 里的东西按字节原样发布——那是你的判断不是工具的判断，扫描器是那些文件唯一的兜底。include publishes verbatim, so anything listed there is your judgement, not sparepack's. The scanner is the only safety net on those files.
• 产出是一组文件，不是一个能跑的工程。没有 package.json、没有 tsconfig，接单者拿到手得先补几行才能 npm test。A pack is a set of files, not a runnable project. No package.json, no tsconfig — a worker has to add a few lines before npm test works.
• 包里的路径镜像你仓库里的路径，不能重映射。从 monorepo 根目录打包会得到 packages/api/src/...，通常不是你要的。Paths in a pack mirror paths in your repo, with no remapping. Packing from a monorepo root gives you packages/api/src/..., which is usually not what you want.
• 清单不随包走。你终端上看到的清单会列出被丢弃的内部函数名、以及哪些 redact 规则命中了——这两样恰好精确描述了这个包存在的目的是隐藏什么，所以写进包里的 MANIFEST.json 只保留 verify 需要的路径、类型和大小。The manifest does not travel. What you see in your terminal lists dropped internal functions by name and which redact patterns fired — both describe precisely what the pack exists to withhold — so the MANIFEST.json inside the pack keeps only what verify needs: paths, kinds, sizes.

隐私分级Privacy tiers

每个任务必须声明一级，按接单者能看到多少排序。Every task declares exactly one, ordered by how much the worker sees.

不知道选哪级：任务能用「一组接口 + 一组测试」描述清楚的，选 P1，这也是绝大多数情况。需要接单者在真实项目里跑起来、点一点才能干的，选 P2。P0 和 P3 是两头的特例。目前只有 P0 和 P1 有实际跑过的记录，P2 有流程文档但还没有真实案例，P3 尚未实现。 Not sure which: if the task can be described by a set of interfaces plus a set of tests, use P1 — that covers most of them. If the worker needs the real project running to do the work at all, use P2. P0 and P3 are the two extremes. Only P0 and P1 have actually been run so far; P2 has a documented process but no real case yet, and P3 is not implemented.

任务板怎么跑How the board works

没有网站，没有服务器，全在 GitHub 上。No website, no server. The whole thing runs on GitHub.

1. 发单——开一个 issue，你的积分进托管。余额不够就发不出去。Post — open an issue. Your points go into escrow. Insufficient balance, no task.
2. 接单——评论 /claim，等 issue 被指派给你之后再动手。同时 2 个、每周 5 个。真人手工干活本来就是这个量级，机器刷单会立刻撞墙。Claim — comment /claim, and start only after the issue is assigned to you. Two concurrent, five per week: that is the throughput of a person working by hand, and a bot hits the wall immediately.
3. 交付——往你的仓库提 PR，附上「这些改动我亲自审阅过、没共享任何凭证」的声明。Deliver — a PR against your repo, with an attestation that they reviewed it themselves and shared no credentials.
4. 结算——你合并，账本记一笔，双方档案更新。Settle — you merge, the ledger records it, both profiles update.

这个仓库永远不托管你的代码。任务元数据、账本和信誉在这里，代码本身在双方自己的仓库之间直接流转。 This repository never hosts your code. Task metadata, the ledger, and reputation live here; the code moves directly between the two parties' own repositories.

定价：只看复杂度Pricing: complexity only

耗额度的任务分三档，没有 XL——再大的必须拆。大额单任务是纠纷的来源，而一个做了一半的 XL 对双方都一文不值。 Quota-consuming tasks come in three sizes and there is no XL — anything bigger gets split. Large single tasks are where disputes come from, and a half-finished XL is worthless to both sides.

还有一类不烧额度的任务，专门为了让「这周额度用完了」不等于「没法参与」： A second class of task burns no quota at all, so that being out of quota does not mean being locked out:

积分是闸门，不是胡萝卜Points are a gate, not a carrot

积分（TP）只能通过完成任务获得、通过发布任务消耗。不可转让、不可交易、不能提现，不过期，没有二级市场，以后也不会有。它的职责是防止有人只发不接，仅此而已。新人 50 TP，刚好够发一个 M 任务。 Task Points are earned by delivering and spent by requesting. Not transferable, not tradable, no cash value, no expiry, no secondary market — and there will not be one. Their job is to stop people posting forever without ever delivering. That is all. New members start with 50 TP, enough for one M task.

真正的回报是一份可验证的公开交付记录：每次交付都是一个合并进别人真实仓库的 PR。这在找工作或谈外包时是有分量的，刷题记录换不来。 The actual reward is a verifiable public track record: every delivery is a merged PR in someone's real repository. That is worth something when you are job hunting, in a way a LeetCode streak is not.

出了争议怎么办When it goes wrong

任一方打 dispute 标签，由一位和本任务无关、有 5 次以上交付的仲裁者接手，目标 3 天出结论：判交付（积分给接单者，事后加需求的发布者不退款）、判退款、或者判拆分并写明理由。每一次裁决都带着仲裁者的 handle 和理由链接写进账本，公开，可上诉一次给另一位仲裁者。 Either party applies the dispute label. An arbitrator with 5+ deliveries and no involvement in the task picks it up, targeting three days: deliver (points to the worker; a requester who moves the goalposts afterwards gets no refund), refund, or split with the reasoning recorded. Every ruling is written into the ledger with the arbitrator's handle and a link to their reasoning. Public, and appealable once to a different arbitrator.

验收标准就是合同。接单时 issue 上没写的东西，不构成拒收的理由。这条对双方都成立，也是为什么任务模板把验收标准设成必填。 Acceptance criteria are the contract. If it was not in the issue when the task was claimed, it is not grounds for refusing delivery. This cuts both ways, and it is why the task template makes acceptance criteria mandatory.

账本：不用信我，自己算The ledger: don't trust me, recompute it

任何积分系统最后都会碰到同一个问题：凭什么信运营方报的余额。这里的答案是把余额变成一个可复现的计算结果而不是一句声明。 Every points system eventually runs into the same question: why believe the operator's numbers. The answer here is to make balances a reproducible computation rather than an assertion.

$ git clone https://github.com/mxx1111/spare-cycles && cd spare-cycles
$ node ledger/verify.mjs

ledger.jsonl — 27 entries

Balances:
  ghzhost                     60 TP
  manav8498                   10 TP
  rafaio1                     10 TP
  mxx1111                      0 TP
  ———————————————————————— —————
  in balances                 80 TP
  in escrow                  140 TP
  total issued               220 TP

All invariants hold.

ledger.jsonl 只追加：不改行、不删行、不调顺序，更正一律是新增的冲正条目。balances.json 是派生产物，两者对不上时以重算为准。校验器检查九条不变量，其中余额非负和托管非负是逐条增量检查的——中途变成负数、后面又补回来的历史一样判无效。 ledger.jsonl is append-only: never edit a line, never delete one, never reorder. Corrections are new compensating entries. balances.json is derived output, and if the two disagree the recomputation wins. The verifier checks nine invariants, and the two non-negativity ones are checked incrementally — a history that dips negative in the middle and recovers is still invalid.

红线 5 长什么样What red line 5 looks like

「积分不可转让」这句承诺，在代码里就是这六行——外加一个「不在这六个里面就是篡改」的判断： The promise that points cannot be transferred is these six lines, plus a rule that anything outside them is tampering:

// ledger/verify.mjs
const TYPES = {
  grant, escrow, settle, refund, split, adjust
}
// 没有 transfer。用户之间的转账在这个 schema 里不存在，No transfer. User-to-user movement does not exist in
// 不是「不允许」，是根本无法表达。this schema — not disallowed, inexpressible.
fail(where, `unknown transaction type "transfer"`
  + ` — COMPLIANCE.md red line 5`)

一条局限值得直说：这套检查抓得到过期的快照和被编辑的历史，但抓不到在同一个提交里既改历史又重新生成快照的人。能抓住那种情况的是「只追加」这条规则和一双读 diff 的眼睛。CI 收窄了缺口，没有把它堵死。 One limit worth stating plainly: this catches a stale snapshot and an edited history, but not someone who edits the history and regenerates the snapshot in the same commit. What catches that is the append-only rule and a human reading the diff. CI narrows the gap; it does not close it.

为什么不用现成的东西Why not just use what exists

这四类东西都存在，也都比这个项目成熟。它们不合用的原因各不相同，而且都是结构性的，不是「做得还不够好」。 All four of these exist and all four are more mature than this project. Each is a bad fit for a different, structural reason — not for want of polish.

所以剩下的空位很窄：私有代码 + 小任务 + 不涉及现金 + 不共享访问权。这个项目就想填这一格，别的不碰。 Which leaves a narrow gap: private code, small tasks, no cash, no shared access. That single cell is what this project is trying to fill, and nothing else.

现在到哪一步了Where this actually is

项目处在 Phase 0：手工跑几个真任务，看看到底有没有人来。第一批任务发布 3 小时内收到第一个 PR。 The project is in Phase 0: run a few real tasks by hand and find out whether anyone shows up. The first batch got its first pull request within three hours.