BoB (Big ol' Brain) — Product Vision & Strategy

Last updated: 2026-10-03

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

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.”

That scaffolding now exists, and it created a second problem: the loop spends most of its time building the loop. The 2026-09-10 architecture review found fourteen of the fifteen busiest issues of the quarter were harness work, and the same seams re-fixed under new numbers. BoB has to maintain itself without taking the laptops away from paying work.

Target Users

Persona	Description	Primary Need
Paul (primary)	Operator and maintainer: runs a portfolio of Cloudflare + SvelteKit + Drupal projects with Claude Code as the primary engineering partner, and supports the clients who run BoB	Consistent, autonomous, multi-project workflows without manual per-project setup — and his own hours going to BoB itself, not to hand-fixing the harness
Client organisations (secondary)	Businesses running their own supported BoB in accounts they own — their GitHub org, their farm, their Claude seats — with IWPI shipping releases and support; the first client is tenant zero (#2207, #2218)	A pinned, stable harness that keeps their estate shipping, with support requests instead of hands-on fixes, and no client code or credential held by IWPI
Future developers (tertiary)	Developers adopting Claude Code for structured, autonomous work	A proven opinionated starting point that skips months of organic discovery

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)

Modify or fork Claude Code itself — BoB wraps it, never forks it
Build IDE plugins, or give the GUI state of its own — BoB Control (#3812) is the operator’s surface and it owns no state: projects, sessions and asks stay in issues, tmux, state files and the fleet feed, and Control shows them and acts through the same commands a shell runs. The CLI and tmux stay underneath it; BoB Desktop is its macOS shell over the same dashboard server (#3595; amended by decision #3601)
Host BoB as a multi-tenant service or provide multi-tenant auth — each client runs its own supported BoB in accounts it owns; IWPI ships releases and support but never hosts client farms or holds client credentials. An IWPI-hosted service or self-serve licensing waits until supported BoB has worked end to end once (#2207)
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
Grow the warp-drive state machine during the moratorium — no new phases or transitions until 2026-10-11 without a decision issue linked from the contract fixture change (#2118, from #2042; the frozen contract is warp-drive-contract.md)
Let the farm take work that was not delegated — the night shift runs only approved work carrying the farm label (or every approved req where a project sets _workflow.farm_eligible: true), and never caps, serial-only items, vision or CLAUDE.md narrative, or anything needs-clarification (the eligibility rule, #2052; see farm-tick.md)

Strategy

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

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 provisions/<project>.json declare which skills, commands, agents, and runbooks each project needs. bob provision resolves 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, and is retrievable on demand (/memory-recall). Compounds over time.
Dev lifecycle IaC — dev.json + seeded test users + bob dev up brings 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. Decisions and notices reach Telegram through the Remote Decision Bridge, which is live: ask_remote / notify_remote inside a session, bob notify from a shell (#2048) — see Remote Mode (RDB).

The Operator’s Surface

BoB Control (#3812) is the one place the operator works from: every project, every running session on every host, a way to start work, a terminal on the session, and the things waiting on him. It is one frame on the dashboard server with four screens — Portfolio, Project, Session and Ask — and it is the same page in a browser, in the desktop app and on a phone. Stopping its server loses nothing, because Control stores nothing (bob-control.md).

Control adopts these capabilities as its modules. Each continues under its own number:

Capability	What it is in Control
#2026 `bob viz`	The Portfolio screen
#1727 Project Monitor (`bob warp viz`)	The Project panel and the warp session screen
#3000 Dispatch from `bob viz`	Dispatch, per project and per session
#3595 BoB Desktop	The desktop shell
#2289 iBoB	The phone shell
#3800 One queue of asks	What the ask panes show; its gate, budget and lifecycle decide what reaches them

Phased Roadmap

Phase	Focus	Success Signal
Now	BoB maintains itself on the farm (#2023) — stabilise first (core freeze #2027, consolidation #2029), then release channels + `bob update` (#2028), the `bob` CLI (#2024) and warp-drive from the command line (#2025), then a dry-run farm tick on bigbrain for a week and live on bigbrain only (#2033); alongside, `bob viz` (#2026), discoverability (#2031), declared state on the consuming side (#2030), the docs diet (#2032) and tracker hygiene (#2035). Rationale: laptop sessions go to paying work while the harness keeps improving unattended, merging only on green CI.	Fix-to-feat under 35% over a rolling 30 days; zero laptop-hours on harness-defect bugs in a month; release-bot commits under 100 per quarter; a weekly farm-written `status-report` issue with tokens per merged req; farm-01 fleet snapshot under 24 h old at all times
Now	BoB is the product: supported BoB for clients, the first client as tenant zero (#2207) — on the #2023 stability floor: operator-neutral BoB (#2214) and tenant isolation (#2215), a client farm in a client-owned cloud account (#2216), the client support service (#2217), tenant zero running its own supported BoB (#2218), the packaged offer (#2219), then exactly one second client (#2220). Rationale: turns the harness into a supported service clients run in their own accounts, so IWPI never becomes a hosting provider and revenue stops being tied to billable hours.	Tenant zero runs a pinned stable BoB release on its own infrastructure for 30 consecutive days with zero BoB-caused incidents; support hours measured every month and covered by the retainer with margin; a second paying client onboarded in materially less setup time than tenant zero; recurring service revenue growing as a share of IWPI revenue
Now	Autonomous multi-flight development (#1670) — the flight-plan lifecycle foundation is done (#1665); next a debrief capability (fresh-context post-flight verification), then a mission capability whose replan loop sequences only already-`approved` work under per-mission budgets. The middle grouping tier stays deferred. Rationale: a multi-flight effort runs unattended with human touches only at `approved` gates, mission-brief questions and todos.	A mission completes ≥3 consecutive flights unattended; every replan decision traces to a debrief artifact and live issue state; debrief catches at least one unmet AC or regression per early mission that self-reporting missed; single-issue and single-flightplan runs unchanged
Next	The second farm wave: node/Cloudflare product repos become farm-eligible once bigbrain runs live; hosted-Actions independence for CI (#1690, blocked on #1648)	Product repos merge farm PRs on green without a laptop session
Later	Drupal repos on the farm once farm-01 has dev-server parity; a build-vs-inherit policy for first-party Claude Code features such as Agent Teams (#1434); an IWPI-hosted service or self-serve licensing, only after supported BoB has worked end to end once (#2207 options B and C)	Multi-agent and scheduling primitives adopted from the platform layer rather than reinvented

Resolved from the 2026-04 roadmap

Row	Item	Resolution
Now	Tenant-zero production use of warp-drive + `bob fork` worktree fan-out	Done — `bob fork` shipped 2026-04 (#110), now `bob fork`
Now	Engine-pluggable docs portal	Done — VitePress + Starlight (#152, #689) live on Cloudflare Pages (#154)
Next	Autonomous CI-fix and merge-conflict handling in warp-drive	Done for merge — unattended runs open a PR and fast-forward only on green (#2053); CI repair itself is carried into the farm tick (#2033), which files a todo on a red PR rather than patching it
Next	IaC portability cleanup (farm-01 symlink leakage)	Done — the leaking legacy PM templates were removed and `make check` rejects machine-absolute paths (#1924)
Next	Per-project `.docs → docs` standardization	Dropped — `docs/` is the only convention BoB provisions against; no project still needs migrating
Later	Lesson recall system; memory query layer	Done — on-demand memory recall (#345)
Later	Claude Agent Teams integration if it ships stable	Carried — as the build-vs-inherit policy (#1434)
Later	Aggregate cross-project health dashboard	Carried — as `bob viz`, the fleet-wide console (#2026)

Success Metrics

Current values measured 2026-09-13 on bigbrain; targets are the #2023 success metrics.

Metric	Current	Target	Timeframe
Fix-to-feat commit ratio, rolling 30 days	49% (88 fix / 180 feat)	< 35%	2026 Q4
Release-bot commits per quarter	378 in the last 90 days	< 100	2026 Q4
Farm-written weekly `status-report` issue	None — the farm tick (#2054) has not shipped	Every week, with tokens per merged req	2026 Q4
Farm-01 fleet snapshot age	No scheduled snapshot (#2067)	Present and < 24 h old at all times	2026 Q4
Warp-drive unattended run success rate (merge-ready PR per autonomous run on `approved` work)	Not yet measured — the cost and churn series (#2072) will report it	> 80%	2026 Q4

The 2026-04 metrics are retired: manifest-driven provisioning covers every registered project, cross-host portability is gated by make check (#1924), the memory layer is queryable (#345), and tenant zero’s migration metrics belong to its own repository, not to BoB.

Risks & Open Questions

Complexity creep — BoB grows faster than it gets pruned. Mitigation: the phase moratorium (#2118), the consolidation capability (#2029), the docs diet (#2032), “only build what’s been needed twice”, and this vision doc as a brake on feature sprawl.
The loop building the loop — harness work crowds out product work. Mitigation: the farm tick (#2033) moves BoB’s own maintenance off the laptops; laptops track the stable release channel, not master (#2028).
Unattended merge ships a broken master — Mitigation: the farm opens a PR and fast-forwards only on green CI (#2053); a red PR becomes a todo, never a patch.
Runaway cost — Mitigation: per-tick budgets for tokens, wall clock and issue count, and a pause after two failed ticks (#2055).
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 (#1434). The Remote Decision Bridge was briefly called deprecated when native remote control shipped around 2026-03; it stayed live because it is the one channel an unattended shell can use, and it now carries the farm’s notices (#2048). Check the platform before building, but do not retire a tool the platform only partly replaces.
Support capacity — one operator supporting client instances, tenant zero and BoB development at once. Mitigation: client onboarding is gated on the #2023 floor, clients track the stable channel with pinned versions, exactly one paying client follows tenant zero, the retainer is priced from measured support time, and Claude Code terms are verified before any quote (#2207).
Runaway or self-authorising missions — a replan loop that generates its own work. Mitigation: replanning may only sequence already-approved work, reads debrief output rather than a session’s summary of itself, and stops at per-mission budgets and a human checkpoint on regression (#1670).
Single-developer bottleneck — Only Paul understands every corner. Mitigation: self-documenting tools, bob tour and the one-day tutorial (#2031), this vision, CLAUDE.md, auto-memory system.

Capabilities

Capabilities live in GitHub Issues labeled cap (gh issue list --label cap). The ones realizing the current roadmap, all under #2023:

Under #2207 (supported BoB for clients):

#2214 Operator-neutral BoB: identity, paths, machines and notification routes declared per operator
#2215 Tenant isolation: client secrets, repos and data stay in client-owned accounts
#2216 Client farm: reproducible BoB farm in a client-owned cloud account
#2217 Client support service: health visibility, support intake, compatibility promise, support-time ledger
#2218 Tenant zero: the first client runs its own supported BoB
#2219 Supported BoB offer: onboarding runbook, support tiers, pricing, licensing position
#2220 Second client: onboard a second paying client

The operator’s surface:

#3812 BoB Control: one app for every project, session, dispatch, terminal and ask

Under #1670 (multi-flight autonomy): the debrief and mission capabilities are not yet filed; each is spawned as its stage approaches.

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.