Don't Build Slop (4 Levels of AI Agent Maturity) - Ara Khan, Cline
Summary
Ara Khan, a developer at Cline, delivers a pragmatic talk at AI Engineer Europe 2026 on avoiding low-quality agent development — what he calls "slop" — by following a structured four-level maturity model. Khan opens by diagnosing a "mass psychosis" he observes in the AI engineering community: practitioners feel overwhelmed by the pace of agent tooling, unable to distinguish between products like Factory, Codex, and Cursor, which have converged on nearly identical UIs. His antidote is a deliberate, hierarchical framework for thinking about agent construction.
Level 1 is framework prototyping, where tools like LangChain and LangGraph allow fast proof-of-concept construction in under 30 minutes. Khan acknowledges frameworks' utility for validating product-market fit but argues they are unsuitable for production due to insufficient modularity and customizability.
Level 2 is building agents from scratch, governed by five concrete rules. Rule 1: model every agent as a state machine — a recursive while loop with clearly defined states, actions, and terminal conditions. Khan illustrates with a file-reading agent progressing from user task through tool call to task completion. Rule 2: every addition risks degrading performance. He cites the OpenAI Codex repository as a concrete example, noting the system prompt for GPT-5.3 is one-third the size of the GPT-5 prompt because newer frontier models suffer sensory overload from excessively long instructions. Cline itself has been rewritten at least seven times to prune accumulated prompt bloat. Rule 3: design agents to fit a pseudo-reinforcement-learning pipeline via a CLI interface, enabling other coding agents to build, test, and iterate on your agent in long-running parallel threads — a meta-engineering pattern Khan calls essential for scalability. Rule 4: invest time in architectural design before coding; thoughtful architecture decisions require human judgment and cannot be delegated to generative agents. Rule 5: master frontier model APIs precisely — reasoning traces from models like Claude Opus 4.6 and Gemini 1.5 Pro must be passed back in the exact cache format the model expects or performance silently degrades, a pitfall many developers miss when using abstraction layers like OpenRouter.
Level 3 is UX form factor. Khan argues that Kanban boards are the correct interface for managing parallel agents, because inference-bound workloads — agents running 8 to 10 minutes per task — naturally push practitioners to run multiple agents simultaneously. Kanban gives engineers an "engineering manager" view: headline status per agent, dependency sequencing across tasks, and visibility into full execution traces. Khan notes he publicly predicted on March 26 that Kanban would become the dominant agent UX, and Claude Code shipped an equivalent feature ten hours before this talk.
Level 4 is cloud deployment. Running agents on cloud machines eliminates local dependency management, enables true parallelism with isolated environments per task, and allows long-running workflows (50 to 60 minutes) triggered from a phone. Khan describes dispatching UI automation tasks — click through VS Code extension settings, run terminal tests — entirely to cloud agents that iterate autonomously until the task succeeds, then submit a PR for human review.
Khan closes with the prediction that the steady-state UX for agent work will be Kanban-based orchestration over cloud-hosted compute, with levels 1 and 2 serving as on-ramps rather than end states.
Key Takeaways
- •Model every agent as a state machine — a recursive while loop with explicit states, actions, and terminal conditions — to maintain a clear mental model during development.
- •Every instruction added to a system prompt risks degrading agent performance; frontier models like GPT-5.3 perform better with prompts one-third the size of their predecessors due to sensory overload from verbose instructions.
- •Design agents with a CLI interface from the start so other coding agents can build, test, and iterate on your agent autonomously in parallel threads.
- •Architectural decisions must be made by humans; do not delegate system design to generative agents even if they write the implementation code.
- •Pass reasoning traces back to frontier models (Claude Opus 4.6, Gemini 1.5 Pro) in the exact cache format each API expects — deviating silently degrades performance with no error signal.
- •Use Kanban boards to manage multiple parallel agents: inference-bound workloads (8-10 minutes per task) make running 2-3 concurrent agents a necessity, and Kanban provides headline status and dependency sequencing.
- •Frameworks like LangChain and LangGraph are valid for proof-of-concept and PMF validation but lack the modularity and customizability needed for production systems.
- •Deploy agents to the cloud to eliminate local dependencies, enable true parallelism with isolated environments, and support long-running tasks (50-60 minutes) triggered from any device.
- •Abstract API layers like OpenRouter may obscure model-specific API requirements, creating invisible performance gaps; prefer direct frontier model API integration when performance matters.
- •The predicted steady-state UX for agentic work is Kanban-based orchestration of cloud-hosted agents, with the developer acting as an engineering manager reviewing results rather than executing tasks.
Transcript
All right. Hi there. 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. It just uh I I if it makes you feel like you what what you do matters. So, today the topic that I want to talk about is like don't build slop, four levels of AI agent maturity. And what I'm trying to do here is that I want to I want to talk a...
Related Sessions
