{"slug": "claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual", "title": "Claude Code para desarrolladores .NET: De cero a productivo en VS Code y Visual Studio", "summary": "Claude Code, the CLI-based AI tool from Anthropic, offers deep integration for .NET developers in VS Code and JetBrains Rider, but lacks official support for Visual Studio as of June 2026. The tool relies on CLAUDE.md files for project context rather than persistent memory, and developers can use Visual Studio's integrated terminal as a workaround. The article provides practical guidance on setup and usage for real C# projects.", "body_md": "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.\n\nEl problema no es la IA. El problema es que nadie te explicó cómo funciona realmente.\n\nEste 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.\n\nClaude 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.\n\nLa diferencia con \"preguntarle a Claude en el navegador\" es enorme:\n\n`dotnet build`\n\n, 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).\n\n```\nnpm install -g @anthropic-ai/claude-code\n```\n\nVerifica la instalación:\n\n```\nclaude --version\n```\n\nPara iniciar una sesión interactiva en tu proyecto, navega al directorio raíz y ejecuta:\n\n```\nclaude\n```\n\nInstala la extensión oficial desde el Marketplace:\n\n`anthropic.claude-code`\n\nUna 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.\n\nJetBrains 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.\n\nVisual Studio ha sido el rey del desarrollo .NET por décadas. Simplemente aún no se ha enterado de que existe Claude.\n\nA junio de 2026, **no existe una extensión oficial de Claude Code para Visual Studio**. Punto. No hay workaround mágico que cambie eso.\n\nLo que sí funciona, y funciona bien, es usar la **terminal integrada de Visual Studio**:\n\n`Ctrl+\\`\n\n, `Ctrl+``\n\n)`claude`\n\nClaude 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 `@`\n\n(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.\n\nMuchos 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.\n\nAquí está el insight más importante del artículo, así que léelo despacio.\n\nClaude 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`\n\n.\n\nCuando ejecutas `claude`\n\ndesde un directorio, Claude realiza un **recorrido del filesystem hacia arriba** desde tu directorio de trabajo actual (CWD), buscando archivos `CLAUDE.md`\n\n. Además, carga `CLAUDE.md`\n\nde los subdirectorios de forma lazy a medida que accede a ellos.\n\nEsto significa dos cosas importantes:\n\n**No está basado en archivos de proyecto** — Claude no lee tu `.csproj`\n\npara descubrir CLAUDE.md. Lo descubre por ubicación en el filesystem. Si tu `CLAUDE.md`\n\nestá en la raíz del repo y ejecutas `claude`\n\ndesde ahí, se carga. Si lo ejecutas desde un subdirectorio, también lo cargará (porque sube hacia arriba).\n\n**En Visual Studio, CLAUDE.md no aparece en el Explorador de Soluciones** — porque no está referenciado en ningún `.csproj`\n\n. 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.\n\nPuedes verificar en cualquier momento qué archivos CLAUDE.md tiene cargados Claude con el comando:\n\n```\n/memory\n```\n\nEsto muestra el contenido actual de memoria, incluyendo todos los CLAUDE.md activos en la sesión.\n\nSi tu proyecto no tiene CLAUDE.md, Claude puede generarlo leyendo el repo:\n\n```\n/init\n```\n\nEsto analiza tu código, estructura de carpetas, y archivos de configuración, y produce un CLAUDE.md base que puedes refinar.\n\nAquí un ejemplo completo y realista para una API de e-commerce en .NET 10:\n\n```\n# ECommerceApi — Contexto para Claude Code\n\n## Descripción del proyecto\nAPI REST para gestión de catálogo y órdenes de compra.\nStack: .NET 10, C# 14, Entity Framework Core 9, PostgreSQL, MassTransit (RabbitMQ).\nArquitectura: Clean Architecture con CQRS via MediatR.\n\n## Comandos esenciales\n\n### Build y tests\ndotnet build ECommerceApi.sln\ndotnet test ECommerceApi.sln --logger \"console;verbosity=normal\"\ndotnet test --filter \"Category=Unit\"\ndotnet test --filter \"Category=Integration\"\n\n### Migraciones EF Core\ncd src/ECommerceApi.Infrastructure\ndotnet ef migrations add <NombreMigracion> --startup-project ../ECommerceApi.Api\ndotnet ef database update --startup-project ../ECommerceApi.Api\n\n### Ejecución local\ncd src/ECommerceApi.Api\ndotnet run\n\n## Estructura del proyecto\nsrc/\n  ECommerceApi.Api/           # Controllers, middleware, DI setup\n  ECommerceApi.Application/   # Commands, queries, DTOs, validators\n  ECommerceApi.Domain/        # Entities, value objects, domain events\n  ECommerceApi.Infrastructure/ # EF Core, repositories, external services\ntests/\n  ECommerceApi.UnitTests/\n  ECommerceApi.IntegrationTests/\n\n## Convenciones de código\n- Usa records para DTOs y value objects\n- Usa init-only properties en domain entities cuando sea posible\n- Pattern matching exhaustivo en switches sobre discriminated unions\n- Nullable reference types habilitados — sin supresiones con !\n- No uses var — tipado explícito siempre\n- Nombres en inglés para código, comentarios pueden ser en español\n\n## Decisiones de arquitectura importantes\n- Los controllers SOLO llaman a MediatR.Send() — lógica cero en controllers\n- Validaciones con FluentValidation en el pipeline de MediatR (no en controllers)\n- Los domain events se despachan DESPUÉS de SaveChanges (outbox pattern)\n- Los integration tests levantan PostgreSQL en Docker via Testcontainers\n\n## Lo que NO hacer\n- No agregar lógica de negocio en Infrastructure\n- No inyectar DbContext directamente en Application — solo via repositorios\n- No usar AutoMapper — mappings explícitos con métodos ToDto() / ToDomain()\n```\n\nEste archivo transforma a Claude de \"asistente genérico de C#\" a \"colega que conoce tu proyecto\". La diferencia en calidad de respuestas es notable.\n\nTener un buen CLAUDE.md es el 50% del trabajo. El otro 50% es saber cómo dar contexto durante la sesión.\n\nLa sintaxis `@`\n\nte permite referenciar archivos y directorios específicos:\n\n```\n@Program.cs                    # Archivo completo\n@src/Application/              # Directorio entero\n@appsettings.json#1-20         # Líneas 1 a 20 del archivo\n@src/Domain/Entities/Order.cs  # Archivo en ruta relativa\n```\n\nEjemplos de uso en conversación:\n\n```\nRevisa @src/Application/Orders/Commands/CreateOrderCommand.cs\ny dime si hay algo que mejorar con los nuevos features de C# 14.\nTengo un bug en @src/Infrastructure/Repositories/OrderRepository.cs#45-80.\nEl método GetPendingOrders() devuelve órdenes canceladas. ¿Ves el problema?\n```\n\nEn 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 `@`\n\n.\n\nEn Visual Studio (terminal), necesitas ser explícito con `@`\n\n— lo cual en realidad te obliga a ser más preciso sobre qué quieres mostrarle a Claude, lo cual no es necesariamente malo.\n\nLas 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.\n\nEl comando `/compact`\n\nresume el historial de la sesión actual, preservando los puntos clave pero reduciendo el tamaño del contexto:\n\n```\n/compact\n```\n\nÚsalo proactivamente cuando llevas un rato en la misma sesión, antes de llegar al límite. Es como hacer un checkpoint.\n\nLos 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.\n\nHay dos ubicaciones:\n\n| Ubicación | Alcance | Ruta |\n|---|---|---|\n| Personal | Solo tú, todos tus proyectos | `~/.claude/skills/<nombre>/SKILL.md` |\n| Proyecto | Todo el equipo, este repo | `.claude/skills/<nombre>/SKILL.md` |\n\nLos Skills de proyecto se versiona junto al código — cuando alguien hace `git clone`\n\n, obtiene los Skills también. Ideal para workflows específicos del equipo.\n\nSimplemente escribe `/nombre-del-skill`\n\nen Claude Code:\n\n```\n/dotnet-test\n/csharp-review\n/ef-migrate\n```\n\nClaude lee el archivo `SKILL.md`\n\ncorrespondiente y ejecuta el flujo definido en él.\n\n`/dotnet-test`\n\nCrea el archivo `.claude/skills/dotnet-test/SKILL.md`\n\n:\n\n```\n# dotnet-test\n\nEjecuta la suite de tests del proyecto y presenta los resultados de forma clara.\n\n## Pasos\n\n1. Ejecuta `dotnet test ECommerceApi.sln --logger \"console;verbosity=normal\"`\n2. Si hay fallos, muestra SOLO los tests fallidos con:\n   - Nombre completo del test\n   - El mensaje de error\n   - La línea del código donde falló\n3. Si todos pasan, confirma con un resumen: total de tests, tiempo de ejecución\n4. Si hay errores de compilación, muéstralos primero antes de hablar de tests\n\n## Notas\n- No muestres los tests que pasaron a menos que el usuario lo pida\n- Si el build falla, no intentes interpretar qué tests fallaron\n```\n\n`/csharp-review`\n\nCrea `.claude/skills/csharp-review/SKILL.md`\n\n:\n\n```\n# csharp-review\n\nRevisa código C# buscando oportunidades de modernización con C# 14 / .NET 10.\n\n## Qué revisar\n\n### Records y tipos de valor\n- ¿Se puede reemplazar una clase inmutable con un record?\n- ¿Los DTOs usan record en vez de class?\n- ¿Se usan init-only properties donde corresponde?\n\n### Pattern matching\n- ¿Hay cadenas de if/else que se pueden reemplazar con switch expressions?\n- ¿Los switches son exhaustivos sobre discriminated unions?\n- ¿Se usa list patterns donde aplica?\n\n### Nullable reference types\n- ¿Hay supresiones con ! sin justificación?\n- ¿Los parámetros nullable están correctamente anotados?\n\n### field keyword (C# 14)\n- ¿Hay propiedades con backing fields explícitos que se pueden simplificar con field?\n\n### Async/await\n- ¿Hay .Result o .Wait() que deberían ser await?\n- ¿Se usa ConfigureAwait correctamente en librerías?\n\n## Formato de respuesta\nPara cada issue encontrado:\n- Código original\n- Código mejorado\n- Una línea explicando por qué es mejor\n\nNo reportes lo que ya está bien — solo oportunidades de mejora.\n```\n\n`/ef-migrate`\n\nCrea `.claude/skills/ef-migrate/SKILL.md`\n\n:\n\n```\n# ef-migrate\n\nGuía para agregar una migración de Entity Framework Core al proyecto.\n\n## Pasos\n\n1. Ejecuta `dotnet ef migrations list --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`\n   para mostrar las migraciones existentes\n\n2. Pregunta al usuario:\n   - ¿Qué cambio hiciste en el modelo de dominio?\n   - ¿Qué nombre quieres para la migración? (sugerencia: usa PascalCase descriptivo, ej: AddOrderShippingAddress)\n\n3. Ejecuta:\n   `dotnet ef migrations add <NombreMigracion> --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`\n\n4. Lee el archivo de migración generado y verifica:\n   - Que el Up() tiene el cambio esperado\n   - Que el Down() revierte correctamente\n   - Que no hay columnas `nvarchar(max)` donde debería haber un tamaño específico\n\n5. Si el usuario quiere aplicar la migración:\n   `dotnet ef database update --project src/ECommerceApi.Infrastructure --startup-project src/ECommerceApi.Api`\n\n## Notas\n- Nunca ejecutes database update en producción desde aquí — solo desarrollo local\n- Si hay conflictos de migración, muestra el error completo antes de sugerir soluciones\n```\n\nEstos tres Skills solos ya justifican el setup. Imagina tener un equipo de 10 personas donde todos invocan `/csharp-review`\n\ny obtienen el mismo estándar de revisión.\n\nMCP (Model Context Protocol) es el mecanismo que permite a Claude Code conectarse con servicios externos como si fueran herramientas nativas.\n\nEn términos simples: un servidor MCP expone capacidades (leer PRs, consultar tickets, buscar documentación) y Claude puede usarlas durante la sesión.\n\nDos ejemplos relevantes para equipos .NET:\n\n**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:\n\n```\n¿Qué cambios pendientes tengo en el PR #247?\n```\n\n**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:\n\n```\n¿Cuáles son los criterios de aceptación de la historia US-1089?\n```\n\nLos servidores MCP se configuran en `~/.claude/mcp.json`\n\no `.claude/mcp.json`\n\na nivel de proyecto. La documentación oficial de Claude Code tiene la lista de servidores MCP disponibles y cómo configurarlos.\n\nLa pregunta que todo desarrollador .NET acaba haciendo. La respuesta honesta:\n\n| Criterio | VS Code + Claude Code | Visual Studio 2022/2026 |\n|---|---|---|\n| Integración con Claude Code | Completa — contexto automático, extensión nativa | Funcional — terminal integrada, sin extensión |\n| Debugging de aplicaciones .NET | Bueno (con extensión C#) | Excelente — el mejor de la industria |\n| IntelliSense y refactoring | Bueno | Excepcional — Roslyn completo |\n| Diseñadores visuales (WinForms, WPF, MAUI) | No disponible | Completos |\n| Profiling y diagnósticos | Limitado | Herramientas de clase mundial |\n| Startup y rendimiento del IDE | Rápido | Lento en proyectos grandes |\n| Desarrollo multiplataforma | Ideal | Limitado |\n| Trabajo con soluciones grandes (50+ proyectos) | Puede ser lento | Optimizado |\n| Skills y workflows de equipo | Integración nativa | Via terminal |\n\n**Recomendación práctica:** No elijas uno. Úsalos en paralelo.\n\nVisual 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.\n\nMuchos 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.\n\n**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`\n\npara generarlo y refínalo con el tiempo.\n\n**La integración de VS Code es completa; Visual Studio usa la terminal** — en VS Code, la extensión `anthropic.claude-code`\n\n(requiere 1.98+) te da contexto automático. En Visual Studio, usa `Ver > Terminal`\n\ny corre `claude`\n\nahí. Funciona igual de bien para la mayoría de tareas.\n\n**Las menciones @ son tu herramienta de precisión** —\n\n`@archivo.cs`\n\n, `@directorio/`\n\n, y `@archivo.cs#10-40`\n\nte 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/`\n\ny versiónalos junto al código. Un `/csharp-review`\n\nconsistente para todo el equipo es más valioso que cualquier guideline de código que nadie lee.\n\n**Gestiona el contexto activamente** — usa `/compact`\n\nantes de que se alargue demasiado la sesión, y usa `/memory`\n\npara verificar qué CLAUDE.md tiene cargado. Entender cómo Claude descubre el contexto (recorrido del filesystem, no archivos de proyecto) elimina mucha confusión.\n\nClaude 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`\n\n, contexto preciso con `@`\n\n, y Skills que encapsulan tu flujo de trabajo. Con eso, la magia deja de parecer aleatoria.", "url": "https://wpnews.pro/news/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual", "canonical_source": "https://dev.to/jgomezdev/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual-studio-d4j", "published_at": "2026-06-15 22:57:12+00:00", "updated_at": "2026-06-15 23:17:15.443811+00:00", "lang": "en", "topics": ["developer-tools", "large-language-models", "ai-tools"], "entities": ["Claude Code", "Anthropic", "VS Code", "Visual Studio", "JetBrains Rider", "CLAUDE.md", ".NET"], "alternates": {"html": "https://wpnews.pro/news/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual", "markdown": "https://wpnews.pro/news/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual.md", "text": "https://wpnews.pro/news/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual.txt", "jsonld": "https://wpnews.pro/news/claude-code-para-desarrolladores-net-de-cero-a-productivo-en-vs-code-y-visual.jsonld"}}