Claude Code Was Surprisingly Well-Crafted and User-Friendly Beyond My Expectations

In the Midst of AI Agent Tools' Dramatic Evolution

The changes happening in development are faster than we imagined.

Just two weeks ago, I was struggling with Claude Code's terminal interface while still feeling "this is revolutionary." But on May 22, Anthropic made an announcement beyond our imagination: the release of Claude Opus 4 and Sonnet 4, and the general availability of Claude Code. Even more surprising was the emergence of AI that could continue coding for 7 consecutive hours.

I started using Claude Code for simple economic reasons. There was potential to reduce API usage costs from $2,000 monthly to about $200 with a Max subscription. But after actually using it, I found value beyond cost reduction.

What particularly impressed me was that the AI had "an obsession with completing tasks." With other tools like Roo Code, subtasks often ended halfway. But Claude Code tends to steadily manage ToDo lists once established and tries to complete them to the end. It feels like having an excellent pair programmer beside you.

As the methods for utilizing AI assistants for development support diversify, I'd like to share my experience using Anthropic's Claude Code. I'll candidly analyze insights gained from API usage with a Max subscription, comparisons with other tools, and practical strengths and challenges.

I decided to try Claude Code after learning it was added to Anthropic's Claude Max plan¹. Previously, I was spending up to $2,000 monthly on Claude's API, so migrating to the Max plan at about $200 could potentially reduce costs by about 90% (there's also a $100 Max plan available).

To state my conclusion upfront: so far, I haven't come close to hitting any limits, and the experience is virtually identical to when I was spending hundreds of dollars monthly, making the cost-performance ratio extremely favorable. Having nearly unlimited access to Claude Sonnet 3.7 with minimal stress is particularly pleasing.

I've summarized my actual usage situation in the flowchart below:

Initially, I started using Claude Code purely for economic benefits. However, after actually using it, I found more useful features than expected, which significantly changed my development workflow. That said, the $200 monthly fee remains expensive for individual developers. In a situation where similar functionality is available through services like Cursor for around $20 per month, what criteria should guide the selection becomes an important point.

When considered on a human resource cost basis, it's quite inexpensive compared to a skilled engineer who might cost tens of thousands of dollars monthly. It's not uncommon for costs to exceed $10,000 per person-month. By comparison, $200 is actually inexpensive. As indicated by the $20 alternatives, there may be possibilities to reduce costs further, but for now, I'm prioritizing performance and low stress levels, so I'm choosing this option despite it being somewhat more expensive.

Fundamental Changes in Development Experience Over Two Weeks

May 12 to May 26, 2025 - two weeks. In the world of AI tools, this is long enough to be called an "era."

From Research Preview to General Availability: Evolution Meeting Developer Expectations

Claude Code, which appeared as a research preview with Claude 3.7 Sonnet on February 24, finally became generally available (GA) on May 22. But this wasn't just a status change. Features that developers truly wanted were implemented one after another.

Most shocking was the fact that Claude Opus 4 continued coding for 7 consecutive hours. In refactoring a complex open-source project at Rakuten, the AI steadily completed long-duration work that would be difficult for human engineers to maintain concentration for. The SWE-bench score recorded 72.5%, significantly surpassing OpenAI's GPT-4.1 at 54.6%².

IDE Integration: Liberation from the Terminal

When I wrote my article, Claude Code could only be used in the terminal. Honestly, this was a major constraint. But with the May 22 update, native integration with VS Code and JetBrains IDEs was realized³.

This allows you to check Claude Code's suggestions directly in the editor and apply changes inline. No need to switch between terminal and editor, making the development flow dramatically smoother.

GitHub Actions Integration: A New Dimension of Automation

One of the most innovative updates was the introduction of Claude Code Actions. This integrates GitHub Actions with Claude Code to automatically respond to PRs and Issues.

Setup is surprisingly simple:

$ claude
> /install-github-app

With this single command, the following becomes possible:

• Automatic code reviews for PRs
• Implementation suggestions from Issues
• Automatic execution of simple fixes
• Visual tracking of progress (dynamic checkbox updates)

Leap in Autonomous Execution: Practical Value of --dangerously-skip-permissions

The --dangerously-skip-permissions option introduced in Anthropic's best practices guide⁴ has the potential to fundamentally change development efficiency.

$ claude --dangerously-skip-permissions

Using this option, Claude continues work to completion without permission checks. It achieves overwhelming efficiency in routine tasks like fixing lint errors and generating boilerplate code. However, as Anthropic itself warns, use in containers without internet connection is recommended.

What I felt using this option myself was the psychological hurdle of "completely entrusting to AI." But when used in appropriate environments, it becomes a powerful tool that continues work with concentration impossible for humans.

Feature Comparison Between Claude Code and Cline/Roo Code: Analysis from Experience

I've previously used Cline and Roo Code, both provided as Visual Studio Code extensions. I'll compare these with Claude Code, focusing on differences that particularly impressed me. I want to evaluate not just from technical specifications, but from the perspective of actual user experience and impact on work efficiency.

Note that while GitHub Copilot also has an Agent mode, it currently doesn't match the functionality of tools like Roo Code, so I'm excluding it from this comparison. My comparison mainly focuses on Roo Code, which I've found to be the best so far.

Opus 4 vs Sonnet 4: Practical Usage Guidelines

With Claude Opus 4 and Sonnet 4 released on May 22, understanding the differences between these two models is important for efficient development.

Here are the key points for differentiation based on actual usage:

• Large-scale code generation and documentation: Sonnet 4's 64,000 token output is advantageous
• Complex architecture design and difficult bug analysis: Opus 4's deep reasoning ability is necessary
• Cost-conscious daily development: Sonnet 4 is sufficient (1/5 the price)

Parallel Processing and Summary Function: Natural Seamlessness

The first thing I noticed when using Claude Code was how incredibly smooth document reading and information processing is. Parallel processing and lightweight model-based summarization are naturally combined⁴.

Roo Code's Orchestrator feature (commonly known as Boomerang mode) performs similar parallel processing, but Claude Code's key difference is that it handles this automatically without requiring explicit awareness from the user. For example, when instructed to "review this project's documentation in advance," it simultaneously explores the project structure, checks configuration files, identifies related files, and returns consolidated results.

This sense of "advanced processing happening without conscious effort" is one of Claude Code's major attractions. It's not simply using an API but is crafted as an AI Agent at the application level. Developers don't need to think about complex processes and can focus on higher-level instructions.

ToDo List Feature: Commitment to Task Completion

One feature I particularly like about Claude Code is the ToDo list functionality. Not only are tasks automatically listed, but the determination to complete tasks through to the end is impressive.

⏺ Now I'll create the Shape component. First, I'll check the README.md to understand the project
  structure and investigate similar component implementations.
⏺ Update Todos
  ⎿ ☐ Analyze image to identify required shape components
     ☐ Create list of shape components needed
     ☐ Read README.md for project structure and component guidelines
     ☐ Examine similar components implementation
     ☐ Create Shape component with Rectangle and Arrow types
     ☐ Create tests for Shape component
     ☐ Create Storybook stories for Shape component

The biggest difference when compared to Roo Code's Orchestrator feature is in subtask completion management. With Roo Code, subtasks tend to abandon completion conditions, often leaving tasks half-finished. In contrast, Claude Code tends to steadily manage and complete items on a ToDo list once established, in my experience.

This characteristic provides a significant benefit in being able to reliably complete complex development tasks. I found myself losing direction less frequently, especially in implementation work requiring multiple steps. The official documentation also emphasizes the importance of the ToDo feature, recommending its "very frequent" use⁴.

Natural Feedback Loop

The aspect I found most valuable about Claude Code is how naturally feedback can be provided during implementation. With other tools, once implementation began, the only option was to interrupt, but Claude Code allows collaboration while providing feedback.

With other tools like Cline, once implementation started, the only option was to stop it, which often led to stress from repeatedly stopping processes midway to achieve desired results. Claude Code is designed with feedback in mind, creating a stronger sense of collaborative coding and allowing work to proceed more naturally.

This enables efficient development while minimizing technical debt by collaborating rather than fully automating. While autonomy is somewhat reduced, it's a significant benefit in terms of final output quality. The Claude Code Best Practices also emphasizes this "low-level flexible approach" design philosophy⁴.

Terminal Interface: Inconvenient but Has Benefits (※Resolved with IDE Integration on May 22)

One of Claude Code's major constraints was its terminal-based interface. No Visual Studio Code editor extensions were provided, requiring all operations to be performed from the command line.

$ claude                  # Launch
$ exit                    # Exit

This is honestly one of the inconvenient aspects. Terminal input is unfamiliar to many, and Visual Studio Code is often more visually accessible.

Another concern with terminals was whether conversations could be restored if interrupted, but this isn't a problem. Conversations are saved locally and can be easily resumed with the --resume command.

$ claude --resume         # Resume previous conversation

However, the terminal-based approach has benefits, such as the ability to run multiple tasks in parallel. Cline and Roo Code only operate in a single instance, preventing simultaneous execution of multiple tasks. With Claude Code, you can launch multiple terminals and assign different tasks to each⁴.

I don't yet have the capacity to review multiple tasks simultaneously, but as I become more accustomed, I'd like to eventually launch multiple terminals to work on several tasks concurrently.

Practicality of Web Search Function

The Web search function, added in a recent Claude Code update, is extremely valuable for development work⁴. It's particularly convenient that when instructed to perform work requiring research, it autonomously decides to conduct web searches.

For example, when investigating the latest API of a specific library or recent framework specification changes, it naturally retrieves necessary information and integrates it into development work. This feature significantly improves work efficiency by reducing context switching, especially in development that frequently requires referencing official documentation.

Practicality of Context Management

Superior context management is another tangible benefit during extended development sessions. When using it for quite lengthy conversations, you may occasionally see displays like "remaining context window capacity: XX%", but this feels considerably longer than when working with Roo Code. I suspect this is influenced by reducing the burden through summarization when reading documents, as mentioned earlier. Although I haven't been completely liberated from the stress of being conscious of context management, it's extremely helpful.

Token Usage Reality

What's being discussed in the developer community is Claude Code's token usage. One developer described it as "This tool uses a truly massive amount of tokens right now. Like, jaw-dropping"⁵.

Anthropic recognizes this and displays costs at the end of sessions, and allows checking during sessions with the /cost command. In my experience:

• Regular development session (2-3 hours): around $5-15
• Large-scale refactoring: can reach $30-50
• Max subscription ($200/month) provides sufficient coverage

Anthropic's Innovative Development Workflow

The best practices published by Anthropic's engineering team⁴ detail how they themselves utilize Claude Code. This goes beyond mere tool usage to demonstrate transformation of development culture through collaboration with AI.

AI Handles Over 90% of Git Operations

Anthropic engineers report that over 90% of Git operations are executed with Claude Code. This includes:

• Automatic generation of commit messages
• Resolution of complex merge conflicts
• Search and analysis of Git history
• Branch strategy proposals

What's particularly impressive is that beyond simple task automation, AI also handles context-aware analysis such as "why was this change made 3 months ago."

Dramatic Reduction in Onboarding Time

In onboarding new engineers, Claude Code functions as a pair programming partner. While previously other engineers needed to provide hands-on teaching, Claude Code now handles the following tasks, dramatically reducing onboarding time:

• Understanding codebase structure
• Explaining design philosophy
• Sharing best practices

By having Claude Code handle these tasks, onboarding time is significantly reduced while also lightening the burden on existing engineers.

Standardization of Team-wide Commands

Custom commands saved as Markdown files in the .claude/commands folder are shared across the entire team. For example:

• Routine debugging processes
• Log analysis workflows
• Performance investigation procedures

By managing these with Git, a mechanism for naturally accumulating and sharing team knowledge is created.

Practical Best Practices: Techniques You Can Try Now

1. Project-specific Configuration (.mcp.json)

{
  "servers": {
    "puppeteer": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-puppeteer"]
    },
    "sentry": {
      "command": "node",
      "args": ["./mcp-servers/sentry.js"]
    }
  }
}

By adding this configuration to your project, the entire team can use the same toolset.

2. Building a Safe Automated Execution Environment

# Full automation in Docker container
$ docker run --rm -it -v $(pwd):/workspace \
  --network none \
  claude-code:latest \
  claude --dangerously-skip-permissions

By running in a container with internet connection blocked, you can safely benefit from automation.

3. Phased Introduction Strategy

1. Start with investigation tasks: Begin with code understanding and analysis
2. Automate routine work: Lint error fixes, test additions, etc.
3. Challenge complex tasks: Refactoring, new feature implementation

Differentiation with GitHub Copilot: Respective Strengths

On May 22, Claude Sonnet 4 and Opus 4 were integrated into GitHub Copilot⁶. While this increased options, it also created a need for usage guidelines.

Claude Code's Strengths

• Long-duration autonomous work: Continuous execution up to 7 hours
• Understanding entire projects: Large-scale changes across files
• Customizability: MCP servers and custom commands

GitHub Copilot's (Claude-integrated) Strengths

• Immediate suggestions within editor: Real-time assistance during coding
• Integration with existing workflows: Complete within VS Code
• Team-wide standardization: Centralized management with Enterprise edition

My differentiation approach:

• Daily coding: GitHub Copilot (Sonnet 4)
• Large-scale refactoring: Claude Code (Opus 4)
• Investigation/analysis tasks: Claude Code (utilizing web search)

Summary: Practical Selection Criteria for AI Agent Tools

Overall, using Claude Code feels like using the app versions of ChatGPT or Claude rather than simply calling an API, resulting in an experience where multiple functions are organically integrated.

Based on my actual experience using Claude Code, I'd like to consider practical criteria for selecting AI agent tools:

1. Task completion reliability: The ability to reliably complete tasks to the end, like Claude Code's ToDo list feature
2. Natural feedback loop: How naturally course corrections can be made during implementation
3. Depth of context understanding: Can it make appropriate judgments based on understanding the entire project?
4. Cost-effectiveness balance: Economic assessment based on usage patterns

Ultimately, compatibility between these elements and your development style is important. Personal factors significantly influence the choice, such as familiarity with terminal operations, desire for frequent feedback, and importance of task management.

Claude Code exceeds being merely a code generation tool, providing value as an AI agent supporting the entire development process. Its practicality largely comes from autonomous task management and natural feedback, which can be expected to significantly improve development efficiency when properly utilized.

References