5 Agent PATTERNS to SIMPLIFY Your Agentic Coding (Claude Code, Gemini CLI, MCP)

Too Long; Didn't Watch — Summary

This video outlines five essential agent interaction patterns—Iterative Human-in-the-Loop, Reusable Prompts, Sub-Agents, Prompt-to-Sub-Agent, and Wrapper MCP Server, plus an Application Pattern—to help engineers effectively scale agentic coding solutions by choosing the right level of complexity for their specific problem, emphasizing starting simple and only scaling when necessary.

Main Takeaways

• Agents are already integrated into workflows, and understanding interaction patterns is crucial for maximizing their utility.
• The five core agent patterns range from simple human-in-the-loop to complex full applications, each suited for different levels of problem complexity and compute needs.
• Reusable prompts are the most efficient pattern for repeatable tasks, offering significant value for minimal overhead.
• Sub-agents are best utilized for specialization and parallelization, particularly with tools like Claude Code, but introduce complexity in context management.
• Wrapper MCP servers provide a controlled interface layer for agents to interact with multiple services and proprietary APIs, offering high customizability.
• A decision framework based on "keep it simple, scale when needed" helps engineers choose the appropriate pattern, avoiding premature optimization and over-engineering.

Detailed Summary

Introduction (0:00 - 1:07)

• Agents are already prevalent in engineering workflows, not a future concept.
• The challenge lies in effectively integrating agents with existing APIs, CLIs, and other agents.
• Choosing the right interaction pattern can significantly impact development time, from hours to days.
• The video will break down five top agent interaction patterns to leverage agents as an advantage.

The Agent Pattern Problem (1:07 - 3:54)

• A scenario is presented: an engineer needs to generate many high-quality images for a presentation using agents like Claude Code and image models like Qwen image edit.
• The core problem is deciding the optimal agent interaction pattern: custom slash command, Claude Code sub-agent, custom MCP server, or a combination.
• The video posits that a majority of AI's economic value will come from AI agents.
• The goal is to identify the best interaction patterns to scale engineering impact with agents like Claude Code, Gemini, and Codeex.

Iterative Human in the Loop (3:54 - 4:55)

• This is the simplest and most common pattern, involving direct back-and-forth prompting with an agent.
• Example: Using an agent to interact with a Replicate MCP server for image generation.
• Pros: Direct oversight, simplicity, quick review, high accuracy, high control.
• Cons: Human is the bottleneck, poor scalability, as the user is "stuck in the loop."
• This pattern is a good starting point but not a suitable end solution for scaling.

Reusable Prompts (4:55 - 6:43)

• This pattern represents the "80/20" rule for agent interaction, offering maximum value for time invested.
• Tools like Gemini CLI and Claude Code support reusable prompts (e.g., cloud/command/name.md).
• Reusable prompts enable writing once, reusing often, and allow for rapid iteration and version control.
• This is the recommended next step when a task becomes repetitive (e.g., after performing it three times).
• Cons: Initial setup overhead, need to manage commands, and introduces a thin abstraction layer.

Sub-Agents Pattern (6:43 - 9:25)

• Claude Code uniquely supports sub-agents, allowing the primary agent to spin up specialized, dedicated agents.
• Example: A "create image" agent and an "edit image" agent for parallelized and specialized image generation and refinement.
• Pros: Specialization, parallelization, reusability with Claude Code, and enhanced interaction with outside services.
• Cons: Potential Claude Code lock-in (model and feature), the "gray box" problem (difficulty in analyzing/debugging sub-agents), and complex prompt flow between primary and sub-agents.

Prompt to Sub-Agent Pattern (9:25 - 12:01)

• This pattern involves a prompt that orchestrates multiple sub-agents to solve a specific workflow.
• Example: A single prompt defining a workflow to generate and refine multiple images using a team of sub-agents.
• Pros: Creates reusable workflows as code/prompts, spawns specialized agents, and allows for passing parameters like the number of agents to spin up.
• This pattern significantly scales compute and reusability for complex tasks.
• Cons: Very token-intensive, complex to debug, and requires extensive prompt engineering and understanding of model behavior.

Wrapper MCP Server Pattern (12:01 - 16:18)

• This pattern involves building a dedicated wrapper MCP (Multi-Agent Communication Protocol) server that agents (Claude Code, Gemini, Codeex) call.
• The MCP server acts as an interface layer, calling APIs, custom services, and other tools directly.
• Pros: Single integration point for all agents, full control and customizability, and the ability to expose specific tools and prompts (custom slash commands) tailored to the domain.
• This is ideal for encapsulating reusable solutions for a domain set of problems or integrating multiple services.
• Cons: Requires manual maintenance of the MCP server and building integrations by hand (or instructing agents to do so), and it's built for agents, not humans.

Application Pattern (16:18 - 17:50)

• This is the highest level of control, essentially building a full-fledged application with its own CLI, MCP server, UI, and API.
• Pros: Full control, infinitely extensible, and multiple access patterns (CLI, MCP, UI, API) for agents to interact with.
• Cons: Extremely high cost in terms of development time, complexity, and resources; considered overkill for simple tasks.
• This pattern is suitable when building a product or a long-term, comprehensive solution for an organization.

Agent Pattern Decision Framework (17:50 - 29:34)

• The core principle is "keep it simple, scale when needed" – solve the problem first with the simplest pattern, then scale up if necessary.
• Ad hoc prompt (Iterative Human-in-the-Loop): Start here for new problems or initial encounters.
• Reusable Prompts: Move to this when a pattern is spotted (e.g., after doing something three times) to automate and codify.
• Sub-Agents: Use only when specialization and parallelization are required; otherwise, stick to reusable prompts in the primary agent.
• MCP Wrapper: Upgrade when needing to expose agents to multiple services, proprietary assets, or when CLI/API calls are insufficient, and a simple, unified interface is desired.
• Full Application: Reserved for complete integration, full control, multiple interface layers, and a long-term product vision.
• Each successive pattern increases compute, complexity, and development time.
• Avoid premature optimization; complexity should be earned, not assumed.
• Larger systems are built from simple working systems; start with basic interactions and build up.
• The presenter emphasizes that "by hand" now often means having a high-composition level agent do the work.
• The framework encourages moving from left to right (simple to complex) and never the reverse.

Notable Quotes

"Agents are not the future. They're already on our desks, in our repos, in our workflows." "What's the best interaction pattern you can use to quickly scale your engineering impact with agents like Cloud Code, Gemini, Codeex, and the next big agent, right?" "This is the low-hanging fruit. This is a great place to start. This is a terrible place to end." "This is the 80/20 of agent interaction patterns." "Three times marks a pattern. If you need reusability, build a reusable prompt next." "Only use sub-agents when you need specialization and parallelization." "Complexity should be earned, not assumed." "Larger working systems are almost always built from simple working systems." "Being an engineer is all about solving the problem."