BoB (Big ol' Brain) — Product Vision & Strategy
Last updated: 2026-04-11
Vision
Section titled “Vision”BoB is a self-improving development framework for Claude Code that turns ephemeral AI sessions into a persistent, cross-project operating system. It turns Claude Code from a stateless chat interface into an orchestrated, autonomous engineering harness — one that carries conventions, memory, quality gates, and work-tracking across every project from a single source of truth, and that can be set loose to run unattended on well-defined work.
Problem Statement
Section titled “Problem Statement”Claude Code is powerful but stateless by default. Every project re-invents its own conventions, hooks, and workflows. Institutional knowledge evaporates between sessions. Autonomous work — where the agent runs for hours with minimal supervision — requires scaffolding that doesn’t exist out of the box: work discovery, state recovery, deterministic guardrails, dev environment reproducibility, and safe stopping points. Without this scaffolding, AI-assisted development stays firmly in “pair programming on demand” mode and never reaches “set it loose on a real backlog and come back to PRs.”
Target Users
Section titled “Target Users”| Persona | Description | Primary Need |
|---|---|---|
| Paul (primary) | Solo developer running a portfolio of Cloudflare + SvelteKit + Drupal projects with Claude Code as the primary engineering partner | Consistent, autonomous, multi-project workflows without manual per-project setup |
| Future developers (secondary) | Developers adopting Claude Code for structured, autonomous work | A proven opinionated starting point that skips months of organic discovery |
Product Principles
Section titled “Product Principles”Ordered by priority — when principles conflict, higher wins.
- Declarative and version-controlled — Every piece of state is a file you can read, diff, and commit. No hidden state, no magic substitutions.
- Single source of truth, distributed by manifest — One place defines a thing. Projects opt in via provisions and symlinks. No copy-paste drift between projects.
- Deterministic guardrails — Hooks, not hopes. If a rule matters, enforce it in a hook the model can’t bypass.
- Remote-native — Tools must work over SSH and tmux as well as locally. Unattended runs on a VM are first-class, not an afterthought.
- Work tracked in GitHub — Capabilities and requirements live in GitHub Issues. Don’t reinvent project management in Markdown files.
- Depth before breadth — One agent going deep on a real problem beats ten agents producing demos. Parallelism is earned by use cases, not adopted for its own sake.
- Portable IaC — Nothing BoB ships should be tied to a specific host’s filesystem layout. Hardcoded paths are a bug.
What We Won’t Do (Non-Goals)
Section titled “What We Won’t Do (Non-Goals)”- Modify or fork Claude Code itself — BoB wraps it, never forks it
- Build IDE plugins or a GUI — CLI + tmux + optional HTML dashboards is the entire surface
- Host a SaaS or provide multi-tenant auth — single developer, shareable but not multi-user
- Train or fine-tune models — BoB uses Claude as-is
- Reimplement platform capabilities Anthropic is about to ship — watch the release notes and adopt platform primitives over BoB-native ones
Strategy
Section titled “Strategy”Competitive Landscape
Section titled “Competitive Landscape”| Alternative | Strengths | Weaknesses | Our Differentiator |
|---|---|---|---|
| Vanilla Claude Code | Zero setup | Stateless, no cross-project memory, no autonomy scaffolding | Persistent memory, manifest-driven tooling, warp-drive loop |
| Cursor / Copilot / IDE AI | Polished UX, inline edits | No hours-long autonomy, no cross-project state, sealed workflow | Unattended autonomous runs with deterministic guardrails |
| Conductor.build / Crystal | Polished parallel-agent GUIs | macOS-only, cannot see code on a remote VM, no declarative harness | Remote-first CLI, declarative tooling, depth per agent |
| Agent frameworks (LangChain, Ruflo, etc.) | Flexible abstractions | Generic, heavy, no Claude Code integration | Native Claude Code skills/hooks/commands; not a separate runtime |
Key Differentiators
Section titled “Key Differentiators”- Warp-drive autonomous loop — Discover work from GitHub Issues, code, test, commit, report, merge. Runs unattended for hours with state-machine recovery and deterministic guardrails.
- Manifest-driven provisioning — Per-project manifests at
~/.claude/provisions/<project>.jsondeclare which skills, commands, agents, and runbooks each project needs.cdprovresolves and symlinks them. No per-project duplication. - Hooks as deterministic guardrails — Branch enforcement, AI-attribution stripping on commits, commit detection, worktree safety. Enforced at the tool-use layer, not on trust.
- Persistent memory — Auto-loaded file-based memory survives between sessions, scoped by user, project, feedback, and reference. Compounds over time.
- Dev lifecycle IaC —
dev.json+ seeded test users +/dev-upbrings any project to a testable state deterministically. Warp-drive integrates with it for health checks between chunks and auto-recovery on failure. - Remote-first — Runs on any Linux box over SSH and tmux. Dual-mode: laptop for interactive work, farm-01 for unattended autonomous runs.
Phased Roadmap
Section titled “Phased Roadmap”| Phase | Focus | Success Signal |
|---|---|---|
| Now | Nanawall production use of warp-drive + cdfork (worktree fan-out: fork, status, drop, pair, --from-issues, serial-only filter — shipped 2026-04, see #110) for the headless migration; engine-pluggable docs portal — VitePress + Starlight A/B (#152, #689) — live at https://bigbrain-docs.pages.dev on Cloudflare Pages (#154) |
3–4x throughput on nanawall module clusters; headless migration proceeds in contract-driven parallel chunks; BoB docs site live at a public URL ✅ |
| Next | Autonomous CI-fix and merge-conflict handling in warp-drive; IaC portability cleanup (purge remaining farm-01 symlink leakage); per-project .docs → docs standardization |
Warp-drive reliably ships merge-ready PRs without human intervention on clean work; BoB repo checks out cleanly on any Unix host |
| Later | Lesson recall system (currently write-only); Claude Agent Teams integration if it ships stable; aggregate cross-project health dashboard; memory query layer | Memory compounds across sessions and is actively retrievable; multi-agent primitives adopted from the platform layer rather than reinvented |
Success Metrics
Section titled “Success Metrics”| Metric | Current | Target | Timeframe |
|---|---|---|---|
| Projects on manifest-driven provisions | ~6 | All active projects | 2026 Q2 |
Warp-drive unattended run success rate (merge-ready PR per autonomous run on approved work) |
Improving | > 80% | 2026 Q2 |
Nanawall module-week throughput via cdfork |
Tooling shipped, awaiting first nanawall production run | 3–4x vs serial | 2026 Q3 |
| Cross-host portability | Partial (farm-01 symlink leakage in project-management/templates/) |
Clean checkout on any Unix | 2026 Q2 |
| Memory layer utility | Write-only | Queryable + auto-loaded with recall | 2026 Q3 |
| Nanawall headless migration capabilities shipped (CAP-01..11) | 0 | 11 | 2026 H2 |
Risks & Open Questions
Section titled “Risks & Open Questions”- Complexity creep — BoB grows faster than it gets pruned. Mitigation: regular simplification passes; “only build what’s been needed twice”; this vision doc as a brake on feature sprawl.
- Claude Code platform drift — Anthropic’s underlying architecture may change (Agent Teams, skills, hooks APIs). Mitigation: loose coupling, test after Claude Code updates, willing to adopt platform primitives and retire BoB-native replacements.
- Single-developer bottleneck — Only Paul understands every corner. Mitigation: self-documenting tools, this vision, CLAUDE.md, auto-memory system.
- Portability leakage — Hardcoded farm-01 paths discovered in
project-management/templates/on 2026-04-11 (entire directory of broken symlinks pointing at/home/farm). Mitigation: treat IaC portability as a recurring audit; the earlier 2026-02-19 IaC audit already caught related cases. - RDB lesson (and its generalization) — Remote Decision Bridge was built, then deprecated when Claude native remote control shipped around 2026-03. Real cost: weeks of work on a feature the platform soon obviated. Mitigation: watch Claude Code releases before building anything the platform might absorb. This applies directly to the
cdforkvs Agent Teams decision — check Agent Teams’ stability before committing to the fullcdforkbuild-out.
Capabilities
Section titled “Capabilities”Link to GitHub Issues labeled cap:
- (BoB’s capabilities currently live in the legacy
project-management/product-spec.md. Migrating them to GitHub Issues labeledcapis a separate cleanup task, tracked outside this vision.)
This document is the anchor for all BoB product decisions. Capabilities and requirements should trace back to this vision. If something doesn’t connect here, question whether it belongs.