Claude Code para desarrolladores .NET: De cero a productivo en VS Code y Visual Studio

Las herramientas de IA se sienten mágicas los primeros días. Le preguntas algo, te responde bien, y piensas: "esto va a cambiar todo". Luego pasan unas semanas, el contexto se confunde, las respuestas se vuelven genéricas, y empiezas a sentir que estás teniendo una conversación con alguien que tiene amnesia selectiva.

El problema no es la IA. El problema es que nadie te explicó cómo funciona realmente.

Este artículo desmitifica Claude Code para desarrolladores .NET. No es un tutorial de "mira qué cool es esto" — es una guía práctica de cómo funciona, por qué funciona así, y cómo sacarle el máximo provecho en proyectos C# reales, tanto en VS Code como en Visual Studio 2022/2026.

Qué es Claude Code (y qué no es)

Claude Code no es una ventana de chat glorificada. Es una CLI (interfaz de línea de comandos) que corre directamente en tu terminal y tiene acceso real a tu sistema de archivos, puede ejecutar comandos, leer y editar archivos, y mantener contexto sobre tu proyecto.

La diferencia con "preguntarle a Claude en el navegador" es enorme:

• En el navegador, pegas código manualmente, pierdes contexto entre sesiones, y Claude no sabe nada de tu proyecto más allá de lo que tú le dices.
• Con Claude Code, Claude vive en tu repositorio. Lee archivos, ejecuta dotnet build, corre tus tests, y entiende la arquitectura de tu solución.

Además de la CLI, existe una extensión para VS Code que integra Claude Code directamente en el editor — con contexto automático de lo que tienes abierto y seleccionado. Para Visual Studio, la historia es diferente (y la contaremos honestamente más adelante).

Instalación y setup

Prerrequisitos

• Node.js 22 LTS o superior
• Una cuenta en claude.ai con acceso a Claude Code

Instalar la CLI

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

Verifica la instalación:

claude --version

Para iniciar una sesión interactiva en tu proyecto, navega al directorio raíz y ejecuta:

claude

VS Code — integración completa

Instala la extensión oficial desde el Marketplace:

• Nombre: Claude Code
• ID: anthropic.claude-code
• Requiere VS Code 1.98 o superior

Una vez instalada, Claude Code aparece en la barra lateral. La integración es profunda: cuando tienes un archivo abierto o código seleccionado, Claude lo recibe automáticamente como contexto. No necesitas copiar y pegar nada.

JetBrains Rider también cuenta con integración completa a través de su plugin oficial — si tu equipo usa Rider, el workflow es muy similar al de VS Code.

Visual Studio 2022/2026 — la verdad sin rodeos

Visual Studio ha sido el rey del desarrollo .NET por décadas. Simplemente aún no se ha enterado de que existe Claude.

A junio de 2026, no existe una extensión oficial de Claude Code para Visual Studio. Punto. No hay workaround mágico que cambie eso.

Lo que sí funciona, y funciona bien, es usar la terminal integrada de Visual Studio:

1. Ve a Ver > Terminal (o Ctrl+\, Ctrl+`)
2. Navega al directorio raíz de tu solución (normalmente ya estás ahí)
3. Ejecuta claude

Claude lee tu repositorio exactamente igual que en VS Code. La diferencia es que no tienes el contexto visual automático — tendrás que mencionar archivos explícitamente con @ (lo veremos en detalle más adelante). Para muchas tareas de refactoring, generación de código y revisión de arquitectura, la terminal es más que suficiente.

Muchos desarrolladores .NET tienen ambos IDEs abiertos en paralelo: Visual Studio para debugging avanzado, diseñadores de formularios, y herramientas de profiling; VS Code para trabajar con Claude Code.

CLAUDE.md — el cerebro de la operación

Aquí está el insight más importante del artículo, así que léelo despacio.

Claude Code no funciona como un chatbot con memoria persistente. Cada vez que inicias una sesión, parte de cero. Entonces, ¿cómo "conoce" tu proyecto? A través de un archivo llamado CLAUDE.md.

Cómo Claude descubre CLAUDE.md

Cuando ejecutas claude desde un directorio, Claude realiza un recorrido del filesystem hacia arriba desde tu directorio de trabajo actual (CWD), buscando archivos CLAUDE.md. Además, carga CLAUDE.md de los subdirectorios de forma lazy a medida que accede a ellos.

Esto significa dos cosas importantes:

1. No está basado en archivos de proyecto — Claude no lee tu .csproj para descubrir CLAUDE.md. Lo descubre por ubicación en el filesystem. Si tu CLAUDE.md está en la raíz del repo y ejecutas claude desde ahí, se carga. Si lo ejecutas desde un subdirectorio, también lo cargará (porque sube hacia arriba).

2. En Visual Studio, CLAUDE.md no aparece en el Explorador de Soluciones — porque no está referenciado en ningún .csproj. Pero Claude sí lo carga. No necesitas agregarlo al proyecto. De hecho, es mejor que no lo hagas — es un archivo de contexto para la IA, no un recurso de tu aplicación.

Verificar qué está cargado

Puedes verificar en cualquier momento qué archivos CLAUDE.md tiene cargados Claude con el comando:

/memory

Esto muestra el contenido actual de memoria, incluyendo todos los CLAUDE.md activos en la sesión.

Generar un CLAUDE.md inicial

Si tu proyecto no tiene CLAUDE.md, Claude puede generarlo leyendo el repo:

/init

Esto analiza tu código, estructura de carpetas, y archivos de configuración, y produce un CLAUDE.md base que puedes refinar.

Ejemplo práctico: CLAUDE.md para un proyecto .NET

Aquí un ejemplo completo y realista para una API de e-commerce en .NET 10:

# ECommerceApi — Contexto para Claude Code

## Descripción del proyecto
API REST para gestión de catálogo y órdenes de compra.
Stack: .NET 10, C# 14, Entity Framework Core 9, PostgreSQL, MassTransit (RabbitMQ).
Arquitectura: Clean Architecture con CQRS via MediatR.

## Comandos esenciales

### Build y tests
dotnet build ECommerceApi.sln
dotnet test ECommerceApi.sln --logger "console;verbosity=normal"
dotnet test --filter "Category=Unit"
dotnet test --filter "Category=Integration"

### Migraciones EF Core
cd src/ECommerceApi.Infrastructure
dotnet ef migrations add <NombreMigracion> --startup-project ../ECommerceApi.Api
dotnet ef database update --startup-project ../ECommerceApi.Api

### Ejecución local
cd src/ECommerceApi.Api
dotnet run

## Estructura del proyecto
src/
  ECommerceApi.Api/           # Controllers, middleware, DI setup
  ECommerceApi.Application/   # Commands, queries, DTOs, validators
  ECommerceApi.Domain/        # Entities, value objects, domain events
  ECommerceApi.Infrastructure/ # EF Core, repositories, external services
tests/
  ECommerceApi.UnitTests/
  ECommerceApi.IntegrationTests/

## Convenciones de código
- Usa records para DTOs y value objects
- Usa init-only properties en domain entities cuando sea posible
- Pattern matching exhaustivo en switches sobre discriminated unions
- Nullable reference types habilitados — sin supresiones con !
- No uses var — tipado explícito siempre
- Nombres en inglés para código, comentarios pueden ser en español

## Decisiones de arquitectura importantes
- Los controllers SOLO llaman a MediatR.Send() — lógica cero en controllers
- Validaciones con FluentValidation en el pipeline de MediatR (no en controllers)
- Los domain events se despachan DESPUÉS de SaveChanges (outbox pattern)
- Los integration tests levantan PostgreSQL en Docker via Testcontainers

## Lo que NO hacer
- No agregar lógica de negocio en Infrastructure
- No inyectar DbContext directamente en Application — solo via repositorios
- No usar AutoMapper — mappings explícitos con métodos ToDto() / ToDomain()

Este archivo transforma a Claude de "asistente genérico de C#" a "colega que conoce tu proyecto". La diferencia en calidad de respuestas es notable.

Dando contexto a Claude

Tener un buen CLAUDE.md es el 50% del trabajo. El otro 50% es saber cómo dar contexto durante la sesión.

Menciones con @

La sintaxis @ te permite referenciar archivos y directorios específicos:

@Program.cs                    # Archivo completo
@src/Application/              # Directorio entero
@appsettings.json#1-20         # Líneas 1 a 20 del archivo
@src/Domain/Entities/Order.cs  # Archivo en ruta relativa

Ejemplos de uso en conversación:

Revisa @src/Application/Orders/Commands/CreateOrderCommand.cs
y dime si hay algo que mejorar con los nuevos features de C# 14.

Tengo un bug en @src/Infrastructure/Repositories/OrderRepository.cs#45-80.
El método GetPendingOrders() devuelve órdenes canceladas. ¿Ves el problema?

Contexto automático en VS Code

En VS Code con la extensión instalada, el archivo que tienes abierto en el editor activo se comparte automáticamente como contexto. Si seleccionas un bloque de código, solo ese bloque se incluye. Esto elimina mucho del trabajo manual de menciones @.

En Visual Studio (terminal), necesitas ser explícito con @ — lo cual en realidad te obliga a ser más preciso sobre qué quieres mostrarle a Claude, lo cual no es necesariamente malo.

Gestionar el contexto largo con /compact

Las sesiones largas tienen un límite de tokens. Cuando el contexto se alarga demasiado, Claude puede empezar a "olvidar" cosas del inicio de la conversación.

El comando /compact resume el historial de la sesión actual, preservando los puntos clave pero reduciendo el tamaño del contexto:

/compact

Úsalo proactivamente cuando llevas un rato en la misma sesión, antes de llegar al límite. Es como hacer un checkpoint.

Skills — comandos personalizados para tu flujo

Los Skills son la característica más poderosa de Claude Code para equipos y proyectos recurrentes. Un Skill es esencialmente un comando personalizado que encapsula un flujo de trabajo completo.

Dónde viven los Skills

Hay dos ubicaciones:

Los Skills de proyecto se versiona junto al código — cuando alguien hace git clone, obtiene los Skills también. Ideal para workflows específicos del equipo.

Cómo invocar un Skill

Simplemente escribe /nombre-del-skill en Claude Code:

/dotnet-test
/csharp-review
/ef-migrate

Claude lee el archivo SKILL.md correspondiente y ejecuta el flujo definido en él.

Ejemplo 1: /dotnet-test

Crea el archivo .claude/skills/dotnet-test/SKILL.md:

# dotnet-test

Ejecuta la suite de tests del proyecto y presenta los resultados de forma clara.

## Pasos

1. Ejecuta `dotnet test ECommerceApi.sln --logger "console;verbosity=normal"`
2. Si hay fallos, muestra SOLO los tests fallidos con:
   - Nombre completo del test
   - El mensaje de error
   - La línea del código donde falló
3. Si todos pasan, confirma con un resumen: total de tests, tiempo de ejecución
4. Si hay errores de compilación, muéstralos primero antes de hablar de tests

## Notas
- No muestres los tests que pasaron a menos que el usuario lo pida
- Si el build falla, no intentes interpretar qué tests fallaron

Ejemplo 2: /csharp-review

Crea .claude/skills/csharp-review/SKILL.md:

# csharp-review

Revisa código C# buscando oportunidades de modernización con C# 14 / .NET 10.

## Qué revisar

### Records y tipos de valor
- ¿Se puede reemplazar una clase inmutable con un record?
- ¿Los DTOs usan record en vez de class?
- ¿Se usan init-only properties donde corresponde?

### Pattern matching
- ¿Hay cadenas de if/else que se pueden reemplazar con switch expressions?
- ¿Los switches son exhaustivos sobre discriminated unions?
- ¿Se usa list patterns donde aplica?

### Nullable reference types
- ¿Hay supresiones con ! sin justificación?
- ¿Los parámetros nullable están correctamente anotados?

### field keyword (C# 14)
- ¿Hay propiedades con backing fields explícitos que se pueden simplificar con field?

### Async/await
- ¿Hay .Result o .Wait() que deberían ser await?
- ¿Se usa ConfigureAwait correctamente en librerías?

## Formato de respuesta
Para cada issue encontrado:
- Código original
- Código mejorado
- Una línea explicando por qué es mejor

No reportes lo que ya está bien — solo oportunidades de mejora.

Ejemplo 3: /ef-migrate

Crea .claude/skills/ef-migrate/SKILL.md:

# ef-migrate

Guía para agregar una migración de Entity Framework Core al proyecto.

## Pasos

1. Ejecuta `dotnet ef migrations list --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`
   para mostrar las migraciones existentes

2. Pregunta al usuario:
   - ¿Qué cambio hiciste en el modelo de dominio?
   - ¿Qué nombre quieres para la migración? (sugerencia: usa PascalCase descriptivo, ej: AddOrderShippingAddress)

3. Ejecuta:
   `dotnet ef migrations add <NombreMigracion> --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`

4. Lee el archivo de migración generado y verifica:
   - Que el Up() tiene el cambio esperado
   - Que el Down() revierte correctamente
   - Que no hay columnas `nvarchar(max)` donde debería haber un tamaño específico

5. Si el usuario quiere aplicar la migración:
   `dotnet ef database update --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`

## Notas
- Nunca ejecutes database update en producción desde aquí — solo desarrollo local
- Si hay conflictos de migración, muestra el error completo antes de sugerir soluciones

Estos tres Skills solos ya justifican el setup. Imagina tener un equipo de 10 personas donde todos invocan /csharp-review y obtienen el mismo estándar de revisión.

MCP — conectando herramientas externas

MCP (Model Context Protocol) es el mecanismo que permite a Claude Code conectarse con servicios externos como si fueran herramientas nativas.

En términos simples: un servidor MCP expone capacidades (leer PRs, consultar tickets, buscar documentación) y Claude puede usarlas durante la sesión.

Dos ejemplos relevantes para equipos .NET:

GitHub MCP — Claude puede leer los PRs abiertos del repo, ver los comentarios de revisión, y ayudarte a resolverlos sin que copies nada manualmente:

¿Qué cambios pendientes tengo en el PR #247?

Azure DevOps MCP — Claude puede ver el contexto del sprint actual, las user stories asignadas, y entender qué estás construyendo sin que tengas que explicarlo:

¿Cuáles son los criterios de aceptación de la historia US-1089?

Los servidores MCP se configuran en ~/.claude/mcp.json o .claude/mcp.json a nivel de proyecto. La documentación oficial de Claude Code tiene la lista de servidores MCP disponibles y cómo configurarlos.

Cuándo usar VS Code vs Visual Studio

La pregunta que todo desarrollador .NET acaba haciendo. La respuesta honesta:

Recomendación práctica: No elijas uno. Úsalos en paralelo.

Visual Studio sigue siendo insustituible para debugging pesado, profiling de memoria, y diseñadores de UI de escritorio. VS Code con Claude Code es donde vas a escribir código más rápido, refactorizar más limpio, y entender más fácil código ajeno.

Muchos equipos .NET han adoptado el siguiente flujo: VS Code para el día a día con Claude Code activo, Visual Studio cuando necesitan el debugger avanzado o las herramientas de diagnóstico. Los dos conviven perfectamente apuntando al mismo proyecto.

Puntos clave

• CLAUDE.md es tu punto de partida — sin él, Claude no conoce tu proyecto. Con él, se convierte en un colaborador que entiende tu arquitectura, tus convenciones y tus decisiones técnicas. Ejecuta /init para generarlo y refínalo con el tiempo.

• La integración de VS Code es completa; Visual Studio usa la terminal — en VS Code, la extensión anthropic.claude-code (requiere 1.98+) te da contexto automático. En Visual Studio, usa Ver > Terminal y corre claude ahí. Funciona igual de bien para la mayoría de tareas.

• Las menciones @ son tu herramienta de precisión — @archivo.cs, @directorio/, y @archivo.cs#10-40 te permiten dar a Claude exactamente el contexto que necesita. En VS Code, el archivo activo se comparte automáticamente; en Visual Studio, sé explícito.

• Los Skills son tu ventaja de equipo — crea Skills en .claude/skills/ y versiónalos junto al código. Un /csharp-review consistente para todo el equipo es más valioso que cualquier guideline de código que nadie lee.

• Gestiona el contexto activamente — usa /compact antes de que se alargue demasiado la sesión, y usa /memory para verificar qué CLAUDE.md tiene cargado. Entender cómo Claude descubre el contexto (recorrido del filesystem, no archivos de proyecto) elimina mucha confusión.

Claude Code no reemplaza tu conocimiento de .NET — lo amplifica. La diferencia entre usarlo mediocremente y usarlo bien está en esas tres cosas: un buen CLAUDE.md, contexto preciso con @, y Skills que encapsulan tu flujo de trabajo. Con eso, la magia deja de parecer aleatoria.