Initial Thoughts: Claude Code 2025

TL;DR: Claude Code is worth every part of the $20 I'm paying for it (I'm not receiving any consideration for this review). In fact, if I was running a coding team, I would easily pop for a team license for this thing because it's that good.

The only thing it's not very good at, and this is a very big thing, is undoing its updates and you have to rely on Git a bit too much.

A Discussion On Speed

I think it's important to start off by acknowledging that Claude Code is a tool that accesses an LLM on a server somewhere in the cloud, wherever Anthropic (the company that created Claude Code and a bunch of LLMs) has set up an API endpoint for various tools to access.

I bring this up because people will rightly want to know if Claude Code is faster than Cursor, for instance, or Copilot. This kind of question has a complex answer, because I would use the same LLM with each of these tools: Claude Sonnet 4, which is my go-to at the time of this writing.

We now have at least three considerations when it comes to the notion of speed:

• The raw speed of your editor or IDE, which is probably VS Code or one of its forks.
• The responsiveness of the API endpoint you're hitting that is then calling over to the LLM you've chosen.
• The responsiveness of the LLM itself.

In terms of editors and IDEs, you can't get much faster than the terminal, which is where Claude Code lives. The last two considerations are the largest.

I don't have exact schematics for how the LLM calls work, but I have set up a few raw ones on Azure for OpenAI and they are a wee bit complicated. For our purposes, we can imagine a few backend systems sending messages around, trying to fulfill our chat request. If those backend systems are on Azure or AWS, how fast they respond will depend on how optimized/scaled out the overall system is.

There are different load profiles too, meaning that middle of day PDT will likely have far more requests than 3am PDT, so the system might "seem" to respond faster.

Finally, the LLM responsiveness is entirely based on the reasoning it has to do to respond to your prompt. If you have a lot of context (instructions, code files) and a big prompt, the answer will take longer.

If you're building out documentation that requires crawling over every code file in your project, the answer will take a very long time, possibly 5 minutes or more.

All of this to say a simple thing: pondering the speed of an AI tool is a fool's errand. Sure, some tools might cache context, rewrite/reduce your prompt for you, or some other trickery behind the scenes to appear faster, but that doesn't make the tool itself any faster.

Claude Code, however, does something that I think is wonderful, and makes it feel like it's zipping along, doing your bidding. I'll describe that below.

Installation

When I was creating the Learn Python video I'll be honest: I was expecting a clunky terminal interaction that really belongs in an editor or IDE. A terminal is good at terminal things, an IDE is good at interactive coding. Why mix the two?

I was wrong, and I'm happy for it. In fact I'll go so far as to say that you might not even need an IDE (and yes, I'm slotting VS Code in that category) if you're happy working in a terminal and know your basic commands. I can't believe I just wrote that, but here we are.

Getting started with Claude Code is as simple as running an NPM command (you'll need Node > 18 to run the CLI):

npm i -g @anthropic-ai/claude-code

This will install Claude Code globally and, the first time you run the binary claude, it will set up and configure things for you.

Setting Context

One thing I keep pushing people to do is to set up your dang instructions! It's like making white rice: wash it first! You can't expect your LLM to know what it is you prefer unless you take the time to tell it, which you can do with Claude Code by adding a CLAUDE.md file to the root of your project.

This is how Claude Code works: you start a session in a given project directory, and that sets the context for any requests you make. That's it. This is the first thing I love about Claude Code: it is so, so simple.

Still, I want to be sure I add my own context too, which is what the project is about, the stack I'm using, code styles, and so on.

Here's the starter I used for the Python video:

# Learning Python while building a database

I want to learn Python and build an ecommerce API application using best application practices for Python in terms of stack. 

Explain things to me as you go, but treat me like someone with over 20 years experience. I know a lot of languages, so just get to the point.

Comments should be short and instructional. Create them so I can read and understand what's going on (and why) as opposed to documenting the code.

Critical that any code generated by "pythonic" and idiomatic. I want to learn what an experienced Python person would do. Working code is good, idiomatic is better.

## Database

 - Database tables will be lower cased using underscores.
 - Every table will have an integer primary key called `id`.
 - `char`, `varchar` and `nvarchar` are never to be used for string fields, only `text`.
 - Use SQLite3 for development and testing, PostgreSQL for production.
 - Every table should have `created_at` and `updated_at` timestamps.
 - Many to Many relationships will have compound primary keys, never a single ID with compound unique.

## The Spec

This is an ecommerce store that will deliver both digital and physical goods. To that end, we need to track:

 - `products` with a sku, name, price, description, and type (digital, hardware, kitchenware, clothing, etc).
 - `inventory` that tracks products and their stock levels as well as location. For digital products, this should indicate download URL.
 - `orders` with a unique, random `number`, `total` in pennies, `date`, `status`, `transaction_id` if it's checked out.
 - `customers` with unique email, name, lifetime value

It's important to note that I don't know Python and the purpose of this exercise is to 1) play with Claude Code and 2) see if Python will finally stick in my brain! The video turned out really well - you should go watch it if you haven't.

The Problem with Copilot's Flow

One thing that drives me nuts about the Copilot extension in VS Code is the noise:

There are a lot of words in this panel that don't make sense to someone unfamiliar with AI tooling, especially the placeholder: Edit files in your workspace in agent mode. Do what with what now?

Then there are the buttons, drop-downs, and icons that really don't belong there (a microphone and paper airplane?).

Note: Microsoft has a mandate that any UI tools you create must comply with accessibility guidelines within the company. Having voice input here isn't a choice, my question is "why is it an icon at the bottom right?".

The idea here is that if you have a simple question, you use "Ask" mode and you get an answer as a chat response. If you have an edit to make, you go into "Edit" mode and the file you're on gets edited, pending your approval.

If you really want to edit things, you use Agent mode, which goes off and does all kinds of things to multiple files at once, and then asks you if that's OK. It's powerful stuff, and what I use most of the time.

There are a few problems with this, however:

• Why the "modes"? It's natural to ask questions, investigate, and then give a command. Followup questions with command options feels better, to me, at least.
• The responses tend to be quite different. Ask and Edit, for instance, don't seem to have the iterative prompt building step that Agent mode does, and therefore don't seem as complete. This is my impression, anyway.
• Switching between modes is clunky and unnatural. For instance: I might want to know what the best ORM is for Python, see an example using a local SQL file as reference, and then have Copilot make a class for me. Up until recently that required a few mode switches in Copilot, and it still does and it's hard to say when or why, but the extension does this for you now.

We discussed this flow a lot when I was at Microsoft and, to the team's credit, they love the feedback. The UX bits are always evolving and I'm sure this will get streamlined at some point.

Claude's Version: More Intuitive

There's a single input box with Claude Code and some hints/tips for how to use it:

I love this. So, so simple. Let's start with the ORM question above and see how this flows:

That last paragraph is enabled by the CLAUDE.md file I'm using, which explains this will be an e-commerce project using SQLite3 and PostgreSQL (for production) and that I want things to be "pythonic", whatever that means (I was told it was important from a Python person).

Oh Yeah? Show Me...

I love how I feel more in control of Claude Code's process and that I can ask follow up questions and move at the pace I'm comfortable with.

To that end, show me the code before I decide one way or another:

Claude replies that it will follow my specs and whip up a sample models.py file, which apparently is how Python people do it: all it one file. I'm OK with that!

Scrolling down, I can read through the code and see if anything catches my eye. If I see something I don't like, I can tell Claude to fix it:

I love the follow ups! I also love the idea of "just do this thing and stop asking questions", which is VS Code's way of doing things (more on that in a second).

Speaking of, here's one last thing I absolutely love about Claude Code! You can go "Full YOLO" mode, if you want, and tell it what you want to do. Something like set up a bare bones Python project that will use Flask and SQLAlchemy:

I LOVE the todo list here. You can see everything that is about to happen and you'll be asked for approval before it happens. You can alternatively tell Claude to "just DO IT" and it will cruise through the tasks, letting you know what it's doing as it goes along.

Copilot's Version

Let's run through this again, but with Copilot. I might do another post focusing on Cursor and Windsurf, but for now I need to keep this post under a million words.

I'll start with the same prompt in "Ask" mode, using the same context instructions (.github/copilot-instructions.md): What is the most popular ORM for Python?

The answer here is pretty lengthy, which I appreciate, and says basically the same thing. I like the alternative suggestions too.

The last bit is helpful too:

I think this is a recent addition to Copilot as I don't remember this being an option before - but I get flipped in to Agent mode and things are set up for me, which is great.

I have time to get up, get a coffee, go to the gym, and call my friends, because I'll be here for a while...

Oops. Not That. Uh Oh.

This is another difference between Claude Code and Copilot: Agent mode in Copilot will go off unless you pause it.

This is what I ended up with after a few minutes:

I have the foundation of a decent Python project here, which is considerably more than I asked for. This would be my fault, of course, because I just went with the follow up question when asked the question:

Want me to set up a SQLAlchemy-based project structure for your ecommerce API?

I probably should have said no, and used my prompt "show me an example in context".

Oh, wait, I can!

Copilot gives you a way to "back out" of any changes the Agent makes:

You can pause (or in my case hit "Cancel" when prompted for a shell command) and then click "Undo". To keep the changes, you obviously have to hit "Keep".

This works pretty well with code changes, but it won't delete files, which makes sense because how would it know if it created those files in the first place? There probably is a way to know, but... whatever, here's what happens when I hit "Undo":

I have a bunch of empty files. No biggie - I can delete those myself, and I will!

Next, I'll prompt Copilot in the same way I did with Claude Code: Show me an example in context...

Out comes a bunch of code which I can then review. It's the same LLM (Claude Sonnet 4) so I'm not going to compare/contrast the answers, but it's a much different process.

Here's where we leave off, without a followup prompt:

Which is too bad because it would seem to be a natural place to ask: "should I create these files for you?". I can do that myself, however, by switching in to Agent mode and prompting create these files (I did, and it did).

How To Undo Things In Claude Code

There are two ways I learned to undo things with Claude Code:

• Get good at Git. Make sure you're working in a branch and you're comfortable rolling back to HEAD or the last commit.
• Ask Claude to undo itself.

I've used both ways and honestly haven't had a problem. The Git solution feels the most natural by simply using git checkout --, which rolls back to the last commit.

Asking Claude to undo its own changes is obviously a gamble, but it worked perfectly the three times I did it. It takes longer, but if you haven't committed your changes in a while, this might be your only way out.

Summary

The VS Code team could learn a thing or two about the natural workflow of Claude Code, leveraging follow up questions and working off a task list. It feels so much more intuitive and simple to understand.

The Anthropic team could learn a bit from VS Code about using Undo. This one seems super obvious, and I can't imagine it's not coming in some form. Then again, the Unix world has a great philosophy: do one thing well. Git is really good at version history, why reinvent the wheel?

As for me: I love Claude Code and will definitely continue to use it as my go-to. I'm a terminal person anyway, and happy to lean on it more.

Have any recommendations for me? Let me know!