Nostreon
Derek Ross
July 8, 2026
How Soapbox Ships So Fast: Our Stack, Our Tools, Our Workflow
People keep asking how a small team ships so many Nostr apps so fast. The honest answer: there's no secret. It's all open source, and it's all in our Toolbox. Here's the whole playbook.
I got on a call last week with a friend in the Nostr ecosystem, a seasoned developer who's shipped real things and now leads engineering at a Nostr company. We weren't there to talk features or partnerships. We got to talking about one thing:
How do you ship so much, so fast, all at once?
How does a small team put out Ditto, Shakespeare, Agora, NostrHub, MKStack, Nostrify, a relay, and a dozen community apps, and keep shipping? What's the workflow? What's the stack? What are the tools?
It's a question I hear a lot lately, so it's worth answering in the open. And the honest answer is almost anticlimactic: there is no secret. It's all open source, and it's all in one place, our Toolbox. Every tool we use to move this fast is something you can pick up today, for free, and most of it we built specifically so that you could.
So here it is, the whole playbook. And if you skim to the end for one thing, make it this: use our tools.
The short version
We ship fast because we removed the three things that usually slow teams down:
The protocol does the hard part
On Nostr, your data lives on relays, not in your app. The app is just a view. That changes everything downstream.
The stack is built for AI
Every layer, from the docs to the framework, is designed so an AI agent actually understands it and can build with it.
AI is a teammate, not autocomplete
The human is the producer. The AI plays the instruments.
Let's go layer by layer.
The protocol: why Nostr makes speed possible
Most teams are slow because software is expensive to change. Technical debt piles up. Rewrites cost weeks. You end up maintaining code you're afraid to touch.
Nostr flips that math. Your data lives on relays as signed events, not locked inside your app's database. The app is just a view layer over shared, portable data. If a frontend gets messy, you rebuild it, and your data survives untouched. NIPs (Nostr Implementation Possibilities) act as guardrails, so even fast, scrappy code still speaks the same protocol as everything else in the ecosystem.
That's the unlock: you can throw an app at the wall, see if it resonates, and rebuild it if it doesn't, without ever losing the data or breaking interop. We call it digital spaghetti. Throw it, see what sticks, refine what works.
The stack: built so AI can build with it
Here's the part people miss. We didn't just adopt AI tooling, we rebuilt our whole developer stack so that AI can use it well. Four pieces, each stacking on the last:
Nostrify is our TypeScript framework for Nostr. Relays, storage, signers, encryption, moderation, all handled in pure TypeScript. It's the foundation every app sits on, and it gives an AI agent a clean, consistent surface to build against instead of reinventing protocol plumbing every time.
Nostrbook is a comprehensive registry of Nostr documentation, structured for both humans and AI (available over MCP). This is the quiet secret weapon. If you want an AI to build correct Nostr apps, it has to actually understand the protocol, the kinds, the NIPs, the conventions. Nostrbook is how the model learns Nostr instead of hallucinating it.
MKStack is our full-stack framework and template for Nostr apps. Proven patterns and best practices baked in from the first commit, so an AI agent starts from a solid, working foundation instead of a blank page. Agora, Chorus, Plektos, Treasures, and more were all built on it.
Shakespeare is the freedom-respecting AI app builder that runs entirely in your browser. It brings the whole stack together: describe what you want, and it builds a real, deployable Nostr app. No lock-in, bring your own AI provider, your own Git, your own hosting, and export everything anytime.
Each layer feeds the next. Good docs (Nostrbook) then solid library (Nostrify) then proven scaffolding (MKStack) then accessible builder (Shakespeare). By the time an AI agent is generating code, it's standing on four layers of context we built on purpose.
The tools: how we actually work day to day
The framework gets you a foundation. The tools are how we move. And here's the honest part: our workflow has evolved. We don't use one tool for everything, we've learned to reach for a specific tool for a specific job.
Shakespeare is where ideas start. It's the fastest path from a thought to a working Nostr app, right in the browser with zero setup, so we use it for ideation and quick prototyping, spinning something up fast to see if an idea has legs. Anyone can pick it up, which is exactly why it's how we (and the whole community) go from zero to something in minutes.
OpenCode is where we go deep. Once an idea is worth building for real, we, as advanced users, fall back to OpenCode in the terminal to get into the nitty-gritty: the full weight of a real dev environment, agentic AI coding, fine control over every file. Shakespeare gets us moving; OpenCode gets us finished. We built Agora in 48 hours at the HRF hackathon using both, and Venezuelan activists were on it within hours.
Cloning MKStack directly. And sometimes we skip the builder entirely. When we already know exactly what we're making, we just clone the MKStack repo and use it as the template to start a new project, a proven Nostr app scaffold, ready to go, straight into OpenCode. Ideation in Shakespeare, template-from-MKStack when we know the shape, deep work in OpenCode. Right tool, right job.
The models matter, and they got dramatically better. We lean heavily on Anthropic's Claude for coding, currently Claude Opus 4.8 and Fable. When "vibe coding" was coined in early 2025, the best models scored under 40% on SWE-bench. The frontier is now past 80%. That jump is a big part of why a small team can ship like a large one: the AI does more of the heavy lifting, correctly, on the first pass.
AI teammates, not just tools. We give AI a real seat at the table. Dirk Rost is our AI intelligence layer, he reviews code, approves merge requests, and keeps a bird's-eye view across every project, so quality scales as fast as we ship. He runs on open-source infra with a personality defined in plain markdown anyone can read. When an AI teammate hits a limitation, we know our users will too, so we fix it faster.
The mindset: you're the producer
Here's the part that isn't a tool at all, and it's the most important one.
Vibe coding done well isn't passive. The human's job isn't to write every line, it's to be the producer. In music, the producer doesn't play every instrument; they bring taste, direction, and the judgment to know when it's done. That's the role. You imagine the end product and prompt it into existence, then you shape every take: accept this diff, reject that one, ask for another pass.
That's why we ship fast without shipping junk. The AI writes the code; the human owns the vision and the standard. Speed comes from removing friction, not from lowering the bar.
The real skill: learning to speak to AI
Here's the honest part nobody wants to hear, and it's the one thing on this whole list you can't just download.
Prompting is a skill. Learning how to speak to an AI, how to frame a problem, how much context to give, when to steer and when to get out of the way, how to recognize why a model went sideways and correct it, is a real, earned craft. It doesn't arrive the day you sign up. It comes after months of practice. The people on our team who ship the fastest aren't the ones with the fanciest setup; they're the ones who've put in the reps.
What you're actually building over those months is a symbiotic relationship. You start to learn how the model thinks, and in shaping how you ask, you teach it how you think. You develop a shared shorthand. You learn its strengths worth leaning on and its failure modes worth guarding against. It learns the shape of what "good" looks like to you. Working together stops feeling like issuing commands and starts feeling like collaborating with a teammate who's getting to know you.
That's the part that can't be shortcut, and it's why the tools alone won't make you fast. The stack removes the friction; the relationship is what you grow into. So the advice is simple, if unglamorous: start now, build something real, and keep going long enough to get good at working together. The tools are free. The fluency is earned.
If you take away one thing: use our tools
Here's the number one takeaway, and it's the whole point of writing this: you don't have to build any of this yourself. Use our tech stack. Use our tools.
Everything we just walked through lives in one place, the Soapbox Toolbox. The open-source developer tools behind everything we ship, from AI app builders to relay infrastructure to protocol explorers. All free. All yours.
[
Shakespeare
Build Nostr apps by chatting with AI. Preview live, deploy in minutes.
MKStack
The full-stack toolkit for shipping Nostr apps fast. Clone it as your template.
Nostrify
The batteries-included Nostr framework powering our apps.
Nostrbook
Docs and an MCP server that give your AI agent the full protocol.
NostrHub
Explore every NIP and event kind. Publish your own.
Ditto Relay
High-performance relay infrastructure. Self-host or connect.
https://gitlab.com/soapbox-pub/ditto-relay
Grab them, wire them into OpenCode or your editor of choice, point your AI at Nostrbook, and start shipping. That's literally how we do it, there's nothing behind the curtain.
We build these tools for a free internet, and we build them in the open specifically so the whole ecosystem can move faster, together.
The best technology belongs to everyone. Open the toolbox and come build with us. 💜🟠
This article was originally published on soapbox.pub.