Claude Code Changed How I Work
I have tried every AI coding tool that came out in the last two years. GitHub Copilot, Cursor, Windsurf, Cline, Aider. They all made me faster to some degree. But Claude Code is the first one that genuinely changed how I approach work. Not because it writes better code (though it does), but because it operates at a completely different level of abstraction.
With Copilot or Cursor, you are still in the driver's seat. You write code and the AI suggests the next few lines. Maybe you use chat to ask it to refactor something. But you are always looking at files, positioning your cursor, accepting or rejecting suggestions.
Claude Code does not work like that. You describe what you want in plain English. It reads your codebase, makes a plan, writes the code across multiple files, runs the tests, sees the failures, fixes them, and creates a commit. You are not guiding it line by line. You are delegating entire tasks.
What Claude Code actually is
Claude Code is Anthropic's agentic coding tool. It runs in your terminal. There is no IDE to learn, no UI to navigate. You type claude and start talking.
cd your-project
claude
That is it. You are in an interactive session where you can describe what you want, and Claude Code will figure out how to do it. It can:
- Read and edit files across your entire project
- Run shell commands (tests, builds, linters, anything)
- Create git commits with meaningful messages
- Search your codebase for relevant context
- Navigate and understand complex project structures
- Execute multi-step workflows with error recovery
The install is a one-liner:
curl -fsSL https://claude.ai/install.sh | bash
You need a Claude subscription (Pro, Max, Teams, or Enterprise) or a Claude Console account. No free tier.
How it works in practice
Here is what a typical session looks like. Say I have a Next.js app and I want to add rate limiting to an API route.
I open a terminal in the project root and type:
claude "Add rate limiting to the /api/chat route. Use an in-memory store
with a sliding window of 10 requests per minute per IP. Return 429 with
a retry-after header when the limit is hit. Add tests."
Claude Code will:
- Read the existing route handler to understand the current structure
- Look at the project's dependencies and test setup
- Create a rate limiting utility
- Modify the route handler to use it
- Write tests for the rate limiter
- Run the tests
- If any fail, read the error output, fix the issue, and run them again
- Show me a diff of everything it changed
I review the diff, and if it looks good I tell it to commit. The whole thing takes a minute or two, and the result is usually solid enough that I only need minor tweaks.
The permission system
Claude Code can run shell commands and edit files, which means it needs guardrails. The permission system has three modes:
Ask mode (default): Claude Code asks for permission before running any command or editing any file. You approve or deny each action.
Auto-edit mode: File edits are approved automatically, but shell commands still require approval.
YOLO mode: Everything runs automatically. Useful for trusted environments like CI/CD but risky on your local machine.
You can also configure tool-level permissions. For example, allow read operations automatically but require approval for writes and shell commands. Or allow specific commands like npm test to run without asking.
claude --allowedTools "Read,Bash(npm test),Bash(npm run lint)"
Beyond the terminal
Claude Code started as a CLI tool but it now runs almost everywhere:
- Terminal (CLI): The core experience
- VS Code: Native extension with inline diffs
- JetBrains IDEs: Plugin for IntelliJ, PyCharm, WebStorm
- Desktop app: Standalone application with diff review and parallel sessions
- Web: Run it at claude.ai/code with no local setup
- GitHub Actions: Automate code review and issue triage in CI/CD
- GitLab CI/CD: Event-driven automation for merge requests
- Slack: Mention Claude to route coding tasks and get PRs back
- Chrome extension: Connect to your browser for live debugging
The web version is particularly interesting. You can work on repos you do not have cloned locally, run multiple sessions in parallel, and review changes in a built-in diff view.
Subagents and the Agent SDK
One of the things that makes Claude Code feel like more than just a fancy autocomplete is subagents. You can define specialized agents for specific tasks:
claude --agent '{"name": "test-runner", "tools": ["Bash"], "instructions": "Run the test suite and report failures"}'
The Agent SDK takes this further. It is available as a CLI, Python package, or TypeScript package, giving you the same tools and agent loop that power Claude Code but in a programmable form:
import { ClaudeCode } from '@anthropic-ai/claude-code';
const agent = new ClaudeCode({
prompt: 'Review the PR diff and list potential issues',
allowedTools: ['Read', 'Bash(git diff)'],
});
const result = await agent.run();
This is what enables the CI/CD integrations. You can write a GitHub Action that runs Claude Code on every PR to check for bugs, suggest improvements, or auto-fix lint issues.
Hooks for automation
Hooks let you run custom logic at specific points in Claude Code's execution. For example:
- Pre-tool hooks: Run before Claude executes a tool (useful for validation or logging)
- Post-tool hooks: Run after a tool executes (useful for cleanup or notifications)
You can use hooks to automatically format files after Claude edits them, send notifications when certain commands run, or enforce project-specific rules.
How it compares to Cursor and Copilot
I still use Cursor for certain tasks. The in-editor experience is better when I am doing focused work on a specific file and want inline suggestions. Cursor's Composer feature for multi-file editing is good.
But for anything that involves understanding a large codebase, running commands, or executing multi-step tasks, Claude Code is in a different category.
Here is how I think about the three:
GitHub Copilot is autocomplete. It predicts the next few lines based on context. It is fast, it is convenient, and it works in every editor. But it does not understand your project as a whole and it cannot take actions.
Cursor is an AI-native IDE. It has good chat, good inline suggestions, and Composer for multi-file edits. It understands project context reasonably well. But it still requires you to drive most of the process.
Claude Code is an autonomous agent. You describe a task and it executes it. It reads files, runs commands, iterates on errors, and produces a complete result. On the SWE-bench benchmark (a standard measure for AI coding ability), Claude Code with Claude Sonnet 4.5 achieves a 77.2% solve rate, which is the highest of any tool as of this writing.
In practice I use Claude Code for:
- Building features from descriptions
- Debugging complex issues across multiple files
- Refactoring and migrations
- Writing tests for existing code
- CI/CD automation and code review
And I use Cursor for:
- Quick edits where I know exactly what I want
- Exploring unfamiliar code with inline chat
- Small tweaks where the overhead of a terminal session is not worth it
The composability angle
The Unix philosophy of Claude Code is underrated. Because it runs in a terminal, you can pipe things into it:
tail -f app.log | claude -p "Alert me on Slack if you see any errors"
git diff main..feature | claude -p "Review this diff and list potential issues"
claude -p "If there are new text strings in the codebase, translate them to French and open a PR"
This makes it useful far beyond interactive coding sessions. You can embed it in scripts, cron jobs, CI pipelines, and monitoring workflows.
What I wish was better
The lack of a free tier is frustrating. You need at least a Pro subscription ($20/month). Cursor has a free Hobby plan. Copilot has a free tier. For Claude Code, you pay from day one.
The terminal interface, while powerful, has a learning curve. If you are used to the visual feedback of an IDE with inline diffs and syntax highlighting, going back to plain text takes adjustment. The VS Code extension helps but it is not as mature as Cursor's editor integration.
Session management could be better. Long sessions sometimes lose context or start repeating themselves. The -c flag to continue a session and -r to resume a specific one help, but it is not always smooth.
And the permission prompts in ask mode get tedious fast. You end up typing "y" dozens of times in a session. Auto-edit mode is a good middle ground but it still asks for shell commands, which is where most of the interesting work happens.
Where this is heading
The trajectory is clear. AI coding tools are moving from suggestion to execution. Copilot started with autocomplete. Cursor added multi-file editing. Claude Code added autonomous task execution. The next step is probably persistent background agents that monitor your project, catch bugs before you notice them, keep dependencies updated, and open PRs for routine maintenance.
Claude Code already supports this through its CI/CD integrations and the Agent SDK. The pieces are in place. It is just a matter of the tooling and trust models maturing.
For now, Claude Code is the closest thing to having a second developer on the team who happens to be available 24/7, never gets tired, and can read your entire codebase in seconds. It is not perfect. But it is enough to change how I work, and I am not going back.