Cold Take

Bondsmith

A spec-driven development workflow engine in Rust - phase contracts enforced in typed code, not by an LLM.

MVP · 2 of 8 shippedRoadmap ↓

rust

Capabilities

  • A Feature moves through a fixed, eight-phase chain - explore → propose → review-spec → implement → review-check → review-and-ship → learn-from-reports → validate-impl - each one a typed contract with postconditions the engine evaluates itself, in Rust. The figure groups those eight into four stages - plan, build, check, ship - and every phase is a hard postcondition gate, not a warning.

  • There is no assert-and-warn escape hatch: a failed postcondition is a hard block - a distinct outcome from a fault, never a downgraded warning - so no LLM grades its own homework mid-flow.

  • Each Feature runs in its own git worktree, provisioned per bound repo with native git2 and cleaned up on every exit path - including a crash - so beats never collide and multi-repo coordination is real today, not planned.

Roadmap

  1. Shipped: Fixed eight-phase flow chain, each phase a typed contract
  2. Shipped: Typed postcondition contracts, hard-blocked on failure
  3. In progress: learn-from-reports: mining patterns from delivery reports
  4. In progress: herdr / fzf / jq editing plugin over flowctl (replaces the retired bondsmith-web Dashboard)
  5. Planned: Session monitoring across every phase and state
  6. Planned: LLM session handling
  7. Planned: Containerization
  8. Planned: Flow contracts loadable from disk (not embedded at compile time)

MVP · 2 of 8 shipped

After MVP

  1. Planned: Web hub Dashboard over flowctl
  2. Planned: Pi target port
  3. Planned: Technical flow

Bondsmith is the workflow engine I run my own feature work through: a Rust CLI that drives a spec-driven flow from exploration to shipped code and refuses to advance when the work doesn't hold up.

The premise is that an LLM is non-deterministic by construction, so the answer isn't to trust it harder. It's to make everything around it deterministic. A feature moves through a fixed chain of phases, each one a typed contract with postconditions the engine evaluates itself, in Rust. No LLM grades its own homework, and there is no assert-and-warn escape hatch: a failed postcondition is a hard block.

A deep-dive post on this is coming. Stay tuned.