SlideRule: A Product Rehearsal Engine for Visible Product Development

What changed

SlideRule, an open-source project, introduces a "product rehearsal engine" designed to clarify ideas and ship runnable products. Unlike traditional methods that can involve lengthy PRD writing and alignment phases, SlideRule aims to condense this into a single coffee break by providing a visible rehearsal process. The core philosophy is that an AI claiming something is done is insufficient; only artifacts passing deterministic gates are considered valid.

The engine operates through a series of "factory hops," each performing one WRITE operation: spec → pages → structure → bind → closure. A hop must demonstrably change a deliverable to report success. SlideRule employs a typed control plane for managing scope cards, assumption cards, and hop intents, preventing leftover pages from hijacking the rehearsal or refinement processes. A key feature is its "fail-closed publish closure," meaning missing evidence halts the process, preventing false green lights.

SlideRule's architecture emphasizes transparency and auditability. The model runs as an application directly in the browser, utilizing a five-system JSON schema for pages, RBAC, workflow, data, and AIGC, with no backend required for the preview. The authoritative engine is written in Python (slide-rule-python using FastAPI), while a Node.js thin proxy handles API requests. Architecture is managed through compilers (arch_graph.py and arch-graph-ts.mjs) that enforce rules against undeclared edges, new cycles, and import ratchets.

Why it matters for builders

For developers, SlideRule offers a paradigm shift in how products are conceived and built. It provides a concrete tool to move from a high-level idea to a tangible, runnable application with a high degree of visibility at every stage. This transparency is crucial for debugging, auditing, and ensuring that the final product aligns with the initial intent. The emphasis on deterministic gates and fail-closed mechanisms builds confidence in the development process.

Builders can leverage SlideRule to significantly reduce the time spent on product planning and iteration. The ability to rehearse and run a product plan in the browser, without extensive setup, allows for rapid validation of concepts. This contrasts sharply with the months-long cycles often associated with learning that a product direction was incorrect.

Practical impact

SlideRule is available as a live demo running in the browser at https://2686521696.github.io/WhyBuddy/agent-loop/sliderule, requiring no installation or backend setup. For those who wish to run it locally, the project can be cloned from GitHub. Docker Compose is provided for a streamlined setup, requiring only an OpenAI-compatible LLM API key and a session secret. The local setup exposes the application on http://localhost:3000.

Developers can explore the system architecture, which includes a frontend UI (Vite + React), a server thin proxy (Express), and the core Python rehearsal engine. The project also includes a "Skill package" designed for use with agents like Trae or Claude, allowing a single sentence input to generate a reviewable spec package. Examples provided showcase SlideRule's capability in generating specs and runnable apps for scenarios like pet-clinic booking, instrument consignment, and venue scheduling.

SlideRule differentiates itself from agent frameworks (like CrewAI or LangGraph) and workflow builders (like Dify or n8n) by its specific focus on generating product structure from a single sentence, providing a spec package, implementing evidence-gated publish closures, and running the rehearsed model as an app in the browser. It also supports replay, audit, and human intervention capabilities.

Caveats and source limits

The provided source material details the architecture, functionality, and usage of SlideRule. However, specific details regarding performance benchmarks, pricing models (as it is open-source, this is less critical but still relevant for potential enterprise adoption or support), and a definitive release date for specific versions are not explicitly stated. The project is presented as a rehearsal engine, and while it generates runnable applications, the complexity and scalability of these applications for production environments are not deeply explored in the provided excerpts. The "North Star" principle highlights a focus on deterministic gates, but the exact nature and implementation of all these gates are not exhaustively detailed. The source mentions optional components like Lobster Executor and Redis, but their integration and impact on the core functionality are not fully elaborated.