Skip to content

Deterministic repository factory

Bob has one job.

Turn a small bob.yaml into a public-ready repository. Bob plans before it writes, proves it owns every file it touches, and refuses to guess. No model. No magic. A ledger.

Model-freeLocal-firstMITEarly alpha — read the plan. Bob insists.

  1. bob planPlan

    Read-only. Compares recipe, lock, and working tree.

  2. bob applyApply

    Explicit. Writes only files with proven ownership.

  3. bob checkCheck

    CI gate. Non-zero exit the moment anything drifts.

  4. no-opConverge

    Run apply twice. The second run does nothing. That is the feature.

blue — read-only authorityorange — explicit mutation

The spec sheet

PLAN

Plan before mutation

Every create, update, adoption, and conflict lands on paper before a single byte lands on disk. Review the plan like a diff, because it is one.

LOCK

Ownership you can audit

bob.lock records a content hash for every file Bob manages. A managed file updates only when its current hash matches the lock. No hash, no touch.

HALT

Conflicts stop the line

One conflict means zero writes. Bob preflights the complete plan and refuses to half-apply anything, ever.

DRIFT

Drift detection for CI

bob check exits non-zero the moment generated infrastructure wanders from the contract. Your pipeline finds out before your users do.

AGENT

Agent-native surfaces

Versioned JSON envelopes on every command, a one-shot bob learn briefing, and six read-only MCP tools. Machines are first-class readers here.

SCOPE

Honest boundaries

No LLM inside. No secret management. No verification theater. Bob builds the repository; proving your feature works is your job.

Your agent can read the manual.
It is one command long.

bob learn --json emits a versioned, machine-clean brief: the lifecycle, every command, the JSON envelope, and the safety invariants an agent can rely on. Run it once at session start and your agent knows exactly what Bob will and will not do.

$ bob learn --json
{
  "schema_version": 1,
  "ok": true,
  "command": "learn",
  "data": { "product": "deterministic repository factory", … }
}

Six MCP tools.
Zero of them write.

bob mcp serve exposes a compact, repository-read-only surface over stdio. Diagnostics go to stderr; stdout stays JSON-RPC-clean.

$ claude mcp add bob -- bob mcp serve .
  • bob_plan
  • bob_check
  • bob_inspect
  • bob_stats
  • bob_recipe_describe
  • bob_validate_manifest

All six stamped READ-ONLY.

Things Bob will not do

  • Run a model, call a network, or guess.
  • Overwrite a file it cannot prove it owns.
  • Touch .git, bob.yaml, or anything outside the workspace.
  • Write half a plan. One conflict, zero writes.
  • Manage your secrets.
  • Declare your feature “verified.” Bob builds; evidence tools judge.

This list is load-bearing.

Put on the hard hat.

One manifest, one plan, one explicit apply. Review the diff like a professional and ship a repository you can defend.

$ brew tap abdul-hamid-achik/tap
$ brew install --cask bob
# or
$ go install github.com/abdul-hamid-achik/bob/cmd/bob@latest
Build something reviewable

Deterministic plans · Explicit authority · Honest integration boundaries

Deterministic plans. Explicit authority. Honest integration boundaries.