an incremental build system for LLM work

Stamp it once. Never pay for it twice.

Stampable is an incremental build system where the compiler is an LLM. Sources, prompts, and agent tasks go in; reports, newsletters, docs, and sites come out, and only the targets whose inputs changed ever rebuild. Everything else is stamped and pinned: zero cost, zero drift.

Build progress and early invites. No spam.

S STAMPED REBUILD · $0.00

127.0.0.1:4242 — your workspace

Your pipeline as a live dependency graph. Every artifact carries its model, its inputs, and its exact cost.

01 the problem

Chat regenerates everything. Differently. Every time.

If your LLM workflow lives in a chat window, every run starts from zero — and you pay for it three times over.

✕You pay again

Ten sources, two changed? A chat re-reads and re-generates all ten. Stampable rebuilds two and pins the rest. The bill scales with what changed, not with what exists.

✕It drifts

LLMs never give the same answer twice, so the eight sections that didn't change come back different anyway — and you proofread all of them again. Stamped artifacts are byte-identical until an input changes.

✕No receipts

Six months later: “where did this paragraph come from?” With chat, nobody knows. Stampable stamps every artifact with the exact inputs, prompt version, model, and cost that produced it.

02 the product

Every artifact knows exactly where it came from.

Stampable editor showing a generated report with a provenance banner — generated artifact, model name, hand edits protected from rebuild

Open any generated file. The receipt is right there.

The editor knows which files are generated, what produced them, and whether you've touched them since.

Provenance on every artifact — model, prompt version, inputs, build time, and cost, recorded in a lockfile you commit.
Hand edits are sacred. Edit a generated file and Stampable refuses to overwrite your work on the next build unless you force it.
Live staleness. Save a source file and every downstream target lights up stale in the graph, in real time.

Fig. 01 — the editor & provenance banner

Or never leave the terminal.

The UI and the CLI share one engine. See what's stale and what the rebuild will cost — before you spend a cent — then build exactly that.

Cost estimates up front. stamp status prices the stale set before you commit to it.
Itemized bills after. Every build reports tokens and dollars per target, not a mystery total.
Agents, not just completions. A target can be a full coding-agent session that writes charts, sites, or data files itself.

Fig. 02 — the CLI, same engine

$ stamp status
  stale   summaries/metrics.md      ~$0.06
  stale   summaries/support.md      ~$0.07
  stale   newsletter.md             ~$0.28
  fresh   7 targets — stamped, $0.00

$ stamp build
  ✓ summaries/metrics.md      $0.05
  ✓ summaries/support.md      $0.08
  ✓ newsletter.md             $0.26
  rebuilt 3 of 10 targets · total $0.39

03 how it works

A Makefile, except the rules are prompts.

Declare targets, point them at inputs and a prompt, or hand the step to a coding agent that writes the artifact itself.

# stampable.yaml
model: claude-opus-4-8

targets:
  summaries/{name}.md:
    from: sources/{name}.md
    prompt: prompts/summarize.md

  newsletter.md:
    from: [summaries/*.md, context/voice.md]
    prompt: prompts/assemble.md

  site/index.html:
    from: newsletter.md
    agent: Build a clean single-page
      site from the newsletter.

Content-addressed staleness

Every target is keyed by a hash of its actual input contents, prompt, and model — not timestamps. If nothing changed, the artifact is pinned and never re-generated.

Agents, not just completions

A target can be a full coding-agent session with file and shell access: charts from your CSVs, a static site from your report, anything a one-shot completion can't do.

A lockfile you commit

The lockfile is both cache state and provenance record. Clone the repo, run stamp build — nothing rebuilds, because nothing changed.

Hand edits are sacred

Touched a generated file yourself? Stampable detects it and refuses to clobber your edit without --force. Your judgment outranks the model's.

04 use cases

What people stamp with it

recurring content

The Monday newsletter that builds itself

Ten sources → per-source summaries → assembled issue → published straight to Buttondown or Beehiiv as a draft. Week two only rebuilds what changed; the voice and untouched sections stay literally identical.

evals & regression

Prompt changes with a blast radius

Test cases → generations → LLM-judge grades → score report. Edit the candidate prompt and exactly the affected generations re-run, with the lockfile pinning which model and prompt version produced every score.

living documents

Docs that track their sources

Literature reviews, due-diligence packets, codebase docs — derived artifacts that stay in sync with their inputs, with a receipt on every page saying exactly what produced it.

team-owned pipelines

Workflows that outlive the chat window

The pipeline is a YAML file and prompt files in git — reviewable, diffable, runnable by anyone (or by cron) with one command. When the person who built it leaves, nothing leaves with them.