The future of agentic coding with Claude Code

In the last year, the landscape of software engineering has fundamentally shifted from direct text manipulation in an IDE to a more hands-off, agentic workflow. This evolution is not just about better autocompletion; it’s about delegating the entire process of text manipulation to a model. This was previously impossible because both the models and the “scaffolding” around them were not sophisticated enough.

The Co-Evolution of Models and “Harnesses”

The key to modern agentic coding lies in the synergy between the language model and the system that directs it. Boris Cherny uses the analogy of a horse and a saddle:

• The Model (The Horse): The underlying AI, like Claude 3.5 Sonnet or Opus, provides the raw power and capability.
• The Harness (The Saddle): The application, like Claude Code, provides the essential scaffolding that makes the model useful. This “harness” includes the system prompt, context management, tools, permissions, and other interfaces that guide the model’s performance.

These two components have co-evolved. As developers and researchers at Anthropic use Claude Code for their daily work, they naturally discover the model’s limitations. This direct experience—seeing where a human needs to intervene or course-correct—creates a powerful, organic feedback loop that informs the model training process. This has led to significant improvements in the model’s ability to operate autonomously for longer periods and adhere to complex instructions.

Evaluating Models: “Vibes” Over Benchmarks

While synthetic benchmarks like SWE-bench have their place, they often fail to capture the complexity and breadth of real-world software engineering tasks. When evaluating a new model or feature, the most effective measure is simply using it for a day’s work. The “vibe”—whether the model feels smarter and more capable across a variety of tasks like writing new code, fixing bugs, or pulling in context from Slack messages or Sentry logs—is often a more reliable signal than any formal evaluation.

This reliance on user experience was baked into Claude Code’s development. A critical factor in its success was an intensely fast and responsive internal feedback loop. By creating a single Slack channel and acting on feedback almost immediately, the team encouraged a constant stream of high-quality user insights, which was essential for navigating the uncharted territory of building AI tools.

The “Hackability” of Claude Code

From its inception, Claude Code was designed to be simple and, most importantly, “hackable.” This philosophy allows users to extend and customize the agent to fit their specific workflows. Key extension points include:

• CLAUDE.md: A file in the repository root or subdirectories that provides additional, persistent context to the agent about the codebase.
• Settings and Permissions: A sophisticated system for controlling the agent’s behavior and capabilities.
• Hooks: An extensive system that allows developers to hook into various parts of the agent’s lifecycle.
• MCP (Meta-Context Protocol): A powerful way to pull in external context from other services.
• User-Defined Slash Commands: Reusable workflows defined in Markdown files within the codebase. For example, a user can create a /commit command with specific instructions on how to write a good commit message and pre-approve the necessary shell commands, streamlining the process.

The Future of Software Engineering and Upskilling

The role of the software engineer is moving up the stack of abstraction. In the near future, an engineer’s work will be a mix of hands-on coding (using an agent as a tool for text manipulation) and higher-level goal setting. Instead of writing individual lines of code, engineers will define objectives and review changes proposed by an agent that operates more proactively.

For those learning to code or adapting to this new paradigm, the advice is twofold:

1. Master the Craft: The fundamentals of computer science—languages, compilers, runtimes, and system design—remain essential.
2. Get Creative: Agents dramatically lower the barrier to execution. The focus shifts from the process of making to the thing being made. An idea for a product or startup can now be built and iterated upon with unprecedented speed. The code itself becomes less precious and more malleable.

Practical Tips for Using Claude Code

To use Claude Code effectively, Cherny suggests a phased approach based on task complexity.

1. For Beginners: Start with Questions. Before asking it to write code, use Claude Code as a research assistant. Ask it questions about the codebase, such as “How do I add a new logger?” or “Why was this function designed this way?” This helps you get comfortable with the agent’s ability to explore and reason about your code.

2. Categorize Your Coding Tasks:

   • Easy Tasks: For simple, one-shot tasks, delegate completely. For instance, tag @Claude on a GitHub issue and let it generate the entire pull request, freeing up your terminal.
   • Medium Tasks: Use Claude Code in your terminal. Start in “plan mode” (Shift + Tab) to align on a high-level plan first. Once you approve the plan, let the agent implement it.
   • Hard Tasks: For complex problems, the human remains in the driver’s seat. Use the agent as a powerful pair programmer. You can ask it to research the codebase, prototype ideas, or write unit tests, but you drive the core implementation.

• Tags:
• Software Engineering
• Developer Tools
• LLMs
• Claude Code
• Agentic Coding