From d48925de236f1c2905ae5527aa148dba92afed8a Mon Sep 17 00:00:00 2001 From: Hermes Date: Thu, 21 May 2026 19:05:28 +0000 Subject: [PATCH] estimates: LOC and dev time for self-driving Lisp Machine - Current Passepartout: ~10,700 lines, 2 months one dev - To v1.0.0: +4,500 lines, 4-6 months - Lisp Machine hardware integration: +6,000 lines, 3-6 months - Total: ~21,000 lines, 9-14 months one dev, 5-7 months team of 2-3 - Why small: Lisp is 3-10x denser, primitives are reused across domains, ACL2 proofs replace test fixtures, LLM generates boilerplate - Comparison: Hermes ~50K, Claude Code ~100K, Llama.cpp ~200K - Not a moonshot. A well-scoped engineering project. --- ideas/passepartout-economics.org | 108 +++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/ideas/passepartout-economics.org b/ideas/passepartout-economics.org index aece83e..ca888cc 100644 --- a/ideas/passepartout-economics.org +++ b/ideas/passepartout-economics.org @@ -959,6 +959,114 @@ a RISC-V cross-compiler, and one patient human who reviews the contrastive queries can achieve a self-driving Lisp Machine in under a month. +*** Size and development time estimates + +These are order-of-magnitude estimates based on the existing +architecture and the roadmap's line-count breakdowns. The numbers +are small because Lisp is more expressive, the architecture reuses +primitives across domains, and the symbolic engine replaces what +would be thousands of lines of Python in a conventional agent. + +**** Current Passepartout (v0.7.2, main branch) + +| Component | Lines of Lisp | Status | +|-----------|---------------|--------| +| Core pipeline (perceive-reason-act, memory, skills, transport, package) | ~1,800 | Built and running | +| Gate stack (security dispatcher, permissions, policy, vault, validator) | ~900 | Built and running | +| Neuro (provider router, provider dispatch, token economics, tokenizer) | ~900 | Built and running | +| Programming tools (lisp, org, repl, literate, standards, tools) | ~1,600 | Built and running | +| Symbolic (archivist, awareness, memory, scope, events, identity, self-improve) | ~1,200 | Built and running | +| Channels (TUI main/state/view, CLI, Telegram, Signal, Discord, Slack) | ~2,300 | Built, on refactor branch | +| TUI (cl-tty migration, ongoing) | ~1,300 | In progress on refactor branch | +| Config, diagnostics, embedding, sensors, integration tests | ~700 | Built and running | +| **Total existing** | **~10,700** | | + +Development time to reach v0.7.2: approximately 2 months, +one developer (April-May 2026 from git log). + +**** New code to reach v1.0.0 (Neurosymbolic Maturity) + +| Phase / Feature | Lines | Est. dev time (one dev) | +|-----------------|-------|------------------------| +| v0.8.0 TUI stabilization (cl-tty) | ~500 | 3-4 weeks | +| v0.9.0 Eval harness + sandbox hardening | ~200 | 1-2 weeks | +| v0.11.0 Phase 0 (type-level gates, core integrity) | ~75 | 3-5 days | +| v0.13.0 Phase 0b (signal authentication, Layer 1) | ~200 | 1-2 weeks | +| v0.15.0 Phase 1 (fact store with provenance) | ~200 | 1-2 weeks | +| v0.17.0 Phase 1a (self-preservation, quarantine, watchdog) | ~120 | 1 week | +| v0.19.0 Phase 2 (Screamer admission gate) | ~200 | 1-2 weeks | +| v0.21.0 Phase 3 (archivist as fact proposer) | ~100 | 1 week | +| v0.23.0 Phase 4 (sufficiency criterion, the Flip) | ~50 | 2-3 days | +| v0.26.0 Phase 5 (VivaceGraph, Merkle DAG, ontology versioning) | ~400 | 2-4 weeks | +| v0.28.0-28.5 Phase 6 (ACL2 base + 5 macro layers) | ~540 | 3-4 weeks | +| v0.37.0 Phase 7 (10-80-10 planner) | ~500 | 3-4 weeks | +| All polish features (skins, export, CLI, MCP, LSP, telemetry, cost, etc.) | ~1,500 | 4-8 weeks | +| Integration testing, hardening, bug fixes | — | 4-8 weeks | +| **Total new code at v1.0.0** | **~4,500** | **4-6 months (one developer)** | + +**** Additional code for a self-driving Lisp Machine + +| Component | Lines | Est. dev time (one dev) | +|-----------|-------|------------------------| +| RISC-V microcode for Lisp dispatch (tagged memory, GC barriers, cons cells) | ~3,000 | 1-2 months | +| PCIe DMA driver from SBCL (C + sb-alien FFI) | ~500 | 2-4 weeks | +| Tenstorrent Tensix core management (allocate, load, benchmark) | ~1,500 | 3-4 weeks | +| Profiling and benchmark harness (Phase 4 applied to hardware) | ~500 | 1-2 weeks | +| Microcode synthesis from ACL2-verified specifications | ~500 | 2-4 weeks | +| **Total for Lisp Machine hardware integration** | **~6,000** | **3-6 months (one developer)** | + +Notable: the microcode for Lisp dispatch (~3,000 lines of RISC-V +assembly) is smaller than the existing Lisp codebase. The hardest +part is not the assembly — it's the verification that the assembly +correctly implements the Lisp primitives, which ACL2 handles. + +**** Total system at self-driving threshold + +| | Lines of code | Dev time (one dev) | Dev time (small team, 2-3) | +|---|---|---|---| +| Passepartout v0.7.2 | ~10,700 | 2 months (done) | 1 month (done) | +| To v1.0.0 | +~4,500 | 4-6 months | 2-3 months | +| Lisp Machine hardware | +~6,000 | 3-6 months | 2-3 months | +| **Total** | **~21,000** | **9-14 months** | **5-7 months** | + +**** Why the numbers are small + +- **Lisp is 3-10x more compact than C++ or Python** for the same + semantics. The entire gate stack (900 lines) would be 3,000-5,000 + lines of Python with middleware classes and serialization glue. +- **The architecture reuses primitives cross-domain.** The Merkle + tree, the gate stack, the fact store, the ACL2 prover — each is + built once and shared by all features. There is no "compliance + package" that duplicates the "refactoring package" infrastructure. +- **The symbolic engine replaces test code.** A conventional agent + needs thousands of lines of test fixtures for behavior validation. + ACL2's proofs replace those. The tests are the theorems. +- **The LLM generates the boilerplate.** The LLM writes gate rules, + macro layer templates, and migration scripts. The symbolic engine + verifies them. The human reviews the 5% edge cases. The bottleneck + is verification throughput, not code writing. + +**** Comparison with other systems + +| System | Lines | Developer-years | +|--------|-------|-----------------| +| Hermes Agent | ~50,000+ | 2+ years, ~3 devs | +| Claude Code | ~100,000+ (estimated) | 3+ years, large team | +| Llama.cpp | ~200,000 | 2+ years, many contributors | +| **Passepartout self-driving** | **~21,000** | **~1 year, 1-3 devs** | +| Symbolics Genera (1980s Lisp OS) | ~1,000,000 | ~10 years, large team | + +The Symbolics comparison is instructive: they built a full Lisp +operating system from scratch in assembly and Lisp, with graphical +interface, networking, file system, and development environment. +Passepartout runs on Linux, which provides the OS layer for free. +The Lisp Machine hardware integration is a PCIe card, not a +replacement of the entire host. The scope is dramatically smaller. + +The surprising result: **a self-driving Lisp Machine is a ~21,000 +line project for a small team working less than a year.** Not a +billion-dollar moonshot. A well-scoped engineering project. + Large refactoring projects (extract module, rename API, split monolith) are the hardest test for any AI agent. Current approaches (Claude Code, Copilot) handle them probabilistically — every step costs tokens, and