When Anthropic announced its Claude 4 models, the marketing focused heavily on improved reasoning and coding capabilities. But having spent months working with AI coding assistants, I’ve learned that the real revolution isn’t about generating better code snippets — it’s about the emergence of genuine agency.

Most discussions about AI coding capabilities focus narrowly on syntactic correctness, benchmark scores or the ability to produce working code. But my hands-on testing of Claude 4 reveals something far more significant: the emergence of AI systems that can understand development objectives holistically, work persistently toward solutions and autonomously navigate obstacles – capabilities that transcend mere code generation.

Rather than rely on synthetic benchmarks, I decided to evaluate Claude 4’s agency through a real-world development task: building a functional OmniFocus plugin that integrates with OpenAI’s API. This required not just writing code, but understanding documentation, implementing error handling, creating a coherent user experience and troubleshooting issues — tasks that demand initiative and persistence beyond generating syntactically valid code.

What I discovered about agentic capabilities may fundamentally change how we collaborate with AI systems in software development.

3 models, 3 approaches to agency

Working with Opus 4: Beyond code generation to development partnership

My experience with Claude Opus 4 demonstrated that we’ve crossed an important threshold. Unlike previous AI systems that excel primarily at generating code snippets in response to specific instructions, Opus 4 exhibited genuine development agency — the ability to drive the development process toward a working solution independently.

When I encountered a database error, Opus 4 didn’t just fix the code I pointed out — it proactively identified the underlying cause:

“I see the problem — OmniFocus plugins require using the Preferences API for persistent storage rather than direct database access. Let me fix that for you.”

It then implemented a complete solution using OmniFocus’s Preferences API.

This illustrates the crucial difference between code generation and true agency. A code generator produces text that looks like code; an agent understands the development context, identifies problems and resolves them within the broader framework of the application’s requirements.

What impressed me most was how Opus 4 went beyond the explicit requirements. Without prompting, it enhanced the implementation with:

• A configuration interface for API settings
• Detailed error messages for debugging
• Input validation to prevent invalid requests
• Progress indicators during API calls

These additions weren’t requested — they emerged from Opus 4’s understanding of what makes a good developer experience, demonstrating comprehension beyond the immediate coding task.

Working with Sonnet 4: The cautious collaborator

Sonnet 4 demonstrated strong capabilities but required guidance to further develop its potential. Our interaction felt like working with a capable but cautious developer who needed regular check-ins.

The initial implementation showed good understanding of the task but contained minor errors in the API integration. When faced with these issues, Sonnet 4 asked clarifying questions:

“I notice OmniFocus has a specific way of handling HTTP requests. Can you point me to the documentation for its URL fetching capabilities?”

After receiving this information, it successfully fixed the implementation, although it took seven to eight iterations to reach a fully working solution.

Interestingly, Sonnet 4 made an unexpected pivot at one point — when struggling with the OpenAI integration, it temporarily suggested removing that functionality in favor of local analysis. While this showed initiative in trying to complete the task, it demonstrated less adherence to the specific requirements.

Working with Sonnet 3.7: The responsive tool

My experience with Sonnet 3.7 felt like using a coding assistant. It required explicit instructions and struggled to maintain the broader context of what I was building.

A typical exchange went like this:

• Me: “The plugin needs to convert tasks to TaskPaper format before sending to OpenAI.”
• Sonnet 3.7: “I’ll implement a function to convert tasks to TaskPaper format.” [Implements basic function without error handling]
• Me: “Now we need to implement the OpenAI API integration.
• Sonnet 3.7: [Implements basic API call without proper error handling or user feedback]

When errors occurred, Sonnet 3.7 struggled to diagnose them independently:

• Me: “I’m getting a ‘file is directory’ error.”
• Sonnet 3.7: “That’s strange, can you show me the full error message?”
• [I provide error details]
• Sonnet 3.7: “This might be related to file paths. Let’s check how the plugin is being saved.”

After 10+ interactions, we still didn’t have a fully functional plugin.

The agency spectrum: Moving beyond code quality

This hands-on comparison revealed something important: the key differentiator between AI coding systems is increasingly not their ability to generate syntactically correct code, but their level of agency — their capacity to understand and work toward development objectives with minimal guidance.

Based on my testing, I’d place these models on an agency spectrum:

• Code generators. Generate syntactically valid code in response to specific prompts, but lack persistence and contextual understanding.
• Responsive assistants. Produce working code but require explicit guidance at each development stage, focusing on immediate instructions rather than overall objectives.
• Collaborative agents. Balance following instructions with initiative, can work semi-autonomously with periodic guidance, but may need redirection.
• Development partners. Internalize development objectives and work persistently toward them, proactively identifying and resolving obstacles without explicit guidance.

This spectrum represents a fundamental shift in how we should evaluate AI coding systems — moving beyond code quality metrics to assess their capacity for autonomous problem-solving in real development contexts.

What this means for development practices

The emergence of agency-capable AI systems has profound implications for development workflows:

From micro-instructions to development objectives

With agentic AI systems, effective collaboration shifts from providing detailed step-by-step instructions to communicating higher-level development objectives and context. I found myself giving Opus 4 instructions like:

“Build a plugin that sends OmniFocus tasks to OpenAI for analysis and summarization. It should handle errors gracefully and provide a good user experience.”

This high-level direction was sufficient for it to build a complete solution – something that would have been impossible with earlier code generation systems. 

Beyond token counting: A new economic calculus

The agency capabilities of the Claude 4 models introduce a new dimension to cost-benefit analysis. While Opus 4 costs more per token ($15/$75 input/output vs. Sonnet 4’s $3/$15), its ability to work autonomously toward solutions dramatically reduces the number of interactions required.

When I needed just three to four interactions with Opus 4 versus 10+ with Sonnet 3.7, the efficiency gain offset the higher per-token cost. More importantly, it saved my time and cognitive load as a developer — costs that rarely factor into model selection but have significant real-world impact.

Adapting development workflows to AI agency

As AI systems move beyond code generation to exhibit genuine agency, development workflows will evolve. My experience suggests a future where AI systems handle not just code writing but implementation planning, error diagnosis and quality assurance – freeing developers to focus on:

• Architecture and system design
• Defining objectives and quality standards
• Critical evaluation of AI-generated solutions
• The human and ethical aspects of software development

This doesn’t mean AI is replacing developers — rather, it’s elevating our role from writing routine code to higher-level direction and oversight.

The road ahead: Beyond current capabilities

Based on this rapid evolution in AI agency, several trends emerge:

• Agency-specialized development systems. Future AI systems may optimize specifically for development agency rather than general intelligence, creating specialized partners for different development domains.
• New collaboration interfaces. Current chat interfaces aren’t optimized for development collaboration. Expect tools that provide AI systems with greater autonomy to explore codebases, run tests and propose coherent solutions.
• Evolving evaluation frameworks. As agency becomes the key differentiator, we’ll need new ways to evaluate AI systems beyond code generation benchmarks, focusing on their ability to understand and achieve development objectives.
• Organizational adaptation. Development teams will need to rethink how they integrate agentic AI capabilities, potentially creating new roles focused on directing and evaluating AI contributions. 

Agency as the new frontier

New LLM models represent a significant milestone in the evolution of AI coding systems — not because they generate better code, but because they exhibit a level of agency that transforms the human-AI development relationship.

The most important insight from my testing is that the frontier has shifted from “can it write correct code?” to “can it understand what we’re trying to build?” New models demonstrate that we’re entering an era where AI systems can function as genuine development partners, not just sophisticated code generators.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?