To unlock the true potential of AI agents, we must move beyond simple loops and learn to bridge the gap between model capability and human ambition.

The Ambition Gap in AI Engineering

There is a persistent question in the AI community: what are we actually spending all these tokens on? Despite the massive valuations and the undeniable cheapening of knowledge work, we haven't yet seen a proportional explosion in global productivity or GDP. Generating true value remains difficult. I believe the bottleneck isn't just the models themselves, but our lack of ambition in how we use them. We often oversimplify agentic engineering, reducing it to a series of loops or basic prompts, when it should be treated as a sophisticated discipline of learning and discovery.

At Anthropic, we operate under a principle of not negotiating against ourselves. In a traditional business setting, you might look at a list of priorities and decide how to trade them off—good, fast, or cheap. But with AI, those traditional trade-offs are beginning to dissolve. If we stop being 'reasonable' and instead ask reality to show us where the actual limits are, we find that we can often achieve all three. To deliver on the promise of AI, we have to free ourselves from old mental models of what is possible and start pushing the boundaries of what these agents can actually do.

Models Are Grown, Not Designed

One of the most important things to understand about Large Language Models (LLMs) is that they are grown, not designed. We cultivate the data, the reinforcement learning environments, and the training pipelines, but the end outcome is organic. We don't truly know what a model will be good at until we interact with it. Capabilities emerge in 'spiky,' unexpected ways rather than in a straight line. For example, many assumed that the path to better AI coding was simply a massive context window—just fit the whole codebase in. Instead, models got better through tool calling, bash integration, and grep.

This organic nature creates what I call 'capability overhang.' This is the delta between what a model is actually capable of and what we are currently utilizing it for. Often, we are 'hobbling' the model by not providing the right environment or tools. A classic example is the 'AI hate tweet' claiming a model can't name Pokemon ending in 'aw.' While a model might struggle to recall this from its weights alone, an unhobbled agent with a code execution tool can solve it in seconds by fetching a list and running a regex. The intelligence is there; the harness is often what's lacking.

The Case of the Automated Video Editor

To illustrate how much capability is currently left on the table, consider video editing. Most people wouldn't think to ask an LLM to edit a complex video, and if you asked the model directly, it might even say it can't do it. However, by treating video editing as a code generation problem, I’ve been able to use Claude to handle end-to-end production. It transcribes raw clips, identifies the best takes based on a script, cuts the footage, and even generates React-based UI overlays to create a finished product.

This process transformed video editing into a folder of code and scripts managed by an agent. But the real breakthrough came when I hit a wall with color grading. I received raw footage that looked overexposed and flat. I didn't know how to fix it because I didn't know what I didn't know. This is the 'unknown unknown.' By using Claude not just as a tool, but as a tutor to help me visualize how pixels change through shaders and vector scopes, I was able to bridge my knowledge gap. Once I understood that skin tones need a different dynamic range than backgrounds, I could finally give the agent the precise instructions it needed to finish the job.

Bridging the Human-Agent Interaction Gap

The tech giants of the 2010s were built on Human-Computer Interaction (HCI)—the art of the UI and the UX. Today, we are developing a new discipline: Human-Agent Interaction. Talking to an LLM is a high-leverage skill, akin to public speaking or technical writing. It requires putting yourself in the model's 'shoes.' If you ask an agent to explain a module in a codebase, it needs to know who you are, your technical level, the scale of the codebase, and the 'for what'—the ultimate goal of the request.

We can unhobble these agents by being more explicit and creating richer feedback loops. Instead of a single prompt, I now use tools that allow the model to 'interview' me, building HTML reports and technical plans before a single line of final code is written. We move from simple markdown communication to rich, interactive visualizations. This isn't just about getting the agent to do what you want; it's about using the agent to help you figure out what you actually want. The most valuable work happens when we stop treating the agent as a black box and start treating it as a partner in navigating the unknown.