# Don't Build Slop (4 Levels of AI Agent Maturity)

Ara Khan, Cline

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/yUmS-F9IX90-dont-build-slop-4-levels-ai-agent) · [Video](https://www.youtube.com/watch?v=yUmS-F9IX90)

## Don't Build Slop: Four Levels of AI Agent Maturity

Build a useful agent by testing the idea quickly, making its execution understandable, coordinating concurrent work, and moving long-running tasks into shared cloud environments.

Familiarity with coding agents, tool calls and basic application development will help; the state-machine and Kanban concepts are explained as they arise.

### Should you run fifteen agents or read every line?

[0:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=29s)

Everyone else seems to have a room full of robots working for them. Should you have fifteen agents running while you supervise, or should you still read every line of code? That is the uncomfortable choice Ara Khan opens with: the apparent productivity of other people's agents makes it difficult to judge how much automation your own work actually needs.

![Illustration of a person holding a tablet on a walkway above rows of robots in a blue-lit room.](https://ai.engineer/api/talk-essay-media/4f3372ce9e2b104ddf43b622c8b51838724c9fd74d4686abcd867c2574d70429)

A lone person overlooks a room full of working robots.

The useful response is to slow down long enough to identify a problem worth solving. Sometimes that means building quickly to find out whether an idea works; sometimes it means deliberately slowing down to make it suitable for production. Khan illustrates the confusion with three similar-looking interfaces from Factory, Codex and Cursor. If the products look interchangeable, copying their appearance offers little guidance about what your agent should do.

His four maturity levels separate the questions that otherwise get bundled into “build an agent.”

| Level | Immediate question | Approach |
|---|---|---|
| 1 | Does the idea work? | Prototype with a framework |
| 2 | Can we control its behavior? | Build an explicit state machine |
| 3 | Can we coordinate the work? | Organize agents through Kanban |
| 4 | Can others run it easily? | Move execution to the cloud |

These are working heuristics for balancing experimentation, implementation, interaction and deployment. Each level addresses a different constraint.

### Use a framework to test the idea

[3:00](https://www.youtube.com/watch?v=yUmS-F9IX90&t=180s)

Suppose you want an agent to aggregate emails. At this stage, finding the best model or designing a bespoke runtime may matter less than discovering whether the workflow is useful. LangChain and LangGraph are examples of frameworks that can get that experiment moving. Khan is explicit about his perspective: he builds Cline's agent experience himself and does not use these frameworks, so he is not offering a detailed comparison of them.

Khan estimates that a framework can produce a working prototype in half an hour for a rudimentary task where choosing the best model is not the priority. The immediate payoff is something concrete to try: you can see whether the agent helps and whether the proposed product has a reason to exist. The accompanying slide broadens the framework menu to LangChain, LangGraph, CrewAI, AutoGen and LlamaIndex.

![Blue AI Agent Framework slide with five labeled pillars and framework logos.](https://ai.engineer/api/talk-essay-media/925413f25af6d52282bc77a791b712cc5a804b35680631fb4442fdce8741e31f)

Five AI agent frameworks: LangChain, LangGraph, CrewAI, AutoGen, and LlamaIndex.

The tradeoff appears when the experiment becomes a serious implementation. Khan's objection is that the customization, modularity and ability to adapt to future models that he wants are difficult to obtain through a framework. That is his opinionated reason to move to the second level, rather than a demonstrated limitation shared by every framework: once controlling the agent becomes the central problem, he prefers to own its implementation.

### Rule one: know which state the agent is in

[4:17](https://www.youtube.com/watch?v=yUmS-F9IX90&t=257s)

Building the agent yourself is too large a subject for one recipe, so Khan gives five rules. The first is to treat the agent as a **state machine**: a loop with conditions, transitions and terminal states. At any moment, you should be able to explain where execution is and what can happen next. That mental model remains useful even when the product surrounding the loop is sophisticated.

His example is a request to read a few files and explain them through Claude Code. The user supplies the task; the agent chooses a file-reading action; the tool returns the contents; the agent determines that it has enough information and calls a completion tool. The task ends at that explicit terminal state.

A small TypeScript implementation can make that control flow visible. Here, `decide` represents the model-facing decision step, while the runtime owns tool execution and termination:

```typescript
import { readFile } from "node:fs/promises";

type FileResult = { path: string; contents: string };
type Action =
  | { kind: "read_files"; paths: string[] }
  | { kind: "complete"; explanation: string };

type State = {
  task: string;
  phase: "deciding" | "reading" | "complete";
  files: FileResult[];
};

type Decide = (state: Readonly<State>) => Promise<Action>;

export async function runAgent(
  task: string,
  decide: Decide,
): Promise<string> {
  const state: State = { task, phase: "deciding", files: [] };

  while (true) {
    state.phase = "deciding";
    const action = await decide(state);

    if (action.kind === "complete") {
      state.phase = "complete";
      return action.explanation;
    }

    state.phase = "reading";
    for (const path of action.paths) {
      const contents = await readFile(path, "utf8");
      state.files.push({ path, contents });
    }
  }
}
```

The file results become inputs to the next decision, rather than ending the task by themselves. Khan notes that a more complex task can keep traversing the same state machine for eight to ten minutes, or even hours. Longer execution makes knowing the current state more valuable; it does not change the underlying loop.

### Rule two: every addition can make the agent worse

[5:55](https://www.youtube.com/watch?v=yUmS-F9IX90&t=355s)

**More instructions do not automatically produce better behavior.** Large system prompts, accumulated edge cases and elaborate `if`/`else` logic can interfere with a frontier model's ability to do its job. Khan describes this as a bitter lesson from agent development: instructions introduced to compensate for earlier limitations may become unnecessary constraints as models improve.

He cites the Codex repository's prompts for **GPT-5** and **GPT-5.3**, invoking a one-third size comparison to illustrate his view that newer models need shorter prompts. The comparison is not precise enough to establish a measured reduction: he does not identify the prompt files, revisions or counting method. The engineering point is to reconsider accumulated instructions instead of assuming each one remains beneficial. Khan describes excessive instruction load as making it harder for the model to determine which direction to follow.

Pruning can extend beyond the prompt. Khan reports that his team rewrote Cline in full after finding too much material inherited from older versions. He also tentatively recalls at least seven complete rewrites of Claude Code, while explicitly saying that its team would know better. Both examples serve his preference for removing obsolete scaffolding rather than continually building around it.

### Rule three: let other agents build and test yours

[7:19](https://www.youtube.com/watch?v=yUmS-F9IX90&t=439s)

An agent implementation should be easy to operate from a **CLI**. Khan calls the resulting development workflow a “pseudo RL pipeline”: another coding agent can change the implementation, run it, inspect the result and try again. The feedback here comes from building and testing the software; he does not describe a model-weight training procedure.

This changes how humans prepare a repository. Instead of only giving an AI instructions, developers also shape the environment so an AI can work through it effectively. Useful `AGENTS.md` instructions, appropriate skills and accessible CI/CD commands make the build-and-test loop easier to follow. End-to-end tests matter because the coding agent needs a way to check the resulting behavior after making changes.

With that loop in place, a long-running coding agent can work in a parallel thread, modify the implementation and test the result while you focus elsewhere. If building or testing requires a difficult sequence of manual interventions, that same friction limits agent-assisted maintenance. **Ease of verification becomes part of the agent's architecture.**

### Rule four: spend human attention on architecture

[8:45](https://www.youtube.com/watch?v=yUmS-F9IX90&t=525s)

High token throughput makes it easy to generate a large implementation before deciding whether its design makes sense. Khan's fourth rule—don't build slop—is a request to spend time on the intended behavior, architecture and design outline before letting generation carry the project forward.

Read the code even if you did not write it by hand. In Khan's experience, the architectural work needs thoughtful human ownership: what the agent is supposed to do, which states it can enter, and how those states connect. An agent can help you reason through that design in conversation, but the conversation should produce decisions you understand. Simply allowing models to keep generating code does not supply that understanding.

### Rule five: preserve each provider's API semantics

[9:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=587s)

Switching models is not always as simple as changing an endpoint and a model name. Khan characterizes provider-specific API behavior as a source of lock-in because it makes models harder to interchange. His examples are **Opus 4.6**, **Gemini 3.1 Pro** and **GPT-5.3 Codex**, whose reasoning-related conversation state requires careful handling.

He uses the broad term **reasoning traces** for information that participates in caching and the model's reasoning loop. Across conversational turns, the application needs to preserve and return that information in the format the provider expects. Flattening a conversation into ordinary text can therefore lose behavior that matters even when the visible messages look intact.

Khan warns that incorrect handling can leave responses apparently working while degrading performance. Failure behavior, however, depends on the provider and request structure. Current [Gemini thought-signature documentation](https://ai.google.dev/gemini-api/docs/generate-content/thought-signatures) specifies a `400` error when a required signature is omitted from the first function call in a Gemini 3 current-turn step. Current [Claude extended-thinking guidance](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) also distinguishes modes: Opus 4.6 supports interleaved thinking through adaptive mode, not manual extended thinking. These current contracts qualify the talk's broad warning; they are not a single shared reasoning protocol.

A routing layer does not remove the need to understand those differences. Khan specifically argues that using OpenRouter alone is insufficient assurance that every provider integration behaves correctly. The practical requirement is to test the conversation and tool-use path for each integration, including the reasoning-related state it must carry between requests.

### Coordinate concurrent work through Kanban

[11:09](https://www.youtube.com/watch?v=yUmS-F9IX90&t=669s)

Once the agent works, the next question is how to interact with several agents at once. Returning to the similar interfaces from the opening, Khan proposes Kanban as a useful form factor, familiar from products such as Linear. He dates his own advocacy to a March 26 tweet.

The reason starts with waiting. Khan describes Codex or Opus tasks running for eight to ten minutes, motivating users to keep two or three agents working concurrently. When inference is the limiting factor, starting another useful task can fill that waiting time. But those agents may be changing the same source, so **parallel execution needs isolation of mutable state**. A board can display the work; the underlying execution arrangement still has to prevent tasks from interfering with one another.

Kanban supplies a headline-level view of each task and makes dependencies easier to reason about: when these two tasks finish, start the next one. The user's role begins to resemble an engineering manager coordinating individual contributors. Instead of following every agent's output continuously, you can inspect the work that currently needs attention.

In this talk, [scheduled for April 10, 2026](https://ai.engineer/europe/2026), Khan says Claude Code had introduced a similar interface about ten hours earlier; that relative release timing remains his account. He names Claude Code and [Cline Kanban](https://cline.bot/blog/announcing-kanban) as workflow options. His emphasis is on the management pattern rather than requiring a particular coding agent.

### Move the environment off each user's machine

[13:11](https://www.youtube.com/watch?v=yUmS-F9IX90&t=791s)

An agent can be useful, tested and easy to inspect without being easy to distribute. Khan poses the next level as a scaling question: what would it take to support millions of tasks or users, or make the agent accessible throughout an 8,000-person company? Those are deployment scenarios, not scale results he demonstrates. Requiring every person to install software and maintain a complicated local workflow makes access harder.

His proposal is to do the environment work centrally and run the agents in the cloud. A separate machine for each agent provides a place for parallel execution without depending on each user's local setup. The agent can prepare its environment and perform interface tasks there. Cloud execution also creates room for longer runs, a capability Khan considers underused.

### Send a UX task, then let implementation and QA iterate

[14:26](https://www.youtube.com/watch?v=yUmS-F9IX90&t=866s)

Khan reports sending cloud-agent tasks from his phone that run for fifteen to twenty minutes. His example is a VS Code extension change with an explicit interaction sequence:

1. Build the extension.
2. Sign in.
3. Open settings.
4. Select the requested theme.
5. Test the result in the terminal.

The task includes both implementation and exercising the resulting interface.

In Khan's account, the cloud agent performs the QA clicks, checks whether they worked and keeps iterating when they fail. He says an extended implementation-and-QA cycle could take fifty to sixty minutes. The point of remote execution is that the task can continue through that cycle without occupying the user's machine or demanding continuous attention.

Several such tasks can be dispatched from a phone or laptop. Later, back at the laptop, the user can pull down the resulting PR. The useful handoff is a change that has gone through the requested interaction checks, ready for the next stage of human work.

### Share the setup, but start with the minimum

[15:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=932s)

A cloud environment also gives collaborators a common setup they can share and modify. Combined with a board for coordinating tasks, that leads to Khan's forecast: much of agent interaction will move toward Kanban, while much of the actual execution will move to cloud compute. It is a prediction about the division between the work interface and the machines doing the work.

That forecast does not make the last two levels easy or mandatory. Khan calls Kanban coordination and cloud deployment intricate problems, then returns to the simplest starting point: build the bare minimum that helps. Move up or down the levels according to the effort the problem warrants. He closes the main talk by acknowledging that these are opinionated heuristics with open questions, rather than a complete prescription for every agent product.

### Planning still happens inside the task

[17:16](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1036s)

The audience question exposes an important requirement for the Kanban interface: where does back-and-forth planning happen? Requirements gathering can be the most useful part of working with an agent, especially when the agent asks questions that clarify what the user wants. A task card must leave room for that conversation.

Khan answers by opening a task and explaining that it exposes the entire task trace. He identifies the interface inside it as the actual Codex CLI. His workflow is to converse there until the task is clear enough for autonomous work, then leave it running and focus elsewhere. The board provides the overview while the task retains the detailed interaction.

A follow-up asks whether the task changes state when it needs review or has a question. Khan says yes: in his file-reading example, the task begins in `in progress` and moves to `review` when it needs human input. That transition is the return path from delegation to conversation. The agent can work independently while the requirements are sufficient, then make the need for human attention visible on the board.

## Resources

- [Introducing Cline Kanban](https://cline.bot/blog/announcing-kanban) — Cline's launch article explains live agent task cards, task dependencies, and orchestration across Cline, Claude Code and Codex.
- [Gemini thought signatures](https://ai.google.dev/gemini-api/docs/generate-content/thought-signatures) — Provider documentation for preserving thought signatures across tool calls, including Gemini 3 validation errors.
- [Claude extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) — Current guidance on manual thinking budgets, adaptive thinking, and model-specific support for interleaved reasoning.

## Slides

### AI Engineer Europe

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

AI Engineer
EUROPE

### Presenting Sponsor: Google DeepMind

Google DeepMind is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=yUmS-F9IX90&t=5s) [Google DeepMind presenting sponsor card on black.](https://assets.ai.engineer/sites/aiecode2025/sha256/9a43b90b83b6eca77e82f00387f025461fb2cd84d99ed7f55e0f7cc2bbdddc7d.webp)

PRESENTING SPONSOR

Google DeepMind

### Platinum Sponsors

[0:10](https://www.youtube.com/watch?v=yUmS-F9IX90&t=10s) [Platinum sponsors Braintrust, WorkOS and OpenAI on black.](https://assets.ai.engineer/sites/aiecode2025/sha256/89dc1308e52949084b65e89cafb6c581e795e5db5cb5cd74c4cd0e87c4fc8258.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### The Mass Psychosis Problem

The speaker describes feeling surrounded by robots breezing through work, leaving people confused about whether they should be running many agents too.

[0:41](https://www.youtube.com/watch?v=yUmS-F9IX90&t=41s) [A slide titled The Mass Psychosis Problem, with the speaker and Google DeepMind branding surrounding it.](https://assets.ai.engineer/sites/aiecode2025/sha256/c186d0941eed21e2806a53d67cc8c0c8b1796b137dd9088a66bc8c431723d8f2.webp)

The Mass Psychosis Problem

AIE
AI Engineer EUROPE 2026
Google DeepMind

### The Mass Psychosis Problem

The speaker describes the confusion of choosing between letting 15 agents run and reading every line of code while others seem to race ahead.

[1:02](https://www.youtube.com/watch?v=yUmS-F9IX90&t=62s) [A slide titled The Mass Psychosis Problem, with the speaker and an event slogan surrounding it.](https://assets.ai.engineer/sites/aiecode2025/sha256/734fc527b75efb782441a666e27a715ea39a0afa0e99483785d2fdc4efd90afc.webp)

The Mass Psychosis Problem

AIE

AI Engineer
EUROPE
2026

Engineering the future of AI

### The Mass Psychosis Problem

The speaker describes the FOMO of choosing between running many agents and reading every line of code. He urges builders to slow down and balance speed with the care needed to take useful agents to production.

[1:09](https://www.youtube.com/watch?v=yUmS-F9IX90&t=69s) [A slide titled The Mass Psychosis Problem, with the speaker and platinum sponsor logos surrounding it.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea17dd0f99a88ac3e3e85e16e97adeebcd949c42fda0d3ee579dc4b8a76de155.webp)

The Mass Psychosis Problem

Interface text:
AIE
AI Engineer
EUROPE
2026
Braintrust
WorkOS
OpenAI

[1:24](https://www.youtube.com/watch?v=yUmS-F9IX90&t=84s) [A slide titled “The Mass Psychosis Problem.”](https://assets.ai.engineer/sites/aiecode2025/sha256/9457c7cfebc0750e2a693e47fedde4db4d09cb6ec43a75948e7d6802376085b5.webp)

The Mass Psychosis Problem

Interface text:
AIE
AI Engineer
EUROPE
2026
AI Engineer
EUROPE

### Local Build Example

The agent reports a static export of 74 pages and 2,372 files, with warnings but no errors. The speaker presents the interface as one of three similar-looking coding-agent examples.

[1:49](https://www.youtube.com/watch?v=yUmS-F9IX90&t=109s) [A coding-agent interface reports a successful local build and summarizes its steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/6360135d7563ee88b7cdc932a80ab730723a050e5a0f2cb6991e886f636693d1.webp)

build this locally

Environment ready
Worked for 3m 22s

The build completed successfully with no errors. There are no code changes to commit since the build only produced output artifacts that are already listed in .gitignore.

Here's a summary of the local build:

Environment setup:
• Installed Node.js v18.9.0 (required by the project's engines field)
• Installed pnpm 8.1.1 (required by packageManager field)
• Ran pnpm install to install all dependencies

Build steps completed (pnpm run build):
1. build:cache - Generated blog/post cache files into public/data/
2. build:feed - Generated RSS/Atom/JSON feed files
3. next build - Compiled the Next.js application (linting + type checking passed with only warnings, no errors)
4. next export - Static HTML export to /workspace/out/ (74 pages, 2,372 total files)
5. next-sitemap - Generated sitemap at https://about.sourcegraph.com/sitemap.xml

The build produces only warnings (array index keys, promise-returning functions in void attributes, etc.) but no errors.
All output is in .gitignore so there are no files to commit.

Interface text:
New Agent
Marketplace
cline/kanban
arafatkatze/about
Local build setup
arafatkatze/arafatk.github.io
arafatkatze/arafatkatze.gith...
arafatkatze/cline
cline
Open Workspace
AIE
AI Engineer EUROPE

### Authentication Migration Example

A coding agent begins a REST-to-gRPC migration by exploring the service and auditing authentication middleware. The speaker presents the screen as one of three similar agent interfaces.

[1:56](https://www.youtube.com/watch?v=yUmS-F9IX90&t=116s) [A coding-agent interface explores an authentication service for migration from REST to gRPC.](https://assets.ai.engineer/sites/aiecode2025/sha256/31e3588991981f65f5c90643aa09c49c010d958b0c7604043c2e8c3f9d6aa44a.webp)

Migrating Auth Service to gRPC with Protobuf

Migrate the auth service from REST to gRPC. Keep the REST endpoints working as a fallback.

Let me start by exploring the current auth service structure.

• Explore codebase structure
• Audit auth middleware usage across the codebase

Good — the existing REST service has four endpoints: POST /auth/login, POST /auth/register, POST /auth/validate-token, and POST /auth/refresh-token.

Let me check where that middleware is consumed before I start the proto definitions.

• Grep [illegible]

Interface text:
+ New
Search
SESSIONS
acme-productions
Migrating Auth Service to gRPC wit...  Now
Implement dashboard from Figma  2m
Building Multi-Tenant Data Pipeline...  4m
Refactoring Event-Driven Architecture...  10m
Designing Rate Limiter with Redis...  1h
acme-web
Fixing Hydration Mismatch in Product C...  2d
Migrating from Webpack to Vite  2d
Adding Dark Mode Toggle with CSS...  3d
backend
local-demos
AI Engineer EUROPE

### Four Levels of Building Agents

Start with a framework to test the idea, then build a state machine to learn architecture. Kanban makes the workflow observable; shipping to the cloud introduces scale and production operations.

[2:17](https://www.youtube.com/watch?v=yUmS-F9IX90&t=137s) [A table lists four levels: use a framework, build a state machine, use Kanban, and ship to the cloud, with lessons for each.](https://assets.ai.engineer/sites/aiecode2025/sha256/bf31502a4e66ba590004ed23c81f7565382c9c0a58cf26a72219e032c68aef70.webp)

Level | What You Do | What You Learn
1 | Use a framework | How agents work at a surface level
2 | Build it yourself as a state machine | Architecture, modularity, model-independence
3 | Kanban the flow | Observability, debugging, systems thinking
4 | Ship to the cloud | Parallelization, scale, production operations

Interface text:
AIE
AI Engineer EUROPE
2026

### Four Levels of Building Agents

Start with a framework to test an idea, then build a state machine, manage the workflow with Kanban, and ship to the cloud for scale and production operations.

[2:37](https://www.youtube.com/watch?v=yUmS-F9IX90&t=157s) [A table lists four levels of building agents and what each teaches.](https://assets.ai.engineer/sites/aiecode2025/sha256/aa042a9e8f5bcf88b3a004854ead221281e14ceb6d5ad11ef0439800b664c461.webp)

Level | What You Do | What You Learn
1 | Use a framework | How agents work at a surface level
2 | Build it yourself as a state machine | Architecture, modularity, model-independence
3 | Kanban the flow | Observability, debugging, systems thinking
4 | Ship to the cloud | Parallelization, scale, production operations

AIE
Engineering the future of AI
AI Engineer EUROPE 2026

### AI Agent Frameworks

The speaker recommends frameworks for getting an agent working quickly, but argues that production systems may outgrow their customization and modularity.

[3:04](https://www.youtube.com/watch?v=yUmS-F9IX90&t=184s) [A graphic names LangChain, LangGraph, CrewAI, AutoGen, and LlamaIndex as AI agent frameworks.](https://assets.ai.engineer/sites/aiecode2025/sha256/640fdde592c7746379055de7e30097e45354816581e4a8d7f032ea4861bd915a.webp)

AI Agent Framework

LangChain
LangGraph
crewai
CrewAI
AutoGen
LlamaIndex

Top 5 Agentic AI Agent Frameworks for Agency Automation 2026

AIE
AI Engineer
EUROPE
2026
Engineering the future of AI

[3:37](https://www.youtube.com/watch?v=yUmS-F9IX90&t=217s) [Slide listing LangChain, LangGraph, CrewAI, AutoGen and LlamaIndex.](https://assets.ai.engineer/sites/aiecode2025/sha256/d5b8ade7fa313f005911398504d970c5f26341e2700e089c6191d387bf718772.webp)

AI Agent Framework

LangChain
LangGraph
crewai
CrewAI
AutoGen
LlamaIndex

Top 5 Agentic AI Agent Frameworks for Agency Automation 2026

AIE
AI Engineer
EUROPE
2026

### Agent State Machine

An agent loops through model requests and tool calls, adding results or user input to context. After presenting results, it can loop on feedback or finish when the user is satisfied.

[4:40](https://www.youtube.com/watch?v=yUmS-F9IX90&t=280s) [Flowchart showing a recursive agent loop with tool calls, user input, completion and new-task branches.](https://assets.ai.engineer/sites/aiecode2025/sha256/e49e6a4a4e85311f2673d18e699add8a494c8d61d5fdf1c6de855a6a720ba122.webp)

User Task
Recursive Loop
API Request
LLM Response
Tool Call?

Always Continue
Action Tools
Add Result to Context

Wait and Continue
Question Tools
Wait for User Input
Add Response to Context

No Tool
Force Tool Use

Completion
attempt_completion
Present Results
User Response?
Provides Feedback
Add Feedback to Context
Satisfied
Task Complete

New Task
new_task
Ask User
User Choice?
Create New Task
End Current
Provide Feedback
Add Feedback to Context

AIE
Engineering the future of AI

### Rule 2: Additions Can Make an Agent Worse

The speaker argues that long system prompts, edge cases, and if/else logic can make frontier models perform worse. He urges builders to keep instructions simple.

[5:53](https://www.youtube.com/watch?v=yUmS-F9IX90&t=353s) [Slide states that every addition to an agent risks making it worse.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f1c19771f30f31649a0ce1150707b83ead08fe2c29b3f39e18ade242223725c.webp)

Rule 2: Every single thing you add to an agent risks making it worse

Interface text:
AIE
AI Engineer EUROPE
AI Engineer EUROPE 2026

### Rule 2: Additions Can Make an Agent Worse

Too many instructions can overwhelm a frontier model. The speaker recommends pruning agent logic and says his team rewrote Cline to remove baggage from older versions.

[6:37](https://www.youtube.com/watch?v=yUmS-F9IX90&t=397s) [Slide states that every addition to an agent risks making it worse.](https://assets.ai.engineer/sites/aiecode2025/sha256/aaf1748668ea0d028ed190bd844383c78cf5fa2f9abb95e1352c05e18cceee6f.webp)

Rule 2: Every single thing you add to an agent risks making it worse

AIE
Engineering the future of AI
AI Engineer EUROPE 2026

### Rule 3: Agents in a Pseudo RL Pipeline

Give an agent a CLI so other coding agents can build and test it easily as part of a pseudo-RL pipeline.

[7:18](https://www.youtube.com/watch?v=yUmS-F9IX90&t=438s) [Slide calls for making agents easy to include in a pseudo reinforcement-learning pipeline.](https://assets.ai.engineer/sites/aiecode2025/sha256/1e45c32252cab419951a7e92e96f4585970ae654079ec3ddc8fff1e74d71a285.webp)

Rule 3: Make agents trivially easy to be a part of a psuedo RL pipeline.

AIE
AI Engineer EUROPE 2026
Engineering the future of AI

[7:37](https://www.youtube.com/watch?v=yUmS-F9IX90&t=457s) [Slide stating that agents should be easy to include in a pseudo-RL pipeline.](https://assets.ai.engineer/sites/aiecode2025/sha256/e3c64fa13a56b0546e9bacc273a8695e225f9c9fe513384c00263ba36d99e751.webp)

Rule 3: Make agents trivially easy to be a part of a psuedo RL pipeline.

AIE
AI Engineer EUROPE 2026
Google DeepMind

### A Kanban interface for parallel agents

Ara’s March 26 post proposes a Kanban board to track parallel agents, citing inference waits of 8–10 minutes and merge conflicts when agents work on the same code.

[11:20](https://www.youtube.com/watch?v=yUmS-F9IX90&t=680s) [A March 26 post proposes a Kanban board to manage parallel agents and discusses inference delays and isolated work.](https://assets.ai.engineer/sites/aiecode2025/sha256/397b08074e829fd77316c20c67e6225a2443c315cb70d0818b626780e80a18d0.webp)

March 26

Calling it now, This form factor of multi agent orchestration will overtake every other agentic UX in the next six months. Doesn’t matter if it’s coding agent, product management agent or something else.

Every multi agent flow of frontier models currently suffers from 2 main problems

1. Inference bound: Most of the time you are just waiting on inference while the agent rips on code in the background and that can take 8-10 minutes fairly regularly so the wait time very expensive productivity wise.
2. Take Isolation: you will work on the same mutating “source code” with multiple agents in parallel each of which are inference bound and so eventually you will run into countless merge conflicts

The kanban board solves for both of them by giving you the ability to act as an engineer manager for your IC individual agents, watching them cleanly with a clear headline level out look of every parallel agent. It works seamlessly with any coding agent whether it’s cline or codex or Claude code.

To me this is a mental model shift that takes 10 minutes, you use the same coding agents like you always used before this but it will fundamentally morph your coding agent experience. Try out kanban and let us know what you think.

npm i -g cline

Is all you need.

Interface text:
Pinned
Ara
@arafatkatze
AIE
AI Engineer EUROPE

### Agent Kanban board

The board puts four tasks in Backlog and one completed task in Review. The speaker proposes Kanban as a way to monitor agents at a glance and coordinate tasks that depend on one another.

[11:25](https://www.youtube.com/watch?v=yUmS-F9IX90&t=685s) [A Kanban board shows backlog tasks, an empty in-progress column, and a completed task in review.](https://assets.ai.engineer/sites/aiecode2025/sha256/81b0c887cecaea43fa8d0eb3c90606d5073553318554699348dac8692e452174.webp)

Backlog 4
Create task (c)

Explore the project by reading three files and then summarizing what you find, then fixing a function.
Cancel Auto-trash

Add a darkmode toggle to the stormwatch app. Context:- Next.js 16 app with Tailwind CSS v4, React 19, App Router. - Currently dark mode is... See more

Use custom favicon and replace the default Next.js favicon at src/app/favicon.ico with a weather-themed icon (e.g., a storm cloud or lightning bolt). Also... See more

Add unit conversion support (Fahrenheit/Celsius) to the weather display. Add a temperature unit toggle to the settings page at... See more

In Progress 0

Review 1
Add a loading skeleton component for the current weather display. Create a new component... See more
Done. Created `src/components/weather-skeleton.tsx` with `animate-pulse` placeholder blocks matching the `CurrentWeather` layout (description text, temperature, feels-like, weather icon, and four stat items). The...
~/.cline/worktrees/5f728/stormwatch [illegible]
[illegible] (2 files +25 -5)
Commit
Open PR

Interface text:
~/Desktop/stormwatch
Open
main
(1 file +9 -0)
AIE
AI Engineer EUROPE
2026

### Agent Kanban board return

The board places four tasks in backlog and a completed loading skeleton in review. The speaker proposes running agents in parallel while others work for eight to ten minutes.

[11:35](https://www.youtube.com/watch?v=yUmS-F9IX90&t=695s) [The same Kanban board shows backlog tasks and a completed task in review.](https://assets.ai.engineer/sites/aiecode2025/sha256/badf86c884bec56e699d2ac6e2a736db07900b302fd236f246b97d0576cdfadf.webp)

Backlog 4

Create task (c)

Explore the project by reading three files and then summarizing what you find, then fixing a function.
Cancel Auto-trash

Add a darkmode toggle to the stormwatch app. Context:- Next.js 16 app with Tailwind CSS v4, React 19, App Router. - Currently dark mode is... See more

Use custom favicon and replace the default Next.js favicon at src/app/favicon.ico with a weather-themed icon (e.g., a storm cloud or lightning bolt). Also... See more

Add unit conversion support (Fahrenheit/Celsius) to the weather display. Add a temperature unit toggle to the settings page at... See more

In Progress 0

Review 1

Add a loading skeleton component for the current weather display. Create a new component... See more

Done. Created `src/components/weather-skeleton.tsx` with `animate-pulse` placeholder blocks matching the `CurrentWeather` layout (description text, temperature, feels-like, weather icon, and four stat items). The...

~/.cline/worktrees/5f728/stormwatch
[illegible] (2 files +25 -5)
Commit
Open PR

Interface text:
~/Desktop/stormwatch
Open
main
1 file +9 -0
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Kanban proposal revisited

Ara proposes a Kanban board to monitor parallel agents while isolating their work: an agent’s 8–10 minute inference wait leaves time to run others, but shared source code can cause merge conflicts.

[11:46](https://www.youtube.com/watch?v=yUmS-F9IX90&t=706s) [The March 26 post about using a Kanban board to manage parallel agents returns.](https://assets.ai.engineer/sites/aiecode2025/sha256/d70e8fd6471729ad182daf4985ae1a26f5dcf210b42e62990ecd96f2a4cd1028.webp)

Pinned
Ara
@arafatkatze

Calling it now, This form factor of multi agent orchestration will overtake every other agentic UX in the next six months. Doesn’t matter if it’s coding agent, product management agent or something else.

Every multi agent flow of frontier models currently suffers from 2 main problems

1. Inference bound: Most of the time you are just waiting on inference while the agent rips on code in the background and that can take 8-10 minutes fairly regularly so the wait time very expensive productivity wise.
2. Take Isolation: you will work on the same mutating “source code ” with multiple agents in parallel each of which are inference bound and so eventually you will run into countless merge conflicts

The kanban board solves for both of them by giving you the ability to act as an engineer manager for your IC individual agents, watching them cleanly with a clear headline level out look of every parallel agent. It works seamlessly with any coding agent whether it’s cline or codex or Claude code.

To me this is a mental model shift that takes 10 minutes, you use the same coding agents like you always used before this but it will fundamentally morph your coding agent experience. Try out kanban and let us know what you think.

npm i -g cline

Is all you need.

March 26

Interface text:
AIE
Engineering the future of AI
AI Engineer EUROPE 2026

### Managed Agents development board

The board instructs users to drag a ticket into In Progress to start an agent. The active website optimization task shows the agent’s edits in an activity log.

[12:52](https://www.youtube.com/watch?v=yUmS-F9IX90&t=772s) [A video shows a development board with backlog, in-progress, review, and done columns.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c742b19d3250d70d06322449017d146b47a6864318bb3cb0931499fc1677dd8.webp)

Development Board
Managed Agents — Drag tickets to “In Progress” to start an agent
Agents Online

BACKLOG 2
TICKET-2 · MEDIUM
SaaS pricing audit and weekly report
Track pricing and plan changes across the SaaS tools our company uses. Search th...
Research

TICKET-3 · HIGH
Incident response: API latency spike
ALERT: P1 — API response times spiked to 4200ms (threshold: 500ms) at 2026-04-...
Incident

IN PROGRESS 1
TICKET-1 · 0:22
Optimize website performance
Running: edit
SCORE 62 → 62
Hide log
Running: edit
Updated all <img> tags: src changed to .webp, added loading='lazy' to below-the-fold images
Adding defer to script tags and removing unused JavaScript...
Running: edit
Session: [illegible]

REVIEW 0
No tasks

DONE 0
No tasks

Interface text:
localhost:8000
Managed Agents
kanban-demo
Search tasks, sessions, or IDs...
Sessions
Board
Memory Store
Settings
API Docs
Support
What is Claude Managed Agents?
Claude
145K subscribers
Subscribe
2.6K
Share
Ask
Save
80,179 views 10 hours ago
Claude Managed Agents is a suite of APIs for building production-ready agents. You define the tools, environments, and success criteria. Claude works until the job is done.
AI Engineer EUROPE

### The Kanban as an Engineering Manager

A Kanban view would help an engineering manager monitor parallel agents, link dependent cards, and review changes by clicking a card after its agent finishes.

[13:04](https://www.youtube.com/watch?v=yUmS-F9IX90&t=784s) [A slide lists agent visibility, monitoring, dependency chains, and diff review as Kanban benefits.](https://assets.ai.engineer/sites/aiecode2025/sha256/520cd7079d9483fda380d075e92b35c7563157a531dafbdd100c9d5535a509d2.webp)

The Kanban as an Engineering Manager

• A clear headline level outlook of every parallel agent: what it's working on, where it is, whether it's stuck
• The ability to watch agents cleanly without context-switching into each one's terminal
• Dependency chains: link cards together so that work flows through in the right order, autonomously
• Diff review on click: when an agent finishes a task, you click the card and review what changed

Event branding: AIE; AI Engineer EUROPE; 2026

### Level 4: Ship It to the Cloud

Level 4 asks how a useful, tested agent can scale to many tasks and users by moving it to the cloud.

[13:22](https://www.youtube.com/watch?v=yUmS-F9IX90&t=802s) [Section title: Level 4: Ship It to the Cloud: Parallelized, Production-Grade.](https://assets.ai.engineer/sites/aiecode2025/sha256/695075064149d0cfd4647b4b2e924687dafd8cba33ea33c72cd9232928fd6685.webp)

Level 4: Ship It to the Cloud: Parallelized, Production-Grade

Interface text:
AIE
AI Engineer
EUROPE
AI Engineer
EUROPE
2026

### Benefits of cloud agents

Cloud agents run tasks in parallel with their dependencies in the cloud. APIs start, monitor, and stop agents as the workload grows.

[13:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=839s) [A slide lists parallelizability, no local dependencies, programmatic orchestration, and horizontal scaling.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6ffdd19973bb75b1928d18486bca95f84dcb0f560c4082b036e781b5bb11407.webp)

• Complete parallelizability: spin up ten instances, fifty, a hundred, each working on a different task or a different branch of the same task
• No local dependencies: everything the agent needs is available in the cloud environment
• Programmatic orchestration: agents are spun up, monitored, and torn down via APIs, not human intervention
• Horizontal scaling: more work doesn't mean a bigger agent, it means more agents

Other visible text:
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

[14:48](https://www.youtube.com/watch?v=yUmS-F9IX90&t=888s) [Slide lists parallelizability, cloud dependencies, programmatic orchestration, and horizontal scaling.](https://assets.ai.engineer/sites/aiecode2025/sha256/47659b00a44a54c3fe3a87fab1314acf739eadf306a29d67923d57c8a587a996.webp)

• Complete parallelizability: spin up ten instances, fifty, a hundred, each working on a different task or a different branch of the same task
• No local dependencies: everything the agent needs is available in the cloud environment
• Programmatic orchestration: agents are spun up, monitored, and torn down via APIs, not human intervention
• Horizontal scaling: more work doesn't mean a bigger agent, it means more agents

Other visible text:
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Cloud computing illustration

Spacecraft stream around glowing clouds as the speaker describes sending tasks to cloud machines, pulling down a PR later, and sharing a common setup across collaborators.

[15:22](https://www.youtube.com/watch?v=yUmS-F9IX90&t=922s) [Illustration of glowing clouds and streams of small spacecraft against a starry background.](https://assets.ai.engineer/sites/aiecode2025/sha256/48b10c1f12fb7201cb2002dcc9566b0659abcac85d37611a658c811adfe9323f.webp)

AIE

AI Engineer
EUROPE

AI Engineer

### Four levels of building agents

The speaker treats the levels as rough heuristics: frameworks teach agents at a surface level; state machines and Kanban develop architecture and observability skills; cloud deployment adds scale and production operations.

[15:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=959s) [Table compares using a framework, building a state machine, using Kanban, and shipping to the cloud with what each level teaches.](https://assets.ai.engineer/sites/aiecode2025/sha256/8d74e830fdcd9ff70750b853f1b697efd55a2a36c8cc11260406c9bc10991d09.webp)

Level | What You Do | What You Learn
1 | Use a framework | How agents work at a surface level
2 | Build it yourself as a state machine | Architecture, modularity, model-independence
3 | Kanban the flow | Observability, debugging, systems thinking
4 | Ship to the cloud | Parallelization, scale, production operations

AIE
Google DeepMind
AI Engineer
EUROPE
2026

## Full transcript

[0:00](https://www.youtube.com/watch?v=yUmS-F9IX90&t=0s) [upbeat music] Hi there.

[0:15](https://www.youtube.com/watch?v=yUmS-F9IX90&t=15s) Um, very nice to see you guys. Um, it's, it's, like, it's so interesting to see, like, it's been such a long day, and you guys still showed up. And, uh, I'm always very flattered when, like, I'm trying to present something and, like, people are there.

[0:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=29s) It just, uh ... I- I- It f- it makes you feel like what you do matters. So today, the topic that I wanna talk about is, like, don't build slop: Four levels of AI agent maturity.

[0:39](https://www.youtube.com/watch?v=yUmS-F9IX90&t=39s) And what I'm trying to do here is that I wanna ... I'm gonna talk about something that, like, a lot of people have brought this up to me, and there's like a mass psychosis problem.

[0:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=47s) So basically, it's something like ... It's like every person feels like, um, there's, like, this, like, giant set of robots around all of you that are just, like, kind of like breezing through, doing a lot of things.

[0:58](https://www.youtube.com/watch?v=yUmS-F9IX90&t=58s) And, and you're, like, in the middle, and you're so confused. You're so confused of, like, what is this? What, what should I do? Should I have, like, 15 agents, like, ripping through all the time and I'm just, like, vibing?

[1:10](https://www.youtube.com/watch?v=yUmS-F9IX90&t=70s) Or, or should I just be like a peasant and just, like, read through every line of code? And it's, it's very hard to, like, make up your mind. I feel like you come to a place like this, and you're always ...

[1:19](https://www.youtube.com/watch?v=yUmS-F9IX90&t=79s) Like, the FOMO just, like, gets to you. You get, like, a panic attack or something. But, like, I think, I think ... I wanna ... I kinda wanna pull back out of this, and I wanna be like, "Guys, let's slow down.

[1:28](https://www.youtube.com/watch?v=yUmS-F9IX90&t=88s) Let's just slow down, and let's think through, like, what are the problems that we can, like, actually solve that will, like, actually help you build, like, really useful agents?"

[1:36](https://www.youtube.com/watch?v=yUmS-F9IX90&t=96s) And I wanna a- take care of, like, every end of the spectrum of, like, your necessity to build things really fast, but at the same time, like, your necessity to, at a certain point, build things slow and take things to production.

[1:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=107s) So that, that's basically, um, the goal. To give you an example of, like, mass psychosis, like there's a lot of things that are very similar. So I'll give, give you example of, like, three UIs.

[1:56](https://www.youtube.com/watch?v=yUmS-F9IX90&t=116s) And these are three frontier labs. And I guarantee you, not one of you can predict which one is which. Uh, one of them is Factory, one of them is Codex, and one of them is Cursor.

[2:05](https://www.youtube.com/watch?v=yUmS-F9IX90&t=125s) I, I am positive none of you know which one is which. Even I don't know which one [chuckles] is which. But yeah. So that's why I say the point. Like, everything is same.

[2:12](https://www.youtube.com/watch?v=yUmS-F9IX90&t=132s) You, you wanna do your own thing. So to build agents in particular, uh, here's what, here's, here's what I would, would present here, that I wanna break down the problem of building agents into, like, four different parts.

[2:23](https://www.youtube.com/watch?v=yUmS-F9IX90&t=143s) The first part is just, like, trying to somehow figure out a way to, like, see if this even makes sense, like this even works. That's, like, where you use a framework.

[2:31](https://www.youtube.com/watch?v=yUmS-F9IX90&t=151s) The second part is, like, when you actually are serious. Like, okay, I actually wanna do something here. Now you build things by yourself, like, as, like, a state machine, like building an actual agent.

[2:40](https://www.youtube.com/watch?v=yUmS-F9IX90&t=160s) The third part is, like, the UX workflow, where you use Kanban, which I suggest is, like, a great, uh, form factor to be able to work with agents. And the fourth part would be, like, shipping to cloud.

[2:50](https://www.youtube.com/watch?v=yUmS-F9IX90&t=170s) So this is, like, mostly out- outline read of, like, how we wanna be able to, uh, work with agents, but I think it will give you a good heuristics of, like, how you, how you would, uh, solve this problem.

[3:00](https://www.youtube.com/watch?v=yUmS-F9IX90&t=180s) So level one of building agents is, like, literally just, like, just, just use a framework. And I, I think there's, like, a couple different frameworks, uh, like LangChain, LangGraph.

[3:08](https://www.youtube.com/watch?v=yUmS-F9IX90&t=188s) Like, I, I wouldn't ... I don't use them. I, I, I work at, like, Cline. I've, I've ... I'm supposed to, like, write all the agentic experience stuff by myself, so why would I use a framework?

[3:18](https://www.youtube.com/watch?v=yUmS-F9IX90&t=198s) So I won't be the best person to give you advice. But I do think that if you're trying to find PMF, if you have a problem that's like, "Hey, I have this problem where I wanna be able to, I don't know, aggregate emails or do something, like, rudimentary, and I think that, like, an AI agent would probably

[3:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=212s) be helpful here. I probably don't care about the best model. I just, I just want something that works." Any of the agent frameworks can give you something that just works in, like, half an hour.

[3:39](https://www.youtube.com/watch?v=yUmS-F9IX90&t=219s) You can just vibe code this. It, it, it's, it's a great thing to get started. It's a great thing to see that agents actually do work and that you can build them yourself.

[3:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=227s) There are a lot of pitfalls with, uh, using frameworks, and one of the biggest ones that I think is that, like, if you really want to take things to production, if you really wanna build something serious, very quickly you'll learn that, like, the level of customizability, the level of, like, futuristicness, the level of, um, modularity that you

[4:07](https://www.youtube.com/watch?v=yUmS-F9IX90&t=247s) need, you just ... you won't find them in a framework. I know a lot of people will disagree with me, and a lot of those people are wrong. Anyway [chuckles], um, so level two is, like, building, building your agents yourself, right?

[4:17](https://www.youtube.com/watch?v=yUmS-F9IX90&t=257s) So here's how you, here's how you build. You, like ... I feel like, I feel like this is, like, a very intricate problem. Like, I can't sum this down.

[4:22](https://www.youtube.com/watch?v=yUmS-F9IX90&t=262s) So I'll, I'll just, like, give you, like, five rules of, like, when you actually write code to build your agents, like, there, there are five rules that you could use.

[4:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=269s) Um, and these rules will, like, give you a rough outline of, like, how to, how to build and write, write code for your own agent. So the first one is, like, you always wanna think of every agent as, like, a state machine.

[4:40](https://www.youtube.com/watch?v=yUmS-F9IX90&t=280s) Um, state machine, it's, like, a sophomore year or freshman year topic. But, like, state machine is basically, like, every agent is, at, at the end of the day, is like a recursive loop.

[4:48](https://www.youtube.com/watch?v=yUmS-F9IX90&t=288s) That's, that's basically ... Like, every, every, every hype cycle, whatever you think, it's at the end of the ... It's all a recursive while loop. It's a while loop with a few conditions.

[4:55](https://www.youtube.com/watch?v=yUmS-F9IX90&t=295s) And no matter what your agent's doing, it, it always ... It doesn't matter it's Cursor, Claude, or whatever, it is a while loop with a few conditions and a few end states.

[5:02](https://www.youtube.com/watch?v=yUmS-F9IX90&t=302s) And what you wanna be able to do is that at any point of time, you wanna be able to have, like, a mental model of which point in the state it is.

[5:11](https://www.youtube.com/watch?v=yUmS-F9IX90&t=311s) So let's say you wanna be able to, like, say, um ... Okay. So let's say you wanna be able to, uh, I guess, read a few files and explain them, uh, through Claude Code.

[5:22](https://www.youtube.com/watch?v=yUmS-F9IX90&t=322s) So it starts from the user task at the top where you ask it, like, "Read a few files." It goes to the state of, like, reading a few files in, like, the action tool where it reads the file.

[5:30](https://www.youtube.com/watch?v=yUmS-F9IX90&t=330s) Then it realize, "Oh, I have read the file. It makes sense." And then it will call the completion tool and just, like, complete. And the, the right, right thing at the bottom, task complete, is when the state machine finishes.

[5:39](https://www.youtube.com/watch?v=yUmS-F9IX90&t=339s) Uh, you can take this in a very complex way where you can, like, rip through the whole state machine for, like, eight to 10 minutes or even, like, hours if you wanted to.

[5:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=347s) Uh, but essentially, every agent is a state machine. And if you can visualize that as a mental model, then every time you're building an agent, it will be so much easier for you to think through that.

[5:55](https://www.youtube.com/watch?v=yUmS-F9IX90&t=355s) Um, the second rule is that every single thing you add to an agent risks making it worse. I think this is the hardest thing that we've learned, and it has been a very bitter lesson that a lot of agent builders have learned, which is that large system prompts, lots of different edge cases, lots of different, like, fancy

[6:12](https://www.youtube.com/watch?v=yUmS-F9IX90&t=372s) if/else logic, all of that for frontier model just, just makes them worse Just like, just, just get out of the way of the model is the, is the lesson that we learned, which is that, like, frontier models are so good at their job that the less instructions you give them, they actually perform better.

[6:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=389s) A classic example is that if you go through the Codex repo, the prompt for GPT-5 versus the prompt for GPT-5.3 is one-third of the size. Uh, part of the reason for that is that the newer models are so good at their job that giving them too many instructions and longer system prompts, it leads to a sensory overload

[6:45](https://www.youtube.com/watch?v=yUmS-F9IX90&t=405s) where they get so many instructions that they get overwhelmed and can't figure out what the right thing to do. Um, so I think the simpler it is, it's always better, and it's like you have to think that, like, every single thing I'm adding, I, I'll be very careful that I'm-- I, I hope to God I'm not making

[6:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=419s) it worse, and just always try to prune it down. We, we took it so far where we literally rewrote the entirety of Cline because we realized there was so much, uh, junk from the older, older versions of Cline.

[7:10](https://www.youtube.com/watch?v=yUmS-F9IX90&t=430s) Claude code has been written, I think, at, at least seven times from scratch, I think. Um, but again, um, the, the, the people of the team might know better.

[7:19](https://www.youtube.com/watch?v=yUmS-F9IX90&t=439s) Um, the third rule is that you wanna be able to make agent an easy part of a pseudo RL pipeline. And this is a tricky one, but basically what this means is that anytime you're building an agent, you wanna be able to have some sort of like a CLI kind of a thing.

[7:34](https://www.youtube.com/watch?v=yUmS-F9IX90&t=454s) The reason for that is that as long as you have something that can build and test the agent really well in the form of a CLI, um, you wanna be able to build things that are very easy to build and test with, um, other coding agents.

[7:49](https://www.youtube.com/watch?v=yUmS-F9IX90&t=469s) So right now there's this thing, there's this, like, interactive dance that's happening between AI and humans where at-- in the back in the day, humans used to, like, guide AI, like, do this.

[7:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=479s) And I think at this point, we're at a point where humans are being guided by AI. And this is, I think, is a part of that where, like, if you're as a human, you wanna be able to build things in such a way that, like, the AI can work very easily through it.

[8:10](https://www.youtube.com/watch?v=yUmS-F9IX90&t=490s) So that might entail writing a- writing, you know, AGENTS.md the right way using the right skills, and building like a CL- CI or, or CD, um, such that like the agent, other coding agents can easily build your agent, test it, make changes to it, and then test it end-to-end is a very critical part.

[8:27](https://www.youtube.com/watch?v=yUmS-F9IX90&t=507s) Because that way, if you wanna make changes, you can just let, let a long-running agent run through in a parallel thread. It'll make all those changes, test it, and you have the whole thing running.

[8:35](https://www.youtube.com/watch?v=yUmS-F9IX90&t=515s) But if it's harder to build and test, it, it would also be harder for you to, like, use agents to work on your agent. Um, super meta. Um, rule number four, don't build slop.

[8:45](https://www.youtube.com/watch?v=yUmS-F9IX90&t=525s) Guys, don't. Please, for the love of God, don't, don't, don't build slop, please. I think that, I think that there's, there's like, there's so much like throughput that you can get and so much, uh, tokens that can go through really, really fast.

[8:58](https://www.youtube.com/watch?v=yUmS-F9IX90&t=538s) I think that the best lessons that we've learned as like real engineers is that, like, it's really worth spending some time just like thinking through the architecture, thinking through the design and the outline of what your agent's supposed to do, making sure it actually makes sense and, uh, and just like actually at least spend some time reading

[9:16](https://www.youtube.com/watch?v=yUmS-F9IX90&t=556s) the code, even if you don't write everything m-- by hand. I think that that is like, for us, we found that that to be super critical because I think that it, it's at least the architecture point of building an agent has to be done by a human and has to be done like very thoughtfully.

[9:30](https://www.youtube.com/watch?v=yUmS-F9IX90&t=570s) Even if you're using like an agent to have a conversation with it, spend a lot of time like trying to think through like what the architecture, what the state machine is going to be.

[9:38](https://www.youtube.com/watch?v=yUmS-F9IX90&t=578s) Don't, don't just let like, uh, other models like rip through the code. Um, and then the f-- rule fifth is Frontier labs kinda wanna lock you down, and this is a tricky one.

[9:47](https://www.youtube.com/watch?v=yUmS-F9IX90&t=587s) A lot of people will disagree, but basically what's happening is that a lot of times when you are working with the APIs of Frontier labs, the APIs are trying to lock you down, and they make the interchangeability harder.

[9:58](https://www.youtube.com/watch?v=yUmS-F9IX90&t=598s) So to give a very precise example, the new set of models that have come out, say, Opus 4.6, uh, Gemini 3.1 Pro, 5.3 Codex, they have this thing called reasoning traces.

[10:08](https://www.youtube.com/watch?v=yUmS-F9IX90&t=608s) And reasoning traces are, um, a part of the cache, and they're also the part of the reasoning, uh, uh, test-time compute loop that the model does. And when you have conversations and back-and-forth conversations with those models, you wanna send the reasoning traces in the exact precise format that is expected.

[10:27](https://www.youtube.com/watch?v=yUmS-F9IX90&t=627s) If you don't, the response would still work except that the performance would be degraded, and you would have no way of knowing. And a lot of people are kind of missing on the massive performance gains that are coming from the new models because they're just like not using the APIs in the exact precise way that they're supposed

[10:42](https://www.youtube.com/watch?v=yUmS-F9IX90&t=642s) to be used. Um, and there are asymmetries in the API. So some would argue that, "Hey, maybe you could use OpenRouter," but I don't think that's enough. I think you really wanna be careful that like if you're using different Frontier labs and different, uh, Frontier lab APIs, like they, they have-- you very carefully thought through, uh, if

[10:58](https://www.youtube.com/watch?v=yUmS-F9IX90&t=658s) the API is working correctly and you've actually tested it. Um, so the form factor is like the next step is like the form factor of like how do you like, how do you visualize the agents, right?

[11:09](https://www.youtube.com/watch?v=yUmS-F9IX90&t=669s) So I think originally I came back to like in the one of the previous slides, I tried to show you guys like the thing where like Codex and, uh, Cursor and others, they were all looking the same.

[11:18](https://www.youtube.com/watch?v=yUmS-F9IX90&t=678s) And I think I have a different claim. So for this, uh, uh, on March 26th, I made a tweet, uh, where I said we-- people should use Kanban. So Kanban boards, I think if anyone has used Linear, whatever, I'm sure all of you are familiar with Kanban boards.

[11:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=692s) So my argument is that Kanban boards are the thing, uh, to use. Um, Henzen in the audience was gracious enough to offer me his thoughts as well. So thank you so much.

[11:41](https://www.youtube.com/watch?v=yUmS-F9IX90&t=701s) So Kanban boards are, are, are this idea that like if you're working through an agent, you're always, uh, inference bound. A lot of you are working through like Codex or Opus, and it's working for eight to ten minutes at a time.

[11:53](https://www.youtube.com/watch?v=yUmS-F9IX90&t=713s) When one of the agent is working for eight to ten minutes, what do you do? You could doomscroll, but you can only doomscroll, scroll long. So then you run another agent, right?

[12:03](https://www.youtube.com/watch?v=yUmS-F9IX90&t=723s) So that way you have at least like two or three agents running in parallel at all times because you're inference bound and they're all like mutating the same source potentially.

[12:12](https://www.youtube.com/watch?v=yUmS-F9IX90&t=732s) So you wanna isolate the thing that they're mutating, uh, to take care of that, like the, the, the isolation of state and then the inference bounding. The best UX form factor to me is Kanban board, mainly because it takes care of-- it gives you like-- it makes you like an engineering manager which can look at all your

[12:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=749s) agents. And you ... Gives you, like, a headline-level view of what they are, and it also helps you build, like, flows with them that like, okay, if these two tasks fir- finish first, then I'll do the other task.

[12:40](https://www.youtube.com/watch?v=yUmS-F9IX90&t=760s) And that helps you, like, become, like ... You, you basically become like an engineering manager, and all your agents are your ICs and, and you can, uh, w- uh, look at them through this.

[12:50](https://www.youtube.com/watch?v=yUmS-F9IX90&t=770s) Um, so I was making this claim on March 26, and 10 hours ago Claude Code came out with the same thing, so I believe I was right. Um, um, okay.

[12:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=779s) So yeah, you can use that through Claude Code, Cline, wherever. You can use Cline as well. Whatever, uh, whatever works for you. Um, so yeah. So you wanna think of, like, ca- uh, Kanban as basically like an engineering manager, which y- you would be.

[13:11](https://www.youtube.com/watch?v=yUmS-F9IX90&t=791s) Then there's, like, a final step of, like, okay, you have, you have, like, an agent. You've tested it, you made it, and you, you have a good UX form factor to be able to, like, interface with it and look at it.

[13:23](https://www.youtube.com/watch?v=yUmS-F9IX90&t=803s) Uh, what do you, what do you do then? Like, how do you, how do you, how do you, how do you have an agent that's just, like, useful, it works well, but it, it scales?

[13:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=812s) It really scales to, like, millions of tasks, millions of users. If you're working for a company which has, say, 8,000 people, how do you, like, how do you make sure that, like, all of them can, like, very easily interface with this?

[13:43](https://www.youtube.com/watch?v=yUmS-F9IX90&t=823s) And I think that rather than, rather than, like, making people install and, like, you know, s- having these complex workflows in the machines and stuff, it's just, it's just so much junk and it's so hard.

[13:53](https://www.youtube.com/watch?v=yUmS-F9IX90&t=833s) Just, like, take it all, take it all out. Put, put the hard work once. Just take it all on the cloud. Um, so there are many benefits of cloud agents, but the primary one is that, like, you can completely parallelize and have, like, a separate machine for each of them.

[14:08](https://www.youtube.com/watch?v=yUmS-F9IX90&t=848s) There are, like, no local dependencies. Like, um, in the cloud, like, the agent can set up the environment, do all the UX tasks. Because right now, one of the most missing pieces, the thing that a lot of people are not using, that I use fairly extensively, is cloud agents, because they can really run, uh, really long.

[14:26](https://www.youtube.com/watch?v=yUmS-F9IX90&t=866s) So I, I on my phone often would send tasks that would run on a cloud agent for like 15 to 20 minutes. So let's say it's, like, a UX change of, like, um, go build this, uh, VS Code extension, and this VS Code extension I want you to sign in here, I want you to click on settings,

[14:42](https://www.youtube.com/watch?v=yUmS-F9IX90&t=882s) I wanna change the settings to, um, uh, pick this theme, and then I want you to test this thing in the terminal. And the cloud agents are so good that they will actually manually do all the clicks of the QA testing that I just described on their own, figure out if they worked, and if they didn't work,

[14:59](https://www.youtube.com/watch?v=yUmS-F9IX90&t=899s) it will just keep iterating, keep trying. And this thing could easily take, like, 50 to 60 minutes. But if you send, like, a lot of these tasks in parallel through your phone or through your laptop or whatever, whatever, um, I think you, you have, like, you have this, like, really easy, customizable, extensible thing, and it helps to

[15:18](https://www.youtube.com/watch?v=yUmS-F9IX90&t=918s) scale really fast. And then you could send the, all these tasks, like, running in, like, the, like the cloud machine. Like, you know, like a messiah. And you could come back to your laptop, and then it's like, oh, you could just pull down the PR, and then you've got the whole thing going.

[15:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=932s) Um, the other aspect of, like, cloud, cloud agents is that, like, if you're working with a lot of different people, um, I think that it's just, like, it helps you build, like, a common setup that, like, so many other people can share and so many people can mutate.

[15:46](https://www.youtube.com/watch?v=yUmS-F9IX90&t=946s) Um, so I think bringing that together, I think would be, like, the final form factor. So my f- my claim is that, like, there exists a future where, um, most of the UX of working with agents would be Kanban, and then most of the actual compute, uh, that's involved with, uh, with agents would be on the, on

[16:04](https://www.youtube.com/watch?v=yUmS-F9IX90&t=964s) the cloud. Um, I think these four levels of frameworks are just, like, some ... The last part of, like, you know, Kanban and shipping to cloud, like, those things are very difficult and very intricate problems, and I think that if I were you, I would just, like, use this, like, as, like, rough heuristics and start with, like,

[16:19](https://www.youtube.com/watch?v=yUmS-F9IX90&t=979s) okay, let me just, like, let me just do the bare minimum easy thing and then just, like, depending on how much effort I wanna put in, I will, like, slide up and down, um, up and down these levels.

[16:29](https://www.youtube.com/watch?v=yUmS-F9IX90&t=989s) So yeah. So that's it for me. And yeah. So, um, I, I made a lot of hot takes. I feel like I think I left a lot of, like, open-ended questions here.

[16:38](https://www.youtube.com/watch?v=yUmS-F9IX90&t=998s) If you have any questions for you, any thoughts, this is my Twitter. You're very welcome to reach out to me, send me any questions. And, uh, yeah. Um, it was very, very kind of you guys to give me your time.

[16:49](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1009s) Uh, thank you so much. [audience applauds] May I take a photo of you? All right.

[17:00](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1020s) Okay. All right. Thank you. And do you guys have any questions? It's, like, I've got a minute. [singing]

[17:13](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1033s) All right. This is it. [laughs] Oh. Yeah.

[17:16](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1036s) Um, how do you do planning inside of a Kanban? Uh, like, uh, I, I find the sort of, like, back and forth requirements gathering, you know, the, the, uh, getting the agent to figure out what it wants from me to be the most useful part of the-

[17:30](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1050s) Oh, yeah, yeah, yeah. Yeah, yeah.

[17:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1052s) So how do you handle that?

[17:32](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1052s) Oh, yeah. Let me, let me show you. Let me show you. So basically, like, I think my interpretation of, of, of Kanban is that, like, it's just, like ...

[17:40](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1060s) If you see the screen, like, you can go into any task, and it will give you, like, the entire trace of the task. Uh, and that point, it's like the ...

[17:48](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1068s) So this, this interface that you're looking at is basically, like, um, the actual CLI of Codex. And I think I would ... I, what I, what I usually do is just, like, have a conversation here, and then I know at a certain point that, like, "Bro, you can go out on your own, do your thing."

[18:02](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1082s) At that point I'll just pull out and just focus on other things.

[18:05](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1085s) And then d- does it transition state when it either needs your review or asks you a question?

[18:09](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1089s) Yes. Yes. Yes. So, so initially the phase, like ... It's like, let's say I would say, like, uh, if I say read a few files or whatever, right? Um, so it will be, like, initially it's in, in the in progress state, and then when it's, uh, when it's, like, it needs my input, it will go through review.

[18:25](https://www.youtube.com/watch?v=yUmS-F9IX90&t=1105s) Um, yeah. All right. Thank you. [upbeat music]
