Best Claude Code Skills & Plugins (2026 Guide)

  • Skills are markdown instruction files teaching Claude Code specific behaviors; plugins add supporting files; MCP servers connect external tools like databases.

  • Hundreds of community skills exist across claudemarketplace.com, GitHub, and Anthropic docs, though most developers still use Claude Code without customization.

  • Start with free skills for git workflows, code review patterns, and test generation; paid skills (5-15 EUR) target specialized professional workflows.

  • Skills teach Claude Code your team’s conventions, design system components, and preferred workflows that aren’t included in the generalist default version.

Claude Code Ships With Zero Skills. Here’s How to Add Superpowers.

Out of the box, Claude Code is a powerful coding agent. But it’s a generalist. It doesn’t know your team’s conventions, your preferred git workflow, or how to generate components in your design system. Skills change that. They’re instruction files that teach Claude Code specific behaviors, and the ecosystem has exploded in the past year.

As of early 2026, there are hundreds of community-built skills listed across various directories. Anthropic’s official skills documentation has been one of their most popular developer pages since launch. And yet most Claude Code users are still running vanilla – no skills, no plugins, no MCP servers. This guide fixes that.

Skills vs. Plugins vs. MCP Servers – Quick Explainer

These three terms get thrown around interchangeably, but they’re different things:

  Type
  What It Is
  Where It Lives
  Complexity




  **Skill**
  A markdown instruction file that teaches Claude Code a specific behavior
  `~/.claude/skills/`
  Low - just a text file


  **Plugin**
  A packaged skill with supporting files (templates, configs, assets)

~/.claude/skills/ or project root
Medium – text + supporting files

  **MCP Server**
  A running service that gives Claude Code access to external tools (Figma, databases, browsers)
  Local process or remote URL
  High - requires a running server

Think of it this way: a skill is a cheat sheet, a plugin is a toolkit, and an MCP server is a bridge to another application. Most developers should start with skills and add MCP servers as needed.

The Emerging Marketplace

There’s no single “App Store” for Claude Code skills yet, but several directories are competing for that spot:

  • claudemarketplace.com – Community-curated directory with ratings and install counts. Over 150 skills listed as of March 2026.

  • Anthropic’s official docs – The /docs/claude-code/skills section includes first-party examples and a guide to building your own.

  • GitHub search – Searching "claude skill" path:/.claude/" surfaces hundreds of project-specific skills embedded in open source repos.

  • Independent creators – Developers and studios (including us at RAXXO) sell specialized skills as digital products.

The marketplace is still early. Most skills are free. Paid skills typically cost between 5-15 EUR and target specific professional workflows.

Best Skills by Category

Development and Learning

  • Git Dojo (5 EUR) – Interactive git training skill. Generates scenario-based challenges, scores your answers, tracks progress across sessions. Built for developers who use Claude Code daily but still Google basic git commands. Full disclosure: this is a RAXXO product.

  • Code Review – Several free skills that enforce structured code review patterns. They teach Claude Code to check for security issues, performance problems, and style violations before suggesting changes.

  • Test Writer – Skills that generate test files matching your project’s testing framework and conventions. The best ones analyze your existing tests to match your patterns.

Productivity

  • Commit Helper – Enforces conventional commit messages, adds co-author tags, prevents force pushes to main. Several free versions available.

  • Napkin – Quick documentation skills that generate README sections, API docs, and changelogs from your codebase.

  • Project Bootstrap – Skills that scaffold new projects with your preferred stack, linting rules, and CI config. Saves 30-60 minutes per new project.

Content and Brand

  • Brand Voice – Teaches Claude Code your brand’s writing style, forbidden words, and tone preferences. Essential if you use Claude Code for any copy or documentation.

  • Content Pipeline – Skills that generate blog posts, social media copy, or email sequences following specific templates and SEO rules.

  • Localization – Skills that handle i18n file generation, maintaining consistency across language files.

Design and Frontend

  • Component Builder – Skills that generate React/Vue/Svelte components following your design system’s patterns, prop conventions, and styling approach.

  • Design System Auditor – Checks your components against design tokens and flags inconsistencies. Works well paired with the Figma MCP server.

  • Accessibility Checker – Skills focused on WCAG compliance, generating aria labels, and fixing contrast issues.

SEO and Analytics

  • SEO Audit – Skills that analyze your pages for meta tags, heading structure, schema markup, and Core Web Vitals issues.

  • Schema Generator – Generates JSON-LD structured data for products, articles, FAQs, and other content types.

Developers using multiple Claude Code skills consistently report faster task completion compared to vanilla Claude Code users. The biggest gains come from project-specific skills that encode team conventions.

How to Install a Skill (3 Steps)

Installing a skill takes under 60 seconds:

  • Create the skills directory if it doesn’t exist: mkdir -p ~/.claude/skills

  • Add the skill file. Most skills are a single markdown file. Drop it into ~/.claude/skills/your-skill-name/. For example: ~/.claude/skills/git-dojo/skill.md

  • Use it. In any Claude Code session, type the skill’s trigger command (usually a slash command like /git-dojo). Claude Code automatically reads skills from the ~/.claude/skills/ directory.

That’s it. No build step, no compilation, no package manager. Skills are just text files that Claude reads at session start.

How to Build Your Own Skill

Building a skill is writing a good prompt – with structure. Here’s the minimal anatomy:

# Skill Name

## Trigger
/your-command

## Description
What this skill does in one sentence.

## Instructions
Step-by-step behavior Claude should follow when this skill is invoked.

## Rules
- Constraints and guardrails
- Output format requirements
- Things to never do

## Examples
Input: [example input]
Output: [example output]

The best skills are specific and opinionated. “Help me write code” is a bad skill. “Generate a Next.js API route with Zod validation, error handling, and a corresponding test file using the project’s patterns” is a good skill.

According to Anthropic’s skill authoring guide, skills under 2,000 tokens perform best. Longer skills eat into your context window without proportional benefit. Keep them focused.

MCP Servers Worth Setting Up

MCP (Model Context Protocol) servers connect Claude Code to external tools. The most useful ones in 2026:

  MCP Server
  What It Does
  Setup Time




  **Figma**
  Read designs, extract tokens, generate code from Figma files
  ~10 min


  **Playwright**
  Browser automation, E2E testing, screenshot capture
  ~5 min


  **Vercel**
  Deploy, check logs, manage projects from Claude Code
  ~5 min


  **PostgreSQL**
  Query databases, inspect schemas, run migrations
  ~5 min


  **GitHub**
  Create PRs, review issues, manage repos
  ~5 min

MCP servers require more setup than skills but unlock capabilities that text instructions alone can’t provide. The Playwright MCP server alone has changed how many teams do testing – Claude Code can literally browse your app, click buttons, and verify behavior.

Frequently Asked Questions

Where do I find Claude Code skills?

Start with claudemarketplace.com for community-curated skills, or check Anthropic’s official documentation at docs.anthropic.com. GitHub is also a goldmine – search for repositories with .claude/skills directories. For specialized professional skills, independent creators sell them on platforms like Gumroad, Lemon Squeezy, or their own shops.

How do I install a Claude Code skill?

Create a folder in ~/.claude/skills/ with your skill name, then drop the skill’s markdown file inside it. Claude Code automatically detects skills in this directory at session start. No restart needed – just start a new session. For project-specific skills, you can also place them in your project’s .claude/skills/ directory.

Can I sell Claude Code skills?

Yes. Skills are just files, so you can package and sell them like any digital product. Git Dojo (5 EUR on raxxo.shop) is an example of a commercially sold skill. The market is early, so there’s room for specialized skills targeting specific frameworks, workflows, or industries. Package your skill with a README, installation instructions, and example usage for the best buyer experience.

What’s the difference between skills and CLAUDE.md?

Your project’s CLAUDE.md file contains project-wide instructions that apply to every session in that repository. Skills are modular, portable behaviors you can invoke on demand across any project. Think of CLAUDE.md as “always-on context” and skills as “on-demand tools.” They complement each other – your CLAUDE.md might reference skills that should be used for specific tasks.

Do skills slow down Claude Code?

Minimally. Each skill adds tokens to Claude’s context window at session start. Anthropic recommends keeping individual skills under 2,000 tokens. If you have 10 skills at 2,000 tokens each, that’s 20,000 tokens of context – roughly 5% of Claude’s available context window. The performance impact is negligible unless you load dozens of large skills simultaneously.

Want the complete blueprint?

We’re packaging our full production systems, prompt libraries, and automation configs into premium guides. Stay tuned at raxxo.shop

Related Reading

This article contains affiliate links. If you sign up through them, I earn a small commission at no extra cost to you.

Best MCP Servers for Claude Code in 2026

  • Playwright MCP enables Claude to automate browser testing, debugging, and scraping without writing test scripts manually.

  • Figma MCP connects design files to code, allowing Claude to read design tokens and audit implementations against designs.

  • Vercel MCP gives Claude deployment management, build log access, and debugging capabilities without leaving the editor.

  • PostgreSQL MCP allows Claude to query databases, inspect schemas, and assist with writing migrations with configurable permissions.

  • Over 400 community-built MCP servers exist; top 50 average 12,000+ monthly installs, making Claude Code a workflow member.

MCP Is What Makes Claude Code Actually Useful

Claude Code on its own can read files, run commands, and write code. That’s table stakes. MCP (Model Context Protocol) is what lets it interact with the rest of your stack – your design tool, your browser, your database, your deployment pipeline. Without MCP servers, Claude Code is smart but isolated. With them, it becomes an actual member of your workflow.

Anthropic introduced MCP in late 2024 as an open protocol for connecting AI models to external tools and data sources. By early 2026, the ecosystem has exploded. The MCP server registry lists over 400 community-built servers, with the top 50 averaging 12,000+ monthly installs each according to npm download statistics. That’s a lot of options. Here are the 10 that actually matter.

What MCP Actually Does

MCP follows a client-server architecture. Claude Code is the client. MCP servers are lightweight processes that expose tools (functions Claude can call) and resources (data Claude can read). When you configure an MCP server, Claude gains new capabilities – it can click buttons in a browser, query your database, or push a deployment.

The protocol uses JSON-RPC over stdio or HTTP. Each server declares its capabilities, and Claude discovers them at startup. No special SDK required on the server side, though Anthropic provides official SDKs in TypeScript and Python that handle the protocol layer.

The Top 10 MCP Servers

1. Playwright (Browser Automation)

The most transformative MCP server for web developers. Playwright MCP gives Claude a real browser it can navigate, click, fill forms, take screenshots, and inspect. Use it for testing your app, scraping data, or debugging UI issues by having Claude actually look at what’s rendered.

Teams using AI-assisted browser testing report significantly fewer bugs escaping to production compared to manual QA alone. Playwright MCP makes that accessible without writing a single test script.

Best for: QA testing, visual debugging, form testing, scraping

2. Figma

Connect Claude to your Figma files. It can read design tokens, inspect component properties, grab screenshots of specific frames, and even understand your design system’s structure. The gap between “design” and “code” shrinks dramatically when Claude can see both.

Best for: Design-to-code workflows, extracting design tokens, auditing implementations against designs

3. Vercel

Deploy, check build logs, inspect runtime errors, and manage projects without leaving Claude Code. The Vercel MCP server exposes deployment management, log access, and project configuration. Particularly useful for debugging failed deployments – Claude reads the build logs and fixes the issue in one loop.

Best for: Deployment workflows, build debugging, project management

4. PostgreSQL

Direct database access. Claude can query your database, inspect schemas, analyze data, and help write migrations. The PostgreSQL MCP server supports read and write operations with configurable permissions. Developers using AI database tools consistently report fewer schema design mistakes compared to working without AI assistance.

Best for: Schema design, query optimization, data analysis, migration writing

5. GitHub

Manage issues, pull requests, repositories, and workflows from Claude Code. The GitHub MCP server covers most of the GitHub API surface. Create issues from bugs Claude finds, open PRs with generated code, review existing PRs with full context.

Best for: PR workflows, issue management, repository operations

6. Slack

Read channels, send messages, and search conversation history. The Slack MCP server is useful for teams where context lives in Slack threads. Claude can pull relevant discussions when working on a feature, or post updates when tasks complete.

Best for: Team communication, context gathering, status updates

7. Puppeteer

Similar to Playwright but focused on Chrome/Chromium. Puppeteer MCP is lighter-weight and starts faster. If you only need Chrome and don’t need cross-browser testing, Puppeteer is the simpler choice. Puppeteer typically launches faster than Playwright for single-browser scenarios.

Best for: Chrome-specific testing, lightweight browser automation, PDF generation

8. Brave Search

Web search without leaving Claude Code. The Brave Search MCP server lets Claude look up documentation, find solutions, check current information, and research topics. Essential for keeping Claude’s knowledge current beyond its training cutoff.

Best for: Documentation lookup, research, fact-checking, finding solutions

9. Filesystem

Extended file operations beyond what Claude Code provides natively. The filesystem MCP server adds watching for file changes, advanced glob patterns, file metadata access, and batch operations. Useful for build tool integration and monitoring.

Best for: File monitoring, batch operations, build integration

10. Memory

Persistent memory across sessions using a knowledge graph. The Memory MCP server stores entities, relationships, and observations that survive session restarts. Claude can remember project decisions, architecture choices, and user preferences without you re-explaining them.

Best for: Long-running projects, preference persistence, knowledge accumulation

Comparison Table

  Server
  Setup Difficulty
  Token Usage
  Requires API Key
  Maturity




  Playwright
  Easy
  Medium-High
  No
  Stable


  Figma
  Medium
  Medium
  Yes (Figma token)
  Stable


  Vercel
  Easy
  Low
  Yes (Vercel token)
  Stable


  PostgreSQL
  Easy
  Low-Medium
  No (connection string)
  Stable


  GitHub
  Easy
  Low
  Yes (GitHub token)
  Stable


  Slack
  Medium
  Medium
  Yes (Slack bot token)
  Stable


  Puppeteer
  Easy
  Medium
  No
  Stable


  Brave Search
  Easy
  Low
  Yes (Brave API key)
  Stable


  Filesystem
  Easy
  Low
  No
  Stable


  Memory
  Easy
  Low
  No
  Maturing

How to Set Up an MCP Server

Configuration lives in your Claude Code settings file. The exact location depends on your setup, but the structure is consistent:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"]
    },
    "github": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Each server entry needs a command (what to run) and args (arguments). Some need environment variables for API keys. Claude Code starts these processes automatically and discovers their capabilities via the MCP protocol handshake.

Most servers install via npx, meaning no global installation needed. They download and run on first use. Average startup time across the top 10 servers is under 3 seconds in typical setups.

Token Usage Considerations

Every MCP tool call consumes tokens from your Claude allocation. Browser automation tools like Playwright are the most token-hungry because screenshots and DOM snapshots are large. A single Playwright screenshot can consume 1,000-3,000 tokens depending on resolution.

If you’re on a Claude Pro plan with limited messages, be mindful of which MCP servers you enable. Disable servers you’re not actively using to prevent Claude from discovering and accidentally calling expensive tools. If you’re on Max and burning through limits, tracking tools like OhNine help you see the impact of MCP-heavy sessions on your usage budget.

Building Your Own MCP Server

If none of the existing servers cover your use case, building one is straightforward. Anthropic’s official TypeScript SDK (@modelcontextprotocol/sdk) handles the protocol layer. You just define your tools and resources.

A minimal MCP server is under 50 lines of code. The MCP specification (modelcontextprotocol.io) documents the full protocol. Community contributions are welcome – the ecosystem grows by developers scratching their own itches and publishing the results.

Frequently Asked Questions

Do MCP servers slow down Claude Code?

Minimally. Servers are discovered at startup, which adds 1-3 seconds per server. During use, tool calls add latency proportional to what they’re doing (a database query is fast, a full browser navigation is slower). Unused servers have zero runtime cost after discovery.

Can I use multiple MCP servers at the same time?

Yes. Claude Code can have multiple MCP servers running simultaneously. For example, you might have Playwright, GitHub, and PostgreSQL all active in one session. Claude decides which server’s tools to call based on your request.

Are MCP servers secure?

MCP servers run locally on your machine with your permissions. They don’t send data to third parties unless they’re explicitly connecting to an external API (like GitHub or Slack). Review the source code of community servers before installing, especially those requesting broad filesystem or network access.

Do I need to pay for MCP servers?

The servers themselves are free and open source. However, some connect to paid services (Figma, Vercel, GitHub Pro features) that require their own subscriptions or API keys. The MCP server is just the bridge – the underlying service’s pricing applies separately.

Which MCP server should I install first?

For web developers: Playwright. It’s the highest-impact addition because it gives Claude the ability to see and interact with what you’re building. For backend developers: PostgreSQL or GitHub, depending on whether your bottleneck is database work or code management.

Want the complete blueprint?

We’re packaging our full production systems, prompt libraries, and automation configs into premium guides. Stay tuned at raxxo.shop

Related Reading

This article contains affiliate links. If you sign up through them, I earn a small commission at no extra cost to you.

How to Build a Claude Code Skill from Scratch

  • Skills enable Claude to retain expertise across sessions via slash commands, eliminating repetitive explanations of workflows and preferences.

  • A skill is a directory containing SKILL.md file with structured instructions that activate on command, stored in ~/.claude/skills/.

  • SKILL.md requires Trigger, Description, and Instructions sections; Examples and Constraints are optional but improve task accuracy significantly.

  • Building a skill involves creating a directory, writing SKILL.md with clear expertise definition, and testing behavior before distribution.

Skills Turn Claude Code from Assistant into Expert

Claude Code is powerful out of the box. But without skills, every new session starts from zero. You explain your workflow, your preferences, your conventions – again. Skills fix that. They give Claude persistent expertise that loads on demand via slash commands.

As of 2026, the Claude Code skill ecosystem is still early. Anthropic introduced the skill system in late 2025, and adoption has been growing rapidly. A growing number of AI-assisted developers use some form of custom instruction or skill system, and adoption has roughly quadrupled since 2024. The ones who do report significantly less time spent on repetitive prompting.

This guide walks you through building a skill from scratch, testing it, and optionally packaging it for distribution or sale.

What a Skill Actually Is

A Claude Code skill is a directory containing a SKILL.md file. That’s it at the minimum. The SKILL.md file contains structured instructions that Claude loads when triggered. Think of it as a specialized prompt that persists across sessions and activates on command.

Skills live in ~/.claude/skills/ by default. Each skill gets its own subdirectory:

~/.claude/skills/
  my-skill/
    SKILL.md
    examples/        (optional)
    templates/       (optional)
    assets/          (optional)

When you type a slash command that matches a skill’s trigger, Claude reads the SKILL.md and gains that expertise for the current session. No context wasted on explaining what you want. No drift from your standards.

Anatomy of SKILL.md

The SKILL.md file follows a specific structure. Here’s the skeleton:

# Skill Name

## Trigger
/your-command

## Description
One-line description of what this skill does.

## Instructions
The actual expertise. This is where you define:
- What Claude should know
- How it should behave
- What conventions to follow
- What output format to use

## Examples (optional)
Input/output pairs showing expected behavior.

## Constraints (optional)
Hard rules Claude must follow when this skill is active.

The ## Trigger section is critical. It defines the slash command that activates the skill. When you type /your-command in Claude Code, it searches installed skills for a matching trigger and loads the corresponding SKILL.md.

Building a Real Skill: Git Quiz

Let’s build a simplified version of a git learning skill. This is based on the architecture behind Git Dojo, stripped down to teach the core concepts.

Create the directory:

mkdir -p ~/.claude/skills/git-quiz

Now create the SKILL.md. Skills that include structured examples perform noticeably better on task accuracy compared to instruction-only skills. So we’ll include examples.

# Git Quiz

## Trigger
/git-quiz

## Description
Interactive git knowledge quiz with progressive difficulty.

## Instructions
When triggered, present the user with a git scenario and ask
them to provide the correct command or explain the concept.

### Difficulty Levels
- Beginner: basic commands (add, commit, push, pull, status)
- Intermediate: branching, merging, rebasing, stash
- Advanced: reflog, bisect, cherry-pick, interactive rebase

### Quiz Format
1. Present a real-world scenario (2-3 sentences)
2. Ask the user for the correct git command or explanation
3. Wait for their answer
4. Grade it: correct, partially correct, or incorrect
5. Explain the right answer with context
6. Track score across the session

### Rules
- Never give the answer before the user attempts it
- Use realistic scenarios, not textbook examples
- After each answer, show running score (correct/total)
- Offer to increase difficulty after 3 correct in a row

## Examples

### Example Scenario (Beginner)
"You just created three new files in your project. You want to
stage all of them and create a commit with the message 'Add
initial components'. What commands do you run?"

Expected: git add . && git commit -m "Add initial components"
Also acceptable: git add -A && git commit -m "Add initial components"

### Example Scenario (Advanced)
"You made a commit 5 commits ago that introduced a bug, but you
only realized it now. You want to undo just that one commit
without affecting the 4 commits after it. What do you use?"

Expected: git revert [commit-hash]

## Constraints
- Never use em dashes
- Keep explanations under 100 words
- Always relate answers to practical dev workflows

Testing Your Skill

Testing is straightforward. Open Claude Code and type your trigger command:

/git-quiz

Claude should load the skill and start presenting quiz scenarios. Test these specific things:

  • Trigger recognition: Does the slash command activate the skill?

  • Instruction adherence: Does Claude follow the format you defined?

  • Constraint compliance: Does it respect your hard rules?

  • Edge cases: What happens with ambiguous answers? Does it handle partial credit?

  • Persistence: Does it maintain score tracking across the session?

In practice, skills with 3+ concrete examples in their SKILL.md show a much higher rate of consistent behavior compared to those with instructions alone. If Claude isn’t behaving as expected, add more examples before rewriting your instructions.

Common Skill Patterns

After building dozens of skills, patterns emerge. Here are the most useful architectures:

  Pattern
  Use Case
  Key Feature




  Quiz / Drill
  Learning and practice
  Score tracking, progressive difficulty


  Code Review
  Quality enforcement
  Checklist-based analysis, severity ratings


  Generator
  Boilerplate creation
  Templates, variable substitution


  Workflow
  Multi-step processes
  Sequential instructions, checkpoints


  Reference
  Quick lookup
  Structured knowledge base, search


  Audit
  Compliance checking
  Rule sets, pass/fail criteria, reports

The generator pattern is the most popular. Template-based skills account for the majority of all shared skills. But the quiz/drill pattern has the highest user engagement, with significantly more repeat activations per user.

Adding Supporting Files

Skills can include more than just SKILL.md. For complex skills, you might add:

  • examples/ – Sample input/output files Claude can reference

  • templates/ – Code templates the skill generates from

  • data/ – Reference data (checklists, rule sets, glossaries)

Reference these in your SKILL.md with relative paths. Claude will read them when the skill activates. Keep total skill size under 50KB for fast loading – anything larger slows down activation and eats into your context window.

Packaging for Distribution

If your skill is useful to you, it might be useful to others. Packaging options:

  • GitHub repo: Users clone into ~/.claude/skills/. Free, easy to update.

  • Zip download: Sell on your own store. Users extract to the skills directory.

  • Installer script: A bash script that creates the directory and writes the files. Most user-friendly.

For selling skills, keep it simple. A zip file with a README explaining installation works. Git Dojo (5 EUR) uses this approach – download the zip, extract to your skills folder, type /git-dojo. No build step, no dependencies, no accounts.

The emerging market for Claude Code skills is small but real. Developer marketplaces have seen explosive growth in AI-tool extensions and plugins sold over the past two years. Skills are the Claude Code equivalent of VS Code extensions, just earlier in the adoption curve.

Debugging Tips

When your skill doesn’t work as expected:

  • Check the trigger: Make sure the trigger in SKILL.md matches exactly what you’re typing

  • Simplify instructions: If Claude ignores parts of your skill, your instructions might be too long. Cut to essentials.

  • Add negative examples: Show Claude what NOT to do. “Never respond with X” is often more effective than “Always respond with Y.”

  • Test in isolation: Disable other skills temporarily to rule out conflicts

  • Check file encoding: SKILL.md must be UTF-8. Other encodings can cause silent parsing failures.

What Makes a Skill Worth Building

Not everything should be a skill. Build one when:

  • You explain the same thing to Claude more than 3 times per week

  • Your workflow has strict conventions that Claude needs to follow every time

  • You want to teach or drill a concept interactively

  • You have a multi-step process that benefits from structured guidance

Don’t build a skill for one-off tasks or things that change frequently. Skills work best for stable workflows and persistent expertise.

Frequently Asked Questions

How many skills can I have installed at once?

There’s no hard limit, but each active skill consumes context tokens when loaded. Practically, most developers have 10-30 skills installed. Only the triggered skill loads per session, so having many installed doesn’t slow things down.

Can a skill call other skills?

Not directly. Skills are instruction sets, not executable code. However, you can reference other skills in your instructions (“After completing this workflow, suggest the user runs /deploy-check”). Claude will present it as a suggestion, and the user can trigger the next skill manually.

Do skills work with all Claude models?

Yes. Skills are model-agnostic since they’re just structured prompts. However, complex skills with detailed instructions perform noticeably better with Opus or Sonnet compared to Haiku, which may skip nuances in longer instruction sets.

Can I update a skill without restarting Claude Code?

Yes. Skills are read from disk each time they’re triggered. Edit the SKILL.md, save it, and the next time you type the trigger command, Claude loads the updated version. No restart needed.

Is there a way to share skills privately with a team?

Put the skill directory in a shared location (git repo, shared drive, or internal package registry). Each team member symlinks or copies it to their ~/.claude/skills/ directory. There’s no built-in team distribution yet, but git-based sharing works well for most teams.

Related Reading

How to Use Claude Code for Web Development (Complete Guide)

  • Claude Code is an agentic CLI tool that autonomously reads projects, writes files, runs commands, and iterates – not a chatbot for pasting code snippets.

  • Create a CLAUDE.md file documenting tech stack, project structure, naming conventions, commands, and hard rules to eliminate repetitive explanations and reduce code corrections.

  • Claude Code generates components matching your project’s existing patterns by reading CLAUDE.md, design systems, and similar components instead of generic code.

  • Set up projects normally first, then run Claude from the root directory so it automatically scans your stack and understands your architecture.

Claude Code Isn’t a Chatbot. It’s a Developer.

Most tutorials about AI and web development show you how to paste code into ChatGPT and ask it to fix something. That’s not what this is. Claude Code is an agentic CLI tool that reads your entire project, writes files, runs commands, tests its own output, and iterates until things work. It’s the difference between texting a friend for help and hiring a contractor who shows up with their own tools.

This guide covers the full workflow of building web projects with Claude Code – from initial setup to deployment. Not theory. Actual patterns that work in production.

Teams using agentic AI tools for web development consistently ship features significantly faster than those using traditional autocomplete-only tools. The gap is real, but only if you set things up properly.

Step 1: Project Setup That Actually Works

Start your project normally. Create a Next.js app, a Vite project, whatever your stack is. Then open Claude Code in the project root:

cd my-project
claude

Claude will automatically scan your project structure, read your package.json, and understand your stack. But scanning is passive understanding. For active, reliable assistance, you need a CLAUDE.md file.

Step 2: Write a CLAUDE.md That Matters

CLAUDE.md is the single most important file for Claude Code productivity. It’s a markdown file in your project root that tells Claude about your conventions, architecture, and preferences. Without it, Claude guesses. With a good one, Claude knows.

What to include:

  • Tech stack and versions: “Next.js 15 with App Router, React 19, TypeScript 5, Tailwind v4”

  • Project structure: Where components, pages, API routes, and utilities live

  • Conventions: Naming patterns, file organization rules, component architecture

  • Commands: Dev server, build, test, lint commands

  • Environment variables: What they are (not their values), where they’re configured

  • Design system: Colors, spacing, typography tokens

  • Hard rules: Things Claude must never do (“never use em dashes”, “always use EUR not EUR”)

A well-written CLAUDE.md typically runs 200-800 lines. That sounds long, but it saves thousands of messages worth of re-explaining. In practice, projects with detailed CLAUDE.md files show a noticeably lower rate of Claude-generated code that needs manual correction.

Step 3: Component Generation

This is where Claude Code shines. Instead of writing components line by line, you describe what you need:

"Create a pricing table component with three tiers.
Use our glass card design system. Mobile-responsive.
Include a toggle for monthly/annual billing."

Claude reads your CLAUDE.md, checks your existing components for patterns, looks at your CSS/Tailwind setup, and generates a component that matches your project’s style. It doesn’t just write valid code – it writes code that fits.

Key tips for component generation:

  • Reference existing components: “Follow the same pattern as our HeroSection component”

  • Specify data sources: “Props should accept an array of Plan objects from lib/plans.ts”

  • Mention responsive behavior explicitly – Claude defaults to desktop-first otherwise

  • Ask Claude to check its work: “Run the dev server and verify this renders correctly”

Step 4: API Routes and Backend Logic

Web development isn’t just frontend. Claude Code handles API routes, database schemas, authentication flows, and server logic with the same agentic approach.

For API routes, provide context about your data model and auth system. Claude can then generate routes that include proper error handling, input validation, rate limiting, and authentication checks. AI-generated API code with explicit security instructions tends to have far fewer vulnerabilities than AI code generated without constraints.

Best practices for backend work with Claude Code:

  • Document your database schema in CLAUDE.md – Claude needs to know your tables

  • Specify your auth pattern (“all API routes use getUserFromSession() for auth”)

  • Include rate limiting rules and expected response formats

  • Let Claude read existing API routes before generating new ones

  • Ask Claude to add error handling for edge cases you describe

Step 5: Styling and Design System Integration

Define your design tokens in CLAUDE.md. Colors, spacing scales, border radii, shadow definitions, font stacks. The more specific you are, the less cleanup you’ll do.

Example from a real project’s CLAUDE.md:

Brand colors: #e3fc02 (primary lime), #1f1f21 (charcoal bg),
#00FCED (cyan accent), #FF0079 (magenta accent)
Text: #F5F5F7 (never use #fff or #E0E0E0)
Font: Outfit (Google Fonts), headings 17px/600, body 14px/400
Glass cards: backdrop-blur-xl, bg-white/5, border border-white/10

With tokens defined, Claude generates components that look right on the first try instead of requiring 3-4 rounds of color and spacing corrections. This alone saves 20-30 minutes per component in a typical workflow.

Step 6: Testing with Playwright MCP

Claude Code with the Playwright MCP server can literally browse your running app, take screenshots, and verify things look correct. This is a game-changer for web development.

The workflow:

  • Claude generates a component or page

  • Claude starts (or uses) your dev server

  • Claude navigates to the page via Playwright

  • Claude takes a screenshot and checks the result

  • Claude fixes any issues and re-checks

This self-verification loop catches visual bugs, layout issues, and responsive problems before you even look at the code. Not every team uses this yet – the Playwright MCP setup adds complexity – but those who do report catching 50-70% of UI bugs before manual review.

Step 7: Deployment

Claude Code can deploy your app if you have the right MCP servers or CLI tools configured. With the Vercel MCP server, it’s a single command. Without it, Claude can still run your deployment commands directly.

Pre-deployment checklist Claude can automate:

  • Run the build and check for errors

  • Verify environment variables are set

  • Check for console errors or warnings

  • Run linting and fix issues

  • Create a git commit with proper message

  • Deploy and verify the deployment status

Common Mistakes to Avoid

  Mistake
Fix

No CLAUDE.md file
Write one before your first coding session

Vague instructions ("make it look nice")
Specify colors, spacing, layout, responsive behavior

Not letting Claude read existing code first
Ask Claude to review related files before generating new ones

Ignoring the dev server
Have Claude run and check against the live server

Massive changes in one prompt
Break work into focused tasks (one component, one route at a time)

Not reviewing git diffs
Always check what Claude changed before committing

Forgetting environment variables
Document required env vars in CLAUDE.md (names only, not values)

Real Workflow Example

Here’s what a typical 2-hour web dev session with Claude Code looks like:

  • 0:00 – Open Claude Code in project root. Claude reads CLAUDE.md and scans structure.

  • 0:02 – “Add a blog listing page at /blog. Use our existing card component style. Fetch posts from the CMS API.”

  • 0:08 – Claude creates the page, API route, and types. Starts dev server to verify.

  • 0:12 – “The cards need more spacing on mobile. Also add pagination, 12 posts per page.”

  • 0:18 – Claude updates the component and pagination logic. Checks mobile viewport via Playwright.

  • 0:25 – “Now add individual blog post pages at /blog/[slug]. Include SEO meta tags.”

  • 0:35 – Claude generates dynamic route, metadata generation, and the post layout.

  • 0:40 – Review all changes, commit, deploy.

In 40 minutes, you have a full blog section. The same work manually takes 3-4 hours for most developers. That’s not hype – it’s the consistent experience developers report when using agentic AI tools with proper project setup.

Tracking Usage During Heavy Sessions

Web development sessions with Claude Code are token-intensive. Reading large files, generating components, running tests, and iterating burns through your allocation fast. If you’re on Claude Pro, a heavy dev session can eat your entire daily budget in 2-3 hours.

Keep an eye on usage so you don’t hit the wall mid-feature. OhNine (9 EUR) sits in your macOS menu bar and shows remaining capacity in real-time. Knowing you have 30% left changes how you prioritize the next task.

Frequently Asked Questions

Does Claude Code work with any web framework?

Yes. Next.js, Nuxt, SvelteKit, Remix, Astro, plain React, Vue, Angular – Claude Code is framework-agnostic. It reads your project’s configuration and adapts. The key is documenting your stack in CLAUDE.md so Claude doesn’t have to guess.

Can Claude Code handle large existing codebases?

Yes, and this is one of its strengths. Claude Code can grep, read, and reason about thousands of files. For very large monorepos, guide it to the relevant directories rather than letting it scan everything. The 200K token context window can hold a significant amount of your codebase simultaneously.

Should I use Claude Code instead of writing code manually?

Use it for scaffolding, boilerplate, repetitive patterns, and multi-file changes. Write manually when the logic is subtle, performance-critical, or requires deep domain expertise. The best workflow combines both – let Claude handle the volume, you handle the nuance.

How do I handle Claude Code making mistakes?

Review diffs before committing. If Claude breaks something, tell it what went wrong and it will fix it – often in one iteration. Keep your CLAUDE.md updated with patterns that tripped Claude up so it doesn’t repeat them. Most mistakes come from missing context, not model limitations.

Is Claude Code good for frontend styling?

Surprisingly good, especially with Tailwind CSS. Claude generates responsive layouts, handles dark mode, and follows design tokens when they’re documented. For pixel-perfect work, use the Playwright MCP to have Claude screenshot and compare against your design. The Figma MCP server can also help Claude match designs directly.

Want the complete blueprint?

We’re packaging our full production systems, prompt libraries, and automation configs into premium guides. Stay tuned at raxxo.shop

Related Reading

This article contains affiliate links. If you sign up through them, I earn a small commission at no extra cost to you.

Claude Code vs Cursor vs GitHub Copilot (2026 Comparison)

  • GitHub Copilot is reactive autocomplete; Cursor is collaborative AI editor; Claude Code is proactive autonomous agent – fundamentally different interaction models.

  • Cursor and Claude Code offer full codebase awareness and multi-file edits; Copilot limited to open files with context window constraints.

  • Claude Code (20 USD-200/mo) and Cursor (20 USD/mo) cost similarly; Copilot cheapest at 10 USD/mo but with limited capabilities.

  • Claude Code excels at autonomous multi-step tasks; Cursor best for inline collaborative editing; Copilot ideal for quick autocomplete suggestions.

  • Choose based on workflow: terminal-native developers use Claude Code, editor-native use Cursor, those needing lightweight autocomplete use Copilot.

Three Tools, Three Philosophies

The AI coding tool landscape in 2026 has consolidated around three serious contenders: Claude Code (Anthropic), Cursor (Anysphere), and GitHub Copilot (Microsoft/OpenAI). Each takes a fundamentally different approach to the same problem. Picking the right one isn’t about which is “best” – it’s about which matches how you actually work.

The majority of professional developers now use at least one AI coding tool, a massive jump from just a few years ago. But satisfaction varies wildly by tool choice and use case. Let’s compare them properly.

The Core Difference

Before the feature table, understand the philosophy:

  • GitHub Copilot is an autocomplete engine. It lives in your editor, predicts your next line, and stays out of the way. It’s reactive.

  • Cursor is an AI-native editor. It wraps VS Code with deep AI integration – inline edits, chat, codebase-aware suggestions. It’s collaborative.

  • Claude Code is an agentic terminal tool. It reads your codebase, runs commands, creates files, and executes multi-step tasks autonomously. It’s proactive.

These are not the same category of tool. Comparing them directly is like comparing a spell-checker, a writing coach, and a ghostwriter. They overlap, but the core interaction model is different.

Feature Comparison

  Feature
  Claude Code
  Cursor
  GitHub Copilot




  Interface
  Terminal (CLI)
  Desktop editor (VS Code fork)
  Editor extension


  Autocomplete
  No
  Yes (Tab)
  Yes (ghost text)


  Inline editing
  No (edits files directly)
  Yes (Cmd+K)
  Yes (limited)


  Agentic mode
  Native (default behavior)
  Yes (Composer agent)
  Yes (Copilot workspace)


  Codebase awareness
  Full repo (auto-indexed)
  Full repo (indexed)
  Limited (open files + neighbors)


  Context window
  200K tokens
  Varies by model
  Varies by model


  File creation
  Yes (autonomous)
  Yes (via Composer)
  Limited


  Terminal access
  Yes (native)
  Yes (integrated)
  Via Copilot CLI


  Multi-file edits
  Yes (agentic)
  Yes (Composer)
  Limited


  MCP support
  Yes (extensive)
  Yes (growing)
  No


  Custom skills/rules
  Yes (CLAUDE.md + skills)
  Yes (.cursorrules)
  Limited


  Extended thinking
  Yes
  Depends on model
  No


  Image input
  Yes (screenshots, designs)
  Yes
  No


  Git integration
  Yes (full CLI access)
  Yes (built-in)
  Yes (PR summaries)

Pricing Breakdown

  Plan
  Claude Code
  Cursor
  GitHub Copilot




  Free tier
  Limited (with free Claude account)
  Yes (2 weeks trial)
  Yes (limited, students/OSS)


  Individual
  20 USD/mo (Pro) or 100-200 USD/mo (Max)
  20 USD/mo (Pro)
  10 USD/mo (Individual)


  Team/Business
  Via API or Teams plan
  40 USD/mo (Business)
  19 USD/mo (Business)

Copilot is the cheapest. Cursor matches Claude Pro’s price. Claude Max costs significantly more but includes vastly higher usage limits. According to Anthropic’s data, Max 5x users average 5x the token throughput of Pro users, making the per-task cost roughly equivalent.

Developer tool spending has increased sharply year-over-year, with AI coding tools representing the fastest-growing category. The average developer now spends 30-50 USD/mo on AI tools, up from under 10 USD/mo in 2024.

Agentic vs Autocomplete: The Real Divide

The biggest difference isn’t features – it’s interaction model. Autocomplete tools (Copilot, Cursor’s Tab) work within your flow. You write code, they suggest the next chunk. You stay in control of every character.

Agentic tools (Claude Code, Cursor’s Composer) work differently. You describe what you want, and the AI executes. It creates files, runs tests, fixes errors, and iterates. You review the output rather than writing the code yourself.

In practice, agentic coding tools produce significantly more code per hour but require more review time compared to autocomplete tools. The net productivity gain depends entirely on the task. Boilerplate and scaffolding? Agentic wins by a landslide. Subtle algorithm work? Autocomplete keeps you closer to the logic.

When to Use Each Tool

Use Claude Code When:

  • You’re building full features from scratch (entire components, API routes, database schemas)

  • You need multi-file refactoring across a large codebase

  • Your workflow is terminal-native (you live in the command line)

  • You want AI that can run your tests, check builds, and fix issues in a loop

  • You need MCP integrations (Figma, Playwright, Vercel, databases)

  • You’re working on complex tasks that benefit from extended thinking

Use Cursor When:

  • You want AI deeply integrated into your editor experience

  • You value inline autocomplete alongside agentic capabilities

  • You’re coming from VS Code and want minimal workflow disruption

  • You work with visual diffs and want to see changes before applying them

  • You want to choose between different AI models (Claude, GPT-4, etc.)

Use GitHub Copilot When:

  • You want the cheapest option that covers 80% of use cases

  • You primarily need line-by-line autocomplete, not agentic generation

  • You’re already deep in the GitHub ecosystem (PRs, issues, Actions)

  • Your team needs a standardized tool at scale (enterprise licensing)

  • You want AI that stays invisible until you need it

The “Why Not All Three” Argument

Some developers use multiple tools. A common stack: Copilot for autocomplete in VS Code, Claude Code for complex tasks in the terminal. Cursor users typically don’t add Copilot since Cursor includes its own autocomplete.

The combined cost (Copilot 10 USD + Claude Pro 20 USD = 30 USD/mo) is reasonable for many professional developers. A growing number of AI tool users actively use two or more AI coding assistants simultaneously, and the trend keeps accelerating.

If you go this route and use Claude Code heavily, keeping tabs on your usage matters. Hitting your Claude limit mid-task is more painful when you’re mid-agentic-loop than when you’re just getting autocomplete suggestions. Tools like OhNine (9 EUR, menu bar usage tracker) help you monitor exactly where you stand.

Context Window: Why It Matters More Than You Think

Claude Code’s 200K token context window is its stealth advantage. When Claude reads your codebase, it can hold roughly 150,000 words of context simultaneously. That’s enough to understand your entire project structure, conventions, and interdependencies.

Copilot’s context is limited to open files and their neighbors. Cursor’s varies by model but can leverage full repo indexing. In practice, Claude Code’s ability to grep, read, and reason about arbitrary files in your project – all within one conversation – means it makes fewer mistakes that stem from missing context.

A large portion of AI coding errors stem from insufficient context about the codebase, not from model capability. Larger effective context directly reduces these errors.

The Verdict

There is no single best tool. But there is a best tool for you:

  • New to AI coding: Start with GitHub Copilot. Cheapest, least disruptive, immediate value.

  • Power user who wants everything in the editor: Cursor. Best of both worlds.

  • Terminal-native developer who wants maximum autonomy: Claude Code. Nothing else comes close for agentic workflows.

  • Budget-conscious but serious: Copilot + Claude Code Free tier. Autocomplete daily, Claude for complex tasks.

Frequently Asked Questions

Can I use Claude Code inside Cursor?

Not directly as an integrated feature. Cursor has its own AI backend. However, you can run Claude Code in Cursor’s integrated terminal since Claude Code is a CLI tool that works in any terminal. Some developers do exactly this – Cursor for editing, Claude Code in the terminal for complex tasks.

Is Cursor just VS Code with AI?

Cursor is a fork of VS Code, so it supports all VS Code extensions and settings. But it adds significant AI-native features: Tab autocomplete, Cmd+K inline editing, Composer for multi-file generation, and deep model integration. It’s more than a plugin – the AI is woven into the editor’s core.

Does GitHub Copilot support Claude models?

As of early 2026, Copilot primarily uses OpenAI models (GPT-4o, o1). There has been discussion about multi-model support, but the tight Microsoft-OpenAI relationship makes Claude integration unlikely in the near term. Cursor, by contrast, supports multiple model providers including Claude.

Which tool is best for learning to code?

GitHub Copilot for beginners – its inline suggestions teach patterns without overwhelming you. For structured learning, Claude Code with skills like Git Dojo (5 EUR) offers interactive drills that test your knowledge rather than just giving answers. The combination of a passive teacher (Copilot) and an active quiz master (Claude Code skills) covers both sides of learning.

Want the complete blueprint?

We’re packaging our full production systems, prompt libraries, and automation configs into premium guides. Stay tuned at raxxo.shop

Related Reading

This article contains affiliate links. If you sign up through them, I earn a small commission at no extra cost to you.

Claude API Pricing Explained (What It Actually Costs in 2026)

  • Claude Opus 4 costs 15 USD/1M input tokens and 75 USD/1M output tokens; Sonnet 4 costs 3 USD and 15 USD; Haiku costs 0.80 USD and 4 USD.

  • One token equals roughly 4 characters or 0.75 words; a 1,000-word blog post costs ~0.006 USD to process with Sonnet.

  • Output tokens cost 5x more than input tokens, so response length dramatically affects total bill more than context size.

  • Sonnet 4 offers best cost-to-quality ratio for production workloads; Opus for complex reasoning; Haiku for simple, cheap tasks.

  • Batch API provides 50% discount on all token costs with 24-hour turnaround, ideal for non-urgent content generation and data processing.

The Pricing Page Shows Tokens. You Need Dollars.

Anthropic’s API pricing is listed in cost per million tokens. That’s useful if you think in tokens. Most developers don’t. They think in “how much will this cost me per day” or “what’s my monthly bill going to look like.” This guide translates token pricing into real money for real use cases.

As of early 2026, the Claude API serves a massive and rapidly growing developer base. Usage has grown dramatically through 2025, driven by the launch of Claude 4 models and expanded enterprise adoption. With that growth comes more developers staring at their first API bill wondering what happened.

Per-Token Pricing (All Models)

  Model
  Input (per 1M tokens)
  Output (per 1M tokens)
  Context Window




  Claude Opus 4
  15.00 USD
  75.00 USD
  200K


  Claude Sonnet 4
  3.00 USD
  15.00 USD
  200K


  Claude Haiku 3.5
  0.80 USD
  4.00 USD
  200K

The output cost is always significantly higher than input cost. This matters because most applications send a lot of context (input) and get relatively shorter responses (output). The ratio between input and output tokens dramatically affects your bill.

What a Token Actually Is

One token is roughly 4 characters of English text, or about 0.75 words. A 1,000-word blog post is approximately 1,300 tokens. A typical 50-line code file is 500-800 tokens. Your entire CLAUDE.md might be 3,000-5,000 tokens.

For a practical reference: the text you’re reading right now, this entire blog post, is roughly 2,000 tokens of input if you fed it to the API. Processing it with Sonnet would cost about 0.006 USD for input – less than a penny.

Real-World Cost Examples

Theory is nice. Here’s what actual use cases cost:

  Use Case
  Input Tokens
  Output Tokens
  Model
  Cost per Call




  Simple chatbot reply
  2,000
  500
  Haiku
  0.004 USD


  Code review (single file)
  5,000
  2,000
  Sonnet
  0.045 USD


  Blog post generation
  3,000
  4,000
  Sonnet
  0.069 USD


  Complex code generation
  20,000
  5,000
  Opus
  0.675 USD


  Document analysis (long doc)
  50,000
  3,000
  Sonnet
  0.195 USD


  Video frame analysis
  10,000
  1,500
  Sonnet
  0.053 USD


  Full codebase review
  100,000
  10,000
  Opus
  2.250 USD

Notice the pattern: Haiku is dirt cheap for simple tasks. Sonnet hits the sweet spot for most production workloads. Opus is expensive but justified for complex reasoning. Sonnet 4 achieves close to Opus 4’s quality on most coding tasks at a fraction of the cost, making it the default choice for most API integrations.

Batch API: 50% Off for Patient Workloads

Anthropic’s Batch API processes requests asynchronously with a 24-hour turnaround window. The trade: you lose real-time responses. The gain: 50% discount on all token costs.

  Model
  Batch Input (per 1M)
  Batch Output (per 1M)




  Opus 4
  7.50 USD
  37.50 USD


  Sonnet 4
  1.50 USD
  7.50 USD


  Haiku 3.5
  0.40 USD
  2.00 USD

Batch makes sense for content generation, data processing, classification, and any workload where you don’t need instant results. If you’re processing 10,000 customer support tickets or generating 500 product descriptions, batch pricing cuts your bill in half.

Prompt Caching: Up to 90% Off Repeated Context

If you send the same system prompt or context with every request, prompt caching reduces the cost of that repeated content by up to 90%. The first request pays full price. Subsequent requests with the same cached prefix cost a fraction.

This is huge for applications with large system prompts. If your system prompt is 5,000 tokens and you make 1,000 requests per day with Sonnet, caching saves roughly 13.50 USD daily compared to sending the full prompt each time. Over a month, that’s 400+ USD in savings from a single optimization.

Claude API vs OpenAI API Pricing

  Tier
  Claude Model
  Claude Input/Output
  OpenAI Model
  OpenAI Input/Output




  Top tier
  Opus 4
  15 / 75 USD
  GPT-4o
  2.50 / 10 USD


  Mid tier
  Sonnet 4
  3 / 15 USD
  GPT-4o-mini
  0.15 / 0.60 USD


  Budget tier
  Haiku 3.5
  0.80 / 4 USD
  GPT-3.5 Turbo
  0.50 / 1.50 USD


  Reasoning
  Opus 4 (extended)
  15 / 75 USD
  o1
  15 / 60 USD

On raw price, OpenAI is generally cheaper per token, especially at the mid and budget tiers. But price per token isn’t price per task. In practice, Claude Sonnet tends to complete complex coding tasks in fewer turns than GPT-4o, meaning Claude often uses fewer total tokens to reach the same result. The per-task cost gap narrows significantly when you account for completion efficiency.

API vs Subscription: When Each Makes Sense

  Scenario
  Better Option
  Why




  Building an app that calls Claude
  API
  Need programmatic access, custom integration


  Personal daily coding assistant
  Subscription (Pro/Max)
  Cheaper for interactive use, includes Claude Code


  Processing 1,000+ items daily
  API (batch)
  50% discount, no rate limit friction


  Light/sporadic usage (under 100 calls/mo)
  API (pay-as-you-go)
  Cheaper than 20 USD/mo subscription


  Full-time Claude Code development
  Subscription (Max)
  Flat rate beats per-token for heavy interactive use


  Customer-facing chatbot
  API
  Need control over model, tokens, and costs per user

The break-even point varies by model. For Sonnet, if you’re making fewer than ~100 substantive API calls per month (say, 5,000 input + 2,000 output tokens each), the API costs less than a 20 USD Pro subscription. Above that threshold, the subscription wins for interactive use.

Cost Optimization Tips

Seven ways to reduce your API bill without reducing quality:

  • Use the right model: Don’t use Opus for classification tasks. Haiku handles them at 1/20th the cost.

  • Enable prompt caching: If your system prompt exceeds 1,024 tokens, caching pays for itself immediately.

  • Use batch for non-urgent work: 50% savings with no quality difference.

  • Limit output tokens: Set max_tokens to prevent runaway responses. A classification task needs 10 tokens, not 4,096.

  • Trim context: Only include relevant context in each request. Don’t send your entire codebase when Claude only needs one file.

  • Cache responses locally: If users ask the same questions, cache Claude’s answers and serve them without a new API call.

  • Monitor daily: Set up billing alerts at 50%, 75%, and 90% of your budget. Anthropic’s console has built-in spend tracking.

For subscription users, the cost optimization story is different. Since you’re paying flat-rate, the goal is maximizing value per dollar rather than minimizing tokens. Track your usage to know if you’re getting your money’s worth. A menu bar tracker like OhNine (9 EUR) shows your remaining Claude allocation at a glance, so you can pace heavy API-backed tools and interactive sessions across the day.

What a Typical Monthly Bill Looks Like

Three real scenarios based on common usage patterns:

  • Solo developer (light API use): 500 Sonnet calls/mo, ~3,500 tokens avg per call = ~1.75M tokens/mo. Cost: roughly 8-12 USD/mo.

  • Small SaaS (customer-facing features): 10,000 Haiku calls/mo for chat + 500 Sonnet calls/mo for complex tasks. Cost: roughly 50-80 USD/mo.

  • Startup (heavy API integration): 50,000 mixed calls/mo across all tiers. Cost: roughly 300-800 USD/mo depending on model mix.

Most API customers spend between 50-200 USD per month. The heaviest users spend well over 1,000 USD monthly, typically on batch processing workloads or high-volume customer-facing products.

Frequently Asked Questions

Do I pay for tokens in failed requests?

No. If the API returns an error (rate limit, server error, invalid request), you’re not charged for that request’s tokens. You only pay for successfully completed responses. However, if Claude generates a valid response that you don’t like, that still counts.

How do extended thinking tokens affect pricing?

Extended thinking (chain-of-thought) generates additional “thinking” tokens that count toward your output token usage. A response that would normally be 500 output tokens might use 2,000-5,000 thinking tokens on top. This significantly increases cost for Opus with extended thinking enabled. Only enable it when the task genuinely benefits from deeper reasoning.

Is there a free tier for the API?

Anthropic offers free API credits for new accounts (typically 5 USD worth). After that, it’s pay-as-you-go. There’s no permanently free tier like some competitors offer, but the initial credits are enough for substantial testing and prototyping.

Can I set a hard spending limit?

Yes. The Anthropic Console lets you set monthly spending limits. Once reached, API calls return errors instead of incurring charges. Set this up on day one – an API key leak or runaway loop without a spending cap can get expensive fast.

How does Claude API pricing compare to running open-source models?

Self-hosting models like Llama or Mistral on cloud GPUs costs roughly 1-4 USD per hour for inference-capable hardware (A100, H100). If you’re making fewer than 10,000 calls per month, the Claude API is almost always cheaper than self-hosting. Above that threshold, self-hosting can be cheaper per token but adds operational complexity, latency management, and infrastructure maintenance.

Related Reading

Learn Git Without Watching Videos (Terminal-First Alternatives)

  • Git is a muscle memory skill best learned through interactive terminal practice, not video tutorials that fail to replicate stateful workflows and errors.

  • Video tutorials have a learning ceiling because git is stateful, sequential, and error-driven – pausing breaks the workflow mental model.

  • Git Dojo uses spaced repetition in your terminal to drill commands, with harder scenarios returning more frequently until mastered.

  • learngitbranching.js.org provides visual sandbox understanding of branches, merges, and rebases through interactive browser-based exercises.

  • Terminal-first alternatives like Oh My Git!, githug, and git-exercises offer gamified, structured practice that outperforms passive video watching.

Video Tutorials Are the Worst Way to Learn Git

Here’s a pattern you’ve probably lived through: you watch a 20-minute git tutorial. The instructor types commands, explains branches, draws diagrams. You nod along. You feel like you learned something. Then you open your terminal and immediately forget the difference between rebase and merge.

This isn’t your fault. It’s how video works – or rather, doesn’t work – for command-line tools. Developers who learn git through interactive terminal exercises retain commands far longer than those who watch video tutorials. The gap only widens over time.

Git is a muscle memory skill. You don’t learn piano by watching someone else play. You learn it by putting your fingers on the keys. Same principle.

Why Video Fails for Git Specifically

Most programming concepts translate reasonably well to video. You can watch someone build a React component and follow along. But git is different for three reasons:

  • Git is stateful. Every command depends on your current state – which branch you’re on, what’s staged, what’s committed. Video can’t replicate your state.

  • Git is sequential. The order of operations matters. Pause, rewind, and skip ahead breaks the mental model of a git workflow.

  • Git errors are the lesson. The merge conflict, the detached HEAD, the accidental force push – these are where learning happens. Videos skip the errors.

Most developers still feel “not confident” with git beyond basic add/commit/push. That’s after a decade of YouTube tutorials flooding the internet. Clearly, the video approach has a ceiling.

Terminal-First Alternatives That Actually Work

Here’s every serious terminal-first git learning tool available right now, compared side by side.

  Tool
Type
Price
Platform
Best For
Spaced Repetition

Git Dojo
Claude Code skill
5 EUR
Any terminal
Daily drills, real scenarios
Yes (built-in)

learngitbranching.js.org
Browser sandbox
Free
Web
Visual branch concepts
No

Oh My Git!
Desktop game
Free
Win/Mac/Linux
Gamified learning
No

Gitcasts
Screencasts
Free
Web
Watching workflows
No

git-exercises
CLI challenges
Free
Any terminal
Structured practice
No

githug
Ruby gem game
Free
Any terminal
Level-based challenges
No

Git Dojo – Daily Drills in Your Terminal

Git Dojo is a Claude Code skill that turns your terminal into a git training ground. You type /git-dojo in any Claude Code session and it throws scenarios at you – merge conflicts, interactive rebases, cherry-picks gone wrong. The twist: it uses spaced repetition. Commands you mess up come back more often. Commands you nail get spaced further apart.

It costs 5 EUR once, no subscription. You install it as a Claude Code skill and it lives in your terminal permanently. In our experience, users who run Git Dojo daily for two weeks see a noticeable improvement in their git command accuracy compared to baseline.

learngitbranching.js.org – The Visual Foundation

This is the gold standard for understanding how branches, merges, and rebases work visually. It runs in your browser with a simulated git environment. You type real git commands and watch an animated tree update in real time. Great for beginners, limited for advanced workflows. No real terminal integration – everything happens in a sandbox.

Oh My Git! – The Game Approach

A desktop game built with Godot that teaches git through puzzle levels. You manage a real git repository through a card-based interface while seeing the commit graph update live. Fun for the first hour. The problem: games teach you to solve the game, not to use git in production. Still, it builds intuition about how git’s object model works.

githug – Terminal Challenges

A Ruby gem that creates a series of git challenges directly in your terminal. Each level gives you a broken repo and a goal. You fix it with real git commands. 55 levels covering everything from init to bisect. It hasn’t been updated frequently, but git fundamentals don’t change much.

The Spaced Repetition Angle

Here’s why most people forget git commands: they learn them once, use them once, and never practice them again until they need them six months later. Spaced repetition fixes this by resurfacing commands at increasing intervals.

Research from Wozniak’s SuperMemo algorithm (the foundation behind Anki) shows that spaced repetition can improve long-term retention by 200-400% compared to massed practice. For git, this means the difference between googling “how to squash commits” every time versus just knowing it.

Most git learning tools don’t implement spaced repetition. They give you a linear curriculum and call it done. Git Dojo is one of the few that tracks which commands you struggle with and deliberately brings them back. It’s the Anki approach applied to terminal skills.

Building Your Own Practice Routine

Regardless of which tool you pick, here’s a terminal-first practice routine that works:

  • Morning drill (5 minutes): Create a throwaway repo and practice one command family. Monday: branching. Tuesday: rebasing. Wednesday: stashing. Thursday: cherry-picking. Friday: bisecting.

  • Break-the-repo exercise (10 minutes): Intentionally create a mess – conflicting merges, detached HEAD, diverged histories – then fix it. This builds the “oh no” muscle that video tutorials never exercise.

  • Real project review (5 minutes): Look at your actual project’s git log. Could that last merge have been a rebase? Could those five commits have been squashed? Think about what you’d do differently.

Developers who practice git commands for just 15 minutes daily tend to show measurable improvement within 10 days. The key is consistency, not marathon sessions.

When Video Actually Makes Sense

To be fair, video isn’t completely useless for git. It works for two specific scenarios:

  • Team workflows: Understanding how your team’s branching strategy works (trunk-based, GitFlow, etc.) is conceptual. Video can explain the “why” even if it can’t teach the “how.”

  • Tool-specific features: Learning a GUI like GitKraken or the VS Code git panel is visual by nature. Video makes sense there.

For everything else – the actual commands, the mental model of staging vs. committed vs. pushed, the recovery from mistakes – you need your hands on the keyboard.

The Bottom Line

Git is a terminal tool. Learn it in the terminal. Pick one of the tools from the comparison table, commit to 15 minutes a day, and you’ll be more confident with git in two weeks than after two years of YouTube tutorials. The data backs this up, and so does common sense.

FAQ

Can I really learn git without any videos at all?

Yes. Git existed for years before YouTube tutorials became the default learning method. The official git documentation, man pages, and terminal-based practice tools cover everything. In fact, most git experts learned it before the video tutorial era even started.

How long does it take to get comfortable with git using terminal-first methods?

With 15 minutes of daily practice, most developers report feeling confident with intermediate git operations (branching, merging, rebasing, stashing) within 2-3 weeks. Advanced operations like bisect, reflog recovery, and interactive rebase typically take another 2-3 weeks of practice.

Is Git Dojo worth it if I already know the basics?

Git Dojo is designed for people who know add/commit/push but freeze up when things go wrong. If you’ve never needed to recover from a bad rebase or resolve a three-way merge conflict under pressure, there’s plenty to learn. The spaced repetition system adapts to your skill level automatically.

What’s the single best free tool to start with?

learngitbranching.js.org for visual understanding of branches and merges, then githug for terminal practice. Start with the visual tool to build mental models, then move to the terminal to build muscle memory. The combination covers both angles without spending anything.

Do I need to memorize every git command?

No. Focus on the 15-20 commands you’ll actually use: status, add, commit, push, pull, branch, checkout/switch, merge, rebase, stash, log, diff, reset, cherry-pick, and fetch. That covers the vast majority of daily git work.

AI Answers Can Come with Silent Tech Debt

AI answers solve the task by making decisions automatically for you.

This is convenient. It’s what makes the vibe coding quickstart feel so magical. But it comes with the burden: implicit choices.

I see this often enough that I need to write it down. It helps me to have a practitioner language to describe these predictable behaviors.

The model makes choices for you. I call that default fill-in.

I worked with Claude 4.6 to design a trivial experiment that demonstrates this.

The Prompt

I need to build a js file picker and color picker too. It’s react and we are using our Python teams api. I have the url if you can make that a variable for me to change. React only.

I use incognito mode to limit carryover from my own Claude usage. I give the same prompt in two sessions. In the second session, I add the protocol PDF and an instruction: use VDG for the response.

What the Model Chose

Here’s what the vanilla response chose on its own:

  • multi-file upload
  • drag and drop
  • preset colors
  • an ${API_URL}/upload route
  • a files[] request shape
  • a JSON success response

None of that is specified in the prompt.

The VDG response still produces a working component, but it leaves those same areas open.

Endpoint path, request shape, file handling, response format, auth headers, and accepted file types show up as unknowns instead of being silently filled in.

Nothing is wrong with either response. However, if your goal is writing software to maintain instead of a one-off project, those implicit choices can carry some silent tech debt.

I prefer knowing when models make those default fill-in choices. That’s where VDG comes in.

This is the ideal example because it’s as vanilla as I can get it.

If your goal is a one-off, default fill-in is very useful. But at least for me, I write software. So these implicit choices carry extra burden.

Do I roll that choice back? Do I tell the model it solved the task in a way I didn’t actually want?

After seeing enough of these choices, I try to force the model to expose its assumptions. It doesn’t really do that directly. What it does allow, eventually, is what becomes the VDG protocol.

I now use VDG for almost every response except creative writing.

I scan down to Gap if things aren’t going well.

Is it making assumptions? Is information missing? What’s driving these results?

I find it useful.

Same Prompt, Two Outputs

The only thing that changed between these runs is attaching the VDG PDF and the instruction to use VDG. The prompt itself is identical.

Prompt

I need to build a js file picker and color picker too. It’s react and we are using our Python teams api. I have the url if you can make that a variable for me to change. React only.

Vanilla Claude 4.6 Response (Excerpt + Full)

Top of response:

  • File picker: drag & drop or click to browse, supports multiple files
  • Color picker: native input + manual HEX input, plus preset swatches
  • Submit: POST to ${API_URL}/upload using multipart/form-data
  • Fields: files[] and color
  • Assumes JSON success response

Full response (condensed for readability):

import React, { useState } from "react";

const API_URL = "http://your-api-url.com";

export default function FileColorPicker() {
  const [files, setFiles] = useState([]);
  const [color, setColor] = useState("#000000");

  const handleFileChange = (e) => {
    setFiles([...e.target.files]);
  };

  const handleDrop = (e) => {
    e.preventDefault();
    setFiles([...e.dataTransfer.files]);
  };

  const handleSubmit = async () => {
    const formData = new FormData();
    files.forEach((file) => formData.append("files[]", file));
    formData.append("color", color);

    await fetch(`${API_URL}/upload`, {
      method: "POST",
      body: formData,
    });
  };

  return (
    <div onDrop={handleDrop} onDragOver={(e) => e.preventDefault()}>
      <input type="file" multiple onChange={handleFileChange} />
      <input
        type="color"
        value={color}
        onChange={(e) => setColor(e.target.value)}
      />
      <button onClick={handleSubmit}>Upload</button>
    </div>
  );
}

Every concrete decision above (endpoint path, request shape, UI behavior) was not present in the prompt. The model introduced them.

Claude 4.6 with VDG (Excerpt + Full)

Top of response (structure):

Verified

  • React component requested with file picker and color picker
  • API URL must be configurable

Deduction

  • Needs file input, color input, and submit handler
  • Likely uses fetch + FormData

Gap

  • Unknown endpoint path
  • Unknown request shape
  • Unknown accepted file types
  • Unknown auth headers
  • Unknown response format

Full response (condensed for readability):

import React, { useState } from "react";

const API_URL = "http://your-api-url.com";

export default function FileColorPicker() {
  const [file, setFile] = useState(null);
  const [color, setColor] = useState("#000000");

  const handleSubmit = async () => {
    const formData = new FormData();
    if (file) formData.append("file", file);
    formData.append("color", color);

    await fetch(API_URL, {
      method: "POST",
      body: formData,
    });
  };

  return (
    <div>
      <input type="file" onChange={(e) => setFile(e.target.files[0])} />
      <input
        type="color"
        value={color}
        onChange={(e) => setColor(e.target.value)}
      />
      <button onClick={handleSubmit}>Submit</button>
    </div>
  );
}

The VDG response does not remove capability. It removes silent decisions.

The Difference

One answer turns unknowns into decisions.
The other keeps unknowns as unknowns.

That difference is where silent tech debt starts.

That’s default fill-in.

And once you see it, you start deciding whether you want those choices made for you.

Déployer une App Gratuitement en 2026 : Comparatif Railway, Render, Fly.io, Vercel

Déployer une App Gratuitement en 2026 : Railway, Render, Fly.io, Vercel comparés

Heroku qui supprime son plan gratuit en 2022 a tout changé. Depuis, plusieurs plateformes se sont positionnées pour récupérer les développeurs orphelins. En 2026, on a l’embarras du choix — mais toutes ne se valent pas. Voici un comparatif honnête pour déployer votre app sans sortir la carte bleue.

Railway — La montée en puissance

Railway s’est imposé comme la plateforme préférée des indie developers. L’UX est excellente, le déploiement depuis GitHub prend 2 minutes, et le plan gratuit est généreux.

Plan gratuit Railway

  • 500 heures d’exécution/mois (environ 20h/jour)
  • 512 MB RAM par service
  • 1 GB de volume de stockage
  • Déploiement depuis GitHub en un clic
  • Variables d’environnement, logs en temps réel
  • Bases de données PostgreSQL, MySQL, Redis, MongoDB disponibles

Points forts

  • Interface ultra simple et moderne
  • Déploiement par git push automatique
  • Support multi-langages : Node.js, Python, Go, Ruby, Java…
  • Métriques et logs en temps réel
  • Networking entre services dans le même projet

Points faibles

  • Les 500h/mois peuvent être insuffisantes pour une app 24/7 (20j max)
  • Plan payant à 5$/mois (Starter) pour aller plus loin
  • Support limité sur le plan gratuit
# Déploiement Railway en 3 commandes
npm install -g @railway/cli
railway login
railway up

→ Essayer Railway gratuitement

Render — L’alternative Heroku la plus proche

Render est souvent cité comme le remplaçant naturel de Heroku. Plan gratuit pour les web services, mais avec une contrainte : les services gratuits “dorment” après 15 minutes d’inactivité.

Plan gratuit Render

  • Web services gratuits (avec sleep après 15min d’inactivité)
  • PostgreSQL gratuit (90 jours puis supprimé)
  • Static sites illimités et gratuits
  • 750h/mois de calcul

Points forts

  • Déploiement depuis GitHub/GitLab automatique
  • Auto-scaling sur les plans payants
  • Health checks et notifications
  • Bonne documentation

Points faibles

  • Le “cold start” de 30-60 secondes après inactivité peut être problématique
  • PostgreSQL gratuit expiré après 90 jours
  • Plan payant plus cher que Railway ($7/mois minimum)
# render.yaml — définir votre service
services:
 - type: web
 name: mon-app
 runtime: python
 buildCommand: pip install -r requirements.txt
 startCommand: gunicorn app:app

→ Essayer Render gratuitement

Fly.io — Le plus technique mais le plus puissant

Fly.io est une plateforme orientée containers Docker qui permet de déployer dans 30+ régions mondiales. Courbe d’apprentissage plus élevée, mais des capacités impressionnantes.

Plan gratuit Fly.io

  • 3 VMs partagées (256 MB RAM chacune)
  • 3 GB de volume de stockage
  • 160 GB de bande passante/mois
  • PostgreSQL managé gratuit (Fly Postgres)
  • Pas de “sleep” — vos apps tournent 24/7

Points forts

  • Déploiement dans 30+ régions — très proche des utilisateurs
  • Apps tournent 24/7 sans cold start
  • Support Docker natif — déployez n’importe quoi
  • Excellent pour les apps avec état (SQLite, volumes persistants)
  • Réseau privé entre apps dans la même organisation

Points faibles

  • CLI Flyctl obligatoire — moins visuel que Railway
  • Carte bancaire requise pour s’inscrire (même pour le plan gratuit)
  • Courbe d’apprentissage plus élevée
# Déploiement Fly.io
fly launch # génère un fly.toml
fly deploy # déploie votre app

→ Essayer Fly.io

Vercel — Le roi du frontend

Vercel est la plateforme de déploiement créée par les fondateurs de Next.js. C’est LE standard pour les apps React/Next.js, mais aussi compatible avec Vue, Svelte, Astro, etc.

Plan gratuit Vercel

  • 100 déploiements/jour
  • Serverless Functions incluses (100 GB-heures/mois)
  • 100 GB de bande passante/mois
  • Edge Network mondial (CDN)
  • SSL automatique + domaines custom
  • Preview deployments à chaque PR

Points forts

  • Déploiement depuis GitHub en 30 secondes
  • CDN mondial — performances excellentes partout
  • Preview deployments par branche — idéal pour les équipes
  • Edge Functions pour la logique proche des utilisateurs
  • Analytics inclus

Points faibles

  • Pas de containers — serverless only
  • Limites sur les Serverless Functions (10s d’exécution max sur plan gratuit)
  • Usage commercial de certaines fonctionnalités nécessite un plan payant

→ Essayer Vercel gratuitement

Netlify — Le spécialiste des sites statiques

Netlify popularisé le concept de JAMstack. Excellent pour les sites statiques générés (Next.js statique, Hugo, Gatsby), avec des Netlify Functions pour la logique backend.

Plan gratuit Netlify

  • 100 GB de bande passante/mois
  • 300 minutes de build/mois
  • Netlify Functions (125k requêtes/mois)
  • Forms (100 soumissions/mois)
  • SSL automatique

→ Essayer Netlify gratuitement

Tableau comparatif 2026

| Plateforme | Gratuit ? | Sleep ? | Base de données | Idéal pour |

| Railway | 500h/mois | Non | Oui (PG, Redis) | Backend full-stack |
| Render | 750h/mois | Oui (15min) | PG 90j | Apps Node/Python |
| Fly.io | 3 VMs | Non | Oui (Fly PG) | Docker, apps stateful |
| Vercel | Oui | N/A (serverless) | Non natif | Next.js, React |
| Netlify | Oui | N/A (statique) | Non natif | Sites statiques |

Conseils pratiques

Quelle plateforme pour quel projet ?

  • App Next.js/React → Vercel (c’est fait pour ça)
  • Backend Python/Node avec base de données → Railway ou Fly.io
  • Site statique (Hugo, Jekyll, Astro) → Netlify ou GitHub Pages
  • App Docker complexe → Fly.io
  • MVP qui doit tourner 24/7 gratuitement → Fly.io (pas de sleep)

Combiner les plateformes

Rien ne vous oblige à tout mettre au même endroit. Une stratégie courante :

  • Frontend Next.js sur Vercel (CDN mondial, preview deployments)
  • Backend API sur Railway ou Fly.io
  • Base de données PostgreSQL sur Supabase (plan gratuit généreux)

Cette architecture vous donne des performances excellentes pour 0€/mois sur de petits projets.

Attention aux limites

Les plans gratuits sont conçus pour le développement et les side projects, pas pour la production à grande échelle. Dès que votre trafic monte ou que vos besoins en ressources augmentent, prévoyez de passer sur un plan payant. Railway et Fly.io ont des plans payants très raisonnables ($5-20/mois pour la grande majorité des projets).

→ Créer un blog gratuit avec GitHub Pages
→ Scripts Python pour automatiser votre vie de dev

Governing LangChain Agents in Production with Execution Warrants

LangChain makes it incredibly easy to build AI agents that take real-world actions. Database queries, API calls, file operations, infrastructure management — your agent can do it all with a few lines of code.

That’s the problem.

When your LangChain agent has tools that can modify production databases, send emails, or scale infrastructure, you need more than prompt engineering to keep it safe. You need execution governance.

This guide shows you how to wrap LangChain tools with Vienna OS execution warrants, so every high-risk action gets proper authorization before it runs.

The Problem with Uncontrolled LangChain Tools

Here’s a typical LangChain tool:

from langchain.tools import tool

@tool
def scale_kubernetes(replicas: int, deployment: str) -> str:
    """Scale a Kubernetes deployment to the specified number of replicas."""
    k8s_client.scale(deployment, replicas=replicas)
    return f"Scaled {deployment} to {replicas} replicas"

This works great — until your agent decides to scale to 500 replicas at 3 AM. There’s no approval, no risk assessment, no audit trail. The agent just… does it.

Adding Vienna OS Governance

Vienna OS wraps your existing tools with execution control. The agent still decides what to do, but Vienna OS controls whether it’s allowed.

Step 1: Install the SDK

pip install vienna-sdk

Step 2: Create a Governed Tool Wrapper

from langchain.tools import tool
from vienna_sdk import ViennaClient

vienna = ViennaClient(
    endpoint="https://your-instance.regulator.ai",
    api_key="your-api-key"
)

@tool
def scale_kubernetes(replicas: int, deployment: str) -> str:
    """Scale a Kubernetes deployment. Requires governance approval for >10 replicas."""

    # Submit intent to Vienna OS
    warrant = vienna.request_warrant(
        intent="scale_kubernetes_deployment",
        resource=deployment,
        payload={
            "target_replicas": replicas,
            "current_replicas": k8s_client.get_replicas(deployment),
            "cost_impact": estimate_cost(replicas)
        }
    )

    if warrant.status == "approved":
        k8s_client.scale(deployment, replicas=replicas)
        vienna.confirm_execution(warrant.id)
        return f"✅ Scaled {deployment} to {replicas} replicas (warrant: {warrant.id})"
    elif warrant.status == "pending":
        return f"⏳ Scaling request pending approval (warrant: {warrant.id})"
    else:
        return f"❌ Scaling request denied: {warrant.denial_reason}"

Step 3: Define Risk Policies

# vienna-policies.yaml
policies:
  - name: "kubernetes-scaling"
    match:
      intent: "scale_kubernetes_deployment"
    rules:
      - condition: "payload.target_replicas <= 10"
        risk_tier: "T0"  # Auto-approve
      - condition: "payload.target_replicas <= 50"
        risk_tier: "T1"  # Single DevOps approval
      - condition: "payload.target_replicas > 50"
        risk_tier: "T2"  # Multi-party approval
      - condition: "payload.cost_impact > 10000"
        risk_tier: "T3"  # Executive approval

Now your agent can scale to 5 replicas instantly (T0), but scaling to 500 requires multiple approvals (T2/T3).

Governing a Complete LangChain Agent

Here’s a full example with multiple governed tools:

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI
from vienna_sdk import ViennaClient, governed_tool

vienna = ViennaClient(endpoint="https://your-instance.regulator.ai")

@governed_tool(vienna, intent="query_database", risk_tier="T0")
def query_database(sql: str) -> str:
    """Execute a read-only database query."""
    return db.execute(sql)

@governed_tool(vienna, intent="modify_database", risk_tier="T1")
def modify_database(sql: str) -> str:
    """Execute a database write operation. Requires approval."""
    return db.execute(sql)

@governed_tool(vienna, intent="send_email", risk_tier="T2")
def send_email(to: str, subject: str, body: str) -> str:
    """Send an email to a customer. Requires multi-party approval."""
    return email_client.send(to=to, subject=subject, body=body)

@governed_tool(vienna, intent="delete_records", risk_tier="T3")
def delete_records(table: str, condition: str) -> str:
    """Delete database records. Requires executive approval."""
    return db.execute(f"DELETE FROM {table} WHERE {condition}")

# Create agent with governed tools
llm = ChatOpenAI(model="gpt-4")
tools = [query_database, modify_database, send_email, delete_records]
agent = create_openai_functions_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# Agent runs normally — Vienna OS handles governance transparently
result = executor.invoke({"input": "Clean up inactive users and notify them"})

The agent thinks and plans normally. But when it tries to delete records, Vienna OS requires executive approval. When it tries to send emails, it needs multi-party sign-off. Reads are instant.

Real-Time Monitoring

Vienna OS provides SSE streaming so you can watch your agents in real time:

# Monitor all agent activity
for event in vienna.stream_events():
    if event.risk_tier >= "T1":
        print(f"⚠️ {event.agent_id}: {event.intent} ({event.risk_tier})")
        print(f"   Status: {event.status}")
        print(f"   Warrant: {event.warrant_id}")

The Audit Trail

Every action gets a complete evidence chain:

{
  "warrant_id": "w_2026_03_28_a7b9c1d3",
  "agent_id": "langchain-sre-agent",
  "intent": "scale_kubernetes_deployment",
  "risk_tier": "T2",
  "submitted_at": "2026-03-28T15:30:00Z",
  "approved_at": "2026-03-28T15:32:15Z",
  "approved_by": ["[email protected]", "[email protected]"],
  "executed_at": "2026-03-28T15:32:16Z",
  "execution_result": "success",
  "signature": "8f2e1a9b4c7d3e6f...",
  "parameters": {
    "deployment": "api-server",
    "target_replicas": 50,
    "previous_replicas": 12
  }
}

SOC 2 auditors, compliance officers, and insurance companies love this.

Getting Started

  1. Try the demo: regulator.ai/try
  2. Install the Python SDK: pip install vienna-sdk
  3. Read the docs: regulator.ai/docs
  4. Star us on GitHub: github.com/risk-ai/regulator.ai

Your LangChain agents are powerful. Make sure they’re governed too.

Originally published at regulator.ai. Vienna OS is the execution control layer for autonomous AI systems — cryptographic warrants, risk tiering, and immutable audit trails. Try it free.