Permisos de Claude Code en settings.json: allow, ask y deny
En la práctica/ 14 min de lectura
Permisos de Claude Code en settings.json: qué hacen allow, ask y deny, qué archivo gana y un juego de reglas listo para un proyecto Node o Next.js.
- IA
- Seguridad
- Claude Code
En este artículo (10)
- Aprobar todo o aprobar cada cosa: los modos de permisos de Claude Code
- allow: lo que Claude puede hacer sin preguntarte
- deny: lo que nunca debe tocar
- ask: lo que te pregunta siempre
- .claude/settings.json en el repo para todo el equipo
- settings.local.json: ajustes locales que no se suben
- Ejemplos listos para un proyecto Node/Next.js
- Errores comunes
- Preguntas frecuentes
- Checklist
Los permisos de Claude Code se configuran en settings.json con tres listas: allow (lo que hace sin preguntar), ask (lo que siempre te pregunta) y deny (lo que nunca puede hacer). Claude Code revisa primero deny, luego ask y al final allow, y la primera regla que coincide decide, sin importar cuál sea más específica.
Con esas tres listas puedes dejar que Claude trabaje en modo automático sin miedo a que lea tu .env o haga un push sin avisar. Aquí tienes los archivos que usamos para un proyecto Node/Next.js, dónde va cada uno, qué archivo gana cuando dos se contradicen y los errores que hacen que una regla no haga nada. Todo está revisado contra la documentación oficial el 19 de noviembre de 2026.
Aprobar todo o aprobar cada cosa: los modos de permisos de Claude Code
Antes de las reglas está el modo. El modo decide qué pasa con todo lo que ninguna regla menciona. Según la documentación de modos de permisos, hay seis:
| Modo | Qué corre sin preguntarte | Para qué |
|---|---|---|
default (Manual) | Solo lecturas | Revisar cada acción |
acceptEdits | Lecturas, ediciones y comandos de archivos como mkdir o mv dentro del proyecto | Iterar y revisar con git diff al final |
plan | Lecturas; no edita tu código hasta que apruebas el plan | Explorar antes de cambiar |
auto | Casi todo, revisado por un modelo clasificador en segundo plano | Tareas largas sin interrupciones |
dontAsk | Lecturas y lo preaprobado; lo demás se rechaza sin preguntar | CI y scripts |
bypassPermissions | Todo | Solo contenedores o máquinas virtuales aisladas |
Cambias de modo con Shift+Tab en la terminal, al arrancar con claude --permission-mode plan o por defecto con permissions.defaultMode. Desde la versión 2.1.283, auto es el modo con el que arrancan las sesiones interactivas en la terminal y en VS Code, así que muchos ya trabajan en modo automático sin haberlo elegido.
El modo automático no es un permiso para todo. La lista de lo que el clasificador permite por defecto incluye leer el .env y mandar credenciales a la API que les corresponde, y hacer push a cualquier rama del repositorio en el que trabajas. Si no quieres eso, el clasificador no te lo va a impedir: lo impiden tus reglas. La documentación es explícita en dos puntos: las reglas deny bloquean en todos los modos, incluido bypassPermissions, y las reglas ask siguen preguntando en modo auto. También avisa que un límite que le dices a Claude en el chat («no hagas push») se puede perder cuando la conversación se compacta; para una garantía, una regla deny.
allow: lo que Claude puede hacer sin preguntarte
Cada regla tiene la forma Herramienta o Herramienta(especificador). Bash sola cubre todos los comandos; Bash(npm run build) cubre solo ese comando exacto. El asterisco reemplaza cualquier texto, espacios incluidos, y estas tres reglas de la documentación de permisos explican casi todos los casos:
- Un
*final con un espacio antes también cubre el comando solo.Bash(npm run test *)cubrenpm run testynpm run test -- --watch. - El espacio cuenta.
Bash(ls *)no cubrelsof;Bash(ls*)sí. - Pon el asterisco después del subcomando.
Bash(git log *)permite sologit log;Bash(git *)permite cualquier comando de git, push incluido.
El sufijo :* es otra forma de escribir el asterisco final: Bash(ls:*) equivale a Bash(ls *). Solo funciona al final; en Bash(git:* push) los dos puntos se leen como texto y la regla no cubre nada útil.
No agregues a allow lo que ya corre sin preguntar. Claude Code trae un grupo fijo de comandos de solo lectura (ls, cat, grep, find, wc, diff y las formas de solo lectura de git, entre otros) que no piden permiso en ningún modo. Tampoco esperes que una regla cubra comandos encadenados: con &&, ; o |, cada parte tiene que estar permitida por separado, así que Bash(npm test) no aprueba npm test && git push. En Windows, las reglas PowerShell(...) tienen la misma forma.
Dos detalles más. Las reglas allow del .claude/settings.json de un repositorio se aplican solo después de que aceptas el diálogo de confianza de esa carpeta. Y al entrar en modo auto, Claude Code desactiva las reglas amplias que permiten ejecutar cualquier código, como Bash(*), intérpretes con comodín (Bash(python*)) y los comandos run de los gestores de paquetes. Esos comandos no se bloquean: pasan a la revisión del clasificador. Las reglas estrechas como Bash(npm test) siguen activas, y Claude Code restaura las demás cuando sales del modo auto.
Desliza la figura para verla completa
deny: lo que nunca debe tocar
Para que Claude no lea un archivo, usa Read en deny. Las rutas siguen la sintaxis de .gitignore: Read(.env) y Read(**/.env) son equivalentes y bloquean cualquier .env dentro del proyecto, a cualquier profundidad. Un Read en deny también bloquea Edit y Write sobre esa ruta, así que Claude tampoco puede crear ni sobrescribir el archivo. La regla alcanza a los comandos de archivos que Claude Code reconoce en la terminal, como cat, head o sed, y a las redirecciones como < .env.
Dónde empieza una ruta depende de cómo la escribas:
~/rutaparte de tu carpeta personal:Read(~/.ssh/**).//rutaes absoluta desde la raíz del disco. En Windows,C:\Users\tuse lee como/c/Users/tu./ruta, con una sola barra, no es absoluta: parte de la carpeta del archivo de settings. En el proyecto es la raíz del proyecto; en~/.claude/settings.jsones~/.claude.- Una regla que empieza con
!saca rutas de las reglas anteriores del mismo archivo:Read(!.env.example)después deRead(**/.env.*)deja leer la plantilla.
Ahora, los límites, porque una regla deny no es un muro. Una regla Bash compara el texto del comando tal como Claude lo escribe: Bash(curl *) detiene curl https://ejemplo.com, pero no /usr/bin/curl ni sh -c 'curl ...'. Y un Read en deny no alcanza a grep -r clave . ni a un script de Node que abre el archivo por su cuenta. Para un bloqueo a nivel del sistema operativo, la documentación recomienda el sandbox; para revisar cada comando con tu propia lógica, un hook PreToolUse, que es lo que armamos en el hook para proteger tu .env. Las dos cosas se suman a las reglas, no las reemplazan.
Si el secreto vive en una variable NEXT_PUBLIC_, ninguna regla lo protege: ya está en el JavaScript que descarga el navegador. Lo explicamos en variables NEXT_PUBLIC_ y secretos.
ask: lo que te pregunta siempre
ask es la lista que hace que el modo automático sea tranquilo. Según la referencia de settings, una regla ask te pregunta incluso en un modo que lo habría aprobado solo, como acceptEdits o bypassPermissions, y en modo auto ninguna regla ask pasa por el clasificador: te llega a ti. En dontAsk, como no hay nadie a quien preguntar, se rechaza.
Las reglas ask y deny se aplican a cualquier parte de un comando encadenado, incluso dentro de una subshell o una sustitución: con Bash(git push *) en ask, npm test && git push también te pregunta. Úsala para lo que sale de tu máquina o no se deshace fácil: git push, instalar o quitar dependencias, borrar archivos, peticiones de red con curl.
El orden importa aquí más que en ningún lado. Como deny se revisa antes que ask, puedes poner Bash(git push --force *) en deny y Bash(git push *) en ask: el push con --force al inicio se bloquea y el push normal te pregunta. Y como ask se revisa antes que allow, una regla allow más específica no te salva del aviso.
.claude/settings.json en el repo para todo el equipo
Claude Code lee cuatro archivos y, si tu organización lo configura, uno administrado. La documentación de settings los ordena así, del que más manda al que menos:
- Administrado (
managed-settings.json, MDM o la consola de claude.ai): nada de lo que está abajo lo cambia. - Línea de comandos:
claude --settings <archivo o JSON>, solo para esa sesión. - Local del proyecto:
.claude/settings.local.json. - Proyecto compartido:
.claude/settings.json. - Usuario:
~/.claude/settings.json.
Ese orden decide cuando un mismo valor sencillo, como defaultMode, aparece en dos archivos. Con las listas es distinto: allow, ask y deny se suman entre archivos, y un deny en cualquier nivel bloquea aunque otro archivo lo permita. Si tu archivo de usuario permite algo y el del proyecto lo niega, gana el deny; y al revés también.
Desliza la figura para verla completa
El .claude/settings.json se sube a git para que todo el equipo tenga las mismas reglas. Tres cosas que conviene saber antes de hacer commit:
- Sus reglas
denyyaskaplican desde el primer momento; lasallowesperan a que cada persona confíe en la carpeta. "defaultMode": "auto"y"bypassPermissions"no tienen efecto desde este archivo ni desde el local. Si quieres arrancar en auto, va en~/.claude/settings.json.- Es JSON estricto: un comentario
//o una coma final rompen el archivo y Claude Code lo reporta como Settings Error. La línea$schemate da autocompletado en el editor.
Para ver qué cargó, usa /permissions, que lista cada regla con el archivo del que viene, y /status, cuya línea Setting sources dice qué archivos se leyeron. claude doctor muestra las entradas que Claude Code rechazó.
settings.local.json: ajustes locales que no se suben
.claude/settings.local.json es tuyo: aplica solo a ti y solo en ese proyecto, y está por encima del archivo compartido. Cuando eliges «Yes, and don't ask again» en un aviso de Bash, Claude Code guarda ahí la regla allow, en la raíz del repositorio; en Windows, fuera de un repositorio o cuando la raíz es tu carpeta personal, lo guarda junto a .claude/settings.json. La primera vez que lo escribe, Claude Code agrega **/.claude/settings.local.json a tus exclusiones globales de git. Si lo creas a mano, agrégalo tú al .gitignore: si git lo rastrea, Claude Code lo trata como archivo del repositorio y sus reglas allow esperan la confianza de la carpeta.
Es el lugar para reglas que solo tienen sentido en tu máquina, como un servidor MCP que registraste solo para ti. En el servidor MCP de Postgres de solo lectura lo llamamos postgres-ro; sus herramientas se escriben mcp__postgres-ro__*. Las reglas mcp__ van sin paréntesis: si les pones uno, Claude Code las ignora al cargar el archivo.
Un detalle que confunde: una regla allow en tu archivo local no le gana a una regla ask del proyecto ni de tu organización. Si respondiste «don't ask again» y te sigue preguntando, alguien tiene una regla ask que cubre ese comando.
Ejemplos listos para un proyecto Node/Next.js
Este es el .claude/settings.json que proponemos para un proyecto con npm. Validado contra el schema publicado de Claude Code:
{
"$schema": "https://json.schemastore.org/claude-code-settings.json",
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run typecheck)",
"Bash(npm run build)",
"Bash(npm test)",
"Bash(npm run test *)"
],
"ask": [
"Bash(git commit *)",
"Bash(git push *)",
"Bash(npm install *)",
"Bash(npm i *)",
"Bash(rm *)",
"Bash(curl *)"
],
"deny": [
"Read(**/.env)",
"Read(**/.env.*)",
"Read(!.env.example)",
"Read(secrets/**)",
"Read(**/*.pem)",
"Bash(git push --force *)",
"Bash(npm publish *)"
]
}
}
$schemaactiva el autocompletado; el schema revisa la forma del archivo, no si una regla tiene sentido.- Las cuatro primeras reglas de
allowson comandos exactos: no aceptan argumentos extra. Cambia los nombres por los scripts de tupackage.json. Bash(npm run test *)cubrenpm run testy sus argumentos, pero nonpm run test:e2e, porque el espacio es parte de la regla. Si tienes ese script, agrégalo aparte.git commitygit pushvan enask: ves el mensaje y la rama antes de que salgan.npm installynpm ison reglas distintas: las reglas de Bash comparan texto y no conocen alias.rmycurlte preguntan en vez de bloquearse, porque borrar.nexto probarlocalhostson tareas normales.Read(**/.env)yRead(**/.env.*)bloquean.env,.env.localy.env.productiona cualquier profundidad;Read(!.env.example)deja leer la plantilla, que no tiene valores reales.Read(secrets/**), al ser deny, bloquea cualquier carpetasecretsdel proyecto;Read(**/*.pem)cubre llaves y certificados.git push --forceva en deny aunquegit pushesté en ask: deny se revisa primero.npm publishva en deny porque una versión publicada no se puede reemplazar.
Desliza la figura para verla completa
Para tu máquina, en ~/.claude/settings.json, bloquea lo que vive fuera de los proyectos. Fíjate en ~/: con una sola /, la regla apuntaría a ~/.claude.
{
"permissions": {
"defaultMode": "acceptEdits",
"deny": [
"Read(~/.ssh/**)",
"Read(~/.aws/**)",
"Read(~/.npmrc)"
]
}
}
Si prefieres arrancar en modo auto, cambia acceptEdits por auto en este archivo: es el único de los tuyos donde ese valor tiene efecto. En la guía está check-permissions.mjs, un script de Node sin dependencias que revisa los errores de este artículo en tus archivos. Este es su resultado con los archivos de arriba y con un proyecto de prueba que escribimos con errores a propósito:
$ node check-permissions.mjs .claude/settings.json .claude/settings.local.json
OK .claude/settings.json
OK .claude/settings.local.json
$ node check-permissions.mjs .claude/settings.json .claude/settings.local.json
FAIL .claude/settings.json
- allow: Bash approves any program
- allow: Bash(git:* push) has ":*" before the end, where the colon is literal
- allow: mcp__github__get_issue(owner:acme) is skipped: mcp__ rules take no parentheses in a settings file
- deny: Write(.env) never matches a path; write Edit(...) or Read(...)
- deny: Grep(secrets/**) never matches a path; write Edit(...) or Read(...)
- defaultMode "auto" has no effect in a project or local file
- no Read deny rule for .env files
FAIL .claude/settings.local.json
- not valid JSON (no comments, no trailing commas): Expected property name or '}' in JSON at position 4 (line 2 column 3)
El schema oficial aceptó ese archivo roto sin quejarse: valida que cada regla tenga forma de regla, no que haga lo que crees. El script no reemplaza a Claude Code; solo marca trampas que la documentación describe.
Errores comunes
- Creer que la regla más específica gana. Gana el orden: deny, ask, allow. Un allow no abre un hueco en un deny.
- Poner
"defaultMode": "auto"en el repositorio. No tiene efecto desde.claude/settings.jsonni desde el local; va en~/.claude/settings.json. Write(.env)oGrep(secrets/**). Las reglas deWrite,GlobyGrepcon ruta no coinciden con nada; usaEdit(...)oRead(...)./secrets/**en tu archivo de usuario. Una sola barra apunta a~/.claude/secrets; usa~/o//.- Tratar una regla de Bash como frontera de seguridad.
/usr/bin/curlysh -cla esquivan; para eso está el sandbox. - Comentarios en el JSON. Rompen el archivo entero; explica las reglas en el README o en el commit.
- Subir
settings.local.jsona git. Tus reglas pasan a ser del repositorio y esperan la confianza de cada persona.
Preguntas frecuentes
¿Las reglas deny funcionan en modo auto y en bypassPermissions?
Sí. La documentación dice que deny bloquea en todos los modos, incluido bypassPermissions. Lo que deja de aplicar en bypassPermissions son las reglas allow, porque ya todo está permitido.
¿Por qué me sigue preguntando si elegí «Yes, and don't ask again»?
Esa respuesta guarda un allow en tu archivo local, y un allow nunca le gana a un ask. Busca con /permissions la regla ask que cubre el comando y de qué archivo viene.
¿Necesito reglas si ya uso el modo automático?
Sí, si hay algo que no debe pasar nunca. El clasificador permite por defecto leer el .env y hacer push a tu repositorio, y lo que le dices en el chat se puede perder al compactar la conversación. Las reglas están en un archivo y no dependen del contexto.
¿Reglas de permisos o un hook?
Primero reglas: son declarativas y fáciles de revisar en un diff. Un hook PreToolUse sirve cuando necesitas lógica, como revisar el texto completo de un comando; un hook que sale con código 2 bloquea antes de que se revisen las reglas.
Checklist
.claude/settings.jsonen git con$schemay las tres listas.allowsolo con comandos exactos o con el asterisco después del subcomando.askpara push, commits, dependencias, borrados y red.denypara.env,.env.*, llaves y lo que no se deshace..claude/settings.local.jsonfuera de git.defaultModeenauto, si lo quieres, solo en~/.claude/settings.json.- Rutas de usuario con
~/o//, nunca con una sola/. /permissionsy/statusmuestran lo que esperas.- Pediste a Claude leer el
.envy lo rechazó.
¿Viste esto en Instagram? Comenta PERMISOS en el Reel y te mando la guía.
Escrito por

Publicado el 19 de noviembre de 2026