AI-assisted software development has changed significantly over the last few years. Developers are no longer using AI only to generate small code snippets or explain programming concepts. Modern AI coding agents can inspect a codebase, understand project structure, edit files, run commands, analyze errors, and help developers complete multi-step development tasks.

Visual Studio Code (VS Code) has become one of the major environments for this style of development. Instead of relying on a single AI experience, VS Code now supports multiple agent harnesses, including GitHub Copilot, Claude, and Codex. Developers can choose the agent experience and model based on the task they are working on.

For developers who use Anthropic's Claude, this creates an interesting workflow.

Claude can work directly with a project inside VS Code, inspect files, make changes, run development commands, and help with tasks such as refactoring, debugging, testing, and code review.

This article explains how VS Code and Claude integration works, the difference between Claude Code and the Claude agent experience in VS Code, how to get started, how CLAUDE.md can provide project instructions, how MCP fits into the workflow, and how .NET developers can use Claude effectively.

What Is Claude Integration with VS Code?

Claude integration with VS Code allows developers to use Anthropic's Claude-powered coding capabilities directly within the VS Code development environment.

Instead of constantly switching between a browser-based AI chat and the code editor, developers can keep the AI agent alongside the project.

A typical workflow looks like this:

Developer
    ↓
VS Code
    ↓
Claude Agent
    ↓
Project Files
    ↓
Tools / Terminal / Tests
    ↓
Code Changes

The important difference is that an agent can work with the context of the actual repository.

For example, instead of asking:

"How do I implement authentication in ASP.NET Core?"

you can ask Claude to inspect your existing authentication implementation and say:

"Review the authentication flow in this project and identify potential problems. Do not modify anything yet."

The second request is much more useful because Claude can reason about the actual project instead of providing a generic answer.

VS Code currently supports provider-specific agents such as Claude, allowing developers to choose a Claude session directly from the Chat interface.

Claude Code vs Claude Agent in VS Code

This distinction is important because the terms can be confusing.

Claude Code is Anthropic's coding agent and agent harness. It can operate from the terminal and interact with a software project using tools and permissions.

Anthropic provides Claude Code for development environments including Windows, macOS, and Linux. Its standard installation can be performed through Anthropic's supported installation methods, and the agent can then be launched from a project directory.

VS Code can also run Claude as a provider-specific agent inside the editor.

The current VS Code documentation describes these as third-party agents. A local Claude session can work directly with the local workspace, while a cloud Claude session can run through the cloud partner-agent workflow.

The simplified distinction is:

Claude Code
    ↓
Anthropic's coding agent / harness
    ↓
Terminal + project

VS Code Claude Agent
    ↓
Claude agent experience
    ↓
VS Code Chat + project

The important point is that these approaches are increasingly compatible rather than completely separate workflows.

VS Code can discover Claude-related sessions and configuration, making it easier to move between different agent experiences.

Why Use Claude with VS Code?

A browser-based AI assistant is useful for questions, explanations, and isolated code examples.

But software development often requires more context.

A real project may contain:

Solution
 ├── API
 ├── Application
 ├── Domain
 ├── Infrastructure
 ├── Tests
 ├── Database
 ├── Configuration
 └── Documentation

Understanding a problem may require examining several files.

Claude's agent workflow is designed for this kind of multi-step work.

For example, you can ask it to:

Inspect the order processing workflow.

Find where order totals are calculated.

Identify why discounts are sometimes applied twice.

Do not change the code yet.

Claude can investigate the relevant files and return a plan before making modifications.

This makes the interaction closer to working with another developer than simply asking an AI for a code snippet.

Getting Started with Claude in VS Code

Before using Claude inside VS Code, make sure you have a current version of VS Code with AI agent capabilities enabled.

VS Code's current agent documentation supports several session types and allows developers to choose Claude for provider-specific workflows.

Open your project in VS Code and open the Chat view.

Then create a new chat session and select Claude as the session type for a local Claude workflow.

You can begin with a small task rather than immediately giving the agent permission to modify the entire repository.

For example:

Inspect the current authentication module.

Explain the architecture and identify any obvious issues.

Do not edit files yet.

This is a good first step because you can evaluate the agent's understanding before allowing changes.

VS Code itself recommends starting with a contained task and using a planning-oriented prompt when you want to understand how the provider-specific agent approaches a repository.

Claude Permission Modes in VS Code

One of the most important aspects of agentic coding is controlling what the AI is allowed to do.

The current Claude agent integration in VS Code provides three important permission modes:

• Plan

• Request approval

• Edit automatically

The Plan mode allows Claude to analyze the task and propose an approach before making changes.

Request approval allows Claude to work with the project while asking for confirmation before making changes.

Edit automatically gives the agent more autonomy to modify files as it works.

VS Code documents these modes as ways to match the amount of autonomy to the risk of the task.

For example, when working on a production .NET application, a sensible workflow might be:

Plan
  ↓
Review
  ↓
Approve
  ↓
Implement
  ↓
Run Tests
  ↓
Review Diff

For a small formatting change, automatic editing may be reasonable.

For a database migration or authentication change, keeping approval in the loop is more appropriate.

Using Claude for Codebase Analysis

One of the strongest use cases for Claude in VS Code is codebase exploration.

Suppose you have inherited an ASP.NET Core application with hundreds of files.

Instead of manually opening every project, you can ask:

Analyze this solution and explain:

1. The main projects
2. The application architecture
3. Database access
4. Authentication
5. External integrations
6. Test projects

Do not change anything.

Claude can then investigate the repository and summarize the architecture.

This is particularly useful when joining an existing project.

You can follow that with a more focused request:

Trace the request flow for creating a new customer.

Start from the API endpoint and follow it through the application service,
repository, database model, and response.

This type of task can save considerable time when learning an unfamiliar codebase.

Claude for C# and .NET Development

Claude can be especially useful for developers working with C#, ASP.NET Core, Entity Framework Core, Blazor, Web APIs, and other .NET technologies.

For example, you might ask:

Review this ASP.NET Core service.

Check for:
- unnecessary database queries
- async issues
- duplicated logic
- exception handling problems
- dependency injection issues
- potential performance problems

Do not modify the code.

After reviewing the response, you can ask Claude to implement the approved changes.

A more practical workflow is:

Analyze
   ↓
Explain
   ↓
Plan
   ↓
Approve
   ↓
Implement
   ↓
Test
   ↓
Review

This reduces the chance of accepting a large amount of generated code without understanding what changed.

Claude for Refactoring

AI coding agents can be useful for repetitive refactoring tasks.

For example:

Find controllers that contain business logic.

Identify the controllers that should delegate that logic
to application services.

Create a refactoring plan without modifying the code.

After reviewing the plan:

Implement the approved refactoring for CustomerController only.

Keep the existing API behavior unchanged.

Run the relevant tests after the change.

This is much safer than simply saying:

Refactor my entire application.

Large, vague instructions can result in unnecessary changes.

A focused request gives the agent a clear scope.

Claude for Debugging

Debugging is another useful application.

Suppose an ASP.NET Core application is throwing an exception.

Instead of copying only the exception message into an AI chat, you can ask Claude to inspect the relevant code.

For example:

Investigate this exception.

Trace the code path that can produce it.

Check the related service, repository, and DbContext usage.

Do not change anything yet.

Claude can inspect the relevant implementation and identify possible causes.

You can then ask:

Implement the smallest fix that addresses the root cause.

Do not refactor unrelated code.

Run the relevant tests.

This last instruction is important.

AI agents can sometimes make additional changes that are not required for the original problem. Keeping the scope explicit helps reduce unnecessary modifications.

Claude for Writing Tests

Claude can also help create unit and integration tests.

For example, a .NET developer might ask:

Review OrderService.cs and its existing tests.

Identify important scenarios that are not currently covered.

Do not write tests yet.

After reviewing the proposed cases:

Add tests for the approved scenarios.

Use the existing xUnit and Moq conventions in this project.

Do not change production code.

This approach allows the existing test style and project conventions to guide the generated tests.

It is also useful for regression testing after a bug fix.

Claude for Code Review

Claude can be used as another review layer before committing code.

For example:

Review the current changes.

Look specifically for:
- logic errors
- security problems
- null handling
- database performance issues
- breaking API changes
- missing tests

Do not modify any files.

The current Claude agent experience in VS Code also provides commands such as /review and /security-review for supported workflows.

The result should still be treated as an additional review rather than a replacement for human code review.

A developer should inspect the actual diff and validate important behavior.

Using CLAUDE.md with VS Code

One of the most useful features for teams using Claude is the CLAUDE.md file.

This file can contain project-specific instructions for Claude.

For example:

# Project Guidelines

- Use C# latest language features supported by this project.
- Use async/await for database operations.
- Use repository interfaces for data access.
- Do not access DbContext directly from controllers.
- Follow existing naming conventions.
- Add xUnit tests for new business logic.
- Do not introduce new dependencies without approval.

VS Code automatically detects CLAUDE.md files and can use them as always-on instructions. It supports locations such as the workspace root, .claude/CLAUDE.md, and ~/.claude/CLAUDE.md. It also supports .claude/rules using Claude's rules format.

This is useful because project conventions do not need to be repeated in every prompt.

The same project instructions can also be used across Claude-based development workflows.

Claude Agents and Skills

Modern AI coding workflows can go beyond a single general-purpose assistant.

Claude supports specialized agents and skills.

VS Code can detect Claude-format agent files in:

.claude/agents/

These files can define specialized agents for particular tasks. VS Code maps Claude-specific tool names to corresponding VS Code tools.

For example, a project could have:

.claude/
 ├── CLAUDE.md
 ├── agents/
 │    ├── code-reviewer.md
 │    ├── test-engineer.md
 │    └── security-reviewer.md
 └── skills/

This can turn a large development workflow into smaller specialized tasks.

For example:

Developer
    ↓
Claude
    ↓
Code Reviewer
    ↓
Test Engineer
    ↓
Security Review

The goal is not to add complexity for its own sake. Specialized agents are most useful when the same process is repeated regularly.

MCP and Claude in VS Code

MCP, or Model Context Protocol, is particularly relevant to Claude-based development.

MCP allows AI agents to interact with external tools and services through standardized interfaces.

For example, a development team could expose tools for:

GitHub
Database
Documentation
Issue Tracker
CI/CD
Internal APIs

The agent can then use those capabilities when authorized.

VS Code also supports MCP servers as part of its agent ecosystem. Current VS Code documentation describes MCP as one of the extension points available to agent workflows.

For a .NET developer, an MCP-enabled workflow could look like:

Claude
   ↓
VS Code
   ↓
MCP
   ├── GitHub
   ├── Documentation
   ├── PostgreSQL tools
   └── Internal APIs

This becomes especially powerful when the AI needs information that does not exist in the local source code.

However, MCP tools should be designed with appropriate authentication, authorization, validation, and least-privilege access.

Using Claude with an Existing .NET Project

Consider a typical ASP.NET Core application:

MyApplication/
│
├── MyApplication.Api/
├── MyApplication.Application/
├── MyApplication.Domain/
├── MyApplication.Infrastructure/
├── MyApplication.Tests/
└── CLAUDE.md

You could define project rules in CLAUDE.md:

# Development Rules

Use:
- ASP.NET Core
- Entity Framework Core
- PostgreSQL
- Repository pattern
- xUnit

Architecture:
- API layer handles HTTP concerns.
- Application layer contains business use cases.
- Infrastructure handles persistence.
- Domain contains core business models.

Do not move business logic into controllers.

Then Claude can use these rules while working on the repository.

For example:

Add a product search endpoint.

Follow the existing architecture.

Use the repository and application service layers.

Add tests.

Do not introduce a new architectural pattern.

The instructions provide context that helps the agent work consistently with the existing codebase.

Using Claude Without Over-Automating Development

AI agents can perform many tasks automatically, but that does not mean every task should be fully automated.

For important changes, a developer should remain involved.

A practical workflow is:

AI investigates
      ↓
Developer reviews plan
      ↓
AI implements
      ↓
AI runs tests
      ↓
Developer reviews diff
      ↓
Developer runs final validation
      ↓
Commit

This is particularly important for:

• Authentication

• Authorization

• Payment processing

• Database migrations

• Security-sensitive code

• Production configuration

• Data deletion

• Infrastructure changes

The purpose of AI-assisted development is not to remove developer responsibility. It is to reduce repetitive work and provide another layer of reasoning and automation.

Common Mistakes When Using Claude in VS Code

Giving Claude Too Much Scope

A request such as:

Improve my whole application.

is too broad.

A better request is:

Review the product search feature.

Identify performance problems.

Do not modify anything yet.

Then proceed step by step.

Accepting Changes Without Reviewing the Diff

Even when the AI produces apparently correct code, review the actual changes.

Look for:

• Unexpected file modifications

• New dependencies

• Changed behavior

• Removed validation

• Security issues

• Unnecessary refactoring

  
  

Ignoring Existing Project Conventions

If a project already uses a specific architecture, testing framework, naming convention, or dependency-injection pattern, tell Claude about it or document it in CLAUDE.md.

Allowing Dangerous Operations Without Approval

Database deletion, production deployment, credential changes, and other sensitive operations should not be given unrestricted agent permissions.

VS Code specifically warns that bypassing Claude's permission checks should only be considered in isolated sandbox environments.

VS Code, Claude, and BYOK

Another option available in modern VS Code is Bring Your Own Key (BYOK).

VS Code supports connecting language models from supported providers, including Anthropic, through its model configuration capabilities. This allows developers to use provider models directly in supported VS Code chat experiences rather than relying only on the models included with a Copilot subscription.

This is useful for developers or teams that already have an account, billing arrangement, or governance setup with a model provider.

However, BYOK and Claude agent sessions are not exactly the same thing.

A model being available in the VS Code model picker does not automatically mean that every provider-specific agent capability is available in the same way.

The model and the agent harness are separate concepts.

A useful mental model is:

Model
  ↓
Claude

Agent Harness
  ↓
Claude Agent / Copilot / Other Agent

Development Environment
  ↓
VS Code

VS Code's current architecture explicitly separates the agent harness from the model, allowing developers to choose how an agent works and which model it uses.

Is Claude Integration Useful for .NET Developers?

For .NET developers, Claude in VS Code can be useful for many everyday tasks.

For example:

C#
   ↓
ASP.NET Core
   ↓
EF Core
   ↓
PostgreSQL / SQL Server
   ↓
xUnit
   ↓
Azure / AWS

Claude can help with codebase exploration, refactoring, debugging, test generation, documentation, API development, and code review.

It can also work with project-specific instructions and external tools through the broader agent and MCP ecosystem.

The important factor is how the developer uses it.

Using AI to generate code without understanding the result can introduce problems.

Using AI to investigate, plan, implement, test, and review within a controlled workflow can provide much more value.

Final Thoughts

The integration between VS Code and Claude is becoming more than a simple AI chat feature.

Modern VS Code allows developers to use provider-specific agents such as Claude directly within the editor, while Anthropic's Claude Code provides its own coding-agent workflow. VS Code can also recognize Claude project instructions, agents, skills, and rules, making it possible to share more of the development context across Claude-based workflows.

For a .NET developer, a practical workflow could look like this:

Open .NET Project
       ↓
Claude analyzes the codebase
       ↓
Developer reviews the plan
       ↓
Claude implements the change
       ↓
Run tests
       ↓
Claude reviews the result
       ↓
Developer reviews the final diff
       ↓
Commit

The biggest benefit is not simply that Claude can write C# faster.

The bigger opportunity is using an AI agent as a development partner that can understand project context, work across multiple files, use tools, follow repository-specific instructions, and help with longer development workflows.

At the same time, developers should keep control over important decisions. AI-generated code still needs testing, review, security validation, and normal software engineering discipline.

When used that way, VS Code + Claude can become a practical AI-assisted development workflow rather than just another code-generation tool.