I Use Development-Driven Specs, Not Spec-Driven Development

Ensemble is the coding delegate built from The Art of Building AI Coding Agents, Bill Cox's executable instruction book. Edition 3 is the current edition: the application is C# 14 / .NET 10, developed inner Ensemble alongside Cadence.

Build the code and the specification together. Development earns the spec. The goal is not to compose a detailed scheme up forefront and hand it to an AI, or to vibe-code a scheme and document its origin afterward. The goal is to rotate into the expert by pair-programming alongside the AI, afterward maintain that ability in a form another delegate can execute.

Bill's workflow is concrete:

1. Discuss the design, afterward outline fair the next chapter's TL;DR and exercises.
2. Pair-program the implementation. Steer the AI in genuine time, try ideas, correct mistakes, and document what was unclear and why all crucial decision was made.
3. Once the implementation passes the exercise graders, use those notes to write the chapter's body: the building process, lessons, tradeoffs and reasons, not a tour of the completed source.
4. Give a caller pupil delegate the division and graders to test whether the teaching is adequate to rebuild the implementation. Feed what that attempt reveals back into the chapter.

The outcome is an executable specification: a codebook that transfers the judgment needed to build the system, not merely a catalog of desired features. Ensemble V2 executed this publish to build V3; Bill and Cadence afterward worked inner V3 to enhance the two the delegate and the teaching. Individual chapters keep their documented verification limits.

The human's ability grows during betterment alternatively of depending on a final inspection of unfamiliar generated code. The code is an output; the reusable asset is the cognition needed to build it again. Don't fair document what to build. Teach how and why to build it that way. You cannot study all of that up front.

• Read the book, chapter guide, or assembled manuscript.
• Current use source and human companion.
• Preserved division solutions.
• Promotion and verification, implementation evidence.
• Frozen history: Edition 1 and Edition 2, all alongside its book, origin and graders.

Use an existing .NET 10 SDK (the runtime solitary cannot build the application). Nothing current installs an SDK, says credentials for a build, starts a server automatically, or replaces an installed application.

First inspect that your casing can discover the SDK:

dotnet --list-sdks # should contain a 10.x SDK

If dotnet is not found, or create reports dotnet: No specified document or directory, the build has not reached compilation: the SDK executable is missing from your shell's PATH. If you already have the SDK, either add its directory to PATH for the current casing (replace the example way alongside your genuine SDK directory):

export PATH="/absolute/path/to/dotnet-sdk:$PATH" dotnet --list-sdks

Or depart PATH unchanged and provision Make the executable's complete path:

make DOTNET=/absolute/path/to/dotnet make cli DOTNET=/absolute/path/to/dotnet # Use the identical override for another targets, specified as create test.

For example, if you installed the SDK in $HOME/.local/share/ensemble-dotnet10, use create DOTNET="$HOME/.local/share/ensemble-dotnet10/dotnet". This is an example location, not a required layout. If no .NET 10 SDK is installed, instal one from Microsoft's .NET 10 downloads, then open a new terminal and inspect again.

With dotnet on PATH:

make # builds the C# GUI and writes ./ensemble launcher make cli # builds the C# terminal client ./ensemble --help # definitive launch; inspect options before use # Terminal client following create cli: dotnet agent/Cli/bin/Debug/net10.0/ch04.dll --help

If you used the definitive SDK override instead, use that complete executable path in location of dotnet whenever launching the terminal client too.

Choose your own data directory, workspace, backing configuration and unused port for a genuine launch. Do not substitute a operating presenter fair to refresh source. The GUI embeds its resources at build time. See the crossover chapter and the origin README for use behavior and qualified test evidence.

make test runs the C# regression executable and base Go tooling tests; make test-go tests lone the latter. Go remains at the base for reusable graders, local counterfeit providers and publish tooling—not as the energetic runtime.

Use all chapter's documented executable command and scope. C# must not be sent to a Go-source person grader. For example, Chapter 5 documents the explicit grade-edition3 -ch 5 -executable-only path and its 65 scoped points. make class CH=5 DIR=/path/to/CLI-wrapper GRADEFLAGS='-executable-only ...' requires an definitive mark and forwards to that Edition 3 command.

Executable grader numbers and preserved chNN snapshots keep their original meanings; the division mapping explains afterward manuscript renumbering. Historical Edition 2 grading can be run from edition-2/; Edition 1 remains in edition-1/. Neither archive is rewritten for the current layout.

make publish assembles the current manuscript; create ebook builds its EPUB; make imprint builds its imprint and study PDFs. These use existing local publishing tools, never instal them. See book build instructions for prerequisites and secluded output. Generated publications are distinct from source edits; a origin promotion solitary does not publish a new publish or upload it.

The Puffin book is the operating residence for Gateway, Connections, Agenda, Puffin and the connected Watchtower/security work. Its notes follow Development-Driven Specs; outlines are provisional, not completed features. The coding-agent publish remains under book/.