The Shakespeare Origin Story: From Goose to Browser-Based AI Development
How Shakespeare evolved from Block's Goose AI agent framework through Stacks to become a browser-based development environment for building Nostr applications
The Evolution of AI-Assisted Development
Shakespeare didn't appear overnight. It's the result of an evolution that started with Block's Goose framework, continued through Soapbox's Stacks project, and culminated in a browser-based development environment that makes building Nostr applications accessible to everyone.
The Evolution Path
Goose
Terminal & App
AI agent framework
for developers
Stacks
Nostr Templates
Template system
for Nostr apps
Shakespeare
Browser-Based
Full development
environment
Chapter 1: Goose by Block
In January 2025, Block (formerly Square) introduced codename goose—an open-source AI agent framework that enabled developers to connect large language models to real-world actions. Goose was designed for software engineers, operating within development environments to automate repetitive tasks like reading and writing files, running tests, and installing dependencies.
Goose's Core Innovation
Goose introduced a modular architecture where developers could:
- Choose Their AI Provider: Connect to any LLM (OpenAI, Anthropic, local models, etc.)
- Use Model Context Protocol (MCP): Anthropic's open standard for connecting AI agents to systems and data sources
- Build Custom Interfaces: Create specialized UIs for different use cases
- Execute Autonomously: Let AI handle tasks end-to-end within the development environment
Goose was powerful but required technical knowledge to use. It offered both a terminal-based tool and an installable app for developers building traditional software projects.
Learn More About Goose
Block's original AI agent framework that inspired the development of Stacks and Shakespeare.
Read Block's AnnouncementChapter 2: Stacks for Nostr
Inspired by Goose's approach to AI-assisted development, the Soapbox team recognized an opportunity to bring similar capabilities to the Nostr ecosystem. In May 2025, we released Stacks—a decentralized template-sharing platform built specifically for Nostr development.
Why We Built Stacks
While Goose was a general-purpose development tool, we needed something optimized for our specific use case:
- Nostr-First Development: Building social apps, content platforms, and decentralized communities
- Template Sharing: A way to package and share complete project templates across the Nostr network
- Faster Bootstrapping: Starting new Nostr projects in minutes instead of days
- Accessible to Non-Developers: Enabling creators without coding backgrounds to build on Nostr
Stacks built on Goose's foundation while adding Nostr-specific features. Like Goose, it included an AI agent (we called it "Dork") that helped developers build projects through conversation. But unlike Goose, Stacks was specifically designed around shareable templates published as Nostr events.
GooseGeneral Purpose
• Terminal & app-based AI agent
• Any type of software project
• Model Context Protocol (MCP)
• Local development environment
StacksNostr Specialized
• Terminal-based with Dork agent
• Nostr application templates
• Model Context Protocol (MCP)
• For Nostr builders
• Template sharing via Nostr
Introducing MKStack
The flagship template in the Stacks ecosystem was MKStack—a comprehensive starter for building Nostr applications. MKStack included:
- Nostrify Integration: Pre-configured Nostr protocol handling
- Modern Design System: React, TypeScript, TailwindCSS, and ShadCN UI components
- Authentication: Nostr login ready to use out of the box
- Documentation: Context files and guides to help AI assistants understand the stack
MKStack proved that the combination of good templates + AI assistance could dramatically speed up Nostr development. Projects that previously took weeks could be built in days or even hours. You can try Stacks today at getstacks.dev.
Chapter 3: Shakespeare Goes Browser-Based
By July 2025, we had learned valuable lessons from Stacks. The terminal-based workflow worked well for developers, but it still had barriers: Node.js installation, command-line knowledge, and local development setup. We wanted to make Nostr development accessible to everyone, not just developers.
This led to Shakespeare—a complete reimagining of the Stacks concept as a browser-based development environment.
The Browser-Based Revolution
Shakespeare eliminated all the traditional barriers to development:
- No Installation: Everything runs in your web browser using modern Web APIs
- No Terminal: Chat interface replaces command-line interactions
- Visual Development: Live preview shows changes in real-time
- Instant Deployment: One-click publishing to decentralized hosting
- Code Editing: Built-in editor for those who want to make manual changes
By moving to the browser, Shakespeare maintained the best parts of Goose (AI-assisted development, model choice) and Stacks (Nostr templates) while removing the technical barriers.
From Terminal to Browser
Goose
(Terminal & App)
- ✓ AI assistance
- ✓ Model choice
- ✓ File operations
- ✗ Requires installation
- ✗ Local-only
Stacks
(Terminal)
- ✓ AI assistance (Dork)
- ✓ Model choice
- ✓ Nostr templates
- ✓ Template sharing
- ✗ Requires installation
- ✗ Terminal-only
Shakespeare
(Browser)
- ✓ AI assistance
- ✓ Model choice
- ✓ Nostr templates
- ✓ Live preview
- ✓ Zero installation
- ✓ Visual interface
- ✓ Code editing
What Shakespeare Inherited from Goose
Shakespeare carries forward several key concepts from Goose:
1. Provider Independence
Goose pioneered the concept of letting users choose their own AI provider rather than being locked to a single vendor. Shakespeare extends this with the Shakespeare AI provider which supports multiple models and accepts payment via either Stripe of Bitcoin Lightning.
2. Autonomous Task Execution
Both Goose and Shakespeare can autonomously handle complex tasks: reading and writing files, managing dependencies, running builds, and deploying projects. The user describes what they want, and the AI handles all the implementation details.
What Shakespeare Added
While inspired by Goose, Shakespeare introduced several innovations:
Custom-Built Tools
While Goose pioneered the use of Model Context Protocol (MCP) for connecting AI to external systems, Shakespeare takes a different approach. Instead of using MCP servers, we built custom tools specifically designed for the needs of our development environment. This includes Nostr tools ported from Nostr MCP, as well as text editor tools ported from Soapbox's JS Dev MCP.
Shakespeare does support connecting to MCP servers over HTTPS for advanced users who want to extend functionality, but the core Nostr capabilities come from our custom-built tools rather than through MCP. This gives us more control over the developer experience and better integration with the browser environment.
Browser-Native Architecture
Shakespeare runs entirely in the browser. Building this was a major accomplishment—creating a full development environment that runs completely client-side without any server-side processing. This eliminates installation and works on any device with a web browser.
Visual Development Environment
Unlike terminal-based tools, Shakespeare provides a complete visual interface with live preview, code editor, file explorer, and real-time deployment. The environment also includes an in-browser terminal that supports many basic commands, plus a custom console tool with a built-in assistant named Quilly. Developers can switch between conversational AI assistance and direct code editing as needed.
Nostr-Native Identity
Shakespeare integrates Nostr login directly, allowing users to authenticate with browser extensions like Alby or nos2x. Projects are tied to Nostr identities, enabling social features like sharing templates, discovering community projects, and publishing to decentralized hosting.
Git Integration
Shakespeare includes built-in Git support, allowing users to version control their projects, push to GitHub/GitLab, and collaborate with others—all from the browser without installing Git locally. Shakespeare also supports Nostr Git (ngit) for decentralized version control on the Nostr network.
The Stacks Connection
Stacks served as the bridge between Goose's general-purpose AI development and Shakespeare's browser-based Nostr focus. Through Stacks, we learned:
- Templates Matter: Good starter templates dramatically improve AI output quality
- Context is Key: Providing AI with project-specific documentation leads to better results
- Community Sharing: Publishing templates as Nostr events creates a network effect where everyone benefits
- Nostr-First Works: Building specifically for Nostr rather than trying to be general-purpose produces better outcomes
These insights shaped Shakespeare's design. While Stacks proved the concept through a terminal interface, Shakespeare made it accessible to everyone through the browser.
Timeline of Development
Standing on the Shoulders of Giants
Shakespeare was directly inspired by the pioneering work of the Goose team at Block. By adapting their concept for Nostr through Stacks, and ultimately transforming it into Shakespeare's browser-based environment, we've created a tool that serves a different audience while honoring the original vision: using AI to give people time back to be their most creative selves.
Experience the Evolution
From Goose to Stacks to Shakespeare—try the culmination of AI-assisted Nostr development.