Overview
A post by Ara Khan on Cline’s blog (August 26, 2025) examines three patterns the team views as attractive in theory but unreliable in practice for building coding agents: multi-agent orchestration, RAG over indexed codebases, and prompt over-instruction. The piece grounds its arguments in observed development workflows, references to public write-ups, and changes in model capabilities. It also situates these views within a timeline spanning early “chat with code” extensions in 2023 through model updates in 2024–2025.
1) Multi-Agent Orchestration
The post argues that orchestrating multiple specialized agents tends to amplify failure modes rather than improve real-world outcomes. It points to Anthropic’s engineering write-up on multi-agent research, which describes how small errors can compound and push systems into unpredictable trajectories, widening the gap between prototype and production (https://www.anthropic.com/engineering/multi-agent-research-system?ref=cline.ghost.io). A figure linked from an external article frames agents as microservices with “brains,” but the post maintains that most useful agentic coding work behaves as a single-threaded process under operational constraints (https://seanfalconer.medium.com/ai-agents-are-microservices-with-brains-ccb42d1504d7?ref=cline.ghost.io).
Cline’s position does not rule out narrow use of subagents. Examples include parallel file reads or trivial web fetches. However, the post suggests these patterns are functionally similar to parallel tool calls and may not constitute “true” orchestration. It cites an Amp Code discussion for context (https://ampcode.com/agents-for-the-agent?ref=cline.ghost.io).
2) RAG for Codebases
According to the post, RAG became popular when models had small context windows, and teams tried to “chat with code” by assembling fragments via vector search. The post claims this often produced scattered edits rather than coherent understanding, and that a simple ls/grep workflow that reads full files more closely mirrors how developers operate, leading to better agent behavior.
The piece links the vector database trend to the 2023 period, when models had approximately 8,092-token contexts and vendors invested heavily in infrastructure, mentioning Pinecone as an example of companies that raised significant capital (https://www.pinecone.io/?ref=cline.ghost.io). Cline notes that when it launched in July 2024, the leading coding model cited internally was Claude 3.5 Sonnet with a 200K token context window, which reduced reliance on stitching disparate snippets. The post also asserts that this “read like a developer” approach has since been mirrored by Amp Code and Cursor.
3) More Instructions ≠ Better Results
The post disputes the idea that stacking ever more constraints, examples, and directives into the system prompt improves performance. It argues that excessive instruction introduces contradictions and noise, resulting in unstable or incoherent behavior. A linked “Signal vs. Noise” essay underscores the core point that adding content can reduce clarity (https://nolongerset.com/signal-vs-noise/?ref=cline.ghost.io).
The timeline offered is that during mid-2024, with Sonnet 3.5 prominent, longer prompts and more examples seemed beneficial. With the arrival of the Sonnet 4 family, these strategies reportedly failed, and similar issues appeared across other agentic systems. The post states that newer models—citing Claude 4, Gemini 2.5, and GPT-5—tend to follow terse, unambiguous instructions more reliably than essay-length prompts.
Context and Takeaways
Across the three areas, the through-line is simplicity over architectural complexity. The post recommends:
- Treating most agent work as single-threaded, reserving subagents for tightly scoped, tool-like tasks.
- Preferring straightforward file discovery and reading sequences over whole-codebase RAG for coding tasks.
- Writing minimal, clear prompts to reduce instruction conflicts and improve consistency.
These claims are presented as empirical lessons from Cline’s agent development, and are supported by links to external discussions and reference material. No universal prescription is offered beyond the emphasis on simpler workflows and concise guidance.
Sources and Further Reading
- Cline post: https://cline.bot/blog/3-seductive-traps-in-agent-building
- Anthropic on multi-agent systems: https://www.anthropic.com/engineering/multi-agent-research-system?ref=cline.ghost.io
- “AI Agents are Microservices with Brains”: https://seanfalconer.medium.com/ai-agents-are-microservices-with-brains-ccb42d1504d7?ref=cline.ghost.io
- Amp Code perspective: https://ampcode.com/agents-for-the-agent?ref=cline.ghost.io
- Pinecone site: https://www.pinecone.io/?ref=cline.ghost.io
- Signal vs. Noise essay: https://nolongerset.com/signal-vs-noise/?ref=cline.ghost.io
TL;DR
- Cline flags three traps: multi-agent orchestration, codebase RAG, and prompt over-instruction.
- The post favors single-threaded workflows with parallel tool calls for narrow tasks.
- For code, ls/grep plus full-file reads are preferred to RAG stitching.
- Newer models are reported to respond better to concise prompts than long, example-heavy scripts.
- Arguments are grounded in observed workflows and linked industry references.
