Master of the Lake (Teach an LLM to Fish)

Give an LLM a fish, feed it for a millisecond. Teach an LLM to fish, and become Master of the Lake!

I've just published "Master of the Lake" - available for listening EXCLUSIVELY at tvox.online/books/1. (Nudge, nudge, NoStarch...)

This work represents the culmination of years developing Contract Style Comments (CSC) as a practical interface for governing AI agents in what I'm calling the "Agentic Epoch" - an era where AI agents are no longer passive tools but active participants in our systems.

The Interface Problem

We've spent decades refining how humans interact with computers: command lines, GUIs, touch interfaces, voice assistants. But we've largely ignored the critical interface problem of our time: how do humans govern AI agents?

Most AI tooling focuses on making agents more capable - better at generating code, more creative in design, more persuasive in writing. But capability without governance creates dangerous systems that appear functional while silently drifting from intent.

CSC provides the missing interface layer: a structured way for humans to specify, verify, and maintain governance over agent behavior.

Beyond Prompts: The CSC Interface

Prompt engineering treats agents like fickle genies - rub the lamp the right way and maybe you'll get what you want. But this approach fundamentally misunderstands the agentic relationship.

CSC shifts us from:

• 
  Prompting (hoping the agent understands)


• 
  To: Contracting (explicitly defining what the agent must uphold)

The interface consists of three interconnected files:

• 
  contract.md - The operational interface: what the agent must do


• 
  why.md - The explanatory interface: why those requirements exist
  


• 
  invariant.md - The boundary interface: what can never change

This isn't just documentation - it's a verifiable interface that agents can check against continuously, making the alignment gap visible before it causes harm.

System Silent-Death: Why Interfaces Matter

We used to fear system crashes - honest failures that clearly indicated something was broken. The agentic era introduces a more dangerous failure mode: system silent-death.

In system silent-death:

• The agent appears productive (generating code, passing tests)


• The system seems to function normally


• But subtle drifts accumulate in behavior, logic, or assumptions


• Catastrophic failures emerge only in production, often long after the divergence began

CSC prevents silent-death by making the agreement between human intent and agent behavior explicit, versioned, and continuously verifiable. When logic changes, the contract must change with it - no silent drift permitted.

The Agentic Development Workflow

With CSC as your interface, development becomes a conversation governed by explicit contracts:

1. 
   Define the interface - Write/update contract.md, why.md, invariant.md


2. 
   Agent implements - The agent works within the defined boundaries


3. 
   Continuous verification - The agent (or a steward agent) validates compliance


4. 
   Interface evolution - When requirements change, update the interface first

This creates a feedback loop where the interface guides implementation, and implementation feedback improves the interface - much like how API contracts work in traditional software development, but applied to the human-agent relationship.

Why This Changes Everything

Traditional software development assumes humans are the constant and code is the variable. The agentic era reverses this: agents are becoming the constant (always available, infinitely scalable) while human intention becomes the variable we must reliably capture and preserve.

CSC provides the interface layer that makes this reversal work:

• For agents: Clear, machine-verifiable boundaries


• For humans: Confidence that agents won't silently violate intent


• For systems: Prevention of the silent-death failure mode


• For teams: A shared, explicit foundation for collaboration

The Invitation

If you're building systems with AI agents - whether you're creating them, directing them, or just trying to keep your infrastructure from silently dying - you need an interface for governance.

CSC isn't about limiting what agents can do. It's about making explicit what they must uphold so that their capabilities can be safely directed toward human goals.

The book is available now as an audiobook at tvox.online/books/1, featuring distinct AI voices for each chapter to optimize comprehension.

This work represents my attempt to build the interface layer necessary for safe, productive collaboration in the agentic epoch. Not by limiting agent potential, but by defining the contractual interface through which that potential can be responsibly harnessed.