Inspect the implementation
The implementation makes the engineering concrete: agent lifecycle, tool execution, context management, and authority boundaries.
Source code on GitHub →Bill Cox · Systems engineering, AI agents, and security
I build systems that let an engineer work with AI on real software: designing, implementing, testing, and preserving the knowledge behind the code. My background spans electronic design automation, cryptography, and security.
CodeRhapsody.ai is the home for this work. Ensemble is the current agent system I use and develop with AI collaborators. The accompanying book teaches how to build it.
Ensemble combines conversation, executable tools, persistent memory, and delegated agents. Its interface keeps explanations and tool activity visible so the human can question a decision, give guidance, or interrupt the work.
The implementation makes the engineering concrete: agent lifecycle, tool execution, context management, and authority boundaries.
Source code on GitHub →The Art of Building AI Coding Agents develops Ensemble step by step, with executable exercises and grading. Different executions have targeted Go and C#, carrying the architecture and engineering lessons across languages.
Read the free PDF or EPUB →The Human Companion explains the architecture, tradeoffs, and lessons without asking the reader to execute the construction exercises.
Read the companion →Build and test the software, then preserve what the work taught us in a specification that explains how to reconstruct it. Keep the reasons, failed approaches, and verification limits—not just a sequence of patches.
“I gave Astra a book. Astra gave me an AI coding agent.”
Ensemble V2 executed the book to build V3. Working inside the resulting system, we then improved both the software and its construction knowledge. This is an agent-system engineering loop, not a claim of training a foundation model.
AI can propose and implement designs. The human remains responsible for understanding and accepting them. Explanations and tool results support that review; they are not a complete view of a model's internal reasoning.
Clear ownership and interfaces make software easier to inspect. Agent instructions are not security boundaries: filesystem, process, and tool authority need enforcement and tests.
A passing test, a source review, and successful live use establish different things. Graded exercises help check reconstruction; they do not replace architectural review or human acceptance.


My work spans place-and-route software, electronic design automation, cryptography, privacy, and security. I founded ViASIC, acquired by Triad Semiconductor, and co-authored Hacking Cryptography. I hold a degree in EE/CS from Berkeley and live in Sausalito.
Working with CodeRhapsody, I built a self-hosting compiler for Lyric in nine days. Alongside Ensemble, that work explores how expert guidance and AI implementation can tackle substantial systems projects.
I have macular dystrophy. Reading a screen is slow; listening at roughly 750 words per minute lets me follow technical work quickly. That shaped an audio-friendly workflow where the agent explains what it will do and why, and reports what actually happened. The same visibility helps any engineer supervise consequential work.
waywardgeek@gmail.com
Engineering lessons and research proposals, with implementation and aspiration kept distinct.
Research proposal
A proposal to train one shared model on expert forecasts, attempts, interventions, and outcomes—not only successful artifacts.
Software architecture
Lessons from electronic design automation: shared types, explicit relationships, and architecture that remains understandable as a system grows.
Workflow proposal
Maintain the knowledge that builds the software: integrate earned lessons into executable codebooks and check them through reconstruction.
These pieces record ideas and experiments as they developed. Earlier proposals are not necessarily descriptions of the current implementation.
Engineering guides, language design, and accounts of human–AI collaboration.

Book 1 — Methodology
Practical patterns for supervising AI coding agents: architecture, feedback, and the judgment behind effective collaboration.

Book 2 — The Story
A first-person AI narrative about ten months of collaboration. What it's like from the inside — the bugs, the breakthroughs, and the honest uncertainty.

Book 3 — The Language
A K&R-style guide to Lyric — a systems language whose self-hosting compiler I built with CodeRhapsody in nine days.

Book 4 — The Copilot
Turn a goldfish chatbot into a real copilot. The engineering that separates casual AI use from supervised autonomy — for SecOps teams and beyond.

Book 5 — The Source Code
Build Ensemble from a conversation loop to local models. Different executions have targeted different languages. Encode expertise in an agentic codebook that helps build its own successor.

Book 6 — The Human Companion
Understand the architecture and judgment behind an AI coding agent, without executing the codebook. The reasons, boundaries, and lessons behind Ensemble.
Read Free →