Programmable Programming Page

Note: This analysis is based entirely on the self-reported description provided by the author. No independent verification, traction data, revenue figures, or customer information are available.

• The description states that PPP is a conversation-first workspace where product managers and designers can make full-stack changes without seeing code, files, Git, models, Skills, or MCP.
• It allows users to:
  • Answer without changing the product;
  • Ask one focused clarification;
  • Generate and activate a full-stack change;
  • Restore an earlier source-plus-data checkpoint.
• Changes are evaluated in sandboxed environments — one for browser (ClojureScript) and one for JVM (Clojure).
• The system supports:
  • Real CLJ, CLJS, CLJC, CSS, SQL migrations, tests, persistent SQLite data;
  • Append-only history and recoverable checkpoints.
• It uses SCI-evaluated transactional hot swapping, not traditional hot reload.
• The architecture includes:
  • A JVM Clojure application serving a ClojureScript host;
  • Reagent and browser SCI for UI rendering in an opaque-origin iframe;
  • SQLite and next.jdbc for database access;
  • Versioned WebSocket protocol for coordination;
  • Docker image with non-root execution.

Inference: PPP appears to be a prototype or proof-of-concept tool built during a hackathon, designed to demonstrate how product conversations could evolve into live software via AI-assisted generation and sandboxed activation.

• The author positions PPP as a next-generation interaction model for product development — one that moves beyond static documents or mockups.
• It claims to follow the lineage of:
  • Emacs Lisp REPL;
  • nREPL;
  • Deep Space 1 Remote Agent experiment.
• The project states it aims to bring “live-programming” ideas out of terminals and into familiar browser workspaces.
• PPP is described as not just hot reload, but a system that:
  • Starts from a conversation;
  • Generates source code;
  • Evaluates and tests client/server/SQL boundaries;
  • Renders candidates in isolation;
  • Advances the product version atomically.

Claim: PPP represents a shift toward product conversations becoming running software.

Inference: The positioning reflects an ambition to disrupt or redefine how non-developers interact with product development, especially in early-stage ideation and prototyping.

• The description identifies product managers and designers as primary users who are blocked by traditional development workflows (Git, folders, runtimes, OAuth).
• These users already know a better interaction model: open Figma to design, Notion to write, share the result.
• PPP is intended for those who want live product planning — where conversations do not end in documents or mockups but become actual software.

Claim: PPP targets non-developers who want to shape products without writing code.

Inference: The ICP likely includes early-stage product teams, startups, and design-led organizations that value rapid iteration over technical complexity.

• No evidence of pricing, monetization strategy, or business model is provided in the description.
• The project is described as a hackathon submission, not a commercial offering.
• There is no mention of subscriptions, usage fees, licensing, or enterprise tiers.

Not evidenced: No indication of how PPP would be sold or priced if it were to become a product.

• Built with:
  • Clojure, ClojureScript, Docker, GPT-5.6 Terra, OpenAI Codex, Playwright, Reagent, SCI, SQLite.
• Architecture:
  • JVM Clojure app;
  • ClojureScript host;
  • Reagent + browser SCI in sandboxed iframe;
  • SQLite and next.jdbc for DB;
  • Versioned WebSocket protocol;
  • Docker image with non-root execution.
• Uses SCI to evaluate generated Clojure code inside explicit namespaces and capabilities.
• Browser code runs in a disposable opaque-origin iframe, isolated from parent context.
• Generated server code is restricted from accessing shell, filesystem, JVM interop, dynamic dependencies, MCP, Skills, host credentials, or unrestricted network.
• Browser code can use JavaScript, timers, keyboard input, Canvas, WebAssembly only inside sandbox.
• Product authentication and workspace data are separated from PPP Control Plane.

Inference: The technical architecture shows a strong focus on safety, sandboxing, and isolation — key features for an AI-assisted development tool.

• The project is described as a public hackathon build, submitted to the OpenAI 2026 hackathon.
• It includes a live demo using GPT-5.6 Terra, OAuth Codex provider, and real browser/server interactions.
• The author mentions:
  • A public judge server;
  • Real OAuth integration;
  • Full-stack changes (signup/signin, game logic);
  • Error handling and diagnostics.
• No evidence of:
  • Customers;
  • Revenue;
  • Adoption metrics;
  • Product usage beyond the demo.

Not evidenced: No signs of traction or product maturity beyond a hackathon prototype.

• The description does not name direct competitors.
• It references:
  • Emacs Lisp REPL;
  • nREPL;
  • Traditional hot reload tools.
• PPP is positioned as an evolution of live-programming concepts, but no comparison to existing AI coding platforms (e.g., GitHub Copilot, Tabnine) or low-code/no-code tools is made.

Inference: PPP may compete with or complement AI-assisted development tools and low-code platforms, though it’s not clearly differentiated in the description.

• The project is described as a hackathon submission, not a commercial product.
• No evidence of:
  • Revenue;
  • Customers;
  • Product adoption;
  • Scalability beyond a single shared-password workspace.
• The system relies heavily on GPT-5.6 Terra and Codex, which are not publicly available or standardized.
• The architecture is described as intentionally limited for security reasons (e.g., no shell access, bounded SCI capabilities).
• There is no indication of:
  • Long-term roadmap;
  • Team size beyond one person;
  • Funding or investor interest.

Red flag: Lack of commercial viability or traction beyond a prototype.

1. What is the current status of PPP — is it still under active development?
2. Are there any plans to scale beyond the single shared-password workspace?
3. How does PPP handle edge cases like model hallucinations or inconsistent outputs?
4. Has PPP been tested with real product teams, or is it limited to internal demos?
5. What are the long-term goals for PPP — is it intended as a standalone tool or part of a larger platform?
6. How does PPP plan to integrate with existing development workflows (e.g., CI/CD, Git)?
7. Are there any technical limitations that prevent PPP from being used in production environments?