This is Hamamoto from TIMEWELL Inc.
When engineers first hear the phrase "agentic coding," many feel a mixture of bewilderment and excitement. In the past, writing code meant typing characters directly into a text editor and manually working through each small step. But tools like Claude Code have upended that convention, dramatically transforming how engineering work actually happens.
This article is based on an interview with Boris, an Anthropic engineer and creator of Claude Code. It covers the background, implementation evolution, and the possibilities that agents hold for the future of software development — with concrete, detailed explanations and an honest account of both successes and some early failures. Let's explore how agents are changing the world of software development, and how we should adapt to this new era.
From "Writing" to "Directing" — What It Means When AI Takes the Lead
Over the past year or so, a major transformation has been quietly but steadily advancing in software development. The traditional approach — typing code character by character, copy-pasting, making incremental edits — has been the norm. But agents like Claude Code are revolutionizing that process. Developers no longer need to manually manage fine-grained code operations; they can simply tell the agent what they want implemented, and the agent autonomously generates, edits, and manages the entire project.
How Agents Changed the Development Flow
As Boris himself describes, the old approach involved IDE autocomplete features and sending code back and forth via chat tools. With the arrival of agents, there's been a major shift away from direct text manipulation inside editors — developers now delegate much of the editing and addition work entirely to the agent. The agent behaves like a true partner, while the developer sets the overall direction and high-level goals.
This agent coding revolution is driven not just by the model's capabilities, but by the supporting structure Boris calls a "harness." He uses a horse analogy: "You need a saddle to ride a horse." In the same way, a great agent requires a well-built harness — the context, tools, permissions, and configuration provided to the model — for it to perform at its best.
Evolution from Early Versions
Early Claude Code used the older Sonnet 3.5 model. At that stage, only about 10% of the codebase was being leveraged, and the model and harness weren't yet refined enough. Boris recalls arriving at the office and being surprised to see several engineers already using Claude Code. The model's performance was still limited, but the potential was visible. Of course, code rewrites and edits weren't always perfect in those early days — there were failures. But those failures became crucial learning that eventually led to the successes.
After subsequent upgrades — through Sonnet 3.7, Claude 4 (Opus), and Opus 4.1 — the agent's capabilities improved dramatically. The harness improved in parallel, stress reduced for developers using it, and productivity rose substantially. The key point is this: the transition to agent coding is not merely about automated code generation — it's an opportunity to rethink the entire development process from the ground up.
- Agents free developers from granular text operations, allowing them to focus on high-level design
- A well-built harness — providing the right tools, configuration, and context — is essential for agent performance
- Early trial and error, with failure as a teacher, led to the steady maturation of agent coding methodology
The shift to agent coding is not simply about "no longer writing code." Rather, it's about evolving into a new development style that combines the attention to detail and code aesthetics of traditional craft with faster, more flexible feature implementation. Developers are no longer just operators — they've entered an era of building genuine partnership with an agent to reach the optimal solution together.
Agents also integrate deeply into developers' working environments. Claude Code can connect to Git history and Sentry logs via MCP, enabling engineers to review agent-suggested changes and automated fix proposals within their daily workflow — adopting a new development style that blends human judgment with AI suggestions. Agents remain tools; humans retain final control. But the dramatically enhanced assistance has allowed engineering productivity to leap forward, with programs now completed far more quickly than before.
Behind all of this progress are the daily, incremental experiments happening in real development environments.
Looking for AI training and consulting?
Learn about WARP training programs and consulting services in our materials.
Claude Code's Evolution and Ecosystem — Internal Refinement and Extensibility Opening New Development Environments
From the start, Claude Code was designed to be simple and highly hackable. Through the CLAUDE.md configuration file placed in a repository, developers can give the agent additional context about a project and tune its behavior for each use case. That extensibility was there from the beginning, but to handle the complexity of modern development tasks, Claude Code has grown to include more diverse extension points than ever before.
Continuous Improvement Through Feedback Loops
The internal development team placed great emphasis on building a continuous feedback collection mechanism — a dedicated Slack channel where engineers could send their observations and requests directly. That feedback loop was extremely active: error reports and requests for behavioral improvements flowed in constantly, and the harness improved directly in response. One example: the feature where the agent reacts to GitHub pull requests and automatically generates code, as well as the mechanism for picking up Slack commands and making real-time code fix suggestions.
Throughout Claude Code's development, the tool wasn't just internally tested — it was used as a live product, by researchers and engineers themselves every single day. In the process, it wasn't just the model that evolved; the harness — context management, tool integration, per-user permissions and settings — all made major advances.
Slash Commands and Subagent Capabilities
New extension features include user-definable slash commands and the agent's own subagent capabilities. One engineer, for example, created a slash command that automatically generates appropriate messages based on Git commit rules — using it repeatedly to dramatically improve their workflow. Claude Code has evolved well beyond a simple code generation tool into an integrated platform for diverse agent capabilities.
What clearly differentiates Claude Code from other AI tools is its hackability and expanding ecosystem. The ability to flexibly customize agent behavior to fit your own work environment is highly attractive to everyone from beginners to professionals. When Claude Code was first introduced, performance and harness capabilities weren't sufficient — errors were frequent. Simple string replacements sometimes didn't work as intended; instructions given for long periods would sometimes break off midway. Those negative experiences and frustrations became valuable learning for the development team and served as the driving force behind improvement.
Through these tool integrations, Claude Code has begun to serve not just as an agent but as "the development environment itself." Internally, the following points are considered especially important:
- Rapidly incorporating user feedback to fix bugs and expand features in real time
- Achieving flexible per-project customization through CLAUDE.md, hook systems, slash commands, and other extensions
- As the model updates, the entire development ecosystem evolves — allowing agents to handle longer, more complex tasks
These efforts aren't just about adding new features; they build an environment where developers can more deeply understand the agent and use it as a reliable partner. The result: Claude Code continues to evolve as an ideal platform for co-creation between developer and agent.
Internal user testing also accumulated knowledge about which types of tasks agents handle best. For simpler tasks, the agent typically produces a result in one shot; for complex tasks, a human must remain involved — making final judgment calls. These real-world insights are crucial inputs for determining Claude Code's ongoing improvement direction. Developers also recognize that agent autonomy has limits, and that maintaining a balance where humans retain ultimate control is essential to the tool's healthy evolution.
As the internal ecosystem matures, Claude Code is steadily growing as the foundation for bringing the "future of coding" to life — not merely as a technological advance, but as a turning point that shapes the culture and process of software development itself. It signals a new possibility: that anyone, through co-creation with an agent, can realize ideas that once seemed impossible.
What Only Humans Can Do — The Skills That Matter in the AI Agent Era
In the near future, agents like Claude Code are expected to become part of everyday software development. Where engineers once wrote each line of code by hand, a new era is approaching in which agents autonomously handle code generation, editing, and entire project management — freeing engineers to focus on larger goals and overall strategy. This future doesn't just automate the easily automatable; it opens a path for engineers to deploy their creativity and deep expertise more strategically than ever before.
A New Partnership Between Engineers and Agents
Boris offers concrete insights into how engineering work will change, drawing from his own experience and current use cases. Today, Claude Code automates routine bug fixes and feature additions, while difficult tasks still require human oversight and feedback. This is a preview of the new partnership the future demands — humans and agents each playing to their respective strengths, complementing each other.
Boris also offers advice on how engineers should approach adapting to this evolving dynamic. The first step: use Claude Code to answer questions and resolve confusion about the codebase and existing systems — experiencing how the agent organizes information and responds before reaching for it to write code. This builds understanding of the agent's capabilities and establishes initial trust. From that foundation, gradually escalate to requesting code generation directly, calibrating how much you delegate based on task difficulty.
In tomorrow's software engineering, agents won't just automate the manual, tedious parts of the development process — they'll become powerful partners that draw out engineers' creativity. Work will shift from traditional programming tasks toward setting larger goals and solving strategic problems. Automated code generation, prototype suggestions, and analysis of error logs and past Git history will all support engineers, enabling faster software development than ever before.
In this changing environment, what engineers need goes beyond traditional programming skills. It includes understanding how to work with agents, knowing how tools function, and grasping the complex ecosystems operating under the hood. Rather than accepting agent-suggested code as-is, engineers must evaluate its quality and make appropriate modifications — that's what protects the final product's integrity. As Boris puts it: "Code itself is no longer unique. Ideas and creativity are the most valuable things," emphasizing freedom from the constraints of complex stack configurations and manual coding that once dominated the field.
Working alongside agents, engineers will find themselves able to complete in hours what used to take days — creating an environment where new ideas and innovative projects become far more accessible. When agents write unit tests automatically, for example, engineers can devote more attention to strategic thinking. Of course, there will still be tasks that require writing code yourself, but that role will shift increasingly toward the creative end of the spectrum.
As agent capabilities improve, the day may come when setting a "goal" is enough, and the agent autonomously works toward achieving it. Engineers may no longer need to specify every detail — just point the way, and the agent figures out the optimal code on its own. In that environment, agents will automatically build their own plans, evaluate progress, and feed back improvements — an extraordinarily advanced dialogue system.
This transformation matters not just for experienced engineers, but for students and new hires entering the field. In today's world, in addition to traditional technical skills, the ability to communicate effectively with agents, understand what they propose, and make appropriate corrections is increasingly required. As Boris notes, the first step toward effective collaboration with an agent is not having it write code, but asking it questions about the codebase to deepen your understanding. This approach deepens the engineer's own learning and cultivates a broader, more flexible way of thinking — going far beyond simple implementation work.
Summary — Code Is Co-Created by Humans and AI. The Future Map That Claude Code Points Toward
Agentic coding has evolved from manual code entry to a revolutionary approach where delegating work to an agent raises overall productivity. Claude Code — at the center of this new paradigm — has overcome early trial and error and minor glitches to play an indispensable role in development environments today, through diverse extensions and feedback loops. Developers who adopt the agent as a partner are freed from granular text operations and look forward to a future where they can focus on larger goals and creative projects. Of course, there will still be moments where human judgment and expertise are essential — but that role will become increasingly strategic.
The agent coding revolution, Claude Code's evolution, and the future possibilities covered in this article carry deep implications not just for engineers, but for everyone learning technology today. Moving forward alongside agents, realizing ideas and approaches that were never possible before — that's what lies ahead. A more efficient and creative world of software development awaits. The mandate now is to keep watching this innovation unfold, and to seek in agent coding the hints that will help us evolve our skills and our way of working.
Reference: https://www.youtube.com/watch?v=iF9iV4xponk