Skip to content

Commit 2657aa3

Browse files
balegasclaude
balegas
and
claude
committed
blog: add draft outline for one-shot app post
Adds the blog planner outline for a post about the --one-shot flag in @electric-sql/start. Covers multi-agent rooms on durable streams, the one-shot experience, and Electric as an open platform. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
1 parent 461576d commit 2657aa3

1 file changed

Lines changed: 199 additions & 0 deletions

File tree

‎website/blog/posts/2026-03-24-one-shot-your-app-on-electric.md‎

Lines changed: 199 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,199 @@
1+
---
2+
title: '...'
3+
description: >-
4+
...
5+
excerpt: >-
6+
...
7+
authors: [balegas]
8+
image: /img/blog/one-shot-your-app-on-electric/header.jpg
9+
tags: [electric, durable-streams, tanstack-db, agents, intent]
10+
outline: [2, 3]
11+
post: true
12+
published: false
13+
---
14+
15+
<!-- ASSET: Video of the full one-shot experience — command to running app. This is the hero asset. -->
16+
17+
Can you one-shot the app you want? One command — describe your app and a team of agents builds it live on Electric and TanStack&nbsp;DB.
18+
19+
```bash
20+
npx @electric-sql/start --one-shot "a collaborative task board with real-time sync"
21+
```
22+
23+
Database provisioned. Sync wired. App running. No sign-up required.
24+
25+
> [!Info] Links
26+
> - [Electric quickstart](/docs/quickstart)
27+
> - [create-electric-app](https://github.com/balegas/create-electric-app)
28+
> - [Durable Streams](https://durablestreams.com)
29+
> - [Agent skills now shipping](/blog/2026/03/06/agent-skills-now-shipping)
30+
> - [TanStack Intent: From Docs to Agents](https://tanstack.com/blog/from-docs-to-agents)
31+
32+
## The pieces are in place
33+
34+
<!-- SECTION: Situation. Matter-of-fact, confident. The reader already knows agents
35+
are capable. Set up the pieces as things that exist and work. Open with the
36+
paradigm shift — we built this for developers and it turns out agents need
37+
the same things. -->
38+
39+
We spent years making Electric easy for developers — instant provisioning, composable primitives, clear APIs. Turns out, the same properties that make a platform easy for developers make it easy for agents.
40+
41+
Coding agents are really good at writing code. Given the right context, they produce working features.
42+
43+
[Intent](https://tanstack.com/blog/from-docs-to-agents) ships agent skills with npm packages — agents that install `@tanstack/db` or `@electric-sql/client` get versioned knowledge of how to use them correctly.
44+
45+
Electric provisions sync infrastructure instantly — database, sync service, no human in the loop.
46+
47+
## The missing piece
48+
49+
<!-- SECTION: Complication. Not doom and gloom — just the last piece that was
50+
missing, and the insight that fills it. The tone is recognition, not alarm. -->
51+
52+
The knowledge is there. The infrastructure is there. What's missing is a way for agents to work together — a coder and a reviewer collaborating on the same app in real-time. There's no standard primitive for multi-agent coordination.
53+
54+
Durable streams turn out to be that primitive. A shared, persistent, addressable stream that agents read from and write to — and that you can watch live.
55+
56+
<!-- SECTION: Implicit question — what does it look like when all these pieces
57+
(agent knowledge, instant infrastructure, multi-agent coordination)
58+
actually come together? The rest of the post answers this. -->
59+
60+
## One command, running app
61+
62+
<!-- SECTION: Answer (a). The hook made tangible. Walk the reader through what
63+
actually happens. Keep it concrete: commands, URLs, what they see. Make
64+
them want to try it. -->
65+
66+
You run `npx @electric-sql/start --one-shot "a collaborative task board with real-time sync"`.
67+
68+
The CLI provisions a Postgres database (via Neon) and an Electric sync service.
69+
70+
It launches a multi-agent session: a coder and a reviewer working in a loop — the coder plans and builds, the reviewer catches issues. You can bring in a UX expert agent when you want one.
71+
72+
You get a URL in your terminal. Open it and you're watching agents collaborate in real-time — designing the schema, writing components, reviewing each other's output.
73+
74+
<!-- ASSET: GIF or screenshot of terminal output showing the URL + the web UI
75+
with agents working -->
76+
77+
The agents use your local Claude installation — `--one-shot` orchestrates [create-electric-app](https://github.com/balegas/create-electric-app) under the hood, connecting your Claude to the multi-agent room.
78+
79+
When they're done, you have a working TanStack app with real-time sync, a live database, and migrations already run. `pnpm dev` and it's running.
80+
81+
<!-- ASSET: Screenshot of the finished app running locally -->
82+
83+
> [!Info] No sign-up required
84+
> The database and Electric source are provisioned in a claimable state. Run your app, try it out, and when you're ready, claim the resources to your Electric account. Until then, everything just works.
85+
86+
## Multi-agent rooms on durable streams
87+
88+
<!-- SECTION: Answer (b). The technical meat. Explain why durable streams are the
89+
right primitive for multi-agent coordination. Show the architecture without
90+
turning it into a docs page. The reader should come away thinking
91+
"that's a clean design." -->
92+
93+
Each agent has its own durable stream — its individual log of everything it does: tool calls, file writes, reasoning. That's the agent's full history.
94+
95+
Agents share messages with the room by writing to a shared room stream. `@room` broadcasts to everyone, `@coder` or `@reviewer` routes to a specific agent. Messages without a prefix stay in the agent's own log — internal reasoning doesn't flood the room.
96+
97+
Agents talk to each other through the room, not directly. A room router watches the room stream and delivers messages to the right agent.
98+
99+
<!-- ASSET: Diagram showing individual agent streams + shared room stream, with
100+
the web UI subscribed to all of them -->
101+
102+
Durable streams make the whole thing observable, live, and persistent. The web UI subscribes to all the streams — you see each agent's work in real-time and the conversation flowing through the room. You can interact through gates — approve a plan, request changes, add an agent.
103+
104+
Disconnect and come back — the streams catch you up from where you left off. No state lost. Share the room link and someone else can follow along or jump in.
105+
106+
This is the same primitive we built for [real-time sync and AI token streaming](/blog/2025/12/09/announcing-durable-streams).
107+
108+
## An open platform that works with your stack
109+
110+
<!-- SECTION: Answer (c). Zoom out. The one-shot works because the pieces are
111+
decoupled and composable. Each one does its job, they compose cleanly,
112+
and the result is a standard app. Confident but not salesy. -->
113+
114+
The app you get is a standard TanStack app. TanStack Start for the framework, TanStack&nbsp;DB for reactive queries, Electric for sync. No custom runtime, no lock-in to the one-shot tooling.
115+
116+
Each piece that makes the one-shot work is independent and useful on its own:
117+
118+
- **Intent** teaches agents your libraries — versioned skills that ship with the npm packages and update when you `npm update`. ([Agent skills now shipping](/blog/2026/03/06/agent-skills-now-shipping))
119+
- **Electric** provisions infrastructure and handles sync — database, sync service, ready in seconds.
120+
- **Durable streams** coordinate the agents and enable collaboration — you watch, interact, and pick up where you left off. They power any use case where you need persistent, real-time streaming.
121+
122+
The one-shot is a showcase of these pieces working together. But you can use any of them independently — add intent skills to your existing project, use Electric for sync without the one-shot, use durable streams for your own multi-agent setup.
123+
124+
## Next steps
125+
126+
Think you can one-shot your app? Run the command and find out.
127+
128+
```bash
129+
npx @electric-sql/start --one-shot
130+
```
131+
132+
Claim your resources on [Electric](/docs/quickstart) when you're ready. Explore [durable streams](https://durablestreams.com), [intents](https://tanstack.com/blog/from-docs-to-agents), and [TanStack&nbsp;DB](/products/tanstack-db).
133+
134+
***
135+
136+
<!-- DELETE EVERYTHING BELOW THIS LINE BEFORE PUBLISHING -->
137+
138+
<!-- ## Meta
139+
140+
### Intent
141+
- **What is this post about?** You can now one-shot a full Electric + TanStack
142+
app from a single command, powered by multi-agent collaboration over durable
143+
streams.
144+
- **What's interesting about it?** One command gives you a live app with
145+
real-time sync, a provisioned database, and cloud infrastructure. You watch
146+
multiple agents collaborate to build it in real-time through a shared room.
147+
- **Reader takeaway?** "I can go from an idea to a working, syncing app with a
148+
live database in minutes — no sign-up, no setup."
149+
- **CTAs?** Challenge: think you can one-shot your app idea? Try it. Claim your
150+
cloud resources after.
151+
- **Why us?** We built Electric to work with your stack. The one-shot showcases
152+
that — agents use intents to learn TanStack and Electric, durable streams to
153+
coordinate, and the result is a standard TanStack app with real-time sync.
154+
155+
### Title brief
156+
Sentence case. Should convey challenge/invitation tone. Options:
157+
- "One-shot your app on Electric"
158+
- "Can you one-shot your app?"
159+
- Something hinting at multi-agent + durable streams without being wordy
160+
161+
### Description brief (SEO)
162+
What the --one-shot flag does, that it uses multi-agent collaboration on durable
163+
streams, and that it provisions Electric infrastructure with no sign-up. Should
164+
mention TanStack DB.
165+
166+
### Excerpt brief (blog listing card)
167+
The challenge — one command, agents build your app live. 2-3 short sentences
168+
matching length of other Electric blog excerpts.
169+
170+
### Image prompt
171+
- Concept: Multiple agents collaborating in a shared space, building something
172+
together — streams connecting them
173+
- Aspect ratio: 16:9 (~1536x950px)
174+
- Dark theme background
175+
- Brand colors: #D0BCFF (purple), #00d2a0 (green), #75fbfd (cyan),
176+
#F6F95C (yellow)
177+
- Center-center composition
178+
- Style: Abstract/architectural, not literal robots. Data flows and connected
179+
nodes.
180+
181+
### Asset checklist
182+
- [ ] Video: full one-shot experience (hero asset)
183+
- [ ] Diagram: agent streams + room stream architecture
184+
- [ ] Screenshot: finished app running locally
185+
- [ ] Header image
186+
187+
### Typesetting checklist
188+
- [ ] Non-breaking spaces where appropriate (product names, etc.)
189+
- [ ] Sentence case in title
190+
- [ ] Check title, image, and post at different screen widths
191+
- [ ] No LLM tells
192+
193+
### Open questions
194+
- Final title
195+
- Video: who's recording it, what app idea to showcase?
196+
- Should the post include terminal output or let the video carry it?
197+
- How much detail on the room protocol (@room, @coder) — inline or link to repo?
198+
199+
-->

0 commit comments

Comments
 (0)