Claude Code: When AI Stops Talking and Starts Doing

Most people who use AI for the first time are using a chatbot. They type something, the AI responds, they type something else. It’s a conversation. Useful, but contained — the AI stays inside the chat window. Nothing happens in the real world unless you make it happen.

Claude Code is different. It doesn’t respond to you. It acts.

Give it a task and it reads your files, decides what needs to change, opens the right tools, makes the changes, checks the results, and iterates until the job is done. You’re not having a conversation. You’re directing a project.

That distinction — from chatbot to agent — is the thing worth understanding before anything else, because it changes how you think about what you’re asking for and what you can reasonably expect.

What an agent actually is

The clearest analogy I’ve found: Claude Code is not a co-worker you’re talking to. It’s a project manager.

A project manager doesn’t do the work directly. They understand what you’re trying to achieve, break it down into tasks, figure out who needs to be involved, delegate the work, check on progress, and pull everything together into a result. They manage across multiple workstreams simultaneously. And when something goes wrong, they handle it — you don’t have to be involved in every detail.

That’s Claude Code. When you say “add a newsletter signup section to the homepage,” it doesn’t write a code snippet and paste it into the chat. It reads your codebase to understand how the site is structured, finds the right file to modify, writes code that fits your existing style and conventions, checks whether anything broke, and commits the change. You describe the outcome. It handles the path.

This is what “agentic” means in practice. The AI has access to tools — file editors, terminal commands, web browsers, external APIs — and it orchestrates them autonomously to accomplish goals. It’s not predicting your next token. It’s managing a project.

You don’t need the terminal

Let’s get this out of the way: Claude Code does not require you to use a command line.

There is a terminal-based version — it’s what developers typically use, and it’s the most powerful configuration. But most of what I do day-to-day happens in the Windows desktop app or the web app. You can also use it from your phone in a pinch.

The apps give you a clean interface: a project selector, a conversation window, and the agent working in the background. For building websites, writing content, automating tasks, and most things a non-developer wants to do, the apps are completely sufficient.

Where the terminal becomes necessary is when you need locally installed MCP servers — extensions that connect Claude Code to specific tools or data sources that live on your machine. For business users who want to connect Claude Code to a local database or a custom internal tool, that’s a terminal-level task. For everything else, the apps cover it.

The terminal is for advanced users and developers. Don’t let it be the reason you don’t start.

Getting started: three steps

The setup that actually matters has three parts:

1. Create a GitHub repository

Your project needs a home on GitHub. If you’re starting a website or a new project from scratch, Claude Code can help you set this up — just describe what you’re building and ask it to create and push the repository. If you already have code somewhere, you’ll need to push it to GitHub first. See the guide on building with GitHub if this step is new to you.

2. Install Claude Code and point it at the repository

In the desktop app or web app, you connect Claude Code to your GitHub repository. It reads the files, builds an understanding of the project, and from that point on, it knows the context — your naming conventions, your folder structure, your existing code patterns. This is what lets it make changes that fit rather than clashing with what’s already there.

3. Set up a cloud environment

This step connects Claude Code to a live environment where it can actually run your code, test changes, and deploy results. For a website, this usually means connecting to your Cloudflare Pages or equivalent deployment. Once this is in place, Claude Code can make a change, trigger a build, check whether the deployment worked, and iterate if it didn’t — all without you touching anything.

After these three steps, you’re operational. Give it a task and see what happens.

Phase one: the dopamine hit

Here is what happens to most people in the first week.

You describe something you’ve been meaning to do — add a page, fix a layout issue, write some content, build a small tool — and Claude Code just does it. Completely. Correctly. In the time it would have taken you to open the right file, it’s already committed and deployed.

You immediately think of three more things you’ve been putting off. You do those. Then five more. You go to bed at midnight having shipped more in one evening than in the previous month.

This phase is real. The productivity step-change is genuine, not hype. And it’s addictive in exactly the way you’d expect — you keep chasing the next result, running three or five things in parallel, watching Claude work. I genuinely sometimes find it hard to stop for the night.

Enjoy this phase. It’s earned. But it doesn’t last forever.

Phase two: hitting the ceiling

At some point — different for everyone, usually within the first few weeks — you hit a wall.

Claude Code misunderstands something and goes off in the wrong direction. It makes a change that works in isolation but breaks something else. It confidently handles a task wrong because it didn’t have the right context. You find yourself correcting the same kinds of mistakes repeatedly.

The tempting response is to get frustrated and conclude that Claude Code isn’t as good as you thought. That’s the wrong conclusion.

The right conclusion is: you’ve outgrown the default configuration. Claude Code out of the box is impressive, but it doesn’t know your specific projects, your conventions, your preferences, your constraints. It’s working from general knowledge. The ceiling you’ve hit is the ceiling of that general knowledge.

The next step isn’t learning more settings. It’s building your systems.

Building your system: where the real power is

This is where most guides stop, and it’s where the actual leverage lives.

The CLAUDE.md file

Every project can have a CLAUDE.md file — a document that Claude Code reads at the start of every session. Think of it as the onboarding document for a new project manager joining your team. It can contain:

• What this project is and what it’s for
• Conventions and rules to follow
• What not to touch
• How deployments work
• Anything Claude keeps getting wrong

Once you have a well-written CLAUDE.md, a lot of the repeated corrections disappear. Claude already knows what you’d correct it on.

Skills

Skills are reusable instructions you can invoke at any time — think of them as saved procedures. “When I say /review-pr, check the current pull request for issues and summarize what changed.” “When I say /deploy, run the build checks and push to production.” You define these once and call them whenever you need them. Over time, you accumulate a library of things Claude can do reliably, on demand.

MCPs (Model Context Protocol servers)

MCPs are extensions that give Claude Code access to tools and data it wouldn’t otherwise have. An MCP can connect Claude to your calendar, your project management tool, your database, a web browsing capability, or a custom internal system. The more MCPs you have configured, the more workstreams Claude can actually manage. This is where Claude Code starts to feel less like a coding tool and more like an operating system for your work.

Knowledge

This is the one most people underestimate. Claude Code is only as useful as the context it can draw on. If it doesn’t know your company’s conventions, your product’s structure, your audience’s characteristics — it works from generic assumptions. Feeding it the right knowledge (documentation, reference material, past decisions) changes the quality of everything it does. I’ve written about this more extensively in the guide to building a company AI OS.

These four — CLAUDE.md, skills, MCPs, knowledge — are what separate people who “use Claude Code” from people who have actually built something with it. The gap between the two is enormous.

Working with GitHub: what you actually need to know

Claude Code is built around GitHub. Most of the time it handles this invisibly — it creates branches, commits changes, and opens pull requests for you to review and merge. You approve the result, merge the PR, delete the branch, done.

But at some point you’ll want to do more than approve pull requests. You’ll want to check what’s in one, open one yourself, handle a conflict. GitHub is not actually complicated — it’s very well documented and the web interface is straightforward — but it’s worth spending an hour learning the basics before you need them under pressure.

One thing that took me a while to discover: you can connect Claude Code to multiple GitHub repositories simultaneously. It can read from one and write to another, or work across several at the same time. This is genuinely powerful for knowledge management — I’ve connected three repositories at once, transferring insights from one project to another, keeping shared knowledge bases in sync without redundant manual work.

Honest about the rough edges

Claude Code is an excellent product with real rough edges. You should know what you’re getting into.

It’s not well productized for non-technical users. When something goes wrong, the error messages are often highly technical and occasionally useless. You’ll see stack traces and exit codes that tell you nothing actionable. The right response is to paste the error into Claude and ask what it means — but it’s jarring the first few times.

Claude doesn’t know itself very well. Claude Code has limited, sometimes outdated knowledge about its own features and how the software works. It can’t give you reliable guidance on its own configuration options from memory. What it can do is browse the official Anthropic documentation and search for relevant guides — ask it to do that when you’re trying to understand a feature. It will figure it out, just not from internal knowledge.

The UI has quirks. The app sometimes doesn’t refresh properly — you’ll need to switch to another conversation and back, or restart the app entirely. Connection errors appear randomly. Anthropic’s servers occasionally run hot enough that responses slow dramatically or fail. None of this is a dealbreaker, but it’s real.

The token limits are the most frustrating constraint. There are per-session limits (the five-hour reset most people know about) and weekly limits that hit much harder if you’ve had an active week. If you’re deep in a project and hit your limit, you stop. There’s not much to do except wait or pay for more. One workaround worth knowing: if you’re a Google One AI Premium subscriber, you can use Claude Opus through Antigravity to keep working when your Claude Code budget runs out.

Model choice matters more than most people realize

Claude Code lets you choose which Claude model runs under the hood. The default is Sonnet, and benchmarks genuinely support the claim that Sonnet is strong at coding and logical problem-solving — it may well be the best choice for most tasks.

In practice, though, I reach for Opus when working with a complex repository where I need the highest quality reasoning. On a large codebase with a lot of context to hold, Haiku feels noticeably limited. The right choice depends on what you’re doing:

• Haiku: Fast, cheap, good for simple, well-defined tasks in small repositories
• Sonnet: The practical default — strong reasoning, manageable cost, handles most work well
• Opus: Best quality, higher cost, worth it when the task is complex and getting it right matters

If something Claude Code does feels slightly off or shallow — if it’s missing context it should have or making decisions that seem underthought — try switching to a more capable model before assuming the task is too hard.

The thing nobody warns you about

You will become addicted.

Not metaphorically. The combination of immediate results, parallel workstreams, and the feeling of pure leverage creates a feedback loop that’s genuinely hard to step back from. I’ve caught myself at midnight thinking “I could just kick off one more thing before I go to sleep” — and then it’s 1am and three things are running and I’m watching the pull requests come in.

This is fine, mostly. The work is real, the results are real. But it’s worth being aware of, especially when your token budget runs out mid-week because you went too hard on a Monday.

The other side of this: once you’ve worked this way for a few months, going back to doing things manually feels genuinely strange. Not impossible. Just slow. You develop a strong intuition for what Claude Code should be able to handle, and you instinctively start framing things as tasks to delegate rather than things to do yourself.

That shift in how you think about work — that’s the real product.

---

Claude Code works best on top of the right foundation. If you haven’t set up the GitHub + Cloudflare Pages pipeline yet, the guide to building a free website with AI covers that from scratch. And for connecting Claude Code to a broader knowledge system across your organization, the guide to building a company AI OS is where that thread continues.