With Claude Code, You Don't Write Code Anymore — You Direct It: How AI Agents Are Changing Real Development
A Quiet Revolution in Software Development
When engineers first hear the words "agentic coding," many feel a mix of confusion and excitement. Not long ago, writing code meant sitting at a text editor, typing characters one by one, handling small tasks manually. But tools like Claude Code have completely transformed this — radically changing the way development work gets done.
This article is based on an interview with Boris, an Anthropic engineer and developer of Claude Code. It covers the background of the tool, how it has evolved, and what AI agents could mean for the future of software development — including some honest accounts of early failures. Let's explore together how agents are reshaping the world of software, and what it means for all of us navigating this new era.
Topics covered:
- From "Writing" to "Directing": What AI-Led Development Actually Looks Like
- Claude Code's Evolution and Ecosystem — Internal Improvements and Extensibility
- What Can Only Humans Do? The Skills the AI Agent Era Demands
- Summary: Toward an Era of Human-AI Co-Creation in Code
Struggling with AI adoption?
We have prepared materials covering ZEROCK case studies and implementation methods.
From "Writing" to "Directing": What AI-Led Development Actually Looks Like
Over the past year or so, a significant transformation has been quietly but surely taking hold in software development. The old approach — typing code character by character, copying, pasting, iterating through small fixes — has been upended by agents like Claude Code. Developers no longer need to operate code at the micro level. Instead, they instruct an agent what feature to implement, and the agent generates, revises, and manages the code across the entire project.
As Boris himself describes it, the old way of leveraging AI — relying on IDE autocomplete or exchanging code snippets via a chat tool — used to be the norm. But with agents, a new workflow has taken hold: shifting away from direct text manipulation inside an editor and delegating large chunks of editing and additions directly to the agent. The agent acts like a personal partner. The developer sets the overall direction and high-level goals, and the agent handles the rest.
This agentic coding revolution depends not just on the model's raw capability, but on what Boris calls the "harness" — the infrastructure that surrounds the model. Boris uses a horse metaphor: "You need a saddle to ride a horse." To use a great agent effectively, you need to provide it with the right context, tools, permissions, and configuration. With a proper harness, the model can perform at its best within the given environment.
Early Claude Code ran on Sonnet 3.5, an older model, and was typically used for only about 10% of total code. Both the model and the harness left a lot to be desired. Boris recalls arriving at the office and being surprised to find a few engineers already using Claude Code. The model's performance wasn't impressive yet — but there was a glimpse of possibility. Of course, in that early state, code rewrites and edits were far from perfect, and failures happened. Those failures became important learning experiences that contributed to where Claude Code is today.
Through successive model upgrades — from Sonnet 3.7 to Claude 4 (Opus) to Opus 4.1 — Claude Code's capabilities improved dramatically. The harness evolved in parallel, reducing friction and enabling genuinely meaningful productivity gains. The key insight here: the move to agentic coding is not just about automated code generation. It's an opportunity to rethink the entire development process from the ground up.
Key takeaways from this shift:
- Agents free developers from minute-level text manipulation, allowing them to focus on high-level design
- A properly built harness — providing the right context, tools, and configuration — is essential to maximizing agent performance
- Early trial-and-error and failures were essential to the steady evolution of agentic coding practices
The shift to agentic coding isn't simply "stop writing code." It's the emergence of a new development style — one that retains the craft and aesthetic of detailed work but enables much faster, more flexible feature implementation. Developers are no longer just operators. They've entered an era of building partnerships with agents to guide projects toward their best possible outcomes.
Claude Code can also be configured to connect to Git history and Sentry logs via MCP, integrating deeply into the developer's entire work environment. Engineers are establishing a new development rhythm: reviewing agent suggestions and auto-generated fix proposals, and making adjustments as needed. The agent remains a tool — humans retain final control — but the leap in engineering productivity is real.
None of this happened without a great deal of daily trial-and-error in the development trenches.
Claude Code's Evolution and Ecosystem — Internal Improvements and Extensibility
Claude Code was designed from the start to be simple and hackable. A configuration file called CLAUDE.md, placed inside a repository, allows developers to provide additional context to the agent and tune its behavior for each project. Early on, this CLAUDE.md provided basic extensibility, but Claude Code has since evolved to offer a far richer set of extension points — necessary for handling the complexity of modern development tasks.
The internal development team placed strong emphasis on continuously collecting user feedback. A dedicated Slack feedback channel for internal engineers enabled direct receipt of opinions and requests — leading to rapid improvements in the harness. For example, features like having the agent respond to a GitHub pull request and automatically generate code, or accepting instructions from Slack and proposing real-time code changes, emerged directly from this feedback loop.
Throughout Claude Code's development, internal usage wasn't just for testing — it was treated as a fully deployed product used daily. Researchers and engineers used the tool every day, sharing observations about what worked, what didn't, and what needed improvement. Through this process, it became clear that improvements to the harness — context management, tool integration, per-user permissions — were just as important as improvements to the underlying model.
New extension features were also added: user-defined slash commands and sub-agent functionality. One engineer, for example, created a slash command that automatically generated appropriate Git commit messages based on commit rules — dramatically improving efficiency through repeated use. Claude Code has evolved from a simple code generation tool into a full integration platform for diverse agent capabilities.
What sets Claude Code clearly apart from other AI tools is its hackability and the breadth of its ecosystem. The ability for developers to flexibly customize the agent's behavior to match their own working environment is compelling for everyone from beginners to professionals. In its early days, errors were frequent — simple string replacements that didn't behave as expected, or instructions that dropped context partway through a long session. These negative experiences were valuable learning for the development team and drove meaningful improvements.
Through these tool integrations, Claude Code is beginning to function less like an agent and more like "the development environment itself." Internally, the following are seen as particularly important:
- Rapidly reflecting user feedback through real-time bug fixes and feature additions
- Flexible per-project customization enabled by CLAUDE.md, hook systems, and slash commands
- As the model improves, the entire development ecosystem evolves — enabling the agent to handle longer and more complex tasks
These efforts go beyond simply adding new features. They directly contribute to creating an environment where developers can understand their relationship with the agent more deeply and use it as a trustworthy partner. As a result, Claude Code is evolving into one of the most promising platforms for human-AI co-creation in development.
Internal user testing also accumulated insights about which types of tasks agents handle best. Simple tasks often get resolved in a single pass, while complex tasks still require human oversight and final judgment. This field experience has provided important guidance for Claude Code's continued improvement direction. Developers also acknowledge that agent autonomy has real limits — and that humans must always retain final control.
As the internal ecosystem grows, Claude Code is steadily maturing as a foundation for what the future of coding could look like — transforming not just the technology, but the culture and processes of software development as a whole. And this transformation points toward a future where anyone, through co-creation with agents, can bring ideas to life that once seemed impossible.
What Can Only Humans Do? The Skills the AI Agent Era Demands
In the future of software development, agents like Claude Code are expected to become part of everyday work. Where engineers once focused entirely on writing every line of code by hand, agents will increasingly handle code generation, revisions, and project-wide progress management — freeing engineers to focus on bigger goals and overall strategy. This doesn't just open the door to automating easily-automatable tasks — it creates space for engineers to deploy their creativity and deep expertise more strategically.
Boris draws on his own experience and current usage patterns to describe how engineering work will change. Today, Claude Code is used to automate everyday bug fixes and feature additions, while difficult tasks still require human oversight and feedback. This points to a new kind of partnership — where agents and humans each play to their strengths and complement each other.
Boris also offers advice from his experience for engineers adapting to this shift. Start by using Claude Code to answer questions about the codebase and existing systems — before having the agent write any code. Experience how the agent organizes information and formulates responses. This approach builds understanding of the agent's capabilities and lays the groundwork for a working trust relationship. From there, gradually work up to asking the agent to generate code directly — calibrating the level of delegation to match the difficulty of each task.
In the future of software engineering, agents won't just automate the manual, tedious parts of development — they'll serve as powerful partners that draw out engineers' creativity. Work will shift from traditional programming tasks toward setting bigger goals and solving strategic problems. Auto-generated code, proposed prototypes, and problem analysis grounded in error logs and Git history — all of this will help engineers move faster than ever before.
This change also demands a new set of skills: beyond traditional programming knowledge, engineers will need to understand how to collaborate effectively with agents, grasp how the tools work, and comprehend the complex ecosystems operating underneath. Rather than accepting agent-generated code as-is, engineers must evaluate quality critically and make appropriate adjustments — safeguarding the final product. As Boris puts it, in this era of transformation, "code itself is no longer uniquely precious. Ideas and creativity are what matter most" — a release from the constraints that came with complex stack configurations and manual code writing.
Collaborating with agents also means completing tasks that previously took hours in a fraction of the time — making it easier than ever to implement new ideas and launch innovative projects. For example, when agents automatically write unit tests, engineers are freed to focus on more strategic thinking. Some tasks will still require writing code directly, but the role will increasingly shift toward the creative end.
As agents become more capable, the future may bring a day when setting a "goal" is enough — the agent figures out how to achieve it autonomously. Engineers will no longer need to specify every detail. They'll point in a direction, and the agent will generate optimal code through its own judgment. In such an environment, agents will autonomously build their own plans, evaluate their own output, and feed back improvement suggestions — an extraordinarily sophisticated interactive system.
This transformation carries deep significance not just for experienced engineers, but for students and new employees just beginning to learn technology. Today, in addition to traditional technical skills, the ability to communicate effectively with agents, understand what their suggestions mean, and make corrections where needed is becoming essential. As Boris suggests, starting by asking the agent questions about the codebase — rather than asking it to write code immediately — is the right first step toward productive collaboration. This approach also deepens the engineer's own learning, cultivating a more advanced and flexible way of thinking that goes well beyond straightforward implementation.
Summary: Toward an Era of Human-AI Co-Creation in Code
Agentic coding has evolved from manual character-by-character code entry toward a revolutionary approach where delegating work to agents raises overall productivity. Claude Code and tools like it have moved past early trial-and-error and minor bugs to play an essential role in development environments — through diverse extension features and tightly integrated feedback loops. By treating the agent as a partner, developers are freed from minute-level text manipulation and can look forward to a future where they focus on bigger goals and creative projects. Some human judgment and expertise will always be required, but the role is becoming increasingly strategic.
The agentic coding revolution, the evolution of Claude Code, and the future possibilities described in this article carry important implications not just for engineers but for anyone learning technology today. Moving into this new era — working alongside agents to accomplish things that weren't possible before. That is where a more efficient and creative world of software development awaits. We need to continue watching this transformation, learning from it, and adapting our skills and working methods accordingly.
Reference: https://www.youtube.com/watch?v=iF9iV4xponk
TIMEWELL's AI Implementation Support
TIMEWELL is a professional team supporting business transformation in the age of AI agents.
Our Services
- ZEROCK: High-security AI agent running on domestic servers
- TIMEWELL Base: AI-native event management platform
- WARP: AI skills development program
In 2026, AI is evolving from a tool you use to a colleague you work with. Let's build your AI strategy together.