Building from first principles
A personal account of the tools, protocols, standards, and ventures I've been building under the Babb Works umbrella.
Most of what I build starts from the same instinct: that the people who do the actual work — manufacturing, field service, production, accounting — deserve tools that are as rigorous and honest as the work itself. Not enterprise dashboards designed for executives. Not SaaS platforms optimised for investor metrics. Tools that encode the real constraints of real work and refuse to pretend otherwise.
Over the past few years this conviction has produced a surprisingly coherent stack. At the bottom sit binary protocols where an unbalanced ledger entry literally cannot be encoded — the wire format rejects it. Above that, portable record formats small enough to transmit over SMS on a $30 phone. Then productivity systems that wrap five open-source tools into a single command-line interface with natural language understanding. Then a digital production system modelled on a Victorian industrial compound that treats information with the same accountability a works manager brought to iron and coal. And at the top, a venture called Clark that aims to rebuild industrial training and production infrastructure across the Niagara Peninsula.
None of this was planned as a unified stack. It grew from solving real problems and refusing to accept the usual compromises. Each layer turned out to need the one below it.
What connects everything
Three threads run through all of it. First, language and syntax sit at the centre of operations. Nearly every project I build is CLI-first. The command line isn't a developer convenience — it's the most honest interface. It forces clarity about what a system actually does, makes operations composable, and produces an audit trail by default. Each tool has its own grammar, its own vocabulary, and those grammars are specified in normative standards.
Second, conservation laws are structural, not aspirational. BitLedger doesn't "encourage" balanced entries — it makes imbalance physically unrepresentable in the wire format. The Works compound requires that every chunk entering the system has a verifiable path to its output or its archive. These aren't policies. They're physics.
Third, the standard comes before the software. Every major system has a companion specification written independently of the implementation. The Workpads standard predates the KaiOS app. The BASICS conformance protocol can assess any project, not just mine. This discipline slows things down, but it means every piece of software has a document you can hold it accountable against.
The portfolio at a glance
Ventures
Clark — A research-driven initiative to build distributed electronics manufacturing and training capacity across the Hamilton–Niagara corridor. Backed by a 140-document corpus, a public evidence site, and a first-node business case. Its software layer, the Clark IPE, integrates Workwarrior into an Eclipse Theia workstation shell with IPC-CFX production-floor communication.
Systems
Workpads — A portable field record system that fits complete job records into URL hashes transmissible by SMS. Runs on KaiOS phones, browsers, and the command line. Thirteen repos, one normative standard.
Workwarrior — A terminal productivity operating system unifying TaskWarrior, TimeWarrior, JRNL, Hledger, and Bugwarrior behind a single profile-based dispatcher with 627 natural language recognition rules. Webwarrior is its zero-dependency browser-native port.
Works — A digital production system and compound standard for information storage, transformation, and output, modelled on a Victorian industrial compound. Nine building types from Intake to Vault. Fully implemented in a Preact browser application.
Protocols
BitPads & BitLedger — A binary protocol family scaling from a 1-byte heartbeat to a 40-bit double-entry ledger transaction. The encoder is hand-assembled x86-64. The same wire format carries financial transactions, propellant mass budgets, power grid obligations, and satellite contracts.
Standards
BASICS, Workpads Standard, Workwarrior Standard, BitPads Standard, Works Standard — Five specifications, each written independently of its implementation and each assessable by automated tooling.
Babb Works
A software and standards company building durable tools for people who do real work.
Babb Works is the entity behind everything on this site. It builds tools, protocols, and standards for operational work — manufacturing, field service, accounting, production coordination. The company's output spans open-source software, normative specifications, a venture-stage industrial initiative, and a growing family of command-line tools that share a common design philosophy.
The name comes from a simple idea: work should be the thing that matters. Not the platform, not the subscription, not the vendor lock-in. Babb builds instruments that respect the actual constraints of working life — conservation laws in ledgers, offline operation on cheap phones, natural language at the terminal — and publishes them with normative specifications so anyone can verify what's claimed.
How it operates
All active repositories are publicly visible on GitHub under github.com/babbworks. Repos are tagged with topic labels (babb-tool, babb-featured, babb-standard, babb-vision) for discoverability. Development follows a source-of-truth model: edits happen in the canonical repo, then sync outward to deployed instances.
The product ecosystem is vertically integrated but loosely coupled. BitPads and BitLedger define the wire formats. Workpads uses those formats for portable records. Workwarrior provides the productivity layer. Clarkware integrates it into a production-floor IDE. Clark deploys it into a real industrial corridor. Each layer functions independently, but together they form a stack where every byte on the wire has a specification and every tool has a standard it can be measured against.
The voice
Babb also has a companion persona — heybabb — a terminal-native CLI companion built on compiled knowledge bases with optional AI enhancement. It narrates work with clarity and care, described internally as "faithful and curious." The character framework that powers it is open-source, so any organisation can build their own CLI companion on the same architecture.
Clark
Rebuilding industrial training and production capacity across the Hamilton–Niagara corridor.
Clark is the largest project in the Babb Works portfolio. It is a research-driven initiative to establish distributed electronics manufacturing and training centres across Southern Ontario's Hamilton–Niagara corridor, with a cross-border thesis extending into the Buffalo–Western New York region. The ambition is not to build a single factory but to seed a network of locally owned, protocol-connected production centres that share curriculum, credentialing, and software while remaining operationally independent.
The core insight is that the Anglosphere's industrial training infrastructure has atrophied to the point where individual firms cannot rebuild it alone. Decades of offshoring hollowed out not just production lines but the apprenticeship pipelines, community colleges, and supplier ecosystems that made production viable. Clark proposes that the recovery unit is not the firm but the corridor — a geographic zone dense enough in transport, talent, and institutional memory to support a critical mass of production activity.
The corridor thesis
The Hamilton–Niagara corridor is Clark's anchor. Hamilton retains deep industrial memory from its steel era, an established post-secondary infrastructure, and real estate that is undervalued relative to the GTA. The Niagara region offers border proximity to the Buffalo manufacturing base, a network of smaller towns with skilled labour pools, and access to both CN and CP rail corridors. The QEW, 403, and 406 highways connect everything within a 90-minute drive radius.
On the American side, Buffalo–Niagara and Western New York provide the counterweight. Existing EMS (electronics manufacturing services) firms like Artaflex, SCI Systems, and CUI Global already operate in the region. The CHIPS Act and I-Corridor initiatives have directed federal investment into semiconductor and advanced manufacturing. Clark's thesis is that the border crossing at Niagara is not a barrier but a seam — a zone where Canadian training capacity and American production demand can meet.
The training model
Clark's curriculum is structured as a 16-course map spanning three levels. Level 1 (Foundations) covers industry history, IPC standards, basic soldering, and component identification. Level 2 (Professional) deepens into SMT assembly, reflow profiling, inspection under IPC-A-610, and production documentation. Level 3 (Advanced) addresses Class 3 high-reliability assembly, BGA rework, X-ray inspection, and conformal coating — the kind of work demanded by defence, aerospace, and medical device contracts.
The model is deliberately bench-centric. Training happens at workstations, not in lecture halls. Each station runs the Clark IPE for task management and process documentation, so the training environment and the production environment share the same software. A trainee's work is recorded from day one in the same systems they'll use as a certified operator.
The evidence approach
Clark maintains a claims register where every public assertion is tracked with an evidence status: safe, provisional, or rejected. The venture corpus — approximately 140 documents covering business plans, field reports, research notes, financial models, and site assessments — is published alongside the public narrative at clark.babb.tel. The intent is that anyone evaluating Clark can inspect not just the pitch but the underlying record. Two industry reports, on the Niagara Peninsula and the Buffalo Region, provide the corridor-level context. The first-node business case targets approximately CAD 135,000 in proof economics over a 24-month bar.
Clark IPE
The Integrated Production Environment: a Theia-based workstation shell for electronics assembly centres.
The Clark IPE is the software layer that sits on every workstation in a Clark centre. It is built on Eclipse Theia 1.69, the open-source IDE framework, extended with custom panels, services, and integrations specific to electronics production. Where Theia provides a general-purpose editor shell with extension architecture, the IPE narrows it into a five-panel workstation interface designed for operators, not software developers.
Architecture
The IPE runs as a Theia application with a Node.js backend and an Electron or browser frontend. The backend exposes a FastAPI service layer for domain operations — profile management, task routing, ledger writes, object storage — while Theia handles the UI shell, keybinding system, and extension lifecycle. PostgreSQL stores structured data (profiles, tasks, credentials, audit records). MinIO provides S3-compatible object storage for binary artifacts: inspection photos, firmware images, gerber files, and test reports.
The five panels are: Task Queue (active work orders, priority-sorted, pulled from Workwarrior), Process View (step-by-step assembly instructions with visual references), Inspection (photo capture, defect classification against IPC-A-610, AI-assisted anomaly detection), Time & Journal (TimeWarrior integration for station-level time tracking and JRNL for shift notes), and Comms (XMPP-based messaging for inter-station and supervisor communication). Each panel is a Theia widget backed by its own service contract.
Workwarrior integration
The IPE embeds Workwarrior as its task and productivity engine. Each workstation runs its own Workwarrior profile, isolated from other stations but synchronisable to a centre-level aggregate. The ww dispatcher is invoked from the IPE's command palette, and the natural language engine is available for operators who prefer typing "start soldering board 4" over navigating menus. UDAs (User Defined Attributes) carry production-specific metadata: board revision, work order number, customer code, IPC class. The MCP server interface allows AI agents running in the Inspection panel to query and update task state programmatically.
IPC-CFX communication
The IPE implements a subset of the IPC Connected Factory Exchange (CFX) protocol for machine-to-machine communication on the production floor. CFX messages are AMQP-transported JSON payloads defined by IPC-2591. The IPE publishes station events (work started, work completed, inspection result, defect logged) as CFX messages and subscribes to equipment events from reflow ovens, pick-and-place machines, and AOI (Automated Optical Inspection) systems. This gives the centre a real-time event bus without requiring proprietary MES software.
Firmware tooling
For centres doing board-level assembly with programmed components, the IPE includes a firmware workflow. It manages JTAG and SWD programming sessions via OpenOCD integration, stores firmware images in MinIO with version metadata and SHA-256 checksums, and records programming results (pass/fail, device ID, programming time) against the work order. The flash programming panel provides a visual status for multi-device batch operations — critical for production runs where a single board may carry three or four programmable ICs.
XMPP and audit trails
All inter-station and operator-supervisor communication runs through XMPP (via the clark-chat component). Messages are persisted and indexed as part of the production audit trail. When an operator flags a defect, the message thread — including photos, inspector notes, and disposition decisions — becomes part of the quality record. This replaces the paper-based traveller documents still common in small-volume electronics assembly with a searchable, timestamped, cryptographically attributable digital record.
Offline-first and deployment
The IPE is designed to operate without continuous network connectivity. The Theia shell, all panel UIs, and the FastAPI services run locally on each workstation. PostgreSQL and MinIO run on the local machine or on a centre-level LAN server. Synchronisation with other stations and with the central profile happens opportunistically when connectivity is available. This is a deliberate architectural choice: production floors have unreliable Wi-Fi, and a workstation that stops functioning because a cloud service is unreachable is a workstation that loses money.
Current development status: the Theia shell boots, four of five panels render, profile CRUD operates end-to-end, and the Workwarrior service contract is stable. The Inspection panel's AI integration and the IPC-CFX event bus are the active development fronts.
Workpads
A field notebook for the working world. Portable, sovereign, offline-first.
Workpads is a portable job record system for people who do physical work in the field. It pairs structured forms with photos, audio, and signoffs, and it runs on the cheapest phones available — KaiOS devices with 240×320 pixel screens, D-pad navigation, and no touch input. A complete job record can be encoded into a URL hash small enough to send over SMS or WhatsApp.
The system is organised around the PADS model: Processes, Actions, Details, Story. These four categories cover most field work — a repair log, a delivery confirmation, a site inspection — while remaining simple enough that someone on a $30 phone can complete one between tasks. Records are encoded using the pads-v1 binary frame format with DEFLATE compression and base64url encoding, producing URLs like workpads.me/p#1pa/<payload>.
The ecosystem spans thirteen repositories: an orchestrator, a normative standard, a canonical JavaScript codec, a KaiOS app (v0.1 live with 14 Places across 5 Worlds deployed), a browser app at workpads.me (currently in active build), a CLI reference implementation, a BASICS conformance environment, build tooling, and public-facing sites at workpads.org and standard.workpads.org. Conflict resolution in sync favours the person on-site, because the person holding the phone knows more than the server.
Workwarrior
A terminal productivity operating system. Five tools, one interface, natural language.
Workwarrior wraps five open-source productivity tools — TaskWarrior, TimeWarrior, JRNL, Hledger, and Bugwarrior — into a single profile-based command-line dispatcher. Each profile gets its own isolated workspace: its own tasks, time records, journal entries, ledger, and configuration. Switch profiles and the entire context switches with you.
The natural language engine is the centrepiece. A compiler written in JavaScript produces 627 heuristic regex rules that map conversational English to precise tool commands. Type something close to what you mean; the engine finds the right tool and the right flags. When the heuristics miss, an optional LLM fallback handles edge cases. The system also serves a browser UI via Python HTTP with real-time SSE updates across 15+ panels, provides two-way GitHub sync via Bugwarrior, and includes a set of power tools called Weapons: Gun (bulk task series), Sword (task splitting with dependencies), Next (recommendation), and Schedule (auto-scheduling).
Webwarrior
Webwarrior is the browser-native reimagining. Same capabilities — tasks, time, journal, ledger — running standalone in any browser with zero installed dependencies and data stored only on the user's device. The architectural shift is fundamental: Workwarrior is a microservice mesh (bash subprocesses, IPC via stdin/stdout); Webwarrior is a modular monolith (ES modules, function calls returning Promises, IndexedDB storage). Every service takes a (profile, args) signature, touches no DOM, and is independently testable in Node.js. A CSP policy of connect-src 'none' guarantees no outbound network calls after page load. Available at webwarrior.babb.tel.
BitPads & BitLedger
From a single heartbeat byte to a fully identified, timestamped, valued, tasked, and annotated record.
BitPads is a universal binary communication protocol built on a single organising principle: conservation. Every meaningful exchange of value — money, mass, energy, data — obeys the same algebraic invariant. Double-entry accounting, Kirchhoff's current law, mass balance, and momentum transfer are all instances of the same rule. BitPads makes that invariant the structural foundation of the wire format.
The protocol scales across a transmission spectrum: 1 byte for a pure signal (heartbeat, ACK), 4 bytes for an anonymous value wave, 13–29 bytes for a full record with identity and timestamps, and 22+ bytes for a complete BitLedger double-entry transaction with CRC-15 integrity. The encoder is hand-assembled x86-64 NASM — no C runtime, no dependencies, direct kernel syscalls. This isn't minimalism for aesthetics; it's minimalism because every byte on the wire must be accountable, and abstraction layers obscure accountability.
BitLedger
BitLedger sits on top of BitPads as a binary financial transmission protocol. A complete double-entry transaction fits in 40 bits — 5 bytes. Three layers: an 8-byte session header with CRC-15, a 6-byte batch header for currency and scaling, and a 5-byte record. The batch constraint is absolute: the sum of all signed flows must equal zero. If it doesn't, the batch is rejected at the encoding stage. Balance isn't a policy — it's a physical property of the format.
BitLedger has been generalised to a universal domain. The same wire format that carries financial transactions can carry propellant mass budgets between spacecraft, power obligations across a grid, data packet allocations in a network, or contractual obligations between satellites. The conservation law is identical. Only the domain label changes.
Works
A digital production system and compound standard for the deliberate storage, transformation, and authorised output of business information.
Works models information management as a physical compound — a Victorian ironworks where raw material enters through one gate, moves through stores and mills, passes inspection, and exits through another gate with full accountability for every gram. The metaphor is structural, not decorative. It enforces properties that software typically treats as afterthoughts: every piece of information has a verifiable location, a transformation history, and an authorised output path.
The standard defines nine building types. Intake receives, verifies, and routes incoming material. Store provides addressed chunk repositories across three tiers (Raw, Staged, Integrated). Mill handles interactive transformation — grouping, reordering, tagging, annotation. Bench is the ephemeral session workspace. Barrel stores programs (instruction sequences, cycle modes, event triggers). Gate authorises output with approve/reject/hold/reroute decisions. Dispatch delivers through five channels. Office sets policy, issues tokens, and maintains the audit log. Vault is append-only archival with a Pacioli guarantee — once written, never altered.
The architectural lineage is explicit: Babbage's Analytical Engine (3D addressing, stored programs), Ada Lovelace's notes (symbolic generality, cyclic operations), and von Neumann's 1945 architecture (the stream bottleneck accepted as a feature, not a bug, because auditability requires serialisation). A full browser implementation exists in Preact with 42 files, OPFS persistence, Web Worker replay, and over 100 passing tests.
Standards-first
Write the specification before the software. Then build a tool that checks conformance automatically.
BASICS
BASICS (Business Application Standardisation In Core Systems) is a conformance protocol for business-focused software. It defines five structural components (Shared Core, Software, Hardware, Firmware, Operational Extensions), three conformance tiers (Core, Field, Industrial), and a governance model with 100-day cycles from draft to decision. No silent requirement drops. Formal migration impact assessments for every change.
The companion CLI tool (basics) runs locally against any repository. It checks for structural compliance — do the required documents exist, are command surfaces documented, are policy artifacts present and correct. Two rule packs: dirty-core for harsh quick checks and assess-core for deeper validation. Machine-readable JSON output plus human-readable Markdown reports. It fills the gap between heavyweight ISO 9001 and the informal practices most teams actually follow.
The specifications
Five standards currently exist, each written independently of its implementation:
- Workpads Standard — pads-v1 codec normatively specified (sections 1–8)
- Workwarrior Standard — profile system, command grammar, service contracts
- BitPads Standard — 8-bit meta layer, enhancement sub-protocol, transmission spectrum
- Works Standard — compound buildings, stream system, Pacioli guarantee
- BASICS Standard — conformance tiers, rule IDs, governance model
CLI-first philosophy
Nearly every project begins at the command line. A CLI forces you to name every operation, define every parameter, and produce composable output. It generates an audit trail by default. It works over SSH, in containers, on servers, in CI pipelines, and inside AI agent tool-call chains (via MCP). Five dedicated CLI tools: ww (Workwarrior), basics (conformance), bitpads (protocol decoder), workpads (record management), and newent (enterprise planning). Language and syntax are not an interface choice. They are the centre of operations.
Everything else
Smaller tools, experiments, and supporting infrastructure.
heybabb
A terminal-native CLI companion built on compiled knowledge bases with optional AI enhancement. Offline-capable, never performative. The reference deployment of the open-source character framework, which any organisation can use to build their own branded CLI companion.
Atlas
An industrial discovery tool for the UK. Web-based, queries OpenStreetMap and Overpass API to locate workshops, manufacturing facilities, and industrial buildings. Built to support Clark's research into distributed production capacity.
newent
A Python CLI for planning new enterprises. Local-first, service-oriented architecture. Structures the early-stage thinking that usually lives in scattered notes into a queryable, version-controlled format.
babb-codecs
Monorepo containing canonical codec implementations for the pads-v1 binary frame format across four platforms: Node.js (bitpad), KaiOS, web, and relational database. Full test suite with cross-platform interoperability enforcement.