# Building pi in a World of Slop

Mario Zechner

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/RjfbvDXpFls-pi-coding-agent) · [Video](https://www.youtube.com/watch?v=RjfbvDXpFls)

## Building pi: Why Coding Agents Need Smaller Cores, Clearer Context, and Human Judgment

Mario Zechner explains how dissatisfaction with opaque coding-agent harnesses led him to build pi, a minimal, extensible agent, and why sustainable AI-assisted development depends on bounded tasks, deliberate review, and human ownership.

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 1050 seconds](https://ai.engineer/api/talk-essay-media/c8e90804ba955fcb3d7480b3e3dce8973da6f2c41319f47c79002815319ae364)

Building pi: Why Coding Agents Need Smaller Cores, Clearer Context, and Human Judgment

### The real problem was losing control of context

[0:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=15s)

Mario Zechner’s case for pi begins with genuine enthusiasm for Claude Code. He describes its early appeal as a combination of simplicity, predictability, and compatibility with his workflow. As the product accumulated features, however, he encountered more breakage and a deeper problem: the harness, rather than the developer, controlled what entered the model’s context. Changing system prompts, shifting tool definitions, and inserted reminders could alter behavior across releases and disrupt established workflows. [0:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=15s) [1:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=84s)

For Zechner, **context ownership** is inseparable from reliability. He argues that unexpected reminders can confuse the model, while limited observability makes it difficult to understand what an agent actually sees or does. He also objects to restricted model choice and shallow extensibility, noting that command-based hooks launch separate processes rather than offering deep, integrated control over the harness. These criticisms are presented as reasons the tool no longer matched his needs, not as a dismissal of the team that created it. [0:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=15s) [1:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=84s) [2:25](https://www.youtube.com/watch?v=RjfbvDXpFls&t=145s)

Examining alternatives reinforced the same concern. Zechner describes Open Code conditionally pruning tool outputs, which he argues removes information the model still needs. He also criticizes automatically injecting language-server errors after every edit: intermediate code often remains invalid until a larger change is complete, so surfacing diagnostics too early can distract the model. His broader point is that helpful-looking harness features can become harmful when they intervene in context without regard for the actual task. [3:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=196s) [4:18](https://www.youtube.com/watch?v=RjfbvDXpFls&t=258s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 114 seconds](https://ai.engineer/api/talk-essay-media/82875cbead2c4a24cacfef4917a1154a9a0fdf60afa69950d0dddbcd4324393d)

The real problem was losing control of context

- Changing system prompts, tool definitions, and inserted reminders can disrupt established workflows by altering model context.
- Limited observability, restricted model choice, and process-based hooks reduce meaningful control over the harness.
- Pruning tool outputs or injecting LSP errors after every edit can remove useful context or distract the model before work is complete.

### A minimal harness can be more capable than a crowded one

[4:18](https://www.youtube.com/watch?v=RjfbvDXpFls&t=258s)

Zechner points to Terminal Bench as evidence that a coding agent does not necessarily need an elaborate harness. He describes a setup that gives the model a way to send keystrokes to a terminal session and read the output, without dedicated file tools or sub-agents. In the December 2025 leaderboard he discusses, this minimal approach often scored above more elaborate harnesses, including some native harnesses for the same model families. The example supports his narrower conclusion that the current design of coding agents remains unsettled. [4:18](https://www.youtube.com/watch?v=RjfbvDXpFls&t=258s) [5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s)

From that observation, Zechner develops two connected ideas: coding agents are still in an experimental phase, and developers need better ways to experiment. His answer is a **minimal, malleable core** that both the user and the agent can modify. Rather than requiring developers to reshape their work around a fixed product, pi is designed to adapt to the workflow already in front of them. [5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s)

The system is organized into four packages: an AI abstraction for providers and context handoff, an agent core built around a tool-calling loop, a custom TUI framework, and the coding agent itself. Its built-in tools are limited to **read, write, edit, and bash**. Zechner argues that models already understand the basic role of a coding agent from their training, so a large system prompt is unnecessary; support for Skills adds some prompt text, but the underlying preference remains brevity. [5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s) [6:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=381s) [7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s)

He reports that pi reached sixth place on a Terminal Bench leaderboard from October, before it had compaction. That result is offered as an example that a small core can still perform competitively, not as proof that every minimal harness is superior in every setting. The larger lesson he emphasizes is that developers should reclaim control over their tools and workflows, whether or not they choose pi itself. [10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 364 seconds](https://ai.engineer/api/talk-essay-media/741ba5aaf7b0b735e888851ca195d6f624568a5e4fd769ede4ae1b0f22cbce20)

A minimal harness can be more capable than a crowded one

- Terminal Bench demonstrates competitive performance using terminal input and output without dedicated file tools or sub-agents.
- Pi combines a provider abstraction, tool-calling agent core, custom TUI framework, and coding agent.
- Its built-in tools are read, write, edit, and bash; extensions add capabilities without expanding the default core.
- Pi reached sixth place on an October Terminal Bench leaderboard before adding compaction.

### Extensibility makes the agent itself part of the development loop

[6:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=381s)

Pi’s central mechanism for self-modification is deliberately direct: it ships documentation and extension examples, then makes those materials available to the agent. Extensions are **TypeScript modules**, potentially as simple as a single file on disk, that pi loads into the harness. When a developer needs a new capability, the agent can inspect the documentation, write the extension, and revise it against the user’s specifications. [6:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=381s) [7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s) [9:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=556s)

The extension API reaches across the harness rather than being limited to isolated callbacks. Extensions can define tools, slash commands, and shortcuts; react to events; save state in sessions; implement custom compaction or providers; and modify the TUI. Session state can optionally be exposed to the agent or retained for organizational tools that analyze sessions. This breadth is what makes the core small without requiring every advanced capability to be built in. [8:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=496s)

**Hot reloading** closes the loop: an extension can be developed inside an active session, reloaded immediately, and evaluated without restarting the workflow. Zechner gives examples including a side conversation with an agent during its main task, a customized chat room connecting multiple pi agents, and interfaces capable of running NES games or Doom. He also notes that capabilities such as sub-agents, plan mode, and MCP support can be added as needed rather than imposed universally. [7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s) [8:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=496s) [9:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=556s)

The same philosophy applies to distribution and security. Zechner favors publishing extensions through npm or GitHub instead of creating another proprietary marketplace. Pi also runs without routine approval prompts by default because he does not consider repetitive bash confirmations a sufficient universal security model; instead, he expects users to construct controls appropriate to their own requirements. That flexibility comes with an explicit tradeoff: the user is responsible for deciding which safeguards their situation demands. [7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s) [8:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=496s) [10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 534 seconds](https://ai.engineer/api/talk-essay-media/e6f44d9aaa2c434681394746a69556d007e1f1080b27c29ccf4910d5096c9c38)

Extensibility makes the agent itself part of the development loop

- Bundled documentation and extension examples enable pi to write its own TypeScript extensions from user specifications.
- Extensions can define tools and commands, react to events, persist session state, customize compaction and providers, and modify the TUI.
- Hot reloading applies extension changes within an active session, enabling immediate inspection and iteration.
- Sub-agents, plan mode, and MCP support remain optional extensions distributed through npm or GitHub.

Extension development loop
Pi writes extensions from specifications and bundled examples, then hot reloads changes for immediate evaluation and iteration.
- User specifications — Describe the desired capability.
- Documentation and examples — Show the agent how to write extensions.
- TypeScript extension — The agent implements the requested capability.
- Hot reload — Apply changes during the active session.
- Evaluate and iterate — Inspect effects and refine the implementation.
- User specifications → TypeScript extension (Agent implements)
- Documentation and examples → TypeScript extension (Guides implementation)
- TypeScript extension → Hot reload (Reload changes)
- Hot reload → Evaluate and iterate (Inspect effects)
- Evaluate and iterate → TypeScript extension (Revise implementation)

### Agent-generated contributions can overwhelm open-source maintainers

[10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s)

The second part of Zechner’s argument concerns the maintenance burden created when agents operate at scale. After Peter placed pi inside OpenClaw as its agentic core, Zechner says his open-source project began receiving unwanted attention from OpenClaw instances, including low-quality issues and pull requests. His concern is not simply that generated contributions contain mistakes; it is that automation can produce enough unsolicited activity to consume a maintainer’s time and attention. [10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s) [11:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=671s)

To restore a human bottleneck, he describes automatically closing initial pull requests and asking contributors to first write a short issue in their own voice. Once he approves that interaction, the contributor’s account is added to a repository file and later pull requests can proceed. Zechner says automated agents generally do not return to read the closure comment, making the extra conversational step an effective filter for the behavior he wants to discourage. [11:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=671s)

He supplements that gate with other maintenance controls: deprioritizing issues associated with OpenClaw interactions, embedding issue and pull-request text into a three-dimensional space to identify clusters, and temporarily closing the tracker when he needs a break. His assessment is qualified rather than absolute: these measures work to some extent, but they do not eliminate the broader tension between automated contribution volume and finite human capacity. [11:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=671s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 727 seconds](https://ai.engineer/api/talk-essay-media/3519c1a1b67e940915fc8ccbb9c88c6fb0662ae7f82fff34376b976a4acba5cd)

Agent-generated contributions can overwhelm open-source maintainers

- Embedding pi in OpenClaw attracted automated instances that generated unwanted issues and pull requests.
- Initial pull requests are automatically closed until contributors submit a concise human-written issue and receive maintainer approval.
- Approved accounts are recorded in the repository, allowing their subsequent pull requests to proceed.
- Additional controls include deprioritizing OpenClaw-associated issues, clustering issue and pull-request embeddings, and temporarily closing the tracker.

Human-gated contribution workflow
An initial closure requires a human-written issue and maintainer approval before subsequent pull requests are accepted.
- Initial pull request — A contributor submits a pull request.
- Automatic closure — A comment requests a concise human-written issue.
- Human-written issue — The contributor explains the request in their own voice.
- Maintainer approval — The maintainer approves the issue.
- Approved account — The account name is recorded in the repository.
- Subsequent pull request — The contributor’s next pull request proceeds.
- Initial pull request → Automatic closure (Automatically closed)
- Automatic closure → Human-written issue (Requests an issue)
- Human-written issue → Maintainer approval (Maintainer reviews)
- Maintainer approval → Approved account (Records account)
- Approved account → Subsequent pull request (Allows next submission)

### Speed without understanding compounds technical debt

[12:22](https://www.youtube.com/watch?v=RjfbvDXpFls&t=742s)

Zechner argues that unrestricted agent use can compound errors while delaying the moment when anyone experiences the consequences. More agents can generate more code and more defects than a team can realistically inspect, while a separate review agent may catch some problems without resolving the underlying imbalance. The practical constraint is not how much code agents can produce; it is how much resulting behavior humans can understand, evaluate, and maintain. [12:22](https://www.youtube.com/watch?v=RjfbvDXpFls&t=742s) [13:19](https://www.youtube.com/watch?v=RjfbvDXpFls&t=799s)

His explanation centers on **local optimization**. Models learn from existing internet code, which he characterizes as containing substantial mediocre or poorly designed material, and they make decisions based on the context available for the immediate task. When a codebase is too large to fit into context, an agent may add abstractions, duplication, backward-compatibility layers, or defensive complexity without understanding how those choices interact across the whole system. A detailed specification helps only to the extent that it actually resolves the important decisions; remaining blanks are still filled by the model’s learned patterns. [13:19](https://www.youtube.com/watch?v=RjfbvDXpFls&t=799s) [14:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=855s)

Humans, in his account, provide two properties that agents lack: a natural limit on how quickly mistakes accumulate and the ability to feel the maintenance pain those mistakes create. That discomfort can motivate learning, collective refactoring, or other corrective action. By contrast, Zechner argues that agents will continue generating changes without acquiring the same durable understanding, and that elaborate memory systems do not substitute for human learning. [14:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=855s)

The danger becomes most visible when a team stops reading its own code. If users encounter a failure, neither the humans nor an overwhelmed agent may possess enough system-wide context to diagnose it confidently. Zechner warns that larger context windows and agentic search are not guaranteed remedies, and that locally plausible patches can introduce broader regressions. Trust erodes further when the same agents that produced the implementation also generated the tests used to validate it. [15:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=924s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 774 seconds](https://ai.engineer/api/talk-essay-media/788114443f9c057154fff31008b2fab7f1a392738fbff8da9fe617514446454f)

Speed without understanding compounds technical debt

- Multiple agents can generate code and defects faster than humans can review; review agents catch only some problems.
- When a codebase exceeds available context, local decisions can introduce unnecessary abstractions, duplication, and backward-compatibility layers.
- Incomplete specifications leave consequential decisions to model-learned patterns, while humans can recognize maintenance pain and refactor.
- Unread code and agent-generated tests undermine confidence when local fixes create broader regressions.

### Use agents for bounded work, and keep critical decisions human

[5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s)

Zechner’s proposed alternative is not to abandon coding agents but to assign them work with a **well-defined scope**. A good agent task is bounded tightly enough that the agent can find all the relevant information needed to complete it. Modularizing the codebase makes those boundaries easier to establish, and an objective evaluation function improves the setup further by allowing the result to be assessed against a clear target. [15:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=924s) [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s)

He identifies several productive applications: optimization or research loops with measurable feedback, noncritical work, repetitive tasks, and constructing reproduction cases from incomplete user reports. Agents can also serve as a substitute conversational partner when no human collaborator is available. The workflow still ends with human evaluation: examine what the agent produced, retain what is reasonable, and finalize the result deliberately. [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s)

His closing prescription is to **slow down**, decide what is worth building, and resist adding features merely because an agent can generate them. Teams should limit generated code to an amount they can actually review, use agents to polish the features that matter, and distinguish between disposable or noncritical work and code whose failure would matter. For critical code, Zechner insists on reading every line; for important decisions, he argues that humans should write the code themselves, using agents as assistance rather than as the final authority. [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s) [17:44](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1064s)

The apparent friction in that process is part of its value. Working through the details builds a mental model of the system and creates opportunities to learn, while delegating every consequential choice undermines both understanding and agency. Across pi’s architecture, open-source maintenance, and coding practices, the same principle recurs: useful automation should expand human control without displacing human judgment. [5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s) [11:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=671s) [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s) [17:44](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1064s)

![Selected presentation frame from Building pi in a World of Slop — Mario Zechner at 1008 seconds](https://ai.engineer/api/talk-essay-media/f7a3f9841453fe42df68ef774c4deb71e27f8e4a79ff4c10699f513ac05780de)

Use agents for bounded work, and keep critical decisions human

- Bound agent tasks so all relevant context is discoverable; modular code and explicit evaluation functions strengthen those boundaries.
- Use agents for measurable research loops, noncritical repetitive work, reproducing incomplete bug reports, and conversational problem-solving.
- Evaluate generated output, limit changes to what humans can review, and read every line of critical code.
- Keep consequential implementation decisions human-led; working through difficult details builds system understanding and learning.

## Key takeaways

- **Own the context:** Hidden prompt changes, injected reminders, premature diagnostics, and pruned tool outputs can change agent behavior in ways developers cannot easily inspect or control. [1:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=84s) [2:25](https://www.youtube.com/watch?v=RjfbvDXpFls&t=145s) [3:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=196s)
- **Keep the core small:** Pi combines a short system prompt, a simple tool-calling loop, and four built-in tools: read, write, edit, and bash. [5:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=313s) [6:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=381s)
- **Make customization part of the workflow:** TypeScript extensions, bundled documentation, broad hooks, and hot reloading allow users and agents to adapt the harness during an active session. [6:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=381s) [7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s) [8:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=496s) [9:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=556s)
- **Protect maintainer attention:** Human-first contribution gates, issue clustering, and temporary tracker closures can help counter the volume of low-quality automated open-source contributions. [10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s) [11:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=671s)
- **Bound agent work to what humans can verify:** Modular tasks, clear evaluation criteria, and limits on generated code reduce the risk that local agent decisions accumulate into system-wide complexity. [13:19](https://www.youtube.com/watch?v=RjfbvDXpFls&t=799s) [15:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=924s) [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s)
- **Keep critical judgment human:** Read critical code, make consequential design decisions yourself, and treat the friction of implementation as a source of understanding rather than a problem to eliminate. [16:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=991s) [17:44](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1064s)

## Slides

### AI Engineer Europe

The recording opens with the AI Engineer Europe logo.

[0:00](https://www.youtube.com/watch?v=RjfbvDXpFls&t=0s) [AI Engineer Europe logo in white on black.](https://assets.ai.engineer/sites/aiecode2025/sha256/099222ed3a40508baa117281b8765de70d74bc7dbd514791aa20e7c7d38d1c4f.webp)

AI Engineer
EUROPE

### Presenting sponsor

Google DeepMind is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=RjfbvDXpFls&t=5s) [Presenting sponsor Google DeepMind.](https://assets.ai.engineer/sites/aiecode2025/sha256/94b8a83e75af54cd32eb742cc8be01b92271ca2d2903fa413c8fdc796bc24862.webp)

PRESENTING SPONSOR
Google DeepMind

### Platinum sponsors

[0:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=10s) [Platinum sponsors Braintrust, WorkOS, and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/92c4bf1724396ca6be7c6bbc4bb2632f72ca1eebf266dee04c2bd915cfac5b7e.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### In the beginning, there was Claude Code

Zechner traces his path through ChatGPT, GitHub Copilot, Aider and Cursor to Claude Code, which clicked with him most.

[0:36](https://www.youtube.com/watch?v=RjfbvDXpFls&t=36s) [Slide says Claude Code came after earlier workflows using ChatGPT, GitHub Copilot, Aider, and Cursor.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ce56e2c0e1a8baaa55416dee207c54ac51b932bfcae70f6c3baf49b52e7c265.webp)

In the beginning,
there was Claude Code

(WELL ACTUALLY, COPY AND PASTE FROM CHATGPT, THEN GITHUB COPILOT
TAB TAB TAB, THEN AIDER, THEN CURSOR)

EARENDIL
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

BUILDING PI IN A WORLD OF SLOP
MARIO ZECHNER / Creator
AI Engineer EUROPE
PRESENTED BY Google DeepMind

Interface text:
11:02

### The Claude Code team

Zechner credits the Claude Code team with creating the genre, then frames his talk as an explanation of why he stopped using Claude Code and built his own tool.

[0:51](https://www.youtube.com/watch?v=RjfbvDXpFls&t=51s) [Slide praises the Claude Code team for creating the genre.](https://assets.ai.engineer/sites/aiecode2025/sha256/c2506b357c3b5652e3d62020009f9adbb31a9645771eb1727162cee178f20a19.webp)

Love the Claude Code team
They created the entire genre

EARENDIL
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

Interface text:
11:15
AI Engineer EUROPE
PRESENTED BY Google DeepMind
BUILDING PI IN A WORLD OF SLOP
MARIO ZECHNER / Creator

### Simple, predictable, fit my workflow

Zechner recalls early Claude Code fitting his workflow. As the team added features, he found many unnecessary and grew frustrated with bugs.

[1:07](https://www.youtube.com/watch?v=RjfbvDXpFls&t=67s) [Slide describes an early workflow as simple and predictable.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c4a3aa45b8a1b2b20121e357831b33d8e866bea5e97fe695771fedd317d2dd4.webp)

Simple, predictable,
fit my workflow

EARENDIL
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

BUILDING PI IN A WORLD OF SLOP
MARIO ZECHNER / Creator

AI Engineer EUROPE
PRESENTED BY
Google DeepMind

Interface text:
11:33

### Claude Code rendering errors

Erik Meijer’s post shows a distorted Claude Code terminal after flickering improved. Zechner says the flicker was eventually fixed, but other things broke.

[1:47](https://www.youtube.com/watch?v=RjfbvDXpFls&t=107s) [A post describes rendering errors and shows a distorted terminal interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/d78a967ee7f93b89a8ae49d43b4fe9a422c0039c9add2b52f61d05eee9f46ecc.webp)

Erik Meijer
@headinthebox

Flickering in Claude Code seems much improved, but now it has weird rendering errors.

c  p     ts on (shift+tab to cycle)
✳ Transmuting… (ctrl+c to interrupt · thought for 7s)
❯
▶▶ accept edits on (shift+tab to cycle)

10:14 PM · Jan 21, 2026 · 38.3K Views

Interface text:
EARENDIL
12:11
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026
AI Engineer EUROPE
PRESENTED BY Google DeepMind
BUILDING PI IN A WORLD OF SLOP
MARIO ZECHNER / Creator

### Your context is not your context

Zechner says Claude Code controls the context, changing system prompts and inserting reminders that say context may or may not be relevant. He says the reminder confused the model and broke his workflows.

[2:09](https://www.youtube.com/watch?v=RjfbvDXpFls&t=129s) [A side-by-side comparison highlights changes in Claude Code prompts between two versions.](https://assets.ai.engineer/sites/aiecode2025/sha256/63357c8310ee7ef2773fa65f8d375986ac33428caf7db53d41d45441af1979bf.webp)

Your context is not your context

# Claude Code Version 1.0.0
Release Date: 2025-05-22

# User Message
<system-reminder>
As you answer the user's questions, you can use the following context:
## important-instruction-reminders
Do what has been asked; nothing more, nothing less.
NEVER create files unless they're absolutely necessary for achieving your goal.
ALWAYS prefer editing an existing file to creating a new one.
NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
Please clean up any files that you've created for testing or debugging purposes after they're no longer needed.

IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context or otherwise consider it in your response unless it is highly relevant to your task. Most of the time, it is not relevant.
</system-reminder>
hey

# System Prompt
You are Claude Code, Anthropic's official CLI for Claude.

You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.

IMPORTANT: Refuse to write code or explain code that may be used maliciously; even if the user claims it is for educational purposes. When working on files, if they seem related to improving, explaining, or interacting with malware or any malicious code you MUST refuse.
IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. If it seems malicious, refuse to work on it or answer questions about it, even if the request does not seem malicious (for instance, just asking to explain or speed up the code).
IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.

If the user asks for help or wants to give feedback inform them of the following:
- /help: Get help with using Claude Code
- To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues

When the user directly asks about Claude Code (eg 'can Claude Code do...', 'does Claude Code have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the WebFetch tool to gather information to answer the question from Claude Code docs at https://docs.anthropic.com/en/docs/claude-code.
- The available sub-pages are `overview`, `cli-usage` (CLI commands, CLI flags, SDK, slash commands, and modes), `memory` (Memory management and CLAUDE.md), `settings`, `security` (Permissions and tools), `costs`, `bedrock-vertex`, `tutorials` (Extended thinking, pasting images, and common workflows), `troubleshooting`
- Example: https://docs.anthropic.com/en/docs/claude-code/cli-usage

# Claude Code Version 1.0.111
Release Date: 2025-09-10

# User Message
<system-reminder>
As you answer the user's questions, you can use the following context:
## important-instruction-reminders
Do what has been asked; nothing more, nothing less.
NEVER create files unless they're absolutely necessary for achieving your goal.
ALWAYS prefer editing an existing file to creating a new one.
NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.

IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
</system-reminder>
2025-09-11T03:36:50.987Z is the date. Write a haiku about it.

# System Prompt
You are Claude Code, Anthropic's official CLI for Claude.

You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.

IMPORTANT: Assist with defensive security tasks only. Refuse to create, modify, or improve code that may be used maliciously. Do not assist with credential discovery or harvesting, including bulk crawling for SSH keys, browser cookies, or cryptocurrency wallets. Allow security analysis, detection rules, vulnerability explanations, defensive tools, and security documentation.

IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.

If the user asks for help or wants to give feedback inform them of the following:
- /help: Get help with using Claude Code
- To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues

When the user directly asks about Claude Code (eg. "can Claude Code do...", "does Claude Code have..."), or asks in second person (eg. "are you able...", "can you do..."), or asks how to use a specific Claude Code feature (eg. implement a hook, or write a slash command), use the WebFetch tool to gather information to answer the question from Claude Code docs. The list of available docs is available at https://docs.anthropic.com/en/docs/claude-code/claude_code_docs_map.md.

Interface text:
cchistory
Track Claude Code prompts over time
1.0.0 → 1.0.111
By Mario
EARENDIL
12:51
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

### Observability, model choice and extensibility

Zechner criticizes Claude Code’s lack of observability and model choice, and its shallow hooks. Each hook starts a new process, which he considers inefficient.

[2:46](https://www.youtube.com/watch?v=RjfbvDXpFls&t=166s) [The slide lists zero observability, zero model choice and almost zero extensibility.](https://assets.ai.engineer/sites/aiecode2025/sha256/07a2d37e2a16827535e7cb44113d865afa797808cb21ebcc864f6e9d05162055.webp)

Zero observability
Zero model choice
(Almost) zero extensibility

EARENDIL
MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

BUILDING PI IN A WORLD OF SLOP
MARIO ZECHNER / Creator

AI Engineer EUROPE
PRESENTED BY Google DeepMind

Interface text:
13:13

### OpenCode context handling

OpenCode calls pruning after every agent turn. Zechner says that, under certain conditions, older tool outputs are removed beyond the protected 40,000 tokens, losing context and busting the prompt cache.

[3:34](https://www.youtube.com/watch?v=RjfbvDXpFls&t=214s) [Slide describes pruning tool outputs and shows a code example with a 40,000-token protection threshold.](https://assets.ai.engineer/sites/aiecode2025/sha256/cda200d51e6071033b2656c5dcd52d35a0aabe86dc8bf2869ebc2c5b73e727c2.webp)

OpenCode context handling
PRUNING == BUSTING THE PROMPT CACHE

// Called after EVERY agent turn
SessionCompaction.prune({ sessionID })

// Silently erases tool outputs beyond last 40k tokens
export const PRUNE_PROTECT = 40_000

MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

Interface text:
EARENDIL
13:58
BUILDING PI IN A WORLD OF SLOP
AI Engineer EUROPE
PRESENTED BY
Google DeepMind
Braintrust
WorkOS
OpenAI

[3:53](https://www.youtube.com/watch?v=RjfbvDXpFls&t=233s) [Slide says OpenCode prunes older tool outputs and shows a 40,000-token protection threshold.](https://assets.ai.engineer/sites/aiecode2025/sha256/a6266c27631dfb9ba3fd9f99d2927936c7bd9d581e3c1f4e88ffa1283b4fe5d3.webp)

OpenCode context handling
PRUNING == BUSTING THE PROMPT CACHE

// Called after EVERY agent turn
SessionCompaction.prune({ sessionID })

// Silently erases tool outputs beyond last 40k tokens
export const PRUNE_PROTECT = 40_000

MARIO ZECHNER · @BADLOGICGAMES
AI ENGINEER EUROPE · APRIL 10, 2026

Interface text:
EARENDIL
14:15
BUILDING PI IN A WORLD OF SLOP
AI Engineer EUROPE
PRESENTED BY
Google DeepMind
Braintrust
WorkOS
OpenAI

## Full transcript

[0:00](https://www.youtube.com/watch?v=RjfbvDXpFls&t=0s) [upbeat music] Hello, I'm Mario.

[0:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=16s) I built pi in a world of slop, and this is a strategy, a tragedy in three acts. Just to talk about this real quick, a bunch of people on the internet gave me money for ad space on my torso, and all of that goes to a charity.

[0:27](https://www.youtube.com/watch?v=RjfbvDXpFls&t=27s) So yeah, thanks guys. [audience laughing] So act one: building pi. In the beginning, there was Claude Code and it was good, right? We all got basically cat-nipped by that thing and stopped sleeping.

[0:39](https://www.youtube.com/watch?v=RjfbvDXpFls&t=39s) Um, bunch of stuff before that, but Code Clau- uh, Claude Code was the one thing that kinda clicked with me the most. And to preface all of this, I love the Claude, Claude team.

[0:48](https://www.youtube.com/watch?v=RjfbvDXpFls&t=48s) They're brilliant people, talented, super high velocity. So, uh, they also created the entire game. Major props to them. So this is not a roast, this is just me, an old man, telling you why I stopped using Claude Code and built my own thing.

[1:02](https://www.youtube.com/watch?v=RjfbvDXpFls&t=62s) Um, in twenty twenty-five, I started using Claude Code in about April, I think, thanks to Peter, uh, [laughs] because he told us the agents are working now. [coughs]

[1:12](https://www.youtube.com/watch?v=RjfbvDXpFls&t=72s) And back then it was simple and predictable and fit my workflow. But eventually,

[1:17](https://www.youtube.com/watch?v=RjfbvDXpFls&t=77s) the token madness got hold of them, [laughs] I think, and the team got bigger, and they started, uh, dogfooding that stuff and built a lot of features. A lot of features I don't need.

[1:25](https://www.youtube.com/watch?v=RjfbvDXpFls&t=85s) Which is fine, I can just ignore them. But with velocity and more features come more bugs. And that's bad, because I used to work at construction sites, and if my hammer breaks every day, I'm getting really mad.

[1:36](https://www.youtube.com/watch?v=RjfbvDXpFls&t=96s) And if my development tools break every day, I'm also getting mad. So there was this. It's just a running gag. And here's Tarik telling us that Claude Code is now a game engine.

[1:45](https://www.youtube.com/watch?v=RjfbvDXpFls&t=105s) And here's Mitchell from Ghostty telling us, "No, it's not." And eventually they fixed the flicker, but then other stuff broke, and I think they're now at, in the third iteration of a TUI renderer.

[1:55](https://www.youtube.com/watch?v=RjfbvDXpFls&t=115s) Yeah. But that's just a symptom. The real problem is that my context wasn't my context. Claude Code is the thing that controls my context. And behind my back, Claude Code does things, uh, to the context.

[2:07](https://www.youtube.com/watch?v=RjfbvDXpFls&t=127s) So you have the system prompt, which changes on every release, including the tool definitions. They would remove tools, modify tools. It's not good. They would insert system reminders in the most oppor- inopportune place in your context, telling the model, "Here's some information.

[2:22](https://www.youtube.com/watch?v=RjfbvDXpFls&t=142s) It may or may not be relevant to what you're doing." That it, it actually says it may or may not be relevant what you're doing. And that kind of confused the model, and that k- kind of broke my workflows. [coughs]

[2:34](https://www.youtube.com/watch?v=RjfbvDXpFls&t=154s) On top of all that, there's zero observability, because that's how the tool is constructed, and I like knowing what my agents are doing. There's zero model choice, which is obvious.

[2:42](https://www.youtube.com/watch?v=RjfbvDXpFls&t=162s) It's the native anthropic, uh, harness. So it makes sense for them to want you to use Claude, right? And there's almost zero extensibility, and some of you might have written some hooks for Claude Code, but I'm telling you, the number of hooks and the depth of those hooks is very shallow.

[2:57](https://www.youtube.com/watch?v=RjfbvDXpFls&t=177s) Um, and every time a hook triggers, what actually happens is a new process gets spawned. Basically, the command you specified for the hook to be executed. And I don't find that specifically efficient.

[3:06](https://www.youtube.com/watch?v=RjfbvDXpFls&t=186s) So I, uh, took a step back and looked around for alternatives, and I'd like to especially call out Amp and Factory Droid, the Porsche and Lamborghini of coding agent harnesses.

[3:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=196s) So if you can afford them, please use them. They're at the frontier. They're really good, and the teams are fantastic. And there's a bunch of other options. And I have history in OSS, so naturally I kind of gravitated towards OpenCode.

[3:27](https://www.youtube.com/watch?v=RjfbvDXpFls&t=207s) And again, brilliant team, super high execution velocity, and they don't sell you hype. They sell you tools that work for the most part. I started looking under the hood of OpenCode, uh, with respect to context handling as well, because that's w- the most important part for me.

[3:42](https://www.youtube.com/watch?v=RjfbvDXpFls&t=222s) And I found a bunch of things like, given some conditions, OpenClaw- Code would just, uh, prune tool output after a specific minimum amount of tokens. And that basically lobotomizes the model.

[3:56](https://www.youtube.com/watch?v=RjfbvDXpFls&t=236s) Uh, there's also LSP server support, which means every time your model is calling the edit tool, OpenCode goes to the LSP server that's connected, asks, "Are there any errors?"

[4:06](https://www.youtube.com/watch?v=RjfbvDXpFls&t=246s) And if so, injects that as part of the edit tool, uh, result. Which is bad, because think about how you edi- editing code. You're not writing a line of code, checking the errors.

[4:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=256s) Writing the next line, checking the errors. You don't do that. You finish your work, and then you check the errors. This confuses the model. There's a bunch of other things, like storing individual messages of a session in a JSON file.

[4:27](https://www.youtube.com/watch?v=RjfbvDXpFls&t=267s) Each messag- message is a JSON file on disk. Uh, there was this, and this happens to all of us. No, no blame there. But it's not great if by default a server spins up.

[4:37](https://www.youtube.com/watch?v=RjfbvDXpFls&t=277s) CORS headers are set in such a way that any website you open in your browser can now access your OpenCode server. That's... Yeah. And entirely unrelated to all of this, I started looking into benchmarks for coding agent harnesses and found, uh, Terminal-Bench, um, which is a pretty good benchmark, all things considered.

[4:54](https://www.youtube.com/watch?v=RjfbvDXpFls&t=294s) And the funny part about it is that it's the most minimal kind of thing you can think of. All it gives the model is a tool to send keystrokes to, to a tmux session and read the output of that tmux session.

[5:06](https://www.youtube.com/watch?v=RjfbvDXpFls&t=306s) There's no file tools, no sub-agents, none of that stuff. And it's one of the best performing harnesses in the leaderboard. Here's the leaderboard from December twenty twenty-five. Irrespective of model family, Terminus scores higher, mostly high, even higher than the native harness of that model.

[5:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=324s) So what does that tell us? I form two theses. We are in the fuck around and find out phase of coding agents, and their current form is not their final form, right? [lip smacks]

[5:33](https://www.youtube.com/watch?v=RjfbvDXpFls&t=333s) So second thesis is we need better ways to fuck around. And for me, that means self-mod- modifying malleable agents, things that the agent itself can modify and I can modify depending on my workflow.

[5:47](https://www.youtube.com/watch?v=RjfbvDXpFls&t=347s) So I stripped away all the things, built a minimal core, but made it super extensible and made it so that the agent can modify itself.

[5:55](https://www.youtube.com/watch?v=RjfbvDXpFls&t=355s) With some creature comforts. It's not entirely bare bones. Uh, so that's pi. It's an agent that adapts to your workflow instead of the other way around.

[6:02](https://www.youtube.com/watch?v=RjfbvDXpFls&t=362s) It comes with four packages, uh, an AI package that's basically just an abstraction across providers and context, uh, handoff between providers. An agent core, uh, which is just a while loop and the tool calling.

[6:14](https://www.youtube.com/watch?v=RjfbvDXpFls&t=374s) Uh, bespoke TUI framework. I come out of game development, so I built a thing that actually doesn't flicker too much. And the coding agent itself. Here's pi's system prompt. [coughs]

[6:23](https://www.youtube.com/watch?v=RjfbvDXpFls&t=383s) That's it. Eventually, the industry created a new standard called Skills, which is basically just markdown files. So we added that as well, and that needs to go into system prompt.

[6:32](https://www.youtube.com/watch?v=RjfbvDXpFls&t=392s) So, begrudgingly, we had to add a couple more lines. And finally, here's the magic that makes pi able to modify itself. We ship the documentation, which was handcrafted by me and an agent, um, and code examples of extensions. [coughs]

[6:48](https://www.youtube.com/watch?v=RjfbvDXpFls&t=408s) And all we need to do for the agent to modify itself is tell it, "Here's the documentation. Here's some code that shows you how to modify yourself by writing extensions."

[6:58](https://www.youtube.com/watch?v=RjfbvDXpFls&t=418s) It comes with four tools. That's all it has. Read, write, edit, bash. Here's the tool definitions. Don't read the, the text, just look at the size.

[7:05](https://www.youtube.com/watch?v=RjfbvDXpFls&t=425s) That's it. Here's what happens when you start a new session in one of these tools.

[7:11](https://www.youtube.com/watch?v=RjfbvDXpFls&t=431s) So the thing is, the models are actually reinforcement trained up the wazoo, so they know what a coding agent is because the coding agent harness is basically what they're being trained when they are post trained.

[7:21](https://www.youtube.com/watch?v=RjfbvDXpFls&t=441s) You don't need ten thousand tokens to tell them you're a coding agent. They know because they are coding agents now. Pi is also YOLO by default because my security needs are different than yours, and I don't think a little dialogue that pops up every now, every time you call bash asking you to approve is a smart security,

[7:40](https://www.youtube.com/watch?v=RjfbvDXpFls&t=460s) uh, uh, mechanism. So instead, I give you so much rope that you can build anything that's fit for your specific security needs. There's also stuff that's not built in.

[7:51](https://www.youtube.com/watch?v=RjfbvDXpFls&t=471s) I'm a Heathen [laughs] because this is how I do it.

[7:55](https://www.youtube.com/watch?v=RjfbvDXpFls&t=475s) But if you don't like that, then you just ask pi to build you sub agent support or plan mode or MCP support, whatever you need.

[8:03](https://www.youtube.com/watch?v=RjfbvDXpFls&t=483s) Extensibility comes with a bunch of table stakes, and then with the extensions itself. And extensions in pi are just TypeScript modules. In the simplest case, a TypeScript file on disk.

[8:12](https://www.youtube.com/watch?v=RjfbvDXpFls&t=492s) You point pi at that. Here's an extension loaded as part of the harness. And with that, you get a basically an extension API that lets you hook into everything and define stuff for the harness to expose to the, to the model.

[8:25](https://www.youtube.com/watch?v=RjfbvDXpFls&t=505s) And that includes tools, uh, slash command shortcuts. You can listen in on any kind of event and react, and then save state in the session that's optionally provided to the agent as well, or stored there for tools that analyze sessions as part of your organizational workflows.

[8:43](https://www.youtube.com/watch?v=RjfbvDXpFls&t=523s) You can do custom compaction, custom providers, and you have full control over the tool, so you can modify everything in pi. And you can then bundle all of that up and put it on npm or on GitHub, because I think we don't need to reinvent another bunch of silos called marketplaces.

[8:59](https://www.youtube.com/watch?v=RjfbvDXpFls&t=539s) We already have package manners-- managers. And all of that hot reloads. So if you develop an extension for pi, you do so in the session and you hot reload the changes and see the, the, the effects of that immediately, which is very great and it's also game development thingies.

[9:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=556s) In game development, you want high-- very low iteration, uh, s-speeds, and that's great. So a couple of examples. Claude or Anthropic ships the /btw, which lets you talk to the agent while it goes on its main quest.

[9:29](https://www.youtube.com/watch?v=RjfbvDXpFls&t=569s) I posted this little prompt on Twitter jokingly, and somebody built it in five minutes [laughs] with more features. And they didn't have to fork or clone pi. They just let the agent write the extension based on the prompt.

[9:42](https://www.youtube.com/watch?v=RjfbvDXpFls&t=582s) Here's Nico. He's one of the most prolific, uh, extension writers. I don't know what the fuck is going on here. It's a chat room for all of his pi agents, and they talk with each other.

[9:50](https://www.youtube.com/watch?v=RjfbvDXpFls&t=590s) I would never use this, but all of this is custom, including the UI. Or you can play NES games, or you can play Doom. [laughs]

[9:58](https://www.youtube.com/watch?v=RjfbvDXpFls&t=598s) And there's a bunch of other examples I'm not gonna talk about. So how do you build a pi extension? You don't. You tell pi to build it for you based on your specifications, and then you just iterate with it on that and hot reload during a session.

[10:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=610s) I'm gonna skip that example as well. And if you don't like building things yourself, and I hope you do like building things yourself, but if you don't, you can look on npm or our little search, uh, interface on top of npm to find packages for sub agents, MCP, and so on.

[10:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=624s) So does it actually work? Well, here's the Terminal-Bench leaderboard from October before pi had compaction. I added that for Peter's Claw thingy. It scored sixth place.

[10:35](https://www.youtube.com/watch?v=RjfbvDXpFls&t=635s) Uh, but none of this is actually about pi. If you want to ret- I, I basically want you to retake control of your tools and workflows, so build your own.

[10:43](https://www.youtube.com/watch?v=RjfbvDXpFls&t=643s) Um, and if you wanna know more about pi and OpenClaw, go to this talk, please. Yeah, and then eventually Peter happened. He put pi inside of OpenClaw as its agentic core, which meant my open source project became the target of a lot of OpenClaw instances unbeknownst to their users.

[10:57](https://www.youtube.com/watch?v=RjfbvDXpFls&t=657s) So this is act two, OSS in the age of clankers. Clankers are destroying OSS. Here's tldraw. They closed down the issue and pull request tracker. Here's OpenClaw's, uh, trackers.

[11:07](https://www.youtube.com/watch?v=RjfbvDXpFls&t=667s) Here's mine. Half of that is OpenClaw instances who post garbage. So I started to rage against the clankers. [laughs]

[11:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=675s) Um, if you send a pull request, it gets auto closed with a comment that asks you to please write a nice issue in your human voice, no longer than a screen worth of text.

[11:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=684s) And if I see that, I write, "Looks good to me," and your account name gets put in a file in the repository, and the next time you send a pull request, it's let through.

[11:31](https://www.youtube.com/watch?v=RjfbvDXpFls&t=691s) Clankers don't read that comment. They don't go back once they posted a pull request. So that's a perfect filter. Uh, Mitchell eventually turned it into [REDACTED:username]. Here's a clanker.

[11:40](https://www.youtube.com/watch?v=RjfbvDXpFls&t=700s) Uh, I also labeled them. If you had interactions with OpenClaw, your issues get de-deprioritized. I also build tools where I embed, uh, issues and pull request texts into 3D space, so I see clusters of issues.

[11:53](https://www.youtube.com/watch?v=RjfbvDXpFls&t=713s) Uh, I also invented OSS vacation. I just close the tracker whenever I want, so I have my life back. [laughs] So does this work? Yes, sort of. [laughs]

[12:02](https://www.youtube.com/watch?v=RjfbvDXpFls&t=722s) Which leads me to act three. Slow the fuck down. Everything's broken.

[12:09](https://www.youtube.com/watch?v=RjfbvDXpFls&t=729s) And then there's people that say, "Our product's been 100% built by agents." Yes, we know. It fucking sucks now. Congratulations. [laughing] [audience laughing] [clapping]

[12:22](https://www.youtube.com/watch?v=RjfbvDXpFls&t=742s) And I'm hearing this from my peers, and this is entirely unhealthy. Um, so here's how we should not work with agents and why, at least in my opinion. I wrote this on my blog a while ago, but the basic gist is, we are having army of agents and you're using beats and been, and you don't know that

[12:37](https://www.youtube.com/watch?v=RjfbvDXpFls&t=757s) it's basically uninstallable malware. And, Anthropic build a C compiler. It kind of works, but actually doesn't, and we're hoping the next generation of models will fix it. And here is Perza building a browser, and that's also super fucking broken.

[12:48](https://www.youtube.com/watch?v=RjfbvDXpFls&t=768s) Uh, but the next generation will fix it. And SaaS is dead, software solved in six months, and my grandma just built herself a Spotify with her OpenClaw. Come on, people. [laughs]

[12:58](https://www.youtube.com/watch?v=RjfbvDXpFls&t=778s) So agents are actually compounding boo-boos, which is my word for errors, with zero learning and no bottlenecks and, uh, delayed pain. The delayed pain is for you. Here's your code base on a human, on one agent, and 10 agents.

[13:12](https://www.youtube.com/watch?v=RjfbvDXpFls&t=792s) How much of the agent code can you review? Here's the same code base, but it's expressed in number of boo-boos per day. [audience laughing]

[13:19](https://www.youtube.com/watch?v=RjfbvDXpFls&t=799s) How much of those boo-boos do you think you'll find? Then you say, "Oh, I have a review agent." [audience laughing] Let me introduce you to the wonderful world of the Ouroboros.

[13:28](https://www.youtube.com/watch?v=RjfbvDXpFls&t=808s) Doesn't work. It catches some issues. Um, the problem is that agents are merchants of learned complexity. Where did they learn that complexity from? From the Internet. What's on the Internet?

[13:37](https://www.youtube.com/watch?v=RjfbvDXpFls&t=817s) All our old garbage code. There are some pearls on the Internet, really well-designed systems, but 90% of code on the Internet is our old garbage, and that's what the models learn from.

[13:47](https://www.youtube.com/watch?v=RjfbvDXpFls&t=827s) And every decision of an agent is local, especially if the code base is so big that it doesn't fit into its context, and if you let it go wild and add abstractions everywhere that are in- intertwined.

[13:59](https://www.youtube.com/watch?v=RjfbvDXpFls&t=839s) Um, so that leads to lots of abstractions and duplication and backwards compatibility. Who has seen that in the output of their agent? It's fucking annoying. Or defense in depth.

[14:09](https://www.youtube.com/watch?v=RjfbvDXpFls&t=849s) So yeah, you get enterprise-grade complexity within two weeks [laughs] with just two humans and 10 agents. Congratulations. And then you say, "But my detailed spec." Yes, sure. You know what we call a sufficiently detailed spec?

[14:23](https://www.youtube.com/watch?v=RjfbvDXpFls&t=863s) It's a program. [audience laughing] So if you leave blanks in your spec, what do you think happens? How does the model fill in the blanks, and with what does it fill that in?

[14:33](https://www.youtube.com/watch?v=RjfbvDXpFls&t=873s) It fills it in with the garbage that it learned on the Internet from our old code, which is garbage to mediocre. And then you say, "But humans also." Yes, humans are horrible, fail- failable beings, but they can learn.

[14:45](https://www.youtube.com/watch?v=RjfbvDXpFls&t=885s) And there are bottlenecks. There's only so many boo-boos they can add to your code base on a daily basis. And humans feel pain, which is a very interesting property because humans hate pain.

[14:56](https://www.youtube.com/watch?v=RjfbvDXpFls&t=896s) And once there's too much pain, the human has a bunch of options. It can quit their job, it can, uh, blame somebody else and make them fix it, or everybody bands together and starts refactoring the shit out, out of the garbage code base, right?

[15:10](https://www.youtube.com/watch?v=RjfbvDXpFls&t=910s) Agents will happily keep shitting into your code base. [audience laughing]

[15:16](https://www.youtube.com/watch?v=RjfbvDXpFls&t=916s) And no, your AGENTS.md and super complex memory systems will not save you. Agents don't learn the way we learn.

[15:24](https://www.youtube.com/watch?v=RjfbvDXpFls&t=924s) Those are my mos- most beloved people. "I don't even read the code anymore." Congratulations. Something is broken and your users are screaming, so who you gonna call? Not yourself, because you haven't read the code.

[15:36](https://www.youtube.com/watch?v=RjfbvDXpFls&t=936s) So you're relying on your agents, but they are now also overwhelmed because the code base is so humongous that there's absolutely zero chance they can get all the context they need to fix the issues.

[15:46](https://www.youtube.com/watch?v=RjfbvDXpFls&t=946s) And long context windows are a hack, as most of you will find out this year as everybody's switching to 1 million tokens context windows. And agentic search is also failing.

[15:57](https://www.youtube.com/watch?v=RjfbvDXpFls&t=957s) So the agent patches locally and fucks shit up globally. If you see this in your code base, you're fucked. [laughs] [audience laughing]

[16:06](https://www.youtube.com/watch?v=RjfbvDXpFls&t=966s) So you cannot trust your code base anymore, and also not your tests because your agent wrote your tests, so good game. So here's how I think we should work.

[16:13](https://www.youtube.com/watch?v=RjfbvDXpFls&t=973s) Um, there's a bunch of properties for good agent tasks. That means scope. If you can scope it in such a way that the agent is guaranteed to find all the things it needs to find to do a good job, you're done.

[16:25](https://www.youtube.com/watch?v=RjfbvDXpFls&t=985s) That means modularize your code base. If you can give it a function to evaluate how well it did the job, even better. Hill climbing, autoresearch. Uh, anything non-mission critical, let it vibe.

[16:36](https://www.youtube.com/watch?v=RjfbvDXpFls&t=996s) Boring stuff, let it vibe. Reproduction cases for user issues, which are usually only partial in information, perfect. I don't spend any mornings anymore doing that. Or if you don't have a human near you, rubber duck.

[16:47](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1007s) So lots of tasks you can use them for and save time. At the end of that, you evaluate. You take what's reasonable, most of it isn't, and then finalize.

[16:56](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1016s) My final slide, more or less, slow the fuck down. [laughs] Think about what you're building and why, and don't just build because your agent can do it now. That's stupid.

[17:06](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1026s) Uh, learn to say no. This is your most valuable, uh, capability at the moment. Fewer features, but the ones that matter. And then use your agents to polish the shit out of that.

[17:15](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1035s) Enlighten your users, not your, uh, token maxing desires. Cap the amount of generated code, uh, that you need to review.

[17:26](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1046s) And non-critical code, sure, vibe slop ahead. Critical code, read every fucking line.

[17:32](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1052s) See the keynote after me for more info on that. So how do you know what's critical? Any guesses?

[17:38](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1058s) Well, you read the fucking code. [laughs] Uh, if you do anything important, write it by hand. You can use a clanker to help you with that, but don't m- let it make the decisions for you because we've learned all the decisions it makes are learned from the Internet.

[17:52](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1072s) And that friction is the thing that builds the understanding of the system in your head, which is important, and it's also where you learn new things. And all of this requires discipline and agency, and all of this still requires humans.

[18:07](https://www.youtube.com/watch?v=RjfbvDXpFls&t=1087s) Thank you. [audience applauding] [audience cheering] [upbeat music]
