An instrument for the Bureau's own fieldwork
Summary. A command-line transcription script the Bureau used internally kept drawing the same request from the people who saw it: can I get this without the terminal? Answering that properly meant more than a window around a script — it meant deciding what the output artifact actually is, writing that down as a standard, and building the product that produces it. Total build: one week elapsed, six and a half hours of working time, executed with Claude Code against written specifications. Field Recorder v1.0.0 shipped as a self-contained Windows application; its output schema was published as Record Format, Revision 1.
Context
The Bureau runs on conversations — scoping calls, walkthroughs, advisory sessions. The operating pattern for every other part of the practice is to capture work as structured artifacts that AI systems can retrieve and reason over. Conversations were the gap: the highest-density information in any engagement, and the only category leaving no usable trace.
The first fix was a script. A CLI tool — Whisper for speech, pyannote for speaker separation — that turned an audio file into an attributed transcript. It worked, the Bureau used it daily, and other people kept asking for it. The requests were the signal: the script had found a real need, and a terminal was the wrong container for it.
Problem
The market alternative was surveyed before building anything. Three requirements, and no product met all three. Confidentiality first: client calls are the least public documents a practice produces, and the dominant transcription products are cloud-mandatory — custody of the audio transfers to a vendor as a condition of use. Second, attribution: a transcript without speaker separation cannot answer who committed to what, which is most of a call's value. Third, and decisive: output built for machine retrieval. Every product examined terminated in a viewer — a place to read transcripts — rather than an artifact another system could consume.
The script already solved the first two. The third was the real project.
Approach
The schema came before the software. Before any interface work, the Bureau defined what a record is: stable identity, capture context, duration, participants, speaker-attributed segments — one JSON artifact legible to a person and addressable by a machine. That definition was written as a versioned standard, Record Format, Revision 1, so the format would outlive any single tool that produces it. The application was then scoped as the standard's reference implementation — not a GUI wrapped around a script, but the first instrument of a format.
Two positions were fixed at the start. On-device transcription is the default and the identity, not a tier — routing a client call through a third party is a decision an operator makes explicitly and once, never a default discovered later. And the data stays inspectable: records live in an open directory in standard formats, with no proprietary store between the operator and their own files.
Build
The build was specification-driven and executed with Claude Code. Before implementation: a product doctrine fixing the naming, lexicon, and data architecture; a visual system fixing the interface down to the stylesheet; and per-phase briefs enumerating not just the features but the failure modes — file locks during deletion, filesystem watchers firing mid-write, retention sweeps racing an open audio player. Claude Code executed against those documents phase by phase; the working time went into the specifications and the review, not the typing.
The result is a Windows tray application. One keystroke starts capture from inside any call software, taking the microphone and the system audio simultaneously and streaming both to disk — a three-hour call costs no memory, and a crash mid-call costs no audio. Transcription runs locally through a managed engine the application installs into its own embedded runtime on first launch; the operator never touches Python. Diarization separates the voices; the operator assigns the names, because the machine detects speakers but cannot know who they are — and the instrument doesn't pretend otherwise.
One week after the first commit, and six and a half hours of working time in, v1.0.0 shipped: a self-contained executable, released under Apache 2.0 with the source public. The license withholds the one thing that matters — the code may be copied; the Bureau's name may not.
Outcome
Field Recorder is in daily operation inside the practice, and the record store it fills is the substrate the Bureau's AI tooling reads from. The script that people kept asking for is now a product anyone can download; the schema it writes is a published standard; and the demand that prompted the build no longer arrives as a request — it arrives as a download.
The instrument is public. The standard is public. The practice keeps its conversations.
Principle
Define the artifact before building the tool. The demand was for a friendlier interface; the product was a data format. When the format is the stable center, every future instrument — and every AI system downstream — inherits the same ground truth. The specification-first pattern that built this in six and a half hours is the same one the Bureau brings to client engagements; this project was the test of whether it holds for a full product cycle. It held.