Claude Code vs Claude.ai: Skills, Agents, and Workflows

The Confusion Nobody Talks About

You use Claude.ai in your browser at work. You've heard about . Someone mentions "agents" or "workflows" or "skills," and you assume it's the same Claude you already know — just with a fancier name.

It isn't.

Claude Code and are two different products built on the same underlying model. The concepts that make Claude Code powerful — skills, subagents, hooks — either don't exist in Claude.ai or exist in a weakened, manual form. Nobody explains this clearly, so you're left wondering if you're missing something.

You might be. This guide tells you what, exactly.

You've probably used both without realizing they're different products

Claude.ai is the browser app at claude.ai. It's a chat interface — you type, Claude responds, you type again. It has Projects (saved context) and file uploads, but every action starts when you send a message.

Claude Code is a CLI you install in your terminal. It can read files, write files, run shell commands, and chain dozens of steps together — without you typing anything in between.

Why the terminology doesn't map cleanly

Anthropic uses the same word — "Claude" — for both. That's the confusion. When the docs say "Claude Code agents" or "Claude Code skills," those terms describe Claude Code-specific architecture. They don't describe anything in the browser app.

What Claude.ai Actually Is

Claude.ai is a conversational AI assistant. Great for writing, brainstorming, explaining concepts, reviewing code snippets. You send a message, you get a response. That's the loop.

It doesn't run code for you by default. It doesn't open files on your computer. It doesn't do anything between your messages — it just waits.

It's a conversational tool — every action requires your next message

If you ask Claude.ai to refactor a function and then test it, you'll get a text response with the refactored code. You then copy it, run it yourself, come back with the result, and start a new turn. Every step is manual.

This isn't a flaw — it's the right tool for a lot of tasks. But it's important to understand the ceiling before you wonder why the floor isn't moving.

Projects: the closest thing to persistent context

Claude.ai has a feature called Projects. You give a Project custom instructions (like "you're a Python expert, always suggest type hints") and it remembers your conversation history within that project. It's useful.

But it's not automation. It doesn't trigger on events. It doesn't run anything. It's a saved prompt plus a longer memory window.

What Claude Code Actually Is

Claude Code runs in your terminal and operates in a loop: it observes the state of your project, decides what to do next, takes an action (read a file, run a command, write code), and loops again. You can leave it running on a task while you do something else.

That's a different category of tool. It's not a chatbot with a longer memory. It's closer to a junior developer you can delegate to — one that has direct access to your filesystem and shell.

It acts, not just responds — the observe → decide → act loop

When you give Claude Code a task like "add error handling to all the API routes," it will:

List the files in your project
Read each route file
Identify what's missing
Write the changes
Run your test suite to verify
Report back when done

You didn't have to supervise any of that. That's the core difference.

It lives in your terminal/IDE, not a browser tab

Claude Code is installed via npm install -g @anthropic-ai/claude-code. It runs in your terminal or inside VS Code's integrated terminal. There's no browser version of Claude Code — that's Claude.ai, which is a different product.

Skills: Claude Code's Reusable Expert Mode

A skill is a Markdown file that gives Claude Code a specialized set of instructions for a specific kind of task. When a skill is activated, Claude Code reads it and shifts into that mode — behaving like a focused expert rather than a general assistant.

For example, a content-writer skill might include rules about frontmatter format, heading style, article length, and tone. Claude Code loads it and writes accordingly, every time, without you re-explaining.

For a full breakdown of how skills work, see What Are Claude Code Skills?. To learn how to make them activate automatically, see How to Auto-Activate Claude Code Skills.

What a skill is (markdown file, specialized instructions)

Skills live in .claude/skills/<skill-name>/SKILL.md — each skill is a directory containing a SKILL.md file. You invoke one directly with a slash command like /content-writer, or Claude loads it automatically when the task matches the skill's description. No special syntax, no registry, no marketplace.

The Claude.ai equivalent: Projects with instructions, or pasting a saved prompt

The closest thing in Claude.ai is a Project with a long system prompt. You write your instructions once, save them to the Project, and Claude remembers them for that conversation thread.

It works. But you can't switch between multiple "modes" mid-session. You can't trigger a skill based on what file you're working in. And none of it runs automatically.

Why it's not really the same

A Claude Code skill is part of a pipeline. Claude Code can load a skill, execute a multi-step task using it, then hand off to another step — all without you. A Claude.ai Project instruction is context for a conversation. One is automation infrastructure; the other is a saved preference.

Agents (Subagents): Parallel Workers You Don't Supervise

Claude Code can spawn subagents — separate Claude instances that run in parallel, each with their own context, tools, and assigned subtask. A parent agent coordinates them, collects results, and continues the pipeline.

This is how the StackBrief content pipeline works: one agent writes the article, another audits it for SEO, another writes the social post. They don't wait for each other or share a conversation thread.

See What Are Claude Code Agents? for a full explanation.

What a subagent is — a spawned Claude instance with its own context and tools

When Claude Code spawns a subagent, it's not "the same conversation with a new message." It's a new Claude instance with a fresh context window, a defined task, and access to whatever tools the parent granted it. It can read files, write files, call APIs — independently.

The parent agent waits for results or runs something else in parallel. When the subagent finishes, it returns output. No human coordinates any of this.

The Claude.ai equivalent: nothing

There is no equivalent in Claude.ai's browser interface. You can open multiple browser tabs with different Projects, but that's not multi-agent coordination — that's you manually switching windows. Each tab is its own isolated conversation with no awareness of the others.

If you need subagents, you need Claude Code.

When you'd actually need this

You'd use subagents when a task is too large for one context window, when parts of the task can run in parallel to save time, or when you want to isolate different concerns (e.g., one agent writes, one agent reviews). For a solo person writing a 1,000-word blog post in Claude.ai, subagents are overkill. For a developer automating a multi-step build and review pipeline, they're the point.

Workflows: Automation That Runs Without You

A workflow in Claude Code is a chain of actions — or a pipeline of agents — triggered by an event. You define what triggers it (a file save, a git commit, a scheduled cron job), and Claude Code handles the rest.

Hooks are the low-level version: scripts that Claude Code calls before or after it takes specific actions. Workflows can be built on top of them. See What Are Claude Code Hooks? for details.

Hooks, CI/CD triggers, multi-agent pipelines

Hooks fire at defined moments: before Claude Code reads a file, after it writes one, before it runs a shell command. You can use a hook to log every action, block dangerous operations, or trigger a downstream process.

Multi-agent pipelines take this further. You define a sequence: agent A generates content, agent B audits it, agent C formats and saves it. Each step is automated. The pipeline runs when you kick it off, and you come back to a finished output.

The Claude.ai equivalent: zero

Everything in Claude.ai is manual. There are no hooks. There are no event triggers. There is no way to say "every time I save a file, run this." The browser tab waits for your next message. Always.

Real example: a hook that auto-runs tests every time Claude saves a file

Here's a simple example of a PostToolUse hook in Claude Code. Every time Claude writes or edits a file matching a test pattern, it automatically runs the test suite:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm test -- --watchAll=false"
          }
        ]
      }
    ]
  }
}

Claude Code saves a file, the hook fires, tests run, results come back into Claude Code's context. You didn't do anything. That loop doesn't exist in Claude.ai.

So Which One Do You Need?

Most people asking this question are already getting value out of Claude.ai. The question is whether Claude Code adds something you're actually missing — not whether it's technically more powerful (it is).

Stick with Claude.ai if...

You're writing, researching, or iterating on ideas
You want a smart assistant to review, summarize, or explain things
You're not building software — you're using software
You want to avoid installing anything
Your workflow is message-response-message-response and that's fine

You need Claude Code if...

You're building software and want Claude to directly edit files and run commands
You want to build automation pipelines that run without you supervising
You want reusable skills that activate in context, not just saved prompts
You want parallel agents handling different parts of a task at once
You're willing to set it up — it takes maybe 10 minutes

If you're on Windows, start with How to Install Claude Code on Windows. If you're on a Mac, use How to Set Up Claude Code on Mac.

Quick Reference Table

| Feature | Claude Code | Claude.ai (browser) | |---|---|---| | Reads and edits your actual files | Yes | No | | Runs shell commands | Yes | No | | Observe → decide → act loop | Yes | No | | Skills (reusable instruction files) | Yes | Not really (Projects are close) | | Subagents (parallel workers) | Yes | No | | Hooks / event triggers | Yes | No | | Automated multi-step pipelines | Yes | No | | Persistent memory across sessions | Via CLAUDE.md | Via Projects | | Works without installing anything | No | Yes | | Good for writing, research, chat | Yes | Yes |

The short version: Claude.ai is for conversations. Claude Code is for autonomous action. Most people need both — Claude.ai for thinking alongside you, Claude Code for doing things without you.