Tools of the Trade

TL;DR: There are three ways to work with AI: talk to it directly in a chat, use an all-in-one platform that handles everything, or use an agent-assisted tool where you control the files and decisions. This chapter maps the landscape — and explains why we recommend starting with one approach before graduating to another.

---

When people say "I built this with Claude" or "I used GPT to make my website," they're skipping a layer. You don't work with the AI model directly — or rather, you can, but it's just one of three approaches. Each puts a different amount of machinery between you and the model, and that machinery decides how much control you get.

Chat interfaces

This is where most people start. You open a website — ChatGPT, Claude.ai, Gemini — type what you want, and the model responds. That's it. No files, no project, no automation. Just a conversation.

Chat works well for small, self-contained tasks: "write me a function that validates email addresses," "generate the HTML for a pricing table," "explain what this error message means." You copy the output, paste it wherever you need it, and move on.

And it's not just code. People use chats for writing, research, brainstorming, analysis — anything where you want a quick answer or a draft. Need a marketing email? A summary of a long document? A meal plan? Chat handles that fine.

The limitation shows up when the task gets bigger. Say you're writing a guide with ten chapters — each one a separate file, with cross-references between them, images, a glossary, and a consistent voice throughout. In a chat, you'd have to paste content in, get output back, paste it into the right file, remember what you changed in chapter 3 when you're working on chapter 7. The model can't see your files, can't remember what you did earlier, and can't work across multiple documents at once. You become the glue holding the project together.

That's where the line between a chat and an agent-assisted tool becomes clear. It's not about code vs. non-code — it's about whether your task lives in a single conversation or spans multiple files and sessions. A chat is a conversation. An agent-assisted tool is a working environment.

All-in-one platforms

These tools run entirely in the cloud. You describe what you want — in plain language — and the platform builds it, hosts it, and deploys it for you. You might never touch a file directly. Just describe, preview, tweak, and publish.

The appeal is speed. You can go from idea to working prototype in minutes. The platform handles the technical decisions: what framework to use, how to structure the code, where to host it. You focus on what you want, not how to build it.

The tradeoff is control. You work within what the platform supports. If you need a specific database, a custom component, or a feature the platform doesn't offer — you're stuck. And your project lives on their servers. If they shut down, change pricing, or deprecate a feature, your project is affected. Moving your code elsewhere can range from inconvenient to impossible.

If you want to start working on apps, try an all-in-one platform first. Try Lovable, Replit, or one of the others. The value-for-money is excellent for straightforward projects. You'll have something working in minutes, not hours.

But here's the real reason: you need to hit the wall. Every platform has limits — a component you can't customize, a database you can't connect, a feature that's just not possible within the platform's boundaries. When you hit that wall, you'll understand why agent-assisted tools exist and what they give you. That understanding makes the transition natural instead of forced.

Agent-assisted tools

This is where the rest of this guide lives.

Agent-assisted tools install on your computer. Your files live on your machine. The AI agent reads your files, takes instructions, writes code, runs commands — all locally. When you're done, the files are right there on your hard drive, in folders you control.

The platform layer here is thin. It connects you to the AI model and gets out of the way. You pick your own tools, your own framework, your own database. You decide where and how to deploy. The agent is powerful — it can make changes across multiple files, run your tests, browse the web for documentation — but you are the one making the decisions.

More setup, more to learn, full control.

Two ways to talk to your computer

Before we look at specific tools, you need to understand two interfaces — because the tools below use one or both.

CLI (Command Line Interface) — A text-only way to talk to your computer. No buttons, no menus. You type a command, press Enter, get a result. If you've ever seen a black screen with green text in a movie — that's it (though in real life it's usually white text on a dark background). Think of it like the old DOS prompt: C:\> dir listed your files, C:\> copy file.txt backup.txt copied them. The Mac/Linux equivalent is called a terminal. Same idea, different name.

IDE (Integrated Development Environment) — A visual application where you write code. It looks like a souped-up text editor with extra powers: it can highlight syntax in color, catch errors as you type, manage your project files in a sidebar, and run your code with a button click. Think of it as the difference between writing in Notepad vs. writing in Word — same content, but one gives you a lot more help. Examples: VS Code, Cursor, Windsurf, Antigravity.

The key distinction: a CLI is text commands, an IDE is a visual application. Some tools work in both — Claude Code started as a pure CLI tool but now also runs as an extension inside VS Code (an IDE). You'll see this pattern: the boundary between CLI and IDE is blurring.

The tools

VS Code: the foundation

VS Code (Visual Studio Code) is a free IDE made by Microsoft. It's the most widely used code editor in the world. On its own, it's a solid text editor with syntax highlighting, a file explorer, and a built-in terminal. But what makes it special is its extension system.

Extensions are add-ons that give VS Code new abilities. Think of VS Code as a smartphone and extensions as apps — the phone is useful on its own, but the apps are what make it powerful for your specific needs. You install extensions with a few clicks inside VS Code — no terminal commands, no configuration files.

This matters because multiple AI agents can run inside VS Code as extensions, and you can install more than one at a time. Each brings a different model and different strengths:

• Claude Code — Anthropic's agent. The most autonomous of the group. It can read your entire project, make changes across multiple files, run commands, and spawn sub-agents to work in parallel. Uses Claude as its model.
• GitHub Copilot — Microsoft/OpenAI's agent. Built into VS Code natively. Strong at inline code suggestions — it predicts what you're about to type and offers completions as you go. Uses GPT and Codex models. Included free with VS Code, with a paid tier for more features.
• Codex — OpenAI's autonomous coding agent. Works like Claude Code — you give it a task and it works independently: reading files, writing code, running tests. Uses OpenAI's models. Currently in preview; requires an OpenAI API key.
• Gemini Code Assist — Google's agent. Connects to Gemini models. Good at explaining code and answering questions about your project. Free tier available.

You can have all of these installed simultaneously. Each is its own separate extension with its own panel — they don't talk to each other, and you can't swap the AI model inside one agent for another. Claude Code always uses Claude, Copilot always uses GPT, Codex always uses OpenAI's models, Gemini Code Assist always uses Gemini. They're separate tools that happen to live in the same editor. In practice, many developers use Copilot for quick inline suggestions while using Claude Code or Codex for larger tasks that require more autonomy.

This is the key difference from Cursor. Cursor is built on top of VS Code, but it takes the opposite approach: one agent, many models. Instead of installing separate extensions for each AI, Cursor lets you switch between Claude, GPT, Gemini, and others from a single dropdown — even mid-conversation. That's convenient if you want to try different models for different tasks without juggling multiple extensions. The tradeoff: Cursor costs $20/mo on top of whatever the AI model costs, its agent is less autonomous than Claude Code — more of a copilot than an independent agent — and it limits how much you can use each model. You get a monthly quota per model, and once you hit the cap, you either wait or switch to a cheaper model.

Windsurf and Antigravity also built on VS Code's open-source foundation, each baking their own AI features directly into the editor. That's why they all look similar (same sidebar, same file explorer, same layout) but each has its own approach to AI built in rather than added as extensions.

So when you learn VS Code, you're not learning one tool — you're learning the interface that nearly every agent-assisted tool uses.

Claude Code: terminal or VS Code?

Claude Code is the only tool here that works in two very different interfaces. Which one you use depends on your comfort level:

Same agent, same capabilities, same model underneath. The difference is purely how you interact with it.

What all agent-assisted tools share

• Your files stay on your computer
• You can use Git (a version control system — think of it as an infinite undo button that also lets multiple people work on the same project) to track changes (we'll cover Git and GitHub in Chapter 7)
• You choose where and how to deploy your project when it's ready
• You need to understand at least the basics of your project's structure

What this guide recommends

For the agent-assisted path, this guide uses VS Code + the Claude Code extension. Here's why:

VS Code is free and has a massive ecosystem of extensions. The Claude Code extension gives you the full power of Claude's agent — sub-agents, tool use, web browsing, autonomous execution — inside a visual editor where you can see your files and code. You get the best of both worlds: a proper IDE for when you want to look at things, and a powerful agent for when you want things done.

What about Cursor? Cursor is a strong alternative. Since it's built on VS Code, it looks and feels similar — but it ships with its own AI agent baked in rather than using an extension. Two advantages: it lets you switch between AI models mid-conversation (Claude today, GPT tomorrow, Gemini for a quick cheap task), and its inline code suggestions are polished. The tradeoff: it costs $20/mo on top of whatever you pay for the AI model, and its agent is less autonomous than Claude Code — it's more of a copilot that works alongside you than an independent agent you dispatch.

Both are solid choices. This guide uses Claude Code because it teaches you the most about how agents actually work — and because you can start with a tool you already have access to through a Claude subscription.

Comparison at a glance