Reelier vs writing a bash/python script
A hand-written script encodes the tool calls you remember making and only the checks you thought to write; Reelier is compiled from the run the agent actually made, so it re-verifies the real sequence — an assertion on every step it can check, plus a drift diff — instead of the one you retyped from memory.
Where a hand-written script wins
Reach for a script first when the job is small and stable. If your automation is three curl calls against endpoints you already understand — pull a status page, POST a metric, read a count — a twenty-line bash or Python script beats Reelier on every axis that matters at that size. There is no package to install, no SKILL.md format to learn, no new vocabulary. You can read the whole thing on one screen, you control every line, and it runs anywhere curl or requests does. For a handful of deterministic calls you have effectively memorized, that is the right tool and Reelier is overhead.
And a script can absolutely assert. Nothing stops you writing if status != 200: sys.exit(1), checking a JSON field, or diffing today's output against a saved fixture — scripts have tested deterministic contracts for decades. The honest version of this page is not “scripts are bad.” A script encodes exactly the checks you chose to write, on purpose, and if you are content hand-maintaining those checks for a job that rarely changes, you do not need anything else on this site.
The flexibility cuts in the script's favor too. A script can express anything — shell out, edit files, branch on arbitrary logic, glue five unrelated systems together in ways no tool-call recorder can. Reelier deliberately replays only deterministic tool calls: MCP calls and its own http.get/http.post builtins. An edit-heavy or shell-heavy job is simply outside what it can freeze, and it says so honestly rather than pretending. If your automation is really a general program, keep it a general program.
Where Reelier fits
The line moves the moment the job grows past a few calls. Hand-maintaining the request and response shapes for eight, twelve, twenty typed tool calls is tedious and quietly error-prone: the payloads you typed drift from the payloads the systems actually return, and the script keeps passing because it only checks what you remembered to check. Reelier compiles the sequence from a run that happened, so the shapes are the real ones — captured, not retyped.
It also hands you the checks, minimally, so you are not writing them by hand. The compiler puts an assertion on every step it can check — a clean recorded result gets a status == 200 plus any value a later step consumes — while a step whose result was missing or failed stays assertion-less, is listed as an open question, and replays unchecked, never silently “passed.” Then reelier diff compares two runs and prints a per-step verdict: SAME when every outcome matches the baseline, DRIFTED when a step changed outcome, appeared, or vanished, with an exit code a cron or CI job can gate on. A script's stdout tells you it ran; it does not tell you the twelfth call's response changed shape unless you wrote that exact check by hand.
The deepest difference is where the automation comes from. A script is written from memory — the calls you think the agent made, retyped by hand — and from the first edit it drifts from what the agent actually did. Reelier is generated from the recorded run itself: reelier scan reads your agent's real history (Claude Code transcripts are the native format; Cursor keeps its history in a SQLite database, so there is no scan — you capture live through the reelier mcp --wrap proxy instead). Because the skill is compiled from the actual tool-call sequence, it cannot drift from what the agent did — it is what the agent did. Nobody hand-writes a non-deterministic agent's real sequence accurately, because they do not have it; Reelier's whole job is to have it.
The trade-offs stay honest. Reelier is a dependency where a script is none, and it covers only the deterministic tool-call core: replay is read-only by default, so a job that writes needs an explicit decision per step — --allow-writes unlocks idempotent writes only, and destructive steps still require --yes — and judgment beyond the tool calls still needs a model, opt-in and BYOK. What you buy for the dependency is an automation that is provably the run the agent made, re-checked every time instead of assumed.
Side by side
| a hand-written script | Reelier | |
|---|---|---|
| Best fit | A few stable tool calls you fully understand and control | Many typed calls that must stay verified as models and APIs move |
| Where the checks come from | You write each assertion by hand | Compiled from the recorded run — an assertion on every step it can check |
| Drift detection | Only what you coded; a changed response shape passes unless you checked it | reelier diff prints a per-step SAME/DRIFTED verdict and exits 1 on drift |
| Source of truth | The calls you remember and retyped | The calls the agent actually made (reelier scan / mcp --wrap) |
| What it can express | Anything — shell, file edits, arbitrary logic | Deterministic tool calls only (MCP + http builtins) |
| Writes on replay | Whatever you coded, every run | Read-only by default; --allow-writes idempotent only, --yes for destructive |
| Dependencies | None — curl / requests | A Node package |
A real receipt
The receipt below is the two-call job you would normally write a shell script for — confirm the npm and GitHub public status APIs are answering — but run as a Reelier skill. Two typed http.get calls, an assertion per step, replayed then diffed. The run receipt and the diff verdict are verbatim from a real replay; the line a script's curl && echo ok never prints is the last one.
npx -y reelier@latest run vendor-status-sweep.skill.md ✓ Step 1 — npm status [passed] 189ms ✓ Step 2 — GitHub status [passed] 88ms PASSED: 2/2 steps ok, 0 failed, 277ms total npx -y reelier@latest diff vendor-status-sweep = Step 1 "npm status": passed, unchanged. = Step 2 "GitHub status": passed, unchanged. ✓ SAME — 2 step(s), every outcome and escalation level identical to the baseline.
Run by the author on 2026-07-21 in a scratch directory: examples/portfolio/vendor-status-sweep.skill.md from seldonframe/reelier, replayed twice with npx -y reelier@latest (resolved to reelier@0.13.0) then diffed. The first replay's receipt and the diff verdict are verbatim; each replay is two HTTP GETs to the public npm and GitHub status APIs — read-only, no account, no key.