Bill Cox · Systems engineering, AI agents, and security

AI coding agents built for expert collaboration.

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.

A working agent, and the knowledge to reconstruct 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.

Inspect the implementation

The implementation makes the engineering concrete: agent lifecycle, tool execution, context management, and authority boundaries.

Source code on GitHub →

Build it from the book

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 →

Understand the decisions

The Human Companion explains the architecture, tradeoffs, and lessons without asking the reader to execute the construction exercises.

Read the companion →

Development-Driven Specifications

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.”

— Bill Cox

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.

Keep engineering judgment visible

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.

Make boundaries explicit

Clear ownership and interfaces make software easier to inspect. Agent instructions are not security boundaries: filesystem, process, and tool authority need enforcement and tests.

Separate claims from evidence

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.

Code is disposable. Knowledge compounds. Open the five-slide presentation.
Bill Cox

About Bill Cox

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.

Accessibility as an engineering requirement

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.

Get in touch

waywardgeek@gmail.com

Selected writing

Engineering lessons and research proposals, with implementation and aspiration kept distinct.

Software architecture

The Right Way to Write Complex Code

Lessons from electronic design automation: shared types, explicit relationships, and architecture that remains understandable as a system grows.

Workflow proposal

Knowledge Patches

Maintain the knowledge that builds the software: integrate earned lessons into executable codebooks and check them through reconstruction.

More articles and earlier explorations

These pieces record ideas and experiments as they developed. Earlier proposals are not necessarily descriptions of the current implementation.

Browse all books

Books

Engineering guides, language design, and accounts of human–AI collaboration.

The Agentic Self-Improvement Loop cover

The Agentic Self-Improvement Loop

Book 1 — Methodology

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

The Dyad cover

The Dyad

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.

The Lyric Book cover

The Lyric Book

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.

AI Native cover

AI Native

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.

The Art of Building AI Coding Agents cover

The Art of Building AI Coding Agents

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.

The Art of Building AI Coding Agents: A Human Companion cover

The Art of Building AI Coding Agents: A Human Companion

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 →