Updated August 2026. We first published this review in March. Since then Claude Code has shipped auto mode, a Chrome integration, background subagents, a desktop app with a built-in browser, cloud routines, and two model generations. Several of our original complaints no longer hold, and a few new ones have shown up. We've rewritten the sections that changed and left the rest alone.
What Is Claude Code?
Claude Code is Anthropic's agentic development tool. It started as a command-line program and that's still where we use it most, but it now also runs as a desktop app, inside VS Code and JetBrains, and as cloud sessions in the browser. The idea is the same everywhere: you describe what you want in plain English, and it reads your codebase, writes code, runs commands, creates files, and works through multi-step tasks on its own.
It's not autocomplete. It's not inline suggestions. It's closer to having a senior developer sitting next to you who can read your entire project and execute on complex, multi-step tasks without hand-holding.
We've been using it daily on real client projects since early 2026 — marketing sites, a Flutter mobile app with a Node backend, admin dashboards, this blog. Here's what we've found.
Getting Started
Setup is straightforward. Install it, authenticate with your Anthropic account, and you're running. There's no editor plugin to configure, no settings to tweak, no keybindings to learn. You open your terminal in a project directory and start talking to it.
npm install -g @anthropic-ai/claude-code
claude
That's it. It picks up context from your working directory — your file structure, your package.json, your git history, any CLAUDE.md instructions you've written. First interaction to productive output takes about 30 seconds.
If you'd rather not live in a terminal, the desktop app is the same tool with a windowed UI, an in-app browser, and (on Mac) an iOS Simulator pane. We still reach for the CLI, but it's no longer the only door in.
What It Does Well
Codebase Awareness
This is still the single biggest differentiator. Claude Code doesn't just see the file you have open — it explores your entire project. Ask it to refactor how your app handles authentication and it will read your routes, your middleware, your database schema, and your frontend components before making a single change. It greps, it globs, it reads files across directories. It understands the relationships between things.
In practice, this means you can give it high-level instructions like "shift all the copy on this site from first-person to third-person" and it will find every page, every component, every meta description, and update them all consistently. With an inline autocomplete tool, you'd be doing that file by file.
Multi-Step Task Execution
Where Claude Code really separates itself is on tasks that involve many coordinated changes. A few real examples from our work this year:
- "Add a new service tier to the services page" — it updated the data file, checked the TypeScript types, verified the CSS grid would accommodate a new card, and added staggered animation support for the 5th item
- "Merge the blog repo into the main site" — it moved the MDX content, rewired the routes under a Next.js route group, ported the theme tokens, and fixed the sitemap config, then built and committed
- "Add JSON-LD, related posts, and 'updated' dates to every blog post" — one prompt, one commit, and the schema validated on the first pass
- "Refresh the case study with the current numbers from the other repo" — it read a sibling project's docs, pulled the actual course counts and feature list, and updated the post, the projects data file, and two social drafts so nothing disagreed
Each of these would take 15-60 minutes of manual work. Claude Code handled them in a few minutes each, and the output was correct on the first pass more often than not.
Tool Use and Terminal Integration
Claude Code doesn't just write code — it runs it. It will execute your build to check for errors, run your test suite, install dependencies, and use git. When it makes a change that breaks the build, it reads the error output and fixes it before you even see the problem.
This creates a tight feedback loop that suggestion-based tools can't match. Instead of proposing code and hoping it compiles, Claude Code verifies its own work.
Auto Mode (New Since March)
Our original review complained that the approval workflow slowed rapid iteration — every file write and shell command needed a yes. That's largely gone. Auto mode replaces the per-action prompts with a background safety check: routine edits and commands just run, and genuinely risky things (destructive git commands, deleting stuff you didn't ask it to delete) get blocked or asked about. As of mid-August it's the default permission mode on paid plans.
It's the middle ground we wanted between "approve everything" and "skip all permissions." In a typical session we now go long stretches without touching a prompt, and the couple of times it did stop us, it was right to.
It Can See Your Browser Now (New Since March)
The other big complaint we had — "no visual context" — is mostly resolved. The Claude in Chrome integration lets Claude Code open tabs, click, fill forms, read the DOM, take screenshots, and read console and network logs in your actual browser. The desktop app has its own built-in browser for the same purpose.
We use this constantly: "open localhost:3000/blog and check that the related-posts block renders in dark mode" is now a thing it just does. It'll also poke around admin panels for you — with the caveat that anything irreversible (submitting forms, posting content, entering credentials) it hands back to you, which is the right call.
It's not perfect. It's slower than a human glancing at a screen, and for fine CSS work you'll still be describing what "off" means. But the "it can't see anything" limitation is no longer true.
Subagents, Background Work, and Parallelism (New Since March)
Claude Code can now spin up subagents — separate Claude instances with their own context — and run them in the background while the main session keeps working. It'll fan out a codebase search across several agents, run a code review as a background job, or (with the newer "workflows" feature) orchestrate a scripted pipeline of dozens of agents for audits and migrations.
For a small studio the practical win is more mundane: the main session stays snappy because it delegates the file-dump-heavy exploration and only gets back the conclusion. /code-review is the version of this we use most — it runs against your diff before you commit and reports actual correctness bugs, not style nits.
Plan Mode
For anything non-trivial we now start in plan mode: Claude reads the code, proposes an approach, and waits. You edit or approve, then it executes. It sounds like extra ceremony but it eliminates the most expensive failure mode — an agent confidently building the wrong thing for ten minutes.
The CLAUDE.md System
You can create a CLAUDE.md file in your project root with instructions — coding conventions, architectural decisions, things to avoid. Claude Code reads this at the start of every session. It's like onboarding a new developer except the onboarding sticks every single time.
Ours documents the route structure, the server-metadata-plus-client-content page pattern, the affiliate link registry, and "don't fire-and-forget promises in serverless handlers." Claude Code respects these consistently. It's a small feature that has an outsized impact on output quality. Skills extend the same idea to reusable procedures — a /deploy or /new-post command that carries its own checklist.
Memory Across Sessions
Claude Code has a persistent memory system that carries context between conversations. It remembers project decisions, user preferences, and feedback you've given it. If you tell it "no fixed prices on the site, custom-scoped quotes only," it saves that and respects it next time — and next month.
This is genuinely useful for ongoing projects. You don't start from zero every session.
Where It Falls Short
It Will Happily Do Too Much
The flip side of autonomy: give it a vague brief and it will build a bigger thing than you wanted. Ask for "a routine to refresh this post next week" and it'll start wiring up scheduling infrastructure when what you meant was "remind me." Ask about a file and it may start editing it. This has gotten better over the year — it asks more and assumes less — but the burden of scoping is still on you, and reviewing a large diff you didn't ask for costs real time.
The fix is habits: plan mode for anything more than a small change, and being explicit about "just answer, don't change anything" when that's what you mean.
Usage and Cost Are Harder to Predict
Token usage on large codebases is still the tax you pay for the whole-project awareness. What's new is that the tools that make it more capable — background subagents, browser control, long-running sessions, code review — also make usage spikier. A day that mixes a couple of subagent fan-outs with some browser work uses noticeably more of a subscription's limits than a day of plain edits.
/usage now breaks down what's driving your limits (by skill, subagent, plugin, MCP server), which helps. But if you're on a subscription plan you will hit the ceiling on heavy days, and if you're on the API you'll want to watch the bill.
The Pace of Change Is Its Own Cost
Claude Code ships multiple releases a week. That's great for capability and mildly exhausting for a working developer: commands get renamed, defaults change (auto mode flipping to default; subagents moving to background), and half of what you read online about it is a few months stale — this review included, until we rewrote it. Budget an hour a month to skim the "what's new" digest.
Long Sessions Degrade
Context windows are huge now (1M tokens on the current models), and Claude Code compresses old context automatically when a session runs long. It mostly works. But after a long day in one session, it will occasionally lose a detail from hours earlier or re-derive something you already settled. Starting a fresh session for a fresh task — and letting memory and CLAUDE.md carry what matters — is still the better habit.
Learning the Right Level of Specificity
There's a calibration period. Give Claude Code too little context and it might make assumptions you don't want. Give it too much and you're writing a novel when you could have just made the change yourself. Learning to communicate at the right level — specific enough to get the right output, brief enough to save time — takes practice.
The sweet spot we've found: describe the what and the why, let it figure out the how. "Add a CTA on the home page for AI automation that links to the new landing page" works better than specifying every CSS class and div structure.
How It Compares
We haven't done deep daily work with Cursor or Windsurf, so we won't pretend to offer a head-to-head benchmark. The philosophical difference has narrowed a bit — Claude Code now has an editor extension, a desktop app, and a browser — but it's still there:
IDE-based tools (Cursor, Copilot, Windsurf) are designed to augment your editing experience. They live where you already work, suggest code as you type, refactor highlighted blocks, and integrate with your visual workflow. They're at their best when you're actively writing code and want intelligent assistance in real time.
Claude Code is designed to execute tasks autonomously. You describe what you want, step away, and come back to a completed result — increasingly with a browser check and a code review already done. It's at its best when the task involves multiple files, requires understanding project context, or would take you 20 minutes of mechanical work to do manually.
They solve different problems. If you're writing a complex algorithm and want smart autocomplete, an IDE tool is probably better. If you need to scaffold a new feature across your full stack, add a landing page with routing and SEO, or refactor a pattern across 15 files — Claude Code is faster.
Many developers use both. Honestly, we've drifted toward using Claude Code for almost everything and the editor for reading diffs.
Who Should Use It
Great for:
- Freelancers and small teams managing multiple projects
- Full-stack work where changes span frontend, backend, and config
- Developers comfortable in the terminal (or willing to try the desktop app)
- Projects with clear conventions (CLAUDE.md makes a huge difference)
- Repetitive multi-file changes (refactors, rebrands, migrations)
- Prototyping and scaffolding new features quickly
- Verifying UI changes in a real browser without leaving the session
Less ideal for:
- Developers who want a fully visual, in-editor workflow
- Pixel-level CSS and animation tuning where you need to see every change instantly
- Quick one-line edits where the overhead isn't justified
- Anyone who wants a tool that looks the same next month as it does today
Pricing
Two ways to pay. Most individuals and small teams use it through a Claude Pro or Max subscription, which bundles Claude Code with the chat product under a usage limit that resets on a rolling window. Heavier users and teams can instead run it against API pay-as-you-go pricing and pay per token; the current models also offer a "fast mode" at a premium per-token rate when you want lower latency.
We're on a subscription. On a normal day it's plenty; on a heavy day of subagent fan-outs, browser work, and long sessions we bump the limit — which is the honest trade-off for the flat monthly price. Compared to the time saved, the ROI is still hard to argue with, but "predictable" is a stronger word than we'd use now.
Our Workflow
Here's how Claude Code fits into our daily process in August 2026:
- Start of day: Open the project, Claude Code picks up context from
CLAUDE.mdand memory - Feature work: Plan mode first for anything non-trivial. Approve the plan, let it build, review the diff
- Bug fixes: Paste the error or describe the behavior, Claude Code traces through the code and fixes it — and checks the fix in the browser if it's UI
- Refactors: Describe the pattern change, Claude Code applies it across the codebase
- Review:
/code-reviewon the diff before committing - Git workflow: Claude Code stages, commits with clear messages, and pushes when asked
- Cross-project work: It'll read a sibling repo for facts, keep multiple projects' copy consistent, and commit to each
The biggest mindset shift is moving from "I write code and AI helps" to "I describe outcomes and AI executes." Once you make that shift, the speed improvement is dramatic. The second shift, this year, was learning to say how much — plan mode and explicit scope are what keep the autonomy pointed in the right direction.
Bottom Line
Claude Code is still the most capable AI development tool we've used, and the gap has widened since March. Not because it writes the best single line of code — that's arguably a wash across the top models — but because it understands entire projects, executes multi-step tasks autonomously, verifies its own work in the build and now in the browser, and gets out of your way while it does it.
It's not replacing our expertise. We still make the architectural decisions, review every change, and direct the work. But it's eliminated hours of mechanical coding — the file creation, the boilerplate, the find-and-replace-across-20-files work that used to eat up afternoons — and it's started eating into the QA loop too.
If you're a developer who spends time on tasks you know how to do but that just take time to do, Claude Code is worth trying. It's a bigger, faster-moving tool than it was six months ago; the terminal-first approach still isn't for everyone, but for those who click with it, it's hard to go back.