how we build
The Playbook
How automations get built when you and Claude work side by side. Do the task by hand, watch the steps settle, then pull them into code one phase at a time. The same method covers fully automatic pipelines, human-in-the-loop processes, and plain data transforms.
One function, one job
Each function takes input and returns output. They connect through the data they pass, so you can rearrange them without rewiring a framework.
UI is a view, not the system
Pipeline state lives in plain data. Any UI can read or write it, so you can swap the view without touching the pipeline underneath.
Prototype by hand, then go headless
Start by doing the task manually with Claude. Each repeated action becomes a gist, and each gist becomes a stage you can call.
A human gate is an empty field
A column waiting for input, a DB field left null, a waitForEvent. They are the same idea: the pipeline pauses until a person fills it in.
State is plain data
JSON in, JSON out. A spreadsheet column, a DB column, and a pipeline input are the same thing wearing different clothes.
Discover, don't design
Do the work by hand first. Pull out a stage only once you've done the same thing three times.
Same code, different context.
The interactive prototype and the production system share the same layers. The logic stays put. What changes is the glue that runs it.
| Layer | Interactive | Production |
|---|---|---|
| Capture | Web app, phone camera, manual entry | Same, or webhook / API trigger |
| AI reasoning | Claude Code (human steers) | Claude API (prompt hardened) |
| Glue | repld gist (ad-hoc, stateful) | FastAPI / Inngest (durable) |
| State / UI | Spreadsheet, DB, file dump | Same — UI is just a view |
| Integration | MCP tools (browser, APIs) | Same MCP tools, called from code |
One gist, many harnesses.
A gist is a plain Python file: data in, data out. Import it into repld while you prototype, into FastAPI to serve it, into Inngest for durable workflows. The file never changes, only what runs it.
gists/ # pure Python, no framework dependency
inventory.py # ERP lookup, sheet write
notify.py # Slack / email dispatch
repld # imports gists for interactive prototyping
fastapi # imports gists for production endpoints
inngest # calls gists as durable step functionsThe pipeline pauses for you.
A human gate is an empty field. Auto stages fill themselves in; human stages wait. The field can live anywhere a person can reach it: a spreadsheet cell, a dashboard, a Slack message, or a prompt in the workspace.
# auto stages fill themselves; human stages wait
[Auto] Finding → system analyzes, writes result
[Human] Decision → human reviews, writes action # ← gate
[Auto] Execution → system executes the action
[Auto] Status → Pending → DoneEvery tool starts as a conversation.
Not every workflow needs every phase. Some jump straight to production. Some stay semi-auto for good. Whichever path it takes, each phase reuses what the last one produced.
- 1 Interactive
You and Claude work a task in the live workspace. Poke at the browser, hit an API, look at what comes back. No plan yet, just doing the thing.
- 2 Scripted
You've done it three times and the steps are obvious. Pull them into a gist, a plain Python file repld hot-reloads. Same code, now importable.
- 3 Semi-auto
Wire a trigger so it runs on its own: @every, a webhook, or a queue. Add a human gate wherever a call needs judgment.
- 4 Production
Event-driven, durable, monitored. The gists from the scripted phase are now production steps. Nothing got thrown away.
This playbook came out of real projects, not a whiteboard. Each one started as manual data entry and a few Claude sessions. By the end it was a multi-stage pipeline: OCR, AI enrichment, a sync back to the system of record, and human gates where someone had to make the call. All of it grew from gists that began as throwaway REPL code.