# Cómo instalar Claude Code en Mac, Windows y Linux: terminal o app

> Windows: un comando en PowerShell o CMD. Mac y Linux: uno en la Terminal o Homebrew. La app de escritorio trae Claude Code sin terminal. Pide plan de pago.

- URL: https://blog.laozhang.ai/es/posts/how-to-install-claude-code
- Published: 2026-03-16
- Updated: 2026-10-21
- Author: LaoZhang AI Team (https://blog.laozhang.ai/es/about)
- Topic: Claude Code
- Tags: Claude Code, Guía de instalación, Herramientas de IA para programar, Herramientas para desarrolladores

---
Claude Code se instala con un solo comando en la terminal: en Windows, `irm https://claude.ai/install.ps1 | iex` en PowerShell; en Mac y Linux, `curl -fsSL https://claude.ai/install.sh | bash`. Si lo que buscas es «Claude para Mac» con ventanas y botones, la app de escritorio de Claude incluye Claude Code en su pestaña Code y no necesita terminal. Las dos rutas piden una cuenta de pago (Pro, Max, Team o Enterprise) o una cuenta de Anthropic Console: el plan gratuito de Claude no da acceso a Claude Code. Los comandos, requisitos y precios corresponden al 21 de octubre de 2026, según la [documentación oficial de configuración de Claude Code](https://code.claude.com/docs/es/setup) y la [página de precios de Claude](https://claude.com/pricing).

## Resumen rápido: el comando de instalación para cada sistema

- **Windows, PowerShell**: `irm https://claude.ai/install.ps1 | iex`. No hace falta abrirlo como administrador y Git for Windows es opcional.
- **Windows, CMD**: `curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd`
- **macOS, Linux y WSL**: `curl -fsSL https://claude.ai/install.sh | bash`
- **Con gestor de paquetes**: `brew install --cask claude-code` (Homebrew) o `winget install Anthropic.ClaudeCode` (WinGet). Estos no se actualizan solos.
- **Comprobar**: el instalador no muestra progreso mientras descarga. Cuando termine, abre una terminal nueva y ejecuta `claude --version`; debe imprimir un número de versión.
- **Sin terminal**: la app de escritorio de Claude para macOS (una sola descarga para Intel y Apple Silicon) y Windows trae Claude Code dentro. Se instala aparte del comando `claude`.
- **Cuenta**: Claude Pro (USD 20 al mes) o superior, o una cuenta de Console con créditos de API.

Si ya sabes qué método quieres, copia el comando de tu sistema y pasa a [Autenticación y primer inicio](#autenticación-y-primer-inicio). Descarga los instaladores solo desde claude.ai, code.claude.com, claude.com/download, el repositorio `anthropics/claude-code` de GitHub o los paquetes oficiales de Homebrew y WinGet; un «instalador de Claude» que llega por un anuncio o una web desconocida no es de Anthropic.

## Claude para Mac y Windows: app de escritorio o Claude Code en la terminal

Son dos instalaciones distintas. La app de escritorio de Claude es la que buscas si quieres «descargar Claude para Mac»: se instala como cualquier programa, tiene las pestañas Chat, Cowork y Code, y en la pestaña Code trabaja con los archivos de una carpeta de tu ordenador. Claude Code en la terminal (el CLI) es el comando `claude` que escribes dentro de la carpeta del proyecto. Instalar una no instala la otra: la [guía de inicio de la app de escritorio](https://code.claude.com/docs/es/desktop-quickstart) indica que, si quieres `claude` en la terminal, hay que instalar el CLI por separado.

| | App de escritorio de Claude | Claude Code en la terminal (CLI) |
|---|---|---|
| Qué descargas | macOS: `.dmg` universal para Intel y Apple Silicon. Windows: instalador x64 (hay otro para ARM64). Linux: beta por apt o `.deb` en Ubuntu y Debian | Un binario que instala el comando de una línea, Homebrew, WinGet, apt, dnf, apk o npm |
| Cómo trabajas | Eliges la carpeta del proyecto en una ventana y revisas cada cambio en un visor de diferencias | Escribes `claude` en la carpeta del proyecto y conversas en la terminal |
| Qué cuenta pide | La pestaña Code requiere Pro, Max, Team o Enterprise | Pro, Max, Team, Enterprise o Console |
| ¿Necesita Node.js? | No, la app ya incluye Claude Code | No (solo la instalación por npm lo usa) |

Para instalar la app de escritorio en Mac:

1. Descarga el instalador para macOS desde la [página de descarga de Claude](https://claude.com/download) o desde la guía de inicio de la app de escritorio.
2. Abre el `.dmg` y arrastra Claude a la carpeta Aplicaciones.
3. Abre Claude desde Aplicaciones e inicia sesión con tu cuenta de Anthropic.
4. Pulsa la pestaña **Code**, arriba en el centro. Si te pide mejorar el plan, tu cuenta es gratuita y no incluye Claude Code.
5. En la fila bajo el cuadro de texto, elige el entorno **Local**, pulsa **Open folder…** y selecciona la carpeta de tu proyecto.

En Windows el proceso es el mismo: ejecuta el instalador descargado y abre Claude desde el menú Inicio. Desde la app también puedes elegir un entorno **WSL** para que Claude Code trabaje dentro de una distribución WSL 2. Si tienes una versión antigua de la app en Windows y al escribir `claude` en la terminal se abre la app en lugar del CLI, actualiza la app: las versiones antiguas registraban un `Claude.exe` que tenía prioridad en el PATH.

## Lo que necesitas antes de instalar Claude Code

![Comparación de seis métodos de instalación de Claude Code: CLI nativo, Homebrew, WinGet, npm, CMD y WSL](https://blog.laozhang.ai/posts/es/how-to-install-claude-code/img/install-methods.webp)

*El gráfico está parcialmente desactualizado y manda el texto: npm sigue soportado y pide Node.js 22 o posterior, y el comando de Homebrew es `brew install --cask claude-code`.*

Antes de ejecutar cualquier comando, comprueba dos cosas: que tu sistema cumple los requisitos mínimos y que tu cuenta incluye Claude Code. La segunda es la que más sorprende, porque el comando se instala sin problema con una cuenta gratuita y el bloqueo aparece al iniciar sesión.

### Requisitos del sistema

La documentación oficial de configuración fija estos mínimos:

| Requisito | Mínimo |
|---|---|
| macOS | 13.0 (Ventura) o posterior, con Apple Silicon o Intel |
| Windows | Windows 10 versión 1809 o posterior, o Windows Server 2019 o posterior, de 64 bits |
| Linux | Ubuntu 20.04+, Debian 10+, Alpine Linux 3.19+ |
| Hardware | 4 GB de RAM o más, procesador x64 o ARM64 |
| Terminal | Bash, Zsh, PowerShell o CMD |
| Red y ubicación | Conexión a internet y estar en un [país admitido por Anthropic](https://www.anthropic.com/supported-countries) |

En Mac, la versión aparece en el menú Apple → **Acerca de este Mac**. La app **Terminal** que viene con macOS (en Aplicaciones → Utilidades) basta; iTerm2 u otros terminales también funcionan.

En Windows no necesitas permisos de administrador ni instalar Git antes. Git for Windows es opcional: aporta Git Bash, que usan las herramientas Bash y Monitor de Claude Code; sin él, Claude Code ejecuta los comandos con PowerShell. Windows de 32 bits no está soportado.

En Linux, la documentación no fija versión mínima para Fedora, RHEL ni Arch. Fedora y RHEL tienen repositorio dnf oficial; en Arch y otras distribuciones sin paquete oficial, el camino documentado es el script nativo. Alpine y otras distribuciones con musl necesitan antes `bash`, `curl`, `libgcc`, `libstdc++` y `ripgrep`, y la variable `USE_BUILTIN_RIPGREP=0`.

### Elegir la cuenta adecuada

Claude Code no está disponible en el plan gratuito de Claude. Necesitas una de estas cuentas (precios de [claude.com/pricing](https://claude.com/pricing) a 21 de octubre de 2026, en dólares estadounidenses y sin impuestos):

| Tipo de cuenta | Precio | Uso incluido | Acceso a Claude Code |
|---|---|---|---|
| Claude Pro | USD 20 al mes; USD 17 al mes con pago anual (USD 200 por adelantado) | Uso base, con límites | Sí |
| Claude Max 5x | USD 100 al mes | 5 veces el uso de Pro | Sí |
| Claude Max 20x | USD 200 al mes | 20 veces el uso de Pro | Sí |
| Team, puesto estándar | USD 25 por puesto al mes; USD 20 con pago anual | Más uso que Pro | Sí |
| Team, puesto premium | USD 125 por puesto al mes; USD 100 con pago anual | 5 veces el uso del puesto estándar | Sí |
| Enterprise | USD 20 por puesto al mes con pago anual (mínimo 20 puestos), más el uso a tarifas de API | Se paga por uso | Sí |
| Anthropic Console | Pago por uso con créditos de API | Lo que pagues | Sí, con clave de API |
| Plan gratuito | 0 | — | No |

Max incluye además entre USD 100 y USD 200 al mes en créditos de API para la plataforma de Claude. Para probar Claude Code por primera vez, Pro es el punto de partida razonable; si topas con los límites a menudo, la comparación [Claude Pro vs Max: precios, límites de uso y cuándo compensa Max](https://blog.laozhang.ai/es/posts/claude-code-pro-vs-max) ayuda a decidir el salto. Para usarlo solo en scripts o en CI, una cuenta de Console con clave de API evita la suscripción mensual.

## Instalar Claude Code en Windows

Para instalar Claude Code en Windows, abre PowerShell (sin «Ejecutar como administrador»), ejecuta `irm https://claude.ai/install.ps1 | iex`, espera a que termine aunque no veas progreso, abre una ventana nueva de PowerShell y comprueba con `claude --version`. Si el número de versión aparece, ya puedes escribir `claude` en la carpeta de tu proyecto.

![Árbol de decisión para la instalación en Windows mostrando las rutas Native PowerShell, WinGet y WSL para la configuración de Claude Code](https://blog.laozhang.ai/posts/es/how-to-install-claude-code/img/windows-decision.webp)

Antes de copiar el comando, fíjate en qué terminal estás: en PowerShell el indicador empieza por `PS`, como `PS C:\Users\TuNombre>`; en CMD aparece solo `C:\Users\TuNombre>`. Cada una tiene su comando, y mezclarlos es la causa más común de error en Windows.

La otra decisión es dónde ejecutar Claude Code:

| Opción | Qué necesita | Aislamiento de comandos (sandboxing) | Cuándo usarla |
|---|---|---|---|
| Windows nativo | Nada; Git for Windows es opcional | No | Proyectos y herramientas de Windows (.NET, PowerShell) |
| WSL 2 | WSL 2 activado | Sí | Toolchains de Linux o si quieres ejecución aislada |
| WSL 1 | WSL 1 activado | No | Solo si WSL 2 no está disponible |

Si dudas, empieza por el instalador nativo; puedes añadir WSL más tarde.

### Instalador nativo de PowerShell (recomendado para la mayoría de usuarios)

1. Abre el menú Inicio, busca «PowerShell» y abre **Windows PowerShell**. No uses la entrada **Windows PowerShell (x86)**: es de 32 bits y da error aunque tu Windows sea de 64.
2. Ejecuta:

```powershell
irm https://claude.ai/install.ps1 | iex
```

3. Cierra la ventana, abre una nueva y comprueba:

```powershell
claude --version
```

4. Entra en la carpeta de tu proyecto y escribe `claude` para iniciar la primera sesión.

El binario queda en `%USERPROFILE%\.local\bin\claude.exe` y se actualiza solo en segundo plano. La configuración y el historial se guardan en `%USERPROFILE%\.claude`.

Si tienes Git for Windows, Claude Code usa Git Bash para su herramienta Bash y mantiene PowerShell disponible. Si Git está instalado pero Claude Code no encuentra Git Bash, indícale la ruta en tu archivo `settings.json`:

```json
{
  "env": {
    "CLAUDE_CODE_GIT_BASH_PATH": "C:\\Program Files\\Git\\bin\\bash.exe"
  }
}
```

### Alternativa con WinGet

Si gestionas el software con WinGet, el gestor de paquetes de Windows, Claude Code tiene paquete oficial:

```powershell
winget install Anthropic.ClaudeCode
```

Instala lo mismo que el script de PowerShell, pero no se actualiza solo: ejecuta `winget upgrade Anthropic.ClaudeCode` de vez en cuando. Si defines la variable `CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE=1`, Claude Code lanza esa actualización por ti; en WinGet puede fallar mientras Claude Code está abierto, porque Windows bloquea el ejecutable, y en ese caso te muestra el comando para hacerlo a mano. WinGet encaja si tu empresa gestiona el software con políticas de paquetes.

### Instalador para Windows CMD

Si trabajas en el Símbolo del sistema (CMD), usa su propio comando:

```cmd
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```

Los mensajes que delatan que copiaste el comando de la otra terminal:

- `'irm' is not recognized as an internal or external command` (en Windows en español: «'irm' no se reconoce como un comando interno o externo…»): estás en CMD con el comando de PowerShell. Abre PowerShell o usa el comando de arriba.
- `The token '&&' is not a valid statement separator`: estás en PowerShell con el comando de CMD. Usa `irm https://claude.ai/install.ps1 | iex`.
- `A parameter cannot be found that matches parameter name 'fsSL'` o `'bash' is not recognized`: pegaste el comando de Mac y Linux en PowerShell. Usa el de PowerShell.
- Si en pantalla aparece el texto del script en lugar de instalarse, copiaste solo la mitad del comando: falta `| iex` en PowerShell o `-o install.cmd` en CMD.

### Ruta WSL (para desarrolladores con enfoque en Linux)

Si prefieres un entorno Linux completo en Windows, instala WSL y después usa el comando de Linux dentro de él:

```powershell
# Paso 1: instala WSL en PowerShell abierto como administrador
# (el permiso lo pide WSL, no Claude Code)
wsl --install

# Paso 2: reinicia el equipo cuando te lo pida
```

```bash
# Paso 3: abre la terminal de WSL (Ubuntu por defecto) e instala Claude Code
curl -fsSL https://claude.ai/install.sh | bash
```

Claude Code se instala y se ejecuta dentro de la terminal de WSL, no desde PowerShell ni CMD. Si instalas por npm dentro de WSL, Node.js también tiene que estar dentro de WSL: el Node.js de Windows no existe para WSL. El instalador nativo no depende de Node.js, así que evita ese problema.

Para que los proyectos vayan rápido, guárdalos en el sistema de archivos de WSL (por ejemplo, `~/projects/`) y no en `/mnt/c/Users/...`: leer archivos a través del límite entre Windows y WSL es bastante más lento. Al iniciar sesión desde WSL, el navegador se abre en Windows y puede mostrarte un código en lugar de volver a la terminal; pégalo donde Claude Code dice `Paste code here if prompted`.

## Instalar Claude Code en macOS y Linux

En Mac y Linux, abre la app Terminal y ejecuta `curl -fsSL https://claude.ai/install.sh | bash`. Es el mismo comando en macOS, en cualquier distribución Linux compatible y dentro de WSL, y funciona igual en Macs con Apple Silicon y con Intel.

### Instalador nativo (recomendado)

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

El script descarga el binario de tu sistema y arquitectura, deja el lanzador en `~/.local/bin/claude` (un enlace a `~/.local/share/claude/versions/`) y no necesita Node.js. Durante la descarga no muestra progreso; espera a que termine. Después abre una ventana nueva de Terminal y ejecuta `claude --version`. Si al final el instalador muestra `Native installation exists but ~/.local/bin is not in your PATH.`, la instalación está bien pero tu terminal todavía no encuentra el comando: la solución está en [la sección de command not found](#command-not-found-claude-o-claude-no-se-reconoce-en-windows).

El instalador nativo se actualiza solo: Claude Code busca versiones nuevas al arrancar y mientras está abierto, las descarga en segundo plano y las aplica la siguiente vez que lo inicias. Para actualizar en el momento, ejecuta `claude update`.

Si prefieres revisar el script antes de ejecutarlo, descárgalo primero:

```bash
curl -fsSL https://claude.ai/install.sh -o install-claude.sh
less install-claude.sh  # revisa el script
bash install-claude.sh
```

### Alternativa con Homebrew

Para quien gestiona sus herramientas con Homebrew, Claude Code está disponible como cask:

```bash
brew install --cask claude-code
```

Hay dos casks. `claude-code` sigue el canal estable, que suele ir una semana por detrás y se salta las versiones con regresiones importantes; `claude-code@latest` recibe cada versión en cuanto sale. Las instalaciones de Homebrew no se actualizan solas:

```bash
brew upgrade claude-code
# o, si instalaste el otro cask:
brew upgrade claude-code@latest
```

Homebrew conserva las versiones antiguas en disco; `brew cleanup` libera ese espacio. Si Homebrew responde `Error: Cask 'claude-code' is unavailable`, tu índice local es antiguo: ejecuta `brew update` y vuelve a instalar.

Homebrew coloca los programas en `/opt/homebrew/bin/` en Macs con Apple Silicon y en `/usr/local/bin/` en Macs con Intel. Si más adelante cambias al instalador nativo para tener actualizaciones automáticas, desinstala antes la versión de Homebrew con `brew uninstall --cask claude-code`, para no tener dos copias de `claude` en el PATH.

### Linux: repositorios apt, dnf y apk

En Linux, además del script, Claude Code publica repositorios firmados para apt (Debian, Ubuntu), dnf (Fedora, RHEL) y apk (Alpine). Configurados en el canal `stable`, en Debian o Ubuntu queda así:

```bash
sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
  -o /etc/apt/keyrings/claude-code.asc
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \
  | sudo tee /etc/apt/sources.list.d/claude-code.list
sudo apt update
sudo apt install claude-code
```

Antes de confiar en la clave, la documentación oficial pide comprobar con `gpg --show-keys /etc/apt/keyrings/claude-code.asc` que la huella es `31DDDE24DDFAB679F42D7BD2BAA929FF1A7ECACE`. Las instalaciones por apt, dnf o apk se actualizan con el gestor del sistema (`sudo apt update && sudo apt upgrade claude-code`), no con Claude Code. Los comandos para dnf y apk están en la [documentación de configuración de Claude Code](https://code.claude.com/docs/es/setup). En Arch y otras distribuciones sin repositorio oficial, usa el script nativo.

### Verificar tu instalación

Sea cual sea el método, comprueba que Claude Code responde:

```bash
claude --version
which -a claude
```

`claude --version` imprime un número de versión con el formato `2.1.211 (Claude Code)` (el número cambia casi a diario). `which -a claude` lista todas las copias de `claude` que hay en tu PATH; en Windows, el equivalente es `where.exe claude`. Si salen dos rutas, tienes dos instalaciones (por ejemplo, npm y la nativa) y conviene quitar una. Para un diagnóstico completo sin abrir sesión, ejecuta `claude doctor`.

## npm sigue soportado: cuándo conviene pasar al instalador nativo

La instalación con `npm install -g @anthropic-ai/claude-code` no está obsoleta: sigue en la documentación oficial y requiere Node.js 22 o posterior. Con un Node.js más antiguo, npm muestra un aviso `EBADENGINE`, pero la instalación termina y `claude` funciona, porque el paquete de npm descarga el mismo binario nativo que el instalador y no usa Node.js al ejecutarse.

La idea de que npm está «obsoleto» viene de la versión 2.1.15 (21 de enero de 2026), que mostraba un aviso de obsolescencia a quienes instalaban por npm; la documentación actual ya no lo presenta así. El mínimo de Node.js subió de 18 a 22 en la versión 2.1.198, del 1 de julio de 2026, según los metadatos del paquete en el registro de npm.

Pasar al instalador nativo es una opción, no una obligación. Compensa cuando:

- La carpeta global de npm no tiene permisos de escritura: Claude Code no puede actualizarse solo y lo avisa una vez al arrancar (`claude doctor` lista las soluciones).
- Te aparecen errores `EACCES` al instalar o actualizar con npm.
- En Windows, la política de ejecución de PowerShell bloquea los lanzadores `.ps1` que crea npm.
- No quieres mantener Node.js solo para Claude Code.

Si sigues con npm, actualiza con `npm install -g @anthropic-ai/claude-code@latest` (no con `npm update -g`, que puede no llegar a la última versión) y no uses nunca `sudo npm install -g`. Si instalaste con `--omit=optional` o `--ignore-scripts`, el binario no llega a copiarse y `claude` responde `Error: claude native binary not installed.`; reinstala sin esas opciones.

Para cambiar de npm al instalador nativo:

```bash
# Paso 1: comprueba cómo está instalado
which claude
# Si la ruta pasa por node_modules o .npm-global, es la versión de npm

# Paso 2: desinstala la versión de npm
npm uninstall -g @anthropic-ai/claude-code

# Paso 3: comprueba que ya no está
which claude  # no debería devolver ninguna ruta

# Paso 4: instala la versión nativa
curl -fsSL https://claude.ai/install.sh | bash  # macOS/Linux
# O BIEN
irm https://claude.ai/install.ps1 | iex  # Windows PowerShell

# Paso 5: abre una terminal nueva y comprueba
claude --version
```

La configuración, el historial y la sesión iniciada viven en `~/.claude/` y no se tocan al cambiar de método, así que no tendrás que volver a configurar nada.

## Autenticación y primer inicio

Con Claude Code instalado, entra en la carpeta de un proyecto y ejecútalo:

```bash
cd /ruta/a/tu/proyecto
claude
```

La primera vez, Claude Code abre el navegador para que inicies sesión con tu cuenta de Claude (Pro, Max, Team o Enterprise) o de Console. Si el navegador no se abre, pulsa `c` para copiar la URL de inicio de sesión y pégala tú en el navegador. Las credenciales se guardan en tu equipo (en macOS, en el Llavero), así que solo tienes que hacerlo una vez.

### Métodos de autenticación

**Cuenta de Claude por el navegador.** Es el método por defecto: la suscripción cubre el uso, con los límites de tu plan. Fuera de una sesión, los comandos de cuenta son `claude auth login` y `claude auth logout`; dentro de una sesión, `/login` y `/logout`.

**Clave de API.** Pensada para entornos sin navegador: CI/CD, contenedores, servidores remotos. Define la variable antes de arrancar:

```bash
export ANTHROPIC_API_KEY=sk-ant-...
claude
```

Si apruebas la clave cuando Claude Code pregunta si quieres usarla, se salta el inicio de sesión y el uso se cobra por tokens en tu cuenta de Console. Las opciones de `settings.json`, modelos y pasarelas están en [Configuración de Claude Code API: claves, settings.json, modelos y gateways](https://blog.laozhang.ai/es/posts/claude-code-api-configuration).

**Proveedores de nube.** Claude Code también funciona con Amazon Bedrock, Agent Platform de Google Cloud (antes Vertex AI) y Microsoft Foundry. Lo usan sobre todo empresas que ya tienen contrato con esos proveedores; cada uno tiene su página en la [documentación de Claude Code](https://code.claude.com/docs/es/setup).

### Inicializa tu proyecto con CLAUDE.md

Después de iniciar sesión, lo más útil que puedes hacer es crear un archivo `CLAUDE.md` en la raíz del proyecto. Este archivo Markdown da a Claude contexto permanente sobre tu código: comandos de compilación, convenciones, decisiones de arquitectura, cómo se ejecutan las pruebas; todo lo que no puede deducir leyendo el código. Sin él, cada sesión empieza sin conocer las particularidades del proyecto.

Genera un `CLAUDE.md` inicial automáticamente:

```bash
# Dentro de una sesión de Claude Code:
/init
```

El comando analiza el proyecto y crea un `CLAUDE.md` con el sistema de compilación, el framework de pruebas y los patrones que detecta. Mantenlo breve; para cada línea, pregúntate: «¿Si la quito, Claude se equivocaría?». Si no, sobra. En monorepos puedes añadir más archivos `CLAUDE.md` en subcarpetas: las reglas de la raíz se aplican en todo el proyecto y las de cada subcarpeta solo cuando se trabaja en ella.

Un ejemplo de `CLAUDE.md` bien estructurado para un proyecto Next.js:

```markdown
# CLAUDE.md

## Commands
- `npm run dev` - Start dev server on port 3000
- `npm run build` - Production build
- `npm test` - Run Jest tests
- `npm run lint` - ESLint check

## Architecture
- Next.js 15 with App Router
- PostgreSQL with Drizzle ORM
- Authentication via Clerk
- All API routes in src/app/api/

## Conventions
- Server components by default; use "use client" only when needed
- TypeScript strict mode; no any types
- Commit messages: imperative mood, < 72 chars
```

La idea es contarle a Claude lo que no puede averiguar leyendo el código: comandos de compilación, convenciones de nombres y decisiones de arquitectura son justo donde más se equivoca sin una indicación explícita.

## Resolución de problemas comunes de instalación

El primer paso ante cualquier fallo es el diagnóstico integrado:

```bash
claude doctor
```

`claude doctor` revisa la instalación y los archivos de configuración sin abrir una sesión, muestra el resultado del último intento de actualización y propone soluciones para cada aviso. Si tu error no aparece abajo, la [guía de solución de problemas de instalación de Claude Code](https://code.claude.com/docs/es/troubleshoot-install) tiene una entrada por mensaje.

### «command not found: claude» o «'claude' no se reconoce» en Windows

La instalación terminó, pero tu terminal no encuentra el comando porque la carpeta de instalación todavía no está en el PATH. El mensaje cambia según el sistema:

| Sistema | Mensaje |
|---|---|
| macOS | `zsh: command not found: claude` |
| Linux | `bash: claude: command not found` |
| Windows CMD | `'claude' is not recognized as an internal or external command` («'claude' no se reconoce como un comando interno o externo…» en Windows en español) |
| PowerShell | `The term 'claude' is not recognized as the name of a cmdlet` («El término 'claude' no se reconoce…» en español) |

Lo primero, en todos los sistemas: cierra la terminal y abre una nueva. Una ventana que ya estaba abierta conserva el PATH antiguo, y la terminal integrada de un editor toma el PATH del editor, así que también hay que cerrar y abrir el editor.

En macOS y Linux, comprueba que el programa existe y añade su carpeta al PATH (para Zsh, el shell por defecto de macOS):

```bash
ls -la ~/.local/bin/claude
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
```

Con Bash en Linux, usa `~/.bashrc` en lugar de `~/.zshrc`; con Bash en macOS, `~/.bash_profile`.

En Windows, comprueba en PowerShell que el ejecutable existe y añade la carpeta al PATH de tu usuario:

```powershell
Test-Path "$env:USERPROFILE\.local\bin\claude.exe"
$currentPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
[Environment]::SetEnvironmentVariable('PATH', "$currentPath;$env:USERPROFILE\.local\bin", 'User')
```

Si `Test-Path` devuelve `False`, no hay instalación nativa: vuelve a ejecutar el instalador. Después de cambiar el PATH, abre una ventana nueva y prueba `claude --version`.

Si el error apareció justo después de una actualización en Windows, puede que falte `claude.exe` y solo quede la copia de seguridad (`claude.exe.old.` seguido de un número). Este comando renombra la más reciente:

```powershell
Get-ChildItem "$env:USERPROFILE\.local\bin\claude.exe.old.*" | Sort-Object Name | Select-Object -Last 1 | Rename-Item -NewName claude.exe
```

Si no hay copia o sigue fallando, reinstala con `irm https://claude.ai/install.ps1 | iex`.

### Errores de permisos EACCES (solo método npm)

Si instalaste con npm y aparecen errores de permisos `EACCES`, no uses `sudo npm install -g`: crea archivos de root en tu carpeta de npm y complica cada instalación global posterior. La solución que da la documentación oficial es cambiar al instalador nativo (`curl -fsSL https://claude.ai/install.sh | bash`). Si prefieres seguir con npm, mueve su carpeta global a tu directorio personal:

```bash
mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
npm install -g @anthropic-ai/claude-code
```

### Fallos de autenticación

Si el inicio de sesión no se completa:

1. Comprueba que has iniciado sesión en [claude.ai](https://claude.ai) en el navegador que se abre.
2. Verifica que tu cuenta tiene un plan con Claude Code: Pro, Max, Team o Enterprise, o una cuenta de Console. Con el plan gratuito no funciona.
3. Cierra la sesión y vuelve a entrar: `/logout` dentro de Claude Code (o `claude auth logout` en la terminal), cierra Claude Code y ejecuta `claude` de nuevo. No existe un comando `claude logout`.
4. Si el navegador no vuelve a la terminal, pulsa `c` para copiar la URL o usa `claude auth login`, que te deja pegar el código de inicio de sesión.
5. En redes corporativas con proxy, puede que necesites definir la variable de entorno `HTTPS_PROXY`.

Para entornos de CI sin navegador, usa la clave de API descrita en la sección de autenticación.

### Problemas específicos de Windows

- **`running scripts is disabled on this system`**: la política de ejecución de PowerShell bloquea los lanzadores `.ps1` que crea npm (`npm.ps1`, `claude.ps1`). No afecta a `irm https://claude.ai/install.ps1 | iex`. Soluciones: permitir scripts locales para tu usuario con el comando de abajo, usar `npm.cmd` y `claude.cmd`, o cambiar al instalador de PowerShell.

```powershell
Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned
```

- **`The process cannot access the file` al instalar**: otra ventana sigue con el instalador o el antivirus está analizando la descarga. Cierra las demás ventanas de PowerShell, borra la carpeta de descargas y repite:

```powershell
Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\downloads"
irm https://claude.ai/install.ps1 | iex
```

- **`Claude Code does not support 32-bit Windows`**: casi siempre significa que abriste **Windows PowerShell (x86)**. Ejecuta `[Environment]::Is64BitOperatingSystem`; si responde `True`, abre la entrada sin «(x86)» y repite la instalación.
- **VS Code dice `Could not locate the Claude CLI on PATH`**: ocurre en Windows cuando la terminal integrada usa PowerShell. Abre PowerShell fuera de VS Code y ejecuta `where.exe claude`; si no devuelve ruta, añade la carpeta al PATH como variable de entorno de usuario o del sistema (no solo en tu perfil de PowerShell) y reinicia VS Code, que lee el PATH al arrancar.
- **Al escribir `claude` se abre la app de escritorio**: una versión antigua de la app registró su propio `Claude.exe`; actualiza la app de escritorio.

### Problemas de red y proxy

Las redes corporativas con proxy pueden bloquear el script de instalación o el inicio de sesión. Si `curl` agota el tiempo durante la instalación, configura el proxy antes de ejecutar el instalador:

```bash
export HTTPS_PROXY=http://proxy.yourcompany.com:8080
export HTTP_PROXY=http://proxy.yourcompany.com:8080
curl -fsSL https://claude.ai/install.sh | bash
```

Si el instalador falla con `syntax error near unexpected token '<'` o con un `403`, la URL de instalación devolvió una página web o un error en lugar del script. Si el mensaje cita «App unavailable in region», Claude Code no está disponible en tu país. Si no, puede ser un corte temporal (espera unos minutos y repite), un problema de red o un proxy o cortafuegos corporativo que bloquea la descarga; en ese caso, pide a tu departamento de TI que permita `claude.ai` y `downloads.claude.ai`. Como alternativa, `brew install --cask claude-code` en Mac o `winget install Anthropic.ClaudeCode` en Windows.

### Rendimiento lento después de la instalación

Si Claude Code arranca pero responde despacio, revisa primero si la conversación se ha alargado mucho: `/compact` resume el historial y libera contexto. Para que no lea carpetas o archivos que no te interesan, no sirve un archivo `.claudeignore`: según la [documentación de permisos de Claude Code](https://code.claude.com/docs/es/permissions), ese archivo no tiene ningún efecto. Usa reglas `Read` en `permissions.deny` de tu `settings.json`:

```json
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./secrets/**)",
      "Read(./dist/**)"
    ]
  }
}
```

## ¿Qué plan de Claude Code es el adecuado para ti?

La decisión depende de cuánto usas Claude Code y de si lo pagas tú o tu empresa. Los precios están en la tabla de [Elegir la cuenta adecuada](#elegir-la-cuenta-adecuada); estas son las reglas para elegir:

- **Claude Pro (USD 20 al mes, USD 17 con pago anual)**: el punto de partida para uso individual. Incluye Claude Code en la terminal y en la app de escritorio, con límites de uso. Si te sorprende el mensaje de límite alcanzado, [Claude Code: cómo resolver Rate limit reached y retomar la tarea](https://blog.laozhang.ai/es/posts/claude-code-rate-limit-reached) explica qué límite es y cuándo se restablece.
- **Claude Max 5x (USD 100) o 20x (USD 200)**: cuando chocas con los límites de Pro de forma habitual. Multiplica por 5 o por 20 el uso de Pro e incluye entre USD 100 y USD 200 al mes en créditos de API.
- **Team**: puesto estándar a USD 25 por persona al mes (USD 20 con pago anual) con facturación y administración centralizadas; el puesto premium, a USD 125 (USD 100 anual), da 5 veces el uso del estándar.
- **Anthropic Console (pago por uso)**: para uso esporádico o solo en pipelines de CI/CD. Cargas créditos y pagas por token consumido, sin suscripción.

Si quieres probar antes de pagar, [Prueba gratis de Claude Pro: pase de 7 días y quién puede usarlo](https://blog.laozhang.ai/es/posts/claude-pro-free-trial) resume las opciones vigentes.

## Comparación de métodos de instalación de un vistazo

| Método | Plataforma | Comando | Actualización automática | Dependencias | Ideal para |
|--------|-----------|---------|-------------------|-------------|-----------|
| Nativo (script) | macOS, Linux, WSL | `curl -fsSL https://claude.ai/install.sh \| bash` | Sí | Ninguna | La mayoría de usuarios |
| Nativo PowerShell | Windows | `irm https://claude.ai/install.ps1 \| iex` | Sí | Ninguna (Git for Windows opcional) | Usuarios de Windows |
| Nativo CMD | Windows | `curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd` | Sí | Ninguna | Entornos sin PowerShell |
| Homebrew | macOS, Linux | `brew install --cask claude-code` | No (`brew upgrade`) | Homebrew | Quien ya usa Homebrew |
| WinGet | Windows | `winget install Anthropic.ClaudeCode` | No (`winget upgrade`) | WinGet | Software gestionado por la empresa |
| apt, dnf, apk | Debian, Ubuntu, Fedora, RHEL, Alpine | Repositorio oficial firmado | Con el gestor del sistema | El gestor de paquetes | Servidores Linux |
| npm | Todas | `npm install -g @anthropic-ai/claude-code` | Sí, si la carpeta global de npm es escribible | Node.js 22+ | Entornos que ya gestionan herramientas con npm |
| WSL | Windows | Comando de Linux dentro de WSL | Sí | WSL 2 (o WSL 1) | Desarrollo orientado a Linux |

El instalador nativo es el método recomendado para casi todo el mundo: no depende de nada y se actualiza solo. Homebrew, WinGet y los repositorios de Linux son buenas alternativas si prefieres un gestor de paquetes y no te importa actualizar a mano. npm sigue soportado; tiene sentido si ya gestionas tus herramientas con Node.js. Para elegir método, actualizar o desinstalar con más detalle, consulta [Cómo instalar Claude Code: guía completa de configuración para todas las plataformas (2026)](https://blog.laozhang.ai/es/posts/claude-code-install).

## Preguntas frecuentes sobre la instalación de Claude Code

### ¿Claude Code requiere Node.js?

No. El instalador nativo, Homebrew, WinGet, los repositorios de Linux y la app de escritorio no necesitan Node.js. Solo la instalación por npm lo pide (Node.js 22 o posterior), e incluso así el `claude` instalado no usa Node.js al ejecutarse.

### ¿Puedo usar Claude Code en Apple Silicon?

Sí. El instalador nativo detecta la arquitectura y descarga el binario ARM64 en Macs con Apple Silicon, y la app de escritorio para Mac es una sola descarga universal para Apple Silicon e Intel.

### ¿Dónde se instala Claude Code?

Con el instalador nativo, en `~/.local/bin/claude` en macOS, Linux y WSL (enlace a `~/.local/share/claude/versions/`) y en `%USERPROFILE%\.local\bin\claude.exe` en Windows. La configuración y el historial están en `~/.claude/`. Con Homebrew queda en la carpeta de Homebrew, y con npm en la carpeta global de npm.

### ¿Cómo desinstalo completamente Claude Code?

No existe un comando `claude uninstall`; depende de cómo lo instalaste. Instalación nativa en macOS, Linux o WSL: `rm -f ~/.local/bin/claude` y `rm -rf ~/.local/share/claude`. En Windows PowerShell: `Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force` y `Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force`. Homebrew: `brew uninstall --cask claude-code`. WinGet: `winget uninstall Anthropic.ClaudeCode`. npm: `npm uninstall -g @anthropic-ai/claude-code`. La carpeta `~/.claude/` (ajustes, historial, servidores MCP) se queda hasta que la borres tú; la extensión de VS Code, el plugin de JetBrains y la app de escritorio la vuelven a crear si siguen instalados.

### ¿Puedo usar Claude Code sin suscripción?

No con una cuenta gratuita de Claude: el plan gratuito no incluye Claude Code. La alternativa sin suscripción es una cuenta de Anthropic Console con créditos de API, en la que pagas por tokens consumidos, o un proveedor de nube como Amazon Bedrock.

### ¿Claude Code funciona en VS Code?

Sí. Hay una extensión oficial para VS Code y un plugin para JetBrains. La extensión de VS Code trae su propia copia de Claude Code para su panel de chat y no añade `claude` al PATH; si también quieres usarlo en la terminal, instala el CLI con los comandos de arriba. Para comprobar con qué cuenta trabaja la extensión, mira [Comprobar la cuenta de Claude Code en VS Code: /status, inicio de sesión y ruta API](https://blog.laozhang.ai/es/posts/check-claude-code-vscode-account).

### ¿Existe una aplicación de escritorio para Claude Code?

Sí: la app de escritorio de Claude incluye Claude Code en su pestaña Code. Se descarga para macOS (universal, Intel y Apple Silicon), Windows (x64 y ARM64) y, en beta, Linux con apt o `.deb`. La pestaña Code pide un plan de pago. La app no instala el comando `claude` de la terminal; si lo quieres también, instálalo aparte. Comparten la carpeta de configuración `~/.claude/`. Y si no quieres instalar nada, [Claude Code en la web: del navegador a tu primer PR](https://blog.laozhang.ai/es/posts/claude-code-web-interface) explica cómo usarlo desde el navegador.

## Próximos pasos después de instalar Claude Code

Con Claude Code funcionando, tres pasos sacan más partido a la instalación. Primero, ejecuta `/init` en tu proyecto para generar el `CLAUDE.md`: con ese contexto, las respuestas encajan mucho mejor con tu código. Segundo, escribe `/help` para ver los comandos integrados, con atajos para revisar código, crear commits o escribir pruebas. Tercero, conecta servidores MCP (Model Context Protocol) para que Claude Code acceda directamente a tus herramientas y fuentes de datos.

Si estás comparando Claude Code con otros agentes, [OpenClaw vs Claude Code: diferencias, costes y cómo usarlos juntos](https://blog.laozhang.ai/es/posts/openclaw-vs-claude-code) repasa en qué destaca cada uno. Si ya lo usas a diario y topas con los límites, [Claude Code: cómo resolver Rate limit reached y retomar la tarea](https://blog.laozhang.ai/es/posts/claude-code-rate-limit-reached) explica qué hacer cuando aparece el aviso. Y si te interesa OpenClaw por su cuenta, la [Guía completa de OpenClaw: configuración API, modelos y costes](https://blog.laozhang.ai/es/posts/openclaw-api-guide) cubre cómo conectarle modelos por API.

## Fuentes

Páginas externas que cita esta guía, en el orden en que aparecen. Última actualización: 2026-10-21.

- [documentación oficial de configuración de Claude Code](https://code.claude.com/docs/es/setup) (code.claude.com)
- [página de precios de Claude](https://claude.com/pricing) (claude.com)
- [guía de inicio de la app de escritorio](https://code.claude.com/docs/es/desktop-quickstart) (code.claude.com)
- [página de descarga de Claude](https://claude.com/download) (claude.com)
- [país admitido por Anthropic](https://www.anthropic.com/supported-countries) (anthropic.com)
- [guía de solución de problemas de instalación de Claude Code](https://code.claude.com/docs/es/troubleshoot-install) (code.claude.com)
- [claude.ai](https://claude.ai/) (claude.ai)
- [documentación de permisos de Claude Code](https://code.claude.com/docs/es/permissions) (code.claude.com)
