How do I connect Claude Code to a Postgres database via MCP?

Run: claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres "postgresql://USER:PASSWORD@localhost:5432/mydb". The -y flag auto-accepts the package install so the command doesn't hang. Then run claude mcp list and confirm postgres shows a connected status. Use a local or staging database for this quick path, not production.

Is the Postgres MCP server read-only?

Yes. The official @modelcontextprotocol/server-postgres package is read-only by design — it exposes schema inspection, query execution inside a read-only transaction, table detail lookup, and relationship traversal. It cannot write data. Third-party variants like postgres-mcp-pro add configurable write access if you need it.

What's the safe way to connect Claude Code to a production database?

Create a dedicated read-only Postgres user (GRANT SELECT only), and reference the connection string through an environment variable in .mcp.json using ${DATABASE_URL} rather than hardcoding it. Commit .mcp.json so the team shares the server config, but keep the actual connection string in each developer's local .env. If a session is ever compromised, the blast radius is zero.

Why does schema access make Claude Code more accurate?

With schema access, Claude Code reads your real table names, column types, and relationships, so it writes queries that work the first time instead of guessing. Without it, you get plausible-looking SQL that fails because user_status is actually onboarding_state. It also improves migration drafting and query debugging by matching your existing conventions.

How do I debug a Postgres MCP server that won't connect?

Use three commands: claude mcp list to check registered servers and status, claude mcp test db to test a specific server, and claude --debug to tail logs including MCP stderr. Most failures are a wrong connection string, a missing env var, or a Node version issue with npx — the debug log shows the exact server error.

Tag: Claude Code

Claude Cowork vs Code vs Agent SDK vs Managed Agents (2026)

Last verified: June 13, 2026

Anthropic ships four distinct ways to put Claude to work as an agent, and they are easy to confuse. The short version: Claude Cowork and Claude Code are interactive products billed through your Claude subscription â€” Cowork for knowledge work in the desktop app, Code for software work in your terminal, IDE, desktop, or browser. The Claude Agent SDK and Managed Agents are programmatic surfaces for developers, billed through the API: the Agent SDK is a Python/TypeScript library that runs the agent loop inside your own process, while Managed Agents is a REST API where Anthropic runs the loop and hosts the sandbox. The tables below give the verified, side-by-side breakdown.

The decision matrix

Three cards: coding depth, latency first, agent reliability — Cowork vs Code vs Agent SDK vs Managed Agents matrix.

Each row is one surface. Read across for who it serves, whether you drive it turn-by-turn or hand it a goal, where the work executes, and how it is paid for.

Surface	Who it is for	Interactive vs autonomous	Where it runs	How it is billed
Claude Cowork	Knowledge workers (non-developers) â€” research, documents, file and spreadsheet work	Interactive, supervised â€” shows you the plan and waits for your approval before acting	The Claude desktop app on your own computer (macOS or Windows); not available on web or mobile	Claude subscription (Pro, Max, Team, Enterprise) â€” draws from your plan’s usage allocation
Claude Code	Developers doing interactive coding â€” build features, fix bugs, automate dev tasks	Interactive â€” you drive it in a session, though it can run agentically across files and tools	Your machine (terminal, VS Code, JetBrains, desktop app) or the browser at claude.ai/code	Claude subscription or an Anthropic Console (API) account
Claude Agent SDK	Developers building custom agents programmatically (Python or TypeScript)	Autonomous â€” Claude reads files, runs commands, and edits code on its own via the agent loop	Your own process and infrastructure	API key (pay-as-you-go credits); see the subscription note below for the June 15, 2026 change
Managed Agents	Developers running production or long-running agents without operating their own sandbox/session infrastructure	Autonomous â€” you send events, Claude executes tools and streams back results	Anthropic-managed cloud sandbox per session (or a self-hosted sandbox on your own infrastructure)	Claude API key + the `managed-agents-2026-04-01` beta header (no subscription path)

Where billing actually differs

The cleanest way to split these four is by the wallet they draw from. The two interactive products are funded by a subscription; the two programmatic surfaces are funded by the API. This is the single distinction that trips people up most often, so it is worth stating plainly in its own table.

Surface	Billing model	Notes
Claude Cowork	Subscription	Included on Pro, Max, Team, and Enterprise. Multi-step tasks consume more of your usage allocation than chatting.
Claude Code	Subscription or API	Most surfaces require a Claude subscription or a Console account; the terminal CLI and VS Code also support third-party providers.
Claude Agent SDK	API (pay-as-you-go)	Authenticated with an `ANTHROPIC_API_KEY`; also supports Bedrock, Claude Platform on AWS, Vertex AI, and Azure. Anthropic does not permit claude.ai login for third-party agents built on the SDK.
Managed Agents	API (credits)	Requires a Claude API key and the beta header; enabled by default for API accounts.

One dated nuance is worth pinning down because it changes how subscription users pay for programmatic work. Starting June 15, 2026, Claude Agent SDK and claude -p usage on subscription plans no longer counts toward your Claude plan’s interactive usage limits; instead, eligible subscribers receive a separate monthly Agent SDK credit (per-user, not pooled), while subscription usage limits stay reserved for interactive use of Claude Code, Cowork, and Claude. If you use the Agent SDK with an API key from the Claude Platform, nothing changes â€” pay-as-you-go billing continues and you do not receive an Agent SDK monthly credit.

SDK vs Managed Agents: the programmatic split

Side-by-side cards defining what Claude Code is and is not — SDK vs Managed Agents — the programmatic split.

Both programmatic surfaces let Claude run tools autonomously, but they differ in where the loop and the work live. Anthropic’s own comparison frames it this way: the Agent SDK “is a library that runs the agent loop inside your own process,” while Managed Agents “is a hosted REST API: Anthropic runs the agent and the sandbox, and your application sends events and streams back results.” Pick by who you want operating the infrastructure.

Dimension	Agent SDK	Managed Agents
Runs in	Your process, your infrastructure	Anthropic-managed infrastructure
Interface	Python or TypeScript library	REST API
Agent works on	Files on your infrastructure	A managed sandbox per session
Session state	JSONL on your filesystem	Anthropic-hosted event log
Best for	Local prototyping; agents that work directly on your filesystem and services	Production agents without operating sandbox/session infrastructure; long-running, asynchronous sessions

A common path, per Anthropic’s docs, is to prototype with the Agent SDK locally, then move to Managed Agents for production.

Quick chooser

Three cards for fast volume, daily workhorse, and deep flagship Claude seats — Quick chooser for the right surface.

If you are not writing code and want Claude to finish a task on your computer, use Cowork. If you are a developer working interactively on a codebase, use Claude Code. If you are building your own agent and want it to run in your own process, use the Agent SDK. If you want Anthropic to run the agent and host the sandbox for long-running or production work, use Managed Agents.

Is Claude Cowork the same as Claude Code?

No. Both appear in the Claude desktop app, but Cowork is aimed at knowledge work (research, documents, spreadsheets, file management) for non-developers, while Claude Code is an agentic coding tool. Cowork runs only in the desktop app (macOS or Windows); Claude Code also runs in the terminal, VS Code, JetBrains, and the browser.

Does a Claude subscription cover the Agent SDK or Managed Agents?

Cowork and Claude Code are included with Claude subscriptions (Pro, Max, Team, Enterprise). The Agent SDK and Managed Agents are API surfaces authenticated with a Claude API key. As of June 15, 2026, subscription users do get a separate monthly Agent SDK credit for SDK and claude -p usage, but Managed Agents has no subscription path â€” it requires an API key and a beta header.

Where does the work actually execute for each surface?

Cowork runs on your own computer in the desktop app. Claude Code runs on your machine (or in the browser). The Agent SDK runs in your own process and infrastructure. Managed Agents executes in an Anthropic-managed cloud sandbox per session, or a self-hosted sandbox you control.

Is the Agent SDK built on Claude Code?

Yes. Per Anthropic, the Agent SDK “gives you the same tools, agent loop, and context management that power Claude Code, programmable in Python and TypeScript.” Anthropic also describes it as “Claude Code as a library.”

Is Managed Agents generally available?

No. As of June 13, 2026, Claude Managed Agents is in beta. Every Managed Agents endpoint requires the managed-agents-2026-04-01 beta header (the SDK sets it automatically), and access is enabled by default for API accounts.

Related on Tygart Media: what Claude Cowork is · Claude Code getting started · Agent SDK migration.

June 13, 2026

Claude Agent SDK Migration: Package Renames an (2026)

Last verified: June 13, 2026

The Claude Code SDK has been renamed to the Claude Agent SDK. Migrating is three mechanical edits plus two behavioral changes you have to opt back into: rename the package, rename the imports, rename ClaudeCodeOptions to ClaudeAgentOptions, then decide whether you want the old Claude Code system prompt and filesystem settings back. The breaking changes landed in v0.1.0. Everything below is taken from Anthropic’s official Agent SDK migration guide and the live package registries, verified June 13, 2026.

The renames at a glance

Side-by-side when to use a script versus an agent — The Agent SDK renames at a glance.

Two packages and one Python type changed names. The documentation also moved out of the Claude Code docs into the API Guide’s Agent SDK section.

Aspect	Old	New
Package (TS/JS)	`@anthropic-ai/claude-code`	`@anthropic-ai/claude-agent-sdk`
Package (Python)	`claude-code-sdk`	`claude-agent-sdk`
Python import	`claude_code_sdk`	`claude_agent_sdk`
Python options type	`ClaudeCodeOptions`	`ClaudeAgentOptions`
Docs location	Claude Code docs	API Guide â†’ Agent SDK

Current published versions

These are the latest versions on the public registries as fetched on June 13, 2026. The migration guide itself uses ^0.0.42 as the example old TypeScript version and ^0.2.0 as the example new one; pin to whatever is current when you install.

Registry	Package	Latest version
npm	`@anthropic-ai/claude-agent-sdk`	`0.3.177`
PyPI	`claude-agent-sdk`	`0.2.101`

TypeScript migration

Swap the package, then update every import. The exported names (query, tool, createSdkMcpServer) are unchanged â€” only the module specifier moves.

npm uninstall @anthropic-ai/claude-code
npm install @anthropic-ai/claude-agent-sdk

// Before
import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-code";

// After
import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";

Update package.json as well, replacing the dependency key from @anthropic-ai/claude-code to @anthropic-ai/claude-agent-sdk.

Python migration

Five stacked panels of daily Claude Code command habits — Python migration path.

Swap the package, update the import path, and rename the options type. The import name changes from underscore-claude_code_sdk to underscore-claude_agent_sdk.

pip uninstall claude-code-sdk
pip install claude-agent-sdk

# Before (claude-code-sdk)
from claude_code_sdk import query, ClaudeCodeOptions

options = ClaudeCodeOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

# After (claude-agent-sdk)
from claude_agent_sdk import query, ClaudeAgentOptions

options = ClaudeAgentOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

The rename is the only change to the type â€” its fields and constructor signature are otherwise the same. Per Anthropic, the new name matches the “Claude Agent SDK” branding.

Breaking change: the system prompt is no longer default

This is the change most likely to silently alter your agent’s behavior. In v0.0.x, the SDK used Claude Code’s system prompt by default. As of v0.1.0, query() uses a minimal system prompt instead. To get the old behavior, explicitly request the claude_code preset.

Goal	systemPrompt value
Restore Claude Code’s prompt	`{ type: "preset", preset: "claude_code" }`
Use your own instructions	a plain string
Minimal prompt (new default)	omit the option

// TypeScript â€” restore the old default
const result = query({
  prompt: "Hello",
  options: {
    systemPrompt: { type: "preset", preset: "claude_code" }
  }
});

// Or a custom system prompt:
const custom = query({
  prompt: "Hello",
  options: { systemPrompt: "You are a helpful coding assistant" }
});

# Python â€” restore the old default
from claude_agent_sdk import query, ClaudeAgentOptions

async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(
        system_prompt={"type": "preset", "preset": "claude_code"}
    ),
):
    print(message)

# Or a custom system prompt:
async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(system_prompt="You are a helpful coding assistant"),
):
    print(message)

settingSources: changed, then reverted

This one is widely mis-reported, so read it carefully. v0.1.0 briefly defaulted to loading no filesystem settings â€” and that default was reverted in subsequent releases. Anthropic’s current guidance is that no migration action is needed for setting sources.

Current behavior: omitting settingSources on query() loads user, project, and local filesystem settings, matching the CLI â€” equivalent to ["user", "project", "local"]. That includes ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, CLAUDE.md files, and custom commands. The accepted values are below.

Source	Loads from
`"user"`	`~/.claude/` â€” user CLAUDE.md, rules, skills, settings
`"project"`	`<cwd>/.claude/` â€” project CLAUDE.md, rules, skills, hooks, `settings.json`
`"local"`	CLAUDE.local.md and `.claude/settings.local.json`

To run isolated from filesystem settings, pass an empty array. This matters for CI/CD, deployed apps, test environments, and multi-tenant systems where local customizations should not leak in.

// TypeScript â€” no filesystem settings
const isolated = query({
  prompt: "Hello",
  options: { settingSources: [] }
});

// Only project settings
const projectOnly = query({
  prompt: "Hello",
  options: { settingSources: ["project"] }
});

# Python â€” no filesystem settings
from claude_agent_sdk import query, ClaudeAgentOptions

async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(setting_sources=[]),
):
    print(message)

Two caveats Anthropic documents explicitly. First, Python SDK 0.1.59 and earlier treated an empty list the same as omitting the option â€” upgrade before relying on setting_sources=[]. Second, some inputs are read regardless of settingSources: managed policy settings, the global ~/.claude.json config, auto-memory, and claude.ai MCP connectors. For true multi-tenant isolation, the docs recommend running each tenant in its own filesystem and setting settingSources: [] plus CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

The full checklist

Work top to bottom; the first three are required, the last two are behavioral decisions.

Step	Action
1	Uninstall old package, install `@anthropic-ai/claude-agent-sdk` / `claude-agent-sdk`
2	Update all imports to the new module / package name
3	Python only: rename `ClaudeCodeOptions` â†’ `ClaudeAgentOptions`
4	If you relied on Claude Code’s prompt, set `systemPrompt` to the `claude_code` preset
5	Decide on `settingSources`: omit for CLI parity, or `[]` to isolate

Do I have to change settingSources when I migrate?

No. Anthropic states no migration action is needed for setting sources. The v0.1.0 change to “load nothing by default” was reverted; omitting settingSources again loads user, project, and local settings, matching the CLI.

What is the new default system prompt?

A minimal system prompt. Before v0.1.0 the SDK inherited Claude Code’s full system prompt by default. To restore it, pass systemPrompt as { type: "preset", preset: "claude_code" } (TypeScript) or system_prompt={"type": "preset", "preset": "claude_code"} (Python).

Did the exported function names change in TypeScript?

No. query, tool, and createSdkMcpServer are unchanged. Only the import path moves from @anthropic-ai/claude-code to @anthropic-ai/claude-agent-sdk.

Which version introduced the breaking changes?

Claude Agent SDK v0.1.0, introduced “to improve isolation and explicit configuration,” per the official guide. The latest published versions as of June 13, 2026 are 0.3.177 on npm and 0.2.101 on PyPI.

Does settingSources: [] fully isolate my agent?

Not by itself. Managed policy settings, the global ~/.claude.json config, auto-memory, and claude.ai MCP connectors are read regardless. For multi-tenant isolation, also run each tenant in its own filesystem and set CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

Related on Tygart Media: Claude Code getting started · Cowork vs Code vs Agent SDK · model migration.

June 13, 2026

Claude Skills vs MCP vs Connectors vs Plugins (2026)

Last verified: June 13, 2026

The simplest way to keep these straight: Skills teach Claude how to do a task, MCP servers and Connectors give Claude access to external systems, Plugins bundle several of these together, and Hooks and slash commands control a Claude Code session. A Skill is a folder of instructions Claude reads when relevant. MCP (the Model Context Protocol) is an open standard that connects Claude to your tools and data. A Connector is Anthropic’s packaging of a remote MCP server inside the Claude apps. A Plugin packages any combination of commands, agents, MCP servers, hooks, and skills for Claude Code. Every definition below is taken verbatim from Anthropic’s official documentation, fetched on the verification date.

The one-glance comparison

Four comparison cards for Claude skills, MCP, connectors, and plugins — One-glance comparison of the four extension surfaces.

This is the liftable summary. Each row is one mechanism; the third column is the distinction people most often get wrong — whether the thing teaches Claude how to do something or gives Claude access to something.

Type	What it is	Teaches-HOW or gives-ACCESS	Where it runs	How you install / enable it
Skill	A modular capability that packages instructions, metadata, and optional resources (scripts, templates) in a `SKILL.md` file that Claude uses automatically when relevant.	Teaches HOW. Provides domain-specific expertise: workflows, context, and best practices (procedural knowledge).	In Claude’s code execution environment / VM, where Claude has filesystem access, bash, and code execution.	claude.ai: upload a zip under Settings > Features. API: upload via the Skills API (`/v1/skills`) with the required beta headers (`code-execution-2025-08-25`, `skills-2025-10-02`, `files-api-2025-04-14`). Claude Code: a `SKILL.md` directory under `~/.claude/skills/` or `.claude/skills/`.
MCP server	An implementation of the Model Context Protocol — “an open-source standard for connecting AI applications to external systems.” Described as “a USB-C port for AI applications.”	Gives ACCESS. Connects Claude to data sources, tools, and workflows so it can access information and perform tasks.	Local (stdio) servers run as processes on your machine; remote servers run over HTTP (recommended) or SSE (deprecated).	In Claude Code: `claude mcp add`, at local, project, or user scope. Also configurable in `.mcp.json` or imported from Claude Desktop / claude.ai.
Connector	A feature that “let[s] Claude access your apps and services, retrieve your data, and take actions within connected services.” Custom connectors use remote MCP.	Gives ACCESS. Same access role as MCP — a Connector is the in-app packaging of a remote MCP server.	Custom connectors are reached from Anthropic’s cloud infrastructure, not from your local machine.	In the Claude apps under Customize > Connectors (or the in-chat “+” menu). Add a directory connector, or “Add custom connector” by URL.
Plugin	“A lightweight way to package and share any combination of” Claude Code customizations.	Both — it’s a container. Bundles things that teach HOW (commands, skills) and things that give ACCESS (MCP servers), plus hooks and subagents.	In Claude Code — “they’ll work across your terminal and VS Code.”	The `/plugin` command (public beta). For a marketplace: `/plugin marketplace add user-or-org/repo-name`, then install from the `/plugin` menu.
Hook	“User-defined shell commands, HTTP endpoints, or LLM prompts that execute automatically at specific points in Claude Code’s lifecycle.”	Controls behavior. Provides deterministic control rather than relying on the LLM to decide.	In Claude Code, firing at lifecycle events (e.g. `PreToolUse`, `PostToolUse`, `UserPromptSubmit`, `SessionStart`, `Stop`).	Configured in JSON settings files such as `~/.claude/settings.json` or `.claude/settings.json`, or bundled in a plugin.
Slash command	A command starting with `/` that controls a Claude Code session. Includes built-ins (e.g. `/help`, `/compact`) and custom commands.	Teaches HOW (custom) / controls session (built-in). Custom commands have been merged into Skills.	In the Claude Code session (terminal or VS Code).	Built-ins ship with Claude Code. Custom: a Markdown file under `.claude/commands/` (project) or `~/.claude/commands/` (personal); a `.claude/skills/<name>/SKILL.md` does the same.

Skills: teaching Claude a procedure

An Agent Skill is “a directory containing a SKILL.md file” with YAML frontmatter plus instructions, and optionally additional markdown files, executable scripts, and reference resources. The point is procedural knowledge — it turns “general-purpose agents into specialists” by giving Claude the workflows and best practices for a task, the way you’d write an onboarding guide for a new teammate. Anthropic ships pre-built Skills for PowerPoint, Excel, Word, and PDF, and you can author your own.

What makes Skills cheap to install in bulk is progressive disclosure: Claude loads information in stages instead of all at once. The numbers below come straight from Anthropic’s Skills overview.

Loading level	When loaded	Token cost (per Anthropic docs)	Content
Level 1: Metadata	Always, at startup	~100 tokens per Skill	`name` and `description` from the YAML frontmatter
Level 2: Instructions	When the Skill is triggered	Under 5k tokens	The `SKILL.md` body — workflows and guidance
Level 3+: Resources	As needed	Effectively unlimited	Bundled files read or executed via bash without loading their contents into context

The name field is capped at 64 characters (lowercase letters, numbers, hyphens; it cannot contain the reserved words “anthropic” or “claude”), and the description is capped at 1,024 characters. One important constraint: custom Skills do not sync across surfaces — a Skill uploaded to claude.ai is not automatically available via the API, and Claude Code Skills are filesystem-based and separate from both.

MCP: the open standard for access

Flow from app/IDE through MCP to servers and data APIs — MCP: the open standard for access.

The Model Context Protocol is, in Anthropic’s words, “an open-source standard for connecting AI applications to external systems.” The canonical analogy: “Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.” Using MCP, “AI applications like Claude or ChatGPT can connect to data sources (e.g. local files, databases), tools (e.g. search engines, calculators) and workflows (e.g. specialized prompts).”

An MCP server can expose three kinds of building block — tools, resources, and prompts. In Claude Code, resources are referenced with @server:protocol://resource/path and prompts surface as commands in the form /mcp__servername__promptname. You connect a server with claude mcp add, choosing a transport and a scope:

Scope	Loads in	Shared with team	Stored in
Local (default)	Current project only	No	`~/.claude.json`
Project	Current project only	Yes, via version control	`.mcp.json` in project root
User	All your projects	No	`~/.claude.json`

For transports, HTTP is “the recommended option for connecting to remote MCP servers,” local stdio servers “run as local processes on your machine,” and SSE is explicitly marked deprecated in favor of HTTP.

Connectors: MCP, packaged for the apps

A Connector is how the Claude apps surface MCP. Per Anthropic’s help center, “Connectors let Claude access your apps and services, retrieve your data, and take actions within connected services,” and “Custom connectors using remote MCP are available on Claude, Cowork, and Claude Desktop.” So a Connector is not a different technology from MCP — a custom connector is a remote MCP server wired into the Claude UI.

The most consequential detail is where the connection originates: “Custom connectors (remote MCP servers) are reached from Anthropic’s cloud infrastructure, not from your local machine.” That means a custom-connector MCP server must be reachable over the public internet — one hosted only on a private network, behind a VPN, or blocked by a firewall will not connect even if you can reach it yourself.

Aspect	Directory (pre-built) connector	Custom connector
Source	Pre-built integrations in the Connectors Directory	Added by you via a remote MCP server URL
Plan availability	Available across Claude plans	Free, Pro, Max, Team, and Enterprise
Free-plan limit	Per directory	“Free users are limited to one custom connector.”
Where to add it	Customize > Connectors, or the in-chat “+” > Connectors > Manage connectors

Plugins: a bundle, not a single thing

A Plugin is “a lightweight way to package and share any combination of” Claude Code customizations. The official announcement lists four bundle components, and the Claude Code documentation adds skills as a fifth thing a plugin can carry:

Component	What it adds
Slash commands	Custom shortcuts for frequently-used operations
Subagents	Purpose-built agents for specialized development tasks
MCP servers	Connections to tools and data sources through MCP
Hooks	Customizations of Claude Code’s behavior at key workflow points
Skills	Per the Claude Code docs, a plugin can include a `skills/` directory; plugin skills use a `plugin-name:skill-name` namespace

You install a plugin “directly within Claude Code using the /plugin command.” To pull from a marketplace — “curated collections where other developers can discover and install plugins” — you run /plugin marketplace add user-or-org/repo-name and then install from the /plugin menu. Plugins “work across your terminal and VS Code.” Plugins were announced on October 9, 2025, as a public beta for all Claude Code users.

Hooks and slash commands: controlling the session

The last two mechanisms aren’t about adding capability — they’re about controlling a Claude Code session. Hooks are “user-defined shell commands, HTTP endpoints, or LLM prompts that execute automatically at specific points in Claude Code’s lifecycle.” Their defining property is determinism: they provide deterministic control rather than relying on the LLM to make decisions. A PreToolUse hook can, for example, block a destructive rm -rf command regardless of what Claude intended. Hooks are configured in JSON settings files (such as ~/.claude/settings.json or a project’s .claude/settings.json) and fire at events including SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop.

Slash commands start with / and control the session. Built-in commands like /help and /compact ship with Claude Code. Custom commands are Markdown files — a project command lives at .claude/commands/<name>.md and a personal one at ~/.claude/commands/<name>.md, with the file name becoming the command. As of the 2026 Claude Code docs, custom commands have been merged into Skills: a file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md “both create /deploy and work the same way,” and existing .claude/commands/ files keep working.

Is a Connector the same as an MCP server?

Effectively yes, for custom connectors. Anthropic states “Custom connectors using remote MCP are available on Claude, Cowork, and Claude Desktop,” and that they “are reached from Anthropic’s cloud infrastructure.” A Connector is the Claude-app packaging of a remote MCP server; MCP is the underlying open standard.

What’s the difference between a Skill and an MCP server?

A Skill teaches Claude how to do a task — it “provide[s] Claude with domain-specific expertise: workflows, context, and best practices.” An MCP server gives Claude access to external systems — it connects Claude “to data sources, tools and workflows.” One is procedural knowledge; the other is a connection.

Do Skills cost a lot of context tokens?

Not until used. Per Anthropic’s docs, Level 1 metadata costs about 100 tokens per Skill and is always loaded; the full SKILL.md body (under 5k tokens) only loads when the Skill is triggered; and bundled resources are read on demand with effectively no upfront cost. This is the “progressive disclosure” design.

What can a Claude Code plugin contain?

“Any combination of” slash commands, subagents, MCP servers, and hooks, per the announcement; the Claude Code documentation adds that a plugin can also bundle a skills/ directory. You install one with the /plugin command, optionally from a marketplace added via /plugin marketplace add.

Are custom slash commands still a thing?

They still work, but they’ve been folded into Skills. The Claude Code docs state custom commands “have been merged into skills,” that existing .claude/commands/ files keep working, and that a command file and an equivalent SKILL.md both produce the same / command. Skills add optional extras like supporting files and automatic invocation.

Related on Tygart Media: what is MCP · Claude MCP guide.

June 13, 2026

Claude Code Billing & Monthly Credit Pools (2026)

Last verified: June 13, 2026

Claude Code has two billing models, and which one applies depends on how you run it, not just which plan you hold. When you use Claude Code interactively in the terminal or IDE on a Pro or Max plan, it draws from the same subscription usage limits as your Claude.ai chats. But starting June 15, 2026, Anthropic separates out programmatic usage: the Claude Agent SDK, the claude -p headless command, the Claude Code GitHub Actions integration, and third-party apps that authenticate through the Agent SDK will no longer count against your interactive subscription pool. Instead they draw from a new, separate monthly Agent SDK credit, billed at standard API rates. This page documents both models, the exact credit amounts per plan, and the SDK package rename you may also need to handle.

The two billing models at a glance

Workshop fuel gauge and metal tokens pouring into an API hopper, metaphor for pay-per-token pricing — Two billing models at a glance — no sticky dollar stickers.

The dividing line is interactive vs. programmatic. One number to remember: setting an ANTHROPIC_API_KEY environment variable overrides your subscription entirely — Claude Code then authenticates with that key and bills as pay-as-you-go API usage, regardless of plan.

Usage type	How it runs	Billed against
Interactive Claude Code	Terminal or IDE, human at the keyboard	Pro/Max subscription usage limits
Claude.ai chat	Web, desktop, mobile	Pro/Max subscription usage limits
Agent SDK (Python/TypeScript)	Your own programmatic projects	Separate Agent SDK credit (from June 15, 2026)
`claude -p` (non-interactive)	Headless / scripted Claude Code	Separate Agent SDK credit (from June 15, 2026)
Claude Code GitHub Actions	CI/CD automation	Separate Agent SDK credit (from June 15, 2026)
Any usage with `ANTHROPIC_API_KEY` set	API-key auth instead of subscription	Standard API rates (pay-as-you-go)

What changes on June 15, 2026

Per Anthropic’s support documentation: “Starting June 15, 2026, Claude Agent SDK and claude -p usage no longer counts toward your Claude plan’s usage limits.” Each subscription tier instead receives a fixed monthly Agent SDK credit. When that credit runs out, additional Agent SDK usage flows to usage credits at standard API rates — but only if you have enabled usage credits. If you have not, “Agent SDK requests stop until your credit refreshes.” Unused credits do not roll over to the next billing cycle, and there is no automatic fallback to the interactive pool.

Plan	Monthly Agent SDK credit
Pro	$20
Max 5x	$100
Max 20x	$200
Team (Standard seats)	$20
Team (Premium seats)	$100
Enterprise (seat-based Premium)	$200

What stays on the interactive subscription pool, unchanged: Claude conversations on web, desktop, and mobile; and interactive Claude Code in the terminal or IDE. The change is scoped strictly to programmatic execution.

How each pool is metered and priced

Infographic with three panels: protect the service, fair share, and cost control explaining rate limits — How each pool is metered.

Claude Code “charges by API token consumption” — the underlying meter is input/output tokens, including thinking tokens billed as output. On a subscription, that token consumption is what counts against your plan limits (interactive) or your Agent SDK credit (programmatic). The Agent SDK credit and any overflow are billed at standard API list rates; the per-model API token prices below are the verified current rates.

Pool	Meter	Price basis
Interactive (Pro/Max)	Tokens, against plan usage limits	Included in subscription
Agent SDK credit	Tokens, against monthly credit	Standard API rates
Overflow past the credit	Tokens, usage credits	Standard API rates (only if usage credits enabled)
API key (`ANTHROPIC_API_KEY`)	Tokens, pay-as-you-go	Standard API rates

Verified current API token prices (per million tokens) for models commonly used in Claude Code:

Model	Model ID	Input $/Mtok	Output $/Mtok
Claude Opus 4.8	`claude-opus-4-8`	$5.00	$25.00
Claude Sonnet 4.6	`claude-sonnet-4-6`	$3.00	$15.00
Claude Haiku 4.5	`claude-haiku-4-5`	$1.00	$5.00

Subscription plan prices

These are the published Claude plan prices the Agent SDK credits attach to. The Max 5x plan starts at $100/month; the $200 figure for Max 20x is documented as the matching Agent SDK credit amount for that tier.

Plan	Price
Free	$0
Pro	$20/month, or $17/month billed annually ($200 up front)
Max 5x	From $100/month
Team (Standard seat)	$25/seat/month, or $20/seat/month billed annually

The SDK rename: claude-code-sdk to claude-agent-sdk

Separate from billing, the SDK itself was renamed. Anthropic’s migration guide states: “The Claude Code SDK has been renamed to the Claude Agent SDK.” If you have code on the old package, you must update the package name, imports, and one Python type. The headless CLI command name is unchanged — it is still claude -p.

Aspect	Old	New
npm package (TS/JS)	`@anthropic-ai/claude-code`	`@anthropic-ai/claude-agent-sdk`
Python package	`claude-code-sdk`	`claude-agent-sdk`
Python options type	`ClaudeCodeOptions`	`ClaudeAgentOptions`
Default system prompt	Claude Code’s preset	Minimal (opt back in via `preset: "claude_code"`)

# TypeScript
npm uninstall @anthropic-ai/claude-code
npm install @anthropic-ai/claude-agent-sdk

# Python
pip uninstall claude-code-sdk
pip install claude-agent-sdk

Decision: which billing path applies to your work

If you are…	Billing path
A developer coding interactively in the terminal	Subscription usage limits (unchanged)
Running `claude -p` in a script or cron job	Agent SDK credit (from June 15, 2026)
Running Claude Code in GitHub Actions	Agent SDK credit (from June 15, 2026)
Building an app on the Agent SDK with subscription auth	Agent SDK credit (from June 15, 2026)
A team or service account wanting budgets + usage reports	Set `ANTHROPIC_API_KEY` → standard API billing

Does interactive Claude Code billing change on June 15, 2026?

No. Anthropic’s documentation confirms interactive Claude Code in the terminal or IDE, and Claude conversations on web, desktop, and mobile, continue using subscription usage limits as before. Only programmatic usage — the Agent SDK, claude -p, GitHub Actions, and third-party Agent SDK apps — moves to the separate Agent SDK credit.

How much is the separate Agent SDK credit?

$20/month on Pro, $100 on Max 5x, $200 on Max 20x, $20 on Team Standard seats, $100 on Team Premium seats, and $200 on Enterprise seat-based Premium. The credit is billed at standard API rates, does not roll over, and refreshes monthly.

What happens when the Agent SDK credit runs out?

Additional Agent SDK usage flows to usage credits at standard API rates — but only if you have enabled usage credits. If you have not enabled them, Agent SDK requests stop until your credit refreshes. There is no automatic fallback to your interactive subscription pool.

How do I avoid the credit pool entirely?

Set an ANTHROPIC_API_KEY environment variable. Claude Code and the Agent SDK then authenticate with that key and bill as standard pay-as-you-go API usage, separate from any subscription. This is Anthropic’s recommended path for apps, CI jobs, service accounts, and team-owned projects that need budgets and usage reporting.

Was the Claude Code SDK renamed?

Yes. It is now the Claude Agent SDK. The npm package @anthropic-ai/claude-code became @anthropic-ai/claude-agent-sdk, the Python package claude-code-sdk became claude-agent-sdk, and the Python type ClaudeCodeOptions became ClaudeAgentOptions. The claude -p CLI command name is unchanged.

Related on Tygart Media: Claude Code getting started · Claude pricing · Pro vs Max.

June 13, 2026

Claude Code Getting Started: Installation, Firs (2026)

Claude Code is Anthropic’s official CLI for Claude — a terminal-based agent you can point at any codebase and have it read, write, test, and ship code. It’s different from the Claude.ai chat interface in one key way: Claude Code can act, not just answer. It reads your actual files, runs your actual commands, and makes changes that stick.

This guide walks you through installation, first run, and the commands that cover 90% of what you’ll do daily.

What Claude Code Is (and Isn’t)

Claude Code runs in your terminal. It gives Claude access to your local machine — file system, shell, and any MCP servers you configure — so it can do real engineering work: implement features, fix bugs, write tests, explain unfamiliar codebases, and run multi-step agentic workflows.

It is not a code autocomplete plugin (that’s what GitHub Copilot does). Claude Code is a conversational agent that works at the task level, not the token level. You describe what you want; it figures out the steps and executes them.

Installation

Claude Code requires Node.js 18 or later. Install via npm:

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

Verify the install:

claude --version

That’s the only dependency. Claude Code is a Node.js CLI — no Docker, no Python env, no platform-specific setup beyond Node.

First-Run Authentication

The first time you run claude, it walks you through authentication. You have two options:

Option 1: Claude subscription (Pro, Max, Team, Enterprise)
Run claude, select “Login with Claude.ai,” and it opens a browser window to authorize. Your subscription covers Claude Code usage — no separate API billing.

Option 2: Anthropic API key
Set your API key as an environment variable before running:

export ANTHROPIC_API_KEY="sk-ant-..."
claude

Or on Windows:

$env:ANTHROPIC_API_KEY = "sk-ant-..."
claude

API key usage is billed per token at standard API rates. For heavy daily use, a Max subscription ($100–$200/month) is usually more economical than API billing.

Your First Session

Navigate to a project directory and start Claude Code:

cd ~/projects/my-app
claude

Claude Code reads your directory automatically. At the > prompt, describe what you want:

> What does this codebase do? Give me a 3-paragraph overview.

Claude reads the files it needs and responds. No configuration required for basic usage — Claude Code infers context from the directory you’re in.

The 5 Commands You’ll Use Daily

1. `claude` — Start an interactive session

claude

Launches the REPL (read-eval-print loop). This is where you spend most of your time. Claude has access to your current directory’s files, can run bash commands, and can call any MCP servers you’ve configured.

Within a session, you can:

Ask questions about the codebase
Request implementations (“add a rate limiter to the auth middleware”)
Have Claude run tests and fix failures
Use /help to see available slash commands
Use /clear to reset context without leaving the session
Press Escape twice to interrupt a running task

2. `claude -p "prompt"` — One-shot non-interactive mode

claude -p "What are all the API endpoints in this codebase?"

Runs a single prompt and exits. No REPL. Good for scripting, CI pipelines, or quick one-off queries you don’t want to interrupt a workflow for. Output goes to stdout — pipe it wherever you need it.

claude -p "Summarize the changes in the last 10 commits" | pbcopy

3. `claude mcp add` — Connect an external tool

claude mcp add github -- npx -y @modelcontextprotocol/server-github

Adds an MCP server to your Claude Code configuration. After running this, Claude can call the server’s tools in any session. Common additions:

# File system access (scoped to a directory)
claude mcp add files -- npx -y @modelcontextprotocol/server-filesystem ~/Documents

# GitHub integration
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# Web search
claude mcp add search -- npx -y @modelcontextprotocol/server-brave-search

The GitHub and Brave Search servers need API tokens — set them as environment variables before the server starts, or pass them via the --env flag in the mcp add command.

4. `claude -c` — Continue the last conversation

claude -c

Resumes your most recent Claude Code conversation, including all prior context. Essential for multi-session work on a feature. If you closed the terminal mid-task, claude -c picks up exactly where you left off.

For a specific prior conversation:

claude --resume SESSION_ID

5. `claude --model` — Select the model for a session

claude --model claude-opus-4-8

Claude Code defaults to the most capable available model for your plan. You can override this per session. Current options:

claude-fable-5 — Highest capability, complex tasks (2x cost vs Opus 4.8)
claude-opus-4-8 — Default for most work, strong balance of quality and speed
claude-sonnet-4-6 — Faster responses, good for routine tasks
claude-haiku-4-5-20251001 — Fastest, lowest cost, short tasks

Slash Commands Inside a Session

While in a Claude Code session (> prompt), these slash commands are available:

Command	What It Does
`/help`	Show all available commands
`/clear`	Clear conversation context (keep the session open)
`/compact`	Compress prior context to save tokens while preserving essential memory
`/cost`	Show token usage and estimated cost for the current session
`/model`	Switch the model mid-session
`/review`	Request a multi-agent code review of the current branch
`/init`	Generate a CLAUDE.md file with project context for this repo
`/exit`	End the session

CLAUDE.md — Project-Level Context

Drop a CLAUDE.md file in your project root and Claude Code reads it automatically at session start. Use it to encode project-specific context Claude shouldn’t have to re-derive every session:

# My Project

## Architecture
- Backend: FastAPI + PostgreSQL
- Frontend: React + TypeScript
- Deployed to: AWS ECS

## Development
- Tests: `pytest tests/`
- Local server: `./scripts/start-dev.sh`
- Database migrations: `alembic upgrade head`

## Rules
- Never modify migration files directly
- All API routes go in `src/routes/`
- Use `httpx` not `requests` for HTTP calls

Generate a starter CLAUDE.md for an existing project with /init.

Permission Modes

Five-step path: account, API keys, billing, usage, workspaces — Permission modes — decide what the agent may touch.

Claude Code asks for confirmation before running bash commands, creating files, or making other changes — unless you grant it broader permissions. There are three ways to control this:

Default: Claude asks before each tool use that modifies files or runs commands
--dangerously-skip-permissions: Skip all confirmations. Use only in isolated environments (Docker containers, CI). Not for everyday use on your primary machine.
Session-level allowlist: During a session, you can approve individual tools for the rest of the session by selecting “Allow always” when prompted

For most work, the default confirmation behavior is the right trade-off — it keeps you in the loop on changes without requiring you to pre-define a permission policy.

IDE Integration

Claude Code integrates with VS Code and JetBrains IDEs. Install the extension from each marketplace, then launch Claude Code from inside the IDE. This keeps the terminal panel visible alongside your editor without alt-tabbing between windows.

The IDE extensions also add shortcuts for common actions like opening Claude Code in the current file’s directory and running one-shot queries against the selected code.

Related on Tygart Media: Claude Code billing · Claude Code vs Cursor · Claude Code tutorial.

Frequently Asked Questions

What’s the difference between Claude Code and Claude.ai?
Claude.ai is the web chat interface — good for questions, document analysis, and writing. Claude Code is a terminal CLI that can access your local files, run commands, and act autonomously on multi-step tasks. Claude.ai can’t modify files on your machine; Claude Code can.

Does Claude Code cost extra on top of my Claude subscription?
No. Claude Pro, Max, Team, and Enterprise subscriptions include Claude Code access. You use the same account. Heavy agentic usage counts toward the plan’s usage limits, but there’s no separate Claude Code fee.

Can Claude Code access the internet?
Not by default. Claude Code’s built-in WebFetch tool can fetch content from a specific URL when you provide it. For live web search, add the Brave Search or similar MCP server. Claude can’t browse freely without explicit tool access.

What does Claude Code do with my code?
Claude Code sends the file contents and context it needs to the Anthropic API for inference. Standard Anthropic API data policies apply — if you’re using an API key, you can configure zero data retention. If you’re using a subscription, default Anthropic retention policies apply. Review Anthropic’s privacy policy for current details.

Is Claude Code open source?
Claude Code itself (the CLI client) is not open source — it’s an Anthropic product. The MCP server ecosystem it connects to includes many open-source servers, and the MCP specification itself is open.

What version of Node.js do I need?
Node.js 18 or later. Run node --version to check. The Long-Term Support (LTS) version is always a safe choice.

Last verified: June 12, 2026. Claude Code is updated frequently — run npm update -g @anthropic-ai/claude-code to stay current.

June 12, 2026

What Is Model Context Protocol (MCP)? The Complete Guid (2026)

Model Context Protocol (MCP) is the reason Claude can read your files, query your database, search the web, and push code to GitHub — all from inside a single conversation. Without it, Claude would be limited to whatever you paste in manually. With it, Claude connects to almost any external system.

Quick answer: MCP is an open standard developed by Anthropic that lets AI models securely connect to external tools, data sources, and services through a standard client-server architecture. You install an MCP server for the system you want Claude to access. Claude becomes a client that calls that server. The server executes the action and returns results.

The Problem MCP Solves

Before MCP, connecting an AI model to external data meant one of two things: either the AI company built a native integration (slow, expensive, proprietary), or you cobbled together a pipeline that passed data manually between systems.

Neither approach scales. If Claude natively supported every database, every API, every file format, and every SaaS tool on the planet, the model would be perpetually behind. And manual copy-paste workflows aren’t agentic — they require you to do all the coordination work the AI should be doing.

MCP solves this with a universal adapter layer. Instead of building individual integrations, Anthropic defined a standard. Now any developer can build an MCP server for any system, and any MCP-compatible AI client (like Claude) can use it automatically.

How MCP Works

Three stacked layers: chat UI, tools, agent runtime — How MCP works as a layer between tools and agents.

MCP uses a client-server model over two transport mechanisms:

stdio: The MCP server runs as a local subprocess on your machine. Claude Code spawns it, communicates via standard input/output. This is the most common setup.
HTTP/SSE: The MCP server runs as a network service. Claude connects over HTTP with Server-Sent Events for streaming. Better for remote or shared servers.

The communication protocol underneath is JSON-RPC 2.0 — a lightweight, well-understood standard for calling methods and getting results.

Each MCP server exposes one or more of three primitives:

Tools: Functions Claude can call. Example: read_file(path), create_issue(title, body), run_query(sql). Claude decides when to call them based on context.
Resources: Data sources Claude can read. Example: the contents of a directory, a database schema, a project’s README. Resources are passive — they don’t take actions, they expose information.
Prompts: Reusable prompt templates that servers can provide to standardize how Claude interacts with them.

When Claude sees a task that could benefit from an available tool, it calls the tool, receives the result, and incorporates it into the response. This happens automatically — you don’t have to tell Claude when to use MCP. Claude decides based on what the server exposes.

MCP in Claude Code vs Claude Desktop

Both Claude Code (the CLI tool) and Claude Desktop support MCP, but they configure servers differently.

Claude Code

Claude Code has built-in MCP management via the claude mcp command family:

claude mcp add my-server -- npx -y @modelcontextprotocol/server-filesystem /path/to/directory
claude mcp list
claude mcp remove my-server

Servers added with claude mcp add are stored in your Claude Code config (~/.claude.json or the project-level .claude/settings.json). Project-level configs let you commit MCP server setups to source control so the whole team gets them automatically.

Claude Code also ships with a set of built-in tools that behave like MCP servers but don’t require separate installation: file read/write/edit, bash execution, glob search, grep, web fetch, and the agent spawning tools you’re reading about in this article.

Claude Desktop

Claude Desktop reads MCP server configuration from a JSON file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

A typical config entry looks like this:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Restart Claude Desktop after editing the config. Each server you add appears in the Claude Desktop interface with a hammer icon, and Claude can access its tools in any conversation.

The Most Useful MCP Servers

Anthropic maintains a reference set of official MCP servers. These are the ones worth knowing:

Server	What It Does	Package
Filesystem	Read/write files and directories on your local machine	`@modelcontextprotocol/server-filesystem`
GitHub	Read repos, create issues, open PRs, push code	`@modelcontextprotocol/server-github`
PostgreSQL	Read-only SQL queries against a Postgres database	`@modelcontextprotocol/server-postgres`
SQLite	Read/write a local SQLite database file	`@modelcontextprotocol/server-sqlite`
Brave Search	Live web search via Brave’s Search API	`@modelcontextprotocol/server-brave-search`
Puppeteer	Headless browser — screenshot pages, scrape, fill forms	`@modelcontextprotocol/server-puppeteer`
Slack	Read channels, send messages, search workspace	`@modelcontextprotocol/server-slack`
Google Drive	Read and search Google Drive files	`@modelcontextprotocol/server-google-drive`
Git	Git operations — log, diff, commit, branch management	`@modelcontextprotocol/server-git`
Memory	Persistent key-value knowledge graph across conversations	`@modelcontextprotocol/server-memory`

Beyond the official set, hundreds of community-built MCP servers cover everything from Notion and Linear to AWS and Docker. The MCP ecosystem grew faster than almost anyone expected after the November 2024 launch.

Installing Your First MCP Server

The fastest path is Claude Code with the filesystem server. This gives Claude read/write access to a directory you specify — useful for any project work.

Prerequisites: Node.js installed (the server runs via npx).

In your terminal:

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Documents/projects

That’s it. Open a Claude Code session. Claude can now list, read, write, and search files inside ~/Documents/projects. Try: “List all Python files in this directory and summarize what each one does.”

For Claude Desktop, edit the claude_desktop_config.json file directly (see format above), then restart the app.

What MCP Cannot Do

Five red warning rows of MCP limitations — What MCP cannot do — permissions and review still matter.

A few things worth understanding before you build on MCP:

MCP servers don’t persist between conversations. Each Claude session starts fresh. If you need state persistence, you need a server with its own storage layer (the Memory server handles this specifically).

MCP doesn’t bypass Claude’s safety guidelines. Claude still decides whether to execute a tool call based on safety and ethics reasoning. Connecting a filesystem server doesn’t give Claude unlimited license to delete files — Claude will still confirm before destructive operations.

Subprocess MCP servers are local. The stdio transport runs servers on your machine. This means they only work when you’re running Claude Code locally. For remote or team-shared access, you need HTTP/SSE transport with a hosted server.

Security Considerations

MCP servers have real permissions. The filesystem server can read and write files. The GitHub server can push code to your repos. The Postgres server can run SQL queries.

Apply the principle of least privilege:

Scope filesystem servers to the directory you actually need, not /
Use read-only database credentials where you don’t need writes
Create GitHub tokens with minimum required scope (e.g., repo for private repos, not org-level admin)
Never commit environment variables containing API keys to source control, even in .claude/settings.json — use env var references instead

MCP servers run with the permissions of the user running Claude. If something goes wrong with a tool call, it can have real consequences. The upside: everything runs locally and through your own credentials — there’s no MCP cloud intermediary with access to your data.

MCP and Claude Code’s Agentic Workflows

The full power of MCP shows up in Claude Code’s multi-step agentic mode. When Claude Code has access to git, a filesystem, a browser, and a search tool simultaneously, it can execute workflows like:

Search the web for a library’s current API (Brave Search)
Read your existing code to understand the integration point (filesystem)
Write the updated code (filesystem write)
Run tests (bash)
Create a PR (GitHub)

Each of these steps would require a separate tool in a traditional automation stack. With MCP, Claude orchestrates all of them within a single session, using whatever servers are available.

This is what makes MCP the infrastructure layer for agentic AI — not a feature, but the foundation that makes complex AI-driven workflows possible.

Related on Tygart Media: Claude MCP · Skills vs MCP vs plugins · how to use Claude.

Frequently Asked Questions

What does MCP stand for?
Model Context Protocol. It’s an open standard for connecting AI models to external tools, data sources, and services through a standard client-server interface.

Who created MCP?
Anthropic created MCP and released it as an open standard in November 2024. The specification and reference servers are open-source on GitHub. While Claude is the primary client, other AI systems can implement MCP clients too.

Do I need to install MCP to use Claude?
No. Claude works without any MCP servers. MCP is an extension layer — you add servers when you want Claude to access specific external systems. Claude Code also ships with a set of built-in tools (file operations, bash, web fetch) that don’t require MCP installation.

Is MCP available on Claude.ai (the web app)?
MCP server support is primarily in Claude Desktop and Claude Code. The Claude.ai web interface has its own tool integrations (web search, document analysis) but doesn’t support custom MCP servers in the same way.

What’s the difference between MCP tools and Claude’s native tools in Claude Code?
Claude Code’s native tools (Read, Write, Bash, Glob, Grep, WebFetch, Agent) are built into the application and don’t require a separate server process. MCP servers are external — they run as subprocesses or network services that Claude Code connects to. Both expose tools that Claude can call; the mechanism for loading them is different.

How do I build my own MCP server?
Anthropic provides official SDKs for building MCP servers in TypeScript, Python, Go, and other languages. The TypeScript SDK (@modelcontextprotocol/sdk) is the most mature. Start with Anthropic’s MCP documentation and the reference server implementations on GitHub as templates.

Last verified: June 12, 2026. MCP specification and server ecosystem evolve quickly — check the official Anthropic MCP documentation for the current spec.

June 12, 2026

AEO Content Optimizer — Claude AI Skill for Featured Snippets
Paste your article. Get back the version built to win the featured snippet.

Who This Is For

Who the AEO content optimizer skill is for.

Built for site owners and content marketers who publish good content that never gets picked as the answer — no featured snippets, no People Also Ask placements, invisible in voice results and AI Overviews while thinner competitor pages take the box.

The Problem

Answer engines do not reward the best content — they reward the most extractable content. A page that buries its answer in paragraph six loses to a page that answers in the first 50 words under a question heading, formatted the way the snippet wants. Restructuring for extraction is mechanical, learnable work — and almost nobody does it. This skill does it on every piece you paste.

What It Does

What it does for featured snippets / AEO.
- Performs answer-first surgery: a direct, self-contained 40–60 word answer placed immediately under each question heading
- Converts topical headings into the question formats searchers actually use, mapped to real query variants
- Matches the winning snippet format per query — paragraph, numbered list, or table — and rebuilds the block to fit
- Builds a genuine FAQ section and generates the matching FAQPage JSON-LD (and warns about duplicate schema before you paste)
- Runs a voice pass so direct answers survive a smart-speaker read
- Returns a change log plus an honest note on what content is missing that the query demands
What You Get

What you get.
- The aeo-content-optimizer.skill file — installs in claude.ai or Claude Code in about two minutes
- README with installation steps and tested example prompts
- Works on existing posts, new drafts, and competitor-gap rewrites
$47 one-time

Buy Now →

Secure checkout via Square — all major cards accepted

Want a custom version built specifically for your business? Email will@tygartmedia.com

Related on Tygart Media: GEO tactics · AEO content cluster · schema injection skill.

Frequently Asked Questions

Do I need technical knowledge to use this?

No. You paste your content and your target question. The skill restructures and returns paste-ready output, including the schema block.

Does it work for my niche?

Yes — the method is format-driven, not topic-driven. Local services, SaaS, e-commerce, professional services, and content sites all follow the same extraction rules.

Will it change my voice or facts?

It restructures; it does not genericize. Anything it cannot verify is flagged for you to supply rather than invented.

How is this delivered?

Within 24 hours of purchase via email from will@tygartmedia.com. Skill file and setup guide delivered as a ZIP download.

Does this require a paid Claude subscription?

Installing as a custom skill requires a paid Claude plan (Pro, $20/mo, or higher) with code execution enabled. Your download also includes a free-plan setup option — paste the skill into a Claude Project’s instructions — that works on any plan.
June 12, 2026
Connect Claude Code to Postgres via MCP: The Right Way (2026)
The most useful thing you can wire into Claude Code isn’t a new model or a clever prompt — it’s your actual database. When Claude Code can read your schema, it stops guessing at table names, column types, and relationships. It starts writing queries that work the first time.

This is the practical walkthrough for connecting Claude Code to a Postgres database via MCP: the command, the credential setup, the safety pattern, and what the workflow actually looks like once it’s running.

What the Postgres MCP server does

What the Postgres MCP server does.

The official @modelcontextprotocol/server-postgres package (maintained in the MCP reference implementations repo) gives Claude Code four tools: schema inspection, query execution inside a read-only transaction, table detail lookup, and relationship traversal. The server cannot write data — it’s read-only by design in the reference implementation, though third-party variants like postgres-mcp-pro add configurable write access if you need it.

For the majority of development workflows — debugging, writing migrations, generating queries — read-only is exactly what you want. Claude Code can see the shape of your data without being able to touch it.

The fastest path: single command setup

Fastest path — single command setup.

If you just want it running against a local database:
```
claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres "postgresql://USER:PASSWORD@localhost:5432/mydb"
```
The -y flag on npx auto-accepts the package install so the command doesn’t hang on first run. Verify with:
```
claude mcp list
```
You should see postgres with a connected status. That’s it — Claude Code now has schema access in the current project.

Don’t do this for a production database. The connection string above is hardcoded. It goes into ~/.claude.json as plaintext. Use a dedicated local or staging database during development, and use env vars for anything that matters.

The right way: env vars and a read-only user

Right way — env vars and a read-only user.

Two things to do before connecting to any real database:

1. Create a read-only Postgres user:
```
CREATE USER claude_readonly WITH PASSWORD 'your-password-here';
GRANT CONNECT ON DATABASE your_db TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO claude_readonly;
```
This user can see everything in public and do nothing else. If something goes wrong — a rogue tool call, a compromised session — blast radius is zero.

2. Reference the connection string via env var in .mcp.json:
```
{
  "mcpServers": {
    "db": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "${DATABASE_URL}"
      }
    }
  }
}
```
Set DATABASE_URL in your shell environment or in a .env file (not committed). Add .mcp.json to the repo — everyone on the team gets the same server config — but the actual connection string lives in each developer’s local environment. This is the same pattern you already use for application config. It’s the right pattern here too.

Add the server at project scope so it’s committed:
```
claude mcp add --scope project --transport stdio db -- npx -y @modelcontextprotocol/server-postgres
```
Then edit .mcp.json to replace the hardcoded connection string with the ${DATABASE_URL} env var reference shown above.

What Claude Code can actually do with schema access

Once the server is connected, the workflow changes significantly. A few real examples:

Schema exploration: Ask Claude Code “what tables are in this database and how are they related?” and it traverses foreign keys, describes join paths, and builds a mental model of your data layer. No more copy-pasting \dt output.

Query generation: “Write a query that finds users who signed up in the last 30 days but haven’t completed onboarding” produces accurate SQL because Claude Code knows your actual column names. With a generic prompt and no schema access, you’d get plausible-looking SQL that fails because user_status is actually onboarding_state.

Migration drafting: “I need to add a last_login_at column to users — show me the migration and check for existing timestamp patterns in the schema.” Claude Code inspects the schema first, matches your existing column naming conventions, and produces a migration that fits your codebase.

Debugging: “This query is returning the wrong count — here’s the query, check it against the schema.” Claude Code can spot that you’re joining on a nullable column, missing a filter on a soft-delete flag, or aggregating before filtering.

Neon and cloud Postgres

If you’re on Neon, there’s a first-party MCP server with additional capabilities: branch management, database creation, and schema migrations via Neon’s branching model. Set it up with:
```
npx neonctl mcp add
```
This runs OAuth through your browser and configures Claude Code automatically. The Neon MCP server is intended for local development and IDE workflows — not production automation — same caution applies.

Debugging when it doesn’t connect

Three commands for when the server shows as disconnected:
```
claude mcp list          # check registered servers and status
claude mcp test db       # test a specific server
claude --debug           # tail logs including MCP stderr output
```
Most connection failures are either a wrong connection string, a missing env var, or Node version issues with npx. The debug log shows the exact error from the server process — read it before assuming the problem is Claude Code.

The practical baseline

Five minutes to set up. The productivity delta on any codebase larger than a few tables is immediate — Claude Code stops making column-name mistakes and starts being genuinely useful for data-layer work. Wire up the read-only user, commit the .mcp.json, and add DATABASE_URL to your team’s .env.example. Done.

The model doing the work in a typical Claude Code session is claude-sonnet-4-6 (workhorse) — it handles schema-aware query generation well without burning through Opus 4.8 credits on every lookup.

Related Reading
Frequently Asked Questions

How do I connect Claude Code to a Postgres database via MCP?

Run: claude mcp add postgres — npx -y @modelcontextprotocol/server-postgres “postgresql://USER:PASSWORD@localhost:5432/mydb”. The -y flag auto-accepts the package install so the command doesn’t hang. Then run claude mcp list and confirm postgres shows a connected status. Use a local or staging database for this quick path, not production.

Is the Postgres MCP server read-only?

Yes. The official @modelcontextprotocol/server-postgres package is read-only by design — it exposes schema inspection, query execution inside a read-only transaction, table detail lookup, and relationship traversal. It cannot write data. Third-party variants like postgres-mcp-pro add configurable write access if you need it.

What’s the safe way to connect Claude Code to a production database?

Create a dedicated read-only Postgres user (GRANT SELECT only), and reference the connection string through an environment variable in .mcp.json using ${DATABASE_URL} rather than hardcoding it. Commit .mcp.json so the team shares the server config, but keep the actual connection string in each developer’s local .env. If a session is ever compromised, the blast radius is zero.

Why does schema access make Claude Code more accurate?

With schema access, Claude Code reads your real table names, column types, and relationships, so it writes queries that work the first time instead of guessing. Without it, you get plausible-looking SQL that fails because user_status is actually onboarding_state. It also improves migration drafting and query debugging by matching your existing conventions.

How do I debug a Postgres MCP server that won’t connect?

Use three commands: claude mcp list to check registered servers and status, claude mcp test db to test a specific server, and claude –debug to tail logs including MCP stderr. Most failures are a wrong connection string, a missing env var, or a Node version issue with npx — the debug log shows the exact server error.
June 3, 2026
Claude Code vs Codex CLI (2026): A Hands-On Head-to-Head
Last verified: June 2026.

Both Claude Code and OpenAI Codex CLI are terminal-native coding agents: you run them inside a repo, they read your files, edit code, run commands, and iterate. I run both daily on real projects. This is the head-to-head I wish existed when I was deciding which one to make my default. No benchmarks-chasing, just install commands, config files, pricing math, and where each one actually earns its keep. For the broader toolchain these slot into, see our AI operator’s stack.

Claude Code vs Codex CLI: the short answer

Claude Code vs Codex CLI — the short answer.

If you want one sentence: Claude Code is the more mature agentic harness (subagents, hooks, skills, deep MCP, a flat-rate plan that makes heavy use affordable), while Codex CLI is the leaner, cheaper-per-token option with strong raw coding from the GPT-5.x line and a tight sandbox model. Most teams that live in the terminal all day end up on Claude Code for the workflow tooling; people who want a fast, low-cost agent on top of an existing OpenAI subscription reach for Codex.

The honest version: they are closer than tribal arguments suggest. The deciding factors are almost never “which model is smarter this week” and almost always pricing structure, sandbox defaults, and how much workflow scaffolding you need.

How do you install each one?

How do you install each one?

Claude Code installs from npm and runs as the claude command:
```
npm install -g @anthropic-ai/claude-code
cd your-project
claude
```
First run walks you through OAuth login (Pro/Max plan) or an ANTHROPIC_API_KEY. On Windows it runs natively in PowerShell now, though a lot of operators still prefer it under WSL for fewer path headaches.

Codex CLI ships an install script and is also on npm:
```
# Mac / Linux
curl -fsSL https://chatgpt.com/codex/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"

# or via npm
npm install -g @openai/codex
```
Then codex in your repo. Auth is either a ChatGPT login (Plus/Pro/Business) or an OpenAI API key via codex login. Both tools are open-source clients hitting hosted models, so the install is the easy part; the model access is what you are really buying.

Which models do they run in 2026?

Claude Code defaults to the current Claude flagship. As of June 2026 that is Opus 4.8 for the hardest reasoning, with Sonnet 4.6 as the fast everyday workhorse and Haiku 4.5 for cheap, high-volume calls. You switch in-session with /model. Opus 4.8 also exposes reasoning-effort levels (high is the default; xhigh and max push deeper on gnarly problems at higher token cost).

Codex CLI runs the GPT-5.x coding line. GPT-5.5 is the current recommended default for complex coding and agentic work, GPT-5.4-mini is the faster/cheaper option for light tasks and subagents, and GPT-5.3-Codex remains a strong coding-tuned choice. Pick the model with codex -m gpt-5.5 or set it in your config.

Practical read: on a clean, well-specified function both produce good code. The gap shows up on long, multi-file refactors where the agent has to hold a lot of context and recover from its own mistakes. That is a harness problem as much as a model problem, which is the next section.

What about workflow features: subagents, hooks, and config?

This is where Claude Code is currently ahead, and it is the real reason it tends to win for power users.
- Subagents – Claude Code spawns isolated sub-sessions with their own context window, tool restrictions, and prompts. Great for “go research this in parallel while the main thread keeps coding.” Codex has a lighter subagent concept (often pointed at GPT-5.4-mini to keep cost down) but it is less fleshed out.
- Hooks – Claude Code fires deterministic scripts at lifecycle points (PreToolUse, UserPromptSubmit, and more). These run real code, so they cannot hallucinate: you can hard-block a dangerous command, auto-format on every edit, or inject context before the model sees a prompt. Codex leans on its approval/sandbox policy and execpolicy rules instead of a general hook system.
- Skills and slash commands – In Claude Code, custom slash commands have merged into skills; /your-command still works and skills add reusable, packaged capabilities. Codex uses prompt files and profiles rather than a skills layer.
- Project memory – Both read a project instruction file. Claude Code uses CLAUDE.md; Codex uses AGENTS.md (checked in a fallback order including AGENTS.override.md and .agents.md). Keep these tight: architecture, conventions, and the few rules the agent keeps forgetting.
Codex’s config story is clean if you like a single file: ~/.codex/config.toml holds your model, approval policy, sandbox mode, MCP servers, and named profiles you switch with codex --profile work. Claude Code spreads config across ~/.claude/ and .claude/settings.json plus per-project files, which is more surface area but more granular control.

How do the sandbox and approval models compare?

This matters more than most comparisons admit, because it governs how much the agent can do without asking.

Codex CLI has an explicit, well-documented sandbox. Sandbox modes run from read-only to workspace-write (edit files in the project, network off by default) up to full access, paired with approval policies like untrusted and on-request. On Windows the native sandbox can run unelevated or elevated. The mental model is clear: pick how much rope, then approve escalations.

Claude Code manages permissions through allow/deny rules and modes (including a plan mode that reasons without touching files, and an auto-accept mode for trusted loops). Combined with PreToolUse hooks you can build a strict policy, but it is more “assemble it yourself” than Codex’s preset sandbox tiers.

If you are dropping an agent onto an unfamiliar or sensitive repo, start read-only in both. Codex makes that posture a one-flag default; Claude Code gives you finer-grained control once you invest in the config.

Do both support MCP?

Do both support MCP?

Yes, and this is a genuine tie that matters. Both speak the Model Context Protocol, so you can wire in the same external tools, databases, and APIs. Codex registers STDIO or streaming-HTTP MCP servers in ~/.codex/config.toml and launches them at session start. Claude Code adds servers via claude mcp add or JSON config. If you have already built MCP integrations, neither tool locks you out. New to MCP, start with our Claude MCP setup guide and the Notion MCP setup walkthrough.

What does each one cost?

Pricing is where the decision often gets made, so here are the real numbers as of June 2026.

Claude Code plans:
- Pro – $20/mo: Sonnet 4.6 plus some Opus, roughly enough for focused daily sessions, not all-day heavy use.
- Max 5x – $100/mo: much larger windows, real Opus headroom.
- Max 20x – $200/mo: the heavy-user tier; effectively flat-rate firehose access.
- API pay-as-you-go: Opus 4.7 about $5/$15 per million input/output… (current Opus tier runs higher), Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5.
Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage governed by your plan’s limits), or pay-as-you-go on the API. GPT-5.3-Codex runs about $1.75 per million input / $14 per million output, with cheaper input on cached tokens. The mini model is far cheaper for light work.

The structural difference: Claude Code’s Max plans are flat-rate, which is why heavy users love them. People have tracked billions of tokens that would cost five figures on API metering but ran around a few hundred dollars on Max. Codex’s per-token rates are lower per unit and great if your usage is bursty or already bundled into a ChatGPT subscription, but a true all-day agent habit can run up metered cost faster than a flat plan. Estimate your monthly token volume honestly, then do the arithmetic both ways.

So which coding agent should you actually use?

Pick Claude Code if you want the deepest agentic workflow (subagents, hooks, skills), you are a heavy daily user who benefits from the flat-rate Max plan, or you need fine-grained, scriptable control over what the agent can do. It is the more complete operator’s harness in 2026.

Pick Codex CLI if you want lower per-token cost, you already pay for ChatGPT and want to use that allowance, you like the clean preset sandbox/approval model, or you simply prefer the GPT-5.x output style. It is lean, fast to stand up, and genuinely capable.

The move a lot of us make: run both. They are cheap relative to engineer time, they share MCP servers, and they have different failure modes. When one gets stuck in a loop on a hard bug, handing the same task to the other with fresh context often breaks the logjam. If you are weighing terminal agents against IDE-native ones, our Claude Code vs Cursor breakdown covers that axis.

Related on Tygart Media: Claude Code vs Cursor · Claude Code getting started · coding benchmarks.

Frequently asked questions

Is Claude Code or Codex CLI better for large refactors?

Claude Code tends to hold up better on long multi-file refactors, mostly because of subagents and hooks that keep context organized and catch mistakes deterministically. Codex can do it too, especially with GPT-5.5, but you lean harder on tight AGENTS.md instructions and approval gates.

Can I use Codex CLI without a ChatGPT subscription?

Yes. Run codex login with an OpenAI API key and you pay per token instead of through a ChatGPT plan. Same for Claude Code with an ANTHROPIC_API_KEY if you would rather meter than subscribe.

Do they work on Windows natively?

Both do in 2026. Claude Code runs in PowerShell (many operators still prefer WSL for cleaner paths), and Codex CLI has a native Windows installer plus a Windows sandbox with unelevated/elevated modes. Watch out for shells that mangle /tmp or C:\ style paths in arguments.

What is the single biggest difference?

Pricing structure and workflow depth. Claude Code offers flat-rate Max plans and a richer harness (subagents, hooks, skills); Codex offers lower per-token rates and a cleaner preset sandbox. Model quality is close enough that those two factors usually decide it.

Which model do they run by default?

Claude Code defaults to the current Claude flagship (Opus 4.8 as of June 2026, with Sonnet 4.6 for everyday speed). Codex CLI recommends GPT-5.5 for complex work, with GPT-5.4-mini and GPT-5.3-Codex as alternatives. Switch in-session with /model or the -m flag.

How do I get either tool cited or surfaced by AI engines for my own docs?

That is a content question, not a tooling one. The same structure that makes this page answerable, short factual answers, question-shaped headers, and a visible FAQ, is what AI engines reward. See how AI engines cite content for the full playbook.
June 3, 2026

Claude Code vs Cursor: Which AI Editor Wins in 2026?

Last verified: June 2026.

Claude Code and Cursor are the two tools most working developers actually reach for in 2026, and they are not the same kind of thing. Cursor is an AI-native code editor (a VS Code fork) where the model lives inside your IDE. Claude Code is a terminal agent that lives in your shell and edits files, runs commands, and drives git from the command line. I run both every day. This is the honest version: what each one is good at, what they cost right now, and a simple rule for picking.

Claude Code vs Cursor: what is the actual difference?

The short answer: Cursor is an editor you type in; Claude Code is an agent you delegate to. Cursor keeps you in the driver’s seat with autocomplete, inline edits, and a chat sidebar that sees your open files. Claude Code takes a goal (“add rate limiting to the upload endpoint and run the tests”) and works the repo autonomously in the terminal, asking permission before it touches things.

Dimension	Claude Code	Cursor
Form factor	Terminal CLI (plus IDE extension, web, desktop)	Full IDE (VS Code fork)
Primary loop	Delegate a task, approve actions	Type code, accept suggestions
Models	Claude only (Sonnet 4.6, Opus 4.8)	Multi-model: Claude, GPT, Gemini
Best at	Multi-file refactors, scripted/headless runs, git workflows	Tight edit loops, autocomplete, staying in one window
Entry price	$20/mo (Pro)	Free (Hobby) / $20/mo (Pro)
Billing model	Usage windows (5-hour + weekly)	Credit pool ($ equal to plan price)

How does each one actually work?

Claude Code (terminal agent)

You install it globally and run it from inside a project directory:

npm install -g @anthropic-ai/claude-code
cd my-project
claude

From there you talk to it in plain language. It reads files, proposes edits as diffs, and runs shell commands only after you approve them. A few patterns I use constantly:

Project memory: drop a CLAUDE.md file in the repo root with build commands, conventions, and “do not touch” rules. Claude Code reads it on every run, so you stop re-explaining the same context.
Headless / scripted runs: claude -p "bump all deps and run the test suite" runs one-shot and exits, which is what makes it scriptable in CI or cron jobs. This is the single biggest thing Cursor cannot do.
Permission control: by default it asks before edits and commands. You can pre-approve safe tools so it stops prompting on every npm test.
Plan mode: ask it to plan before it writes, review the plan, then let it execute. This is how you avoid a runaway agent rewriting half the codebase.

Cursor (AI IDE)

Cursor is a download, not a package install. You open your folder and the AI is wired into the editing surface:

Tab completion: multi-line, context-aware autocomplete that predicts your next edit, not just the next token. This is the feature people stay for.
Inline edit (Cmd/Ctrl+K): select code, describe the change, get a diff in place.
Agent mode: a chat panel that can edit multiple files and run terminal commands, closing the gap with Claude Code from inside the IDE.
Model picker: switch between Claude Sonnet, GPT, and Gemini per request from a dropdown. Useful when one model is stuck and you want a second opinion without leaving the window.

What does Claude Code cost in 2026?

Claude Code is billed by usage windows, not per-request credits. As of June 2026:

Pro: $20/month. Sonnet 4.6 and Opus 4.6, roughly 10 to 40 prompts per 5-hour window depending on repo size.
Max 5x: $100/month. ~5x Pro limits and access to Opus 4.8.
Max 20x: $200/month. ~20x Pro limits, all models including Opus 4.8.
API (pay-per-token): Opus 4.7 at $5 input / $25 output per million tokens; Sonnet 4.6 at $3 / $15.

The mechanic to understand: there is a 5-hour rolling session window (your budget resets from your first prompt) plus a weekly active-compute cap that only counts time the model is actually reasoning. If you hit a wall mid-afternoon, you are usually waiting for the 5-hour window to roll, not the week.

What does Cursor cost in 2026?

Cursor moved to a credit-pool model (the switch happened in mid-2025). Every paid plan includes a monthly credit pool equal to the plan price in dollars, and each request burns credits based on which model you pick and how heavy the request is. As of June 2026:

Hobby: Free. Limited tab completions and agent requests, plus a one-week Pro trial on signup.
Pro: $20/month ($16 annual). Frontier model access, MCP support, cloud agents, and a $20 credit pool.
Pro+: $60/month. ~3x the credits.
Ultra: $200/month. ~20x usage and priority features.
Teams: $40/user/month with SSO and admin controls.

Practical note on the credit pool: model choice matters a lot. Roughly, $20 of credits buys about 225 Claude Sonnet requests or about 550 Gemini requests, because Anthropic models cost more per call than Gemini in Cursor’s pricing. If you run Claude on everything, the $20 pool drains faster than newcomers expect. This is the source of most “what happened to Cursor pricing” confusion.

Which models do you actually get?

This is the cleanest dividing line.

Claude Code is Claude-only. You get Anthropic’s frontier coding models (Sonnet 4.6 for speed/cost, Opus 4.8 for the hardest agentic work on Max). No GPT, no Gemini. If you trust Claude for code, the single-vendor integration is tighter and the agent behavior is tuned end to end.
Cursor is multi-model. Claude, OpenAI, and Google models from one dropdown. The advantage is hedging: if one model whiffs on a problem, switch and retry in seconds. The trade-off is that no single model is integrated as deeply as Claude is in its own first-party tool.

Which one is better for big refactors and automation?

Claude Code, clearly. Two reasons. First, the terminal-agent loop is built for “go do this across the whole repo” tasks, and plan mode plus CLAUDE.md keep it on rails. Second, headless mode (claude -p "...") means you can wire it into scripts, pre-commit hooks, and scheduled jobs. Cursor’s agent mode is strong inside the IDE, but it is fundamentally an interactive editor, not a thing you call from a cron line.

Which one is better for everyday coding flow?

Cursor, for most people. If your day is reading, editing, and iterating on code you understand, Cursor’s tab completion and inline edits keep you in one window with near-zero friction. You never leave the editor to get help. Developers who are uneasy handing a whole task to an autonomous agent also tend to prefer Cursor because they stay in control of every keystroke.

Can you use both together?

Yes, and a lot of people do. The common setup: Cursor as the editor, Claude Code in Cursor’s integrated terminal. You get Cursor’s autocomplete and visual diff review for hands-on work, and you drop into Claude Code when you want to delegate a multi-file job or run something headless. They do not conflict. If you are building a broader operator setup around these tools, see our AI operator’s stack for how the pieces fit, and our Claude MCP setup guide for wiring external tools and data into Claude Code via MCP.

Claude Code vs Cursor vs Codex?

Codex is the third option people weigh, and it sits closer to Claude Code as an agent than to Cursor as an editor. The decision usually comes down to which model family and which workflow you trust. We break that specific matchup down in Claude Code vs Codex.

Bottom line: when to pick which

Pick Claude Code if you want an autonomous agent for refactors, you live in the terminal and git, you need scriptable/headless runs, and you are happy with Claude as your one model.
Pick Cursor if you want best-in-class autocomplete, you prefer staying inside a visual editor, you value swapping between Claude/GPT/Gemini, and you want to keep your hands on the keyboard.
Pick both if you can swing two subscriptions: Cursor for the edit loop, Claude Code in the terminal for delegation. Start each on the $20 tier and only upgrade the one you hit limits on.

FAQ

Is Claude Code or Cursor cheaper?

Both start at $20/month (Cursor also has a free Hobby tier). The difference is the meter: Claude Code limits you by 5-hour usage windows plus a weekly cap, while Cursor gives you a $20 credit pool that drains per request based on the model. Heavy Claude usage in Cursor burns the pool faster than people expect.

Does Cursor use Claude?

Yes. Cursor offers Anthropic’s Claude models alongside OpenAI and Google models, selectable per request. But you are using Claude through Cursor’s integration, not Anthropic’s first-party Claude Code agent, so the agentic behavior differs.

Can Claude Code edit files and run commands like an IDE agent?

Yes. Claude Code reads and writes files, runs shell commands, and drives git directly from the terminal. By default it asks permission before edits and commands, and you can pre-approve safe tools to cut down the prompts.

Which is better for beginners?

Cursor. The visual editor, inline diffs, and autocomplete are more forgiving than a terminal agent, and the free Hobby tier lets you learn before paying. Claude Code rewards people who are already comfortable in the shell and with git.

Do I need to know the command line to use Claude Code?

Largely yes. Claude Code is a CLI-first tool, and while it does most of the git and shell work for you, you will be living in a terminal. There is also an IDE extension and a desktop app, but the terminal is where it is strongest.

Can I run Claude Code in CI or on a schedule?

Yes, via headless mode: claude -p "your task" runs once and exits, which makes it usable in CI pipelines, git hooks, and scheduled jobs. Cursor has no equivalent because it is an interactive editor.

Will using both at once cause conflicts?

No. A common and stable setup is Cursor as your editor with Claude Code running in Cursor’s integrated terminal. They operate on the same files without stepping on each other, as long as you are not having both edit the exact same file simultaneously.

Related on Tygart Media: Claude Code vs Codex · Cursor command center · Claude Code getting started.

June 3, 2026

Tag: Claude Code

The decision matrix

Where billing actually differs

SDK vs Managed Agents: the programmatic split

Quick chooser

Is Claude Cowork the same as Claude Code?

Does a Claude subscription cover the Agent SDK or Managed Agents?

Where does the work actually execute for each surface?

Is the Agent SDK built on Claude Code?

Is Managed Agents generally available?

The renames at a glance

Current published versions

TypeScript migration

Python migration

Breaking change: the system prompt is no longer default

settingSources: changed, then reverted

The full checklist

Do I have to change settingSources when I migrate?

What is the new default system prompt?

Did the exported function names change in TypeScript?

Which version introduced the breaking changes?

Does settingSources: [] fully isolate my agent?

The one-glance comparison

Skills: teaching Claude a procedure

MCP: the open standard for access

Connectors: MCP, packaged for the apps

Plugins: a bundle, not a single thing

Hooks and slash commands: controlling the session

Is a Connector the same as an MCP server?

What’s the difference between a Skill and an MCP server?

Do Skills cost a lot of context tokens?

What can a Claude Code plugin contain?

Are custom slash commands still a thing?

The two billing models at a glance

What changes on June 15, 2026

How each pool is metered and priced

Subscription plan prices

The SDK rename: claude-code-sdk to claude-agent-sdk

Decision: which billing path applies to your work

Does interactive Claude Code billing change on June 15, 2026?

How much is the separate Agent SDK credit?

What happens when the Agent SDK credit runs out?

How do I avoid the credit pool entirely?

Was the Claude Code SDK renamed?

What Claude Code Is (and Isn’t)

Installation

First-Run Authentication

Your First Session

The 5 Commands You’ll Use Daily

1. claude — Start an interactive session

2. claude -p "prompt" — One-shot non-interactive mode

3. claude mcp add — Connect an external tool

4. claude -c — Continue the last conversation

5. claude --model — Select the model for a session

Slash Commands Inside a Session

CLAUDE.md — Project-Level Context

Permission Modes

IDE Integration

Frequently Asked Questions

The Problem MCP Solves

How MCP Works

MCP in Claude Code vs Claude Desktop

Claude Code

Claude Desktop

The Most Useful MCP Servers

Installing Your First MCP Server

What MCP Cannot Do

Security Considerations

MCP and Claude Code’s Agentic Workflows

Frequently Asked Questions

Who This Is For

The Problem

What It Does

What You Get

Frequently Asked Questions

Do I need technical knowledge to use this?

Does it work for my niche?

Will it change my voice or facts?

How is this delivered?

Does this require a paid Claude subscription?

1. `claude` — Start an interactive session

2. `claude -p "prompt"` — One-shot non-interactive mode

3. `claude mcp add` — Connect an external tool

4. `claude -c` — Continue the last conversation

5. `claude --model` — Select the model for a session