Skip to content

Reconstruction prompt

Hand over a recipe, not the dish: one block of text the recipient's own agent reads and rebuilds into a close cousin of what you made. No link to keep alive, no account on either side, nothing to host — it travels in whatever message you already use.

Reach for it when you want to spread a pattern — a tool's shape, a workflow, a layout — past walls a private repo can't cross. Skip it when the recipient has no AI agent to feed it to: that's the hard limit, and a website or Artifact carries those people instead.

Last verified: 2026-06-07 · Confidence: high on the model (text, no host, lossy, un-revocable); recipient-AI limits are an estimate.

It allows you to

  • Send a buildable spec, not the files. One block of text describes the thing well enough that a fresh agent rebuilds a working version from scratch.
  • Skip every account and host. No repo, no Publish button, no seat to assign — plain text in an email, a chat, a doc.
  • Cross any boundary your message can. It goes wherever you can paste text, including across companies a private repo's invite rules would block.
  • Leave the sensitive parts out on purpose. It rebuilds the recipe, so your real data, keys, and accounts don't ride along — you name what matters, blank-placeholder the rest.
  • Let them remix freely. What they get is theirs to change from the first second — no copy-of-a-copy, no asking you.
    • Caveats: the rebuild is a close cousin, not a byte-for-byte twin, and once sent it can't be pulled back — both in Good to know.

Ideal for

  • A workflow you want copied without your data — a grant-screening agent setup you pass to three partner orgs, each rebuilding it against their own applicant data. A repo would hand them your files; the recipe hands them only the shape.
  • A tool that has to cross an org wall — a survey-cleaning script for an external collaborator whose company blocks private-repo invites. Text in an email usually gets through where the invite won't. [estimate]
  • A throwaway you'd never maintain — a one-off conference-schedule viewer you don't want a live link to babysit. Send the recipe and forget it.
  • A starting point others should diverge from — a "draft a donor update" helper where every recipient should land on their own flavour, not a clone. Divergence is the feature.
  • Anthropic's public Claude Cookbooks are this pattern at scale: copy a recipe, run it in your own environment with your own key, get a working build. [confirmed]

Who can get in

  • Access = your channel. Whoever you send it to can use it — no login, no gate, no owner. Forwarding is invisible to you, and you can't recall a copy once it's out. [confirmed]
  • They need their own AI. The defining limit: the recipient must have an agent to paste it into — Claude Code, the Claude app, or any equivalent. No agent → nothing happens. [confirmed]
  • Never put a secret in it. A sent copy can't be revoked, so strip keys and real data before it leaves; treat anything that slips in as exposed. [estimate]

Which rungs it can hold. Only anyone you hand the text to — no just-you, named-people, or public-listing rung; access is exactly your send list. → Who can see it? [confirmed]

Handing data to the host. No host — the recipe sits in your own message channel, not on any company's servers. The exposure is whatever you write into it. The host that matters is wherever the recipient's agent runs (e.g. Anthropic for Claude). [confirmed]

What you do to set it up

  • Ask: in the folder or chat where you built the thing, tell your agent "read this and write a self-contained prompt someone could paste into their own agent to rebuild it — leave out my keys and real data." Then eyeball the block for secrets and send it. → Write a reconstruction prompt.
  • One-time: Set up Claude Code (~10 min once) to draft it. New to phrasing the ask? How to ask your agent (~2 min).
  • The only un-delegable step is the secret check — ~2 min of your own eyes on the block before it leaves; it can't be undone after.
  • No agent handy? Write the spec by hand — what it is, every feature, the tech, the look — but an agent reading your actual files is faster and misses less. [estimate]

What the other person does

  • Paste and build: drop the block into their own agent, say "build this," wait. ~1–2 min of input, then the agent works. [estimate]
  • Expect a close cousin. Not pixel-for-pixel; if a feature's missing, it wasn't named in the spec — add the line and re-run.
  • Pay: nothing to receive it; only their own AI usage. Free tiers handle small rebuilds fine; a big one may bump a usage limit and need a wait or a paid plan. [estimate]

Other ways to share

  • Want their agent to rebuild it on demand, not just once from a pasted block? → package the recipe as a Claude skill — it sits in their Claude and fires whenever the task comes up.
  • Recipient might not have an agent? → a Claude Artifact or deployed website. Both open in any browser — ~5 sec, no agent, nothing to rebuild — where a recipe is dead weight.
  • Want the exact files, history, and changes flowing back? → a GitHub repo. The recipe trades fidelity and two-way collaboration for reach and zero hosting.

Sources

Good to know

  • Un-revocable once sent. Plain text in someone's inbox can't be recalled. The one mistake with no undo is a secret slipping in — if one does, treat that key as exposed and rotate it. [confirmed] (secret-check step)
  • Lossy on purpose. The output is a close cousin, never identical — different wording, maybe a different colour. For a faithful copy, share the actual files via a repo. [confirmed]
  • No vendor lock. The recipient can paste it into Claude, Codex, or any agent — the recipe doesn't name a tool unless you do. [estimate]
  • Free tiers shift. Per-tool message caps change often and vary by demand, so we don't quote numbers — plan for: small rebuilds fine free, big ones may wait or need paying. [unclear]