Saltar al contenido

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)
  1. Aprobar todo o aprobar cada cosa: los modos de permisos de Claude Code
  2. allow: lo que Claude puede hacer sin preguntarte
  3. deny: lo que nunca debe tocar
  4. ask: lo que te pregunta siempre
  5. .claude/settings.json en el repo para todo el equipo
  6. settings.local.json: ajustes locales que no se suben
  7. Ejemplos listos para un proyecto Node/Next.js
  8. Errores comunes
  9. Preguntas frecuentes
  10. 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:

ModoQué corre sin preguntartePara qué
default (Manual)Solo lecturasRevisar cada acción
acceptEditsLecturas, ediciones y comandos de archivos como mkdir o mv dentro del proyectoIterar y revisar con git diff al final
planLecturas; no edita tu código hasta que apruebas el planExplorar antes de cambiar
autoCasi todo, revisado por un modelo clasificador en segundo planoTareas largas sin interrupciones
dontAskLecturas y lo preaprobado; lo demás se rechaza sin preguntarCI y scripts
bypassPermissionsTodoSolo 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 *) cubre npm run test y npm run test -- --watch.
  • El espacio cuenta. Bash(ls *) no cubre lsof; Bash(ls*) sí.
  • Pon el asterisco después del subcomando. Bash(git log *) permite solo git 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.

orden de evaluación: deny, luego ask, luego allowllamada de Claudegit push origin mainun comando, tres listasrevisadas siempre en este ordendenyBash(git push --force *)si coincide: bloqueadagit push origin main no coincide: pasa a askaskBash(git push *)coincide: te preguntaaquí se decide: la primera que coincide ganaallowBash(git push origin main)más específica, llega tardeno se evalúa: ask ya decidiósi ninguna regla coincide, decide el modo de permisoslo específico no gana: gana el ordenfuente: documentación de permisos de Claude Code

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:

  • ~/ruta parte de tu carpeta personal: Read(~/.ssh/**).
  • //ruta es absoluta desde la raíz del disco. En Windows, C:\Users\tu se 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.json es ~/.claude.
  • Una regla que empieza con ! saca rutas de las reglas anteriores del mismo archivo: Read(!.env.example) después de Read(**/.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:

  1. Administrado (managed-settings.json, MDM o la consola de claude.ai): nada de lo que está abajo lo cambia.
  2. Línea de comandos: claude --settings <archivo o JSON>, solo para esa sesión.
  3. Local del proyecto: .claude/settings.local.json.
  4. Proyecto compartido: .claude/settings.json.
  5. 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.

archivos de settings: el de más arriba gana1 administradamanaged-settings.json, MDM o consolala pone tu organización; nada abajo la cambia2 línea de comandosclaude --settings <archivo o JSON>solo para esa sesión3 local del proyecto.claude/settings.local.jsonsolo tú, en este proyecto; fuera de git4 proyecto compartido.claude/settings.jsonen git para todo el equipo; allow espera la confianza5 usuario~/.claude/settings.jsontú, en todos tus proyectoslas listas allow, ask y deny se sumanun deny en cualquier archivo bloquea aunque otro archivo lo permita

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 deny y ask aplican desde el primer momento; las allow esperan 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 $schema te 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 *)"
    ]
  }
}
  1. $schema activa el autocompletado; el schema revisa la forma del archivo, no si una regla tiene sentido.
  2. Las cuatro primeras reglas de allow son comandos exactos: no aceptan argumentos extra. Cambia los nombres por los scripts de tu package.json.
  3. Bash(npm run test *) cubre npm run test y sus argumentos, pero no npm run test:e2e, porque el espacio es parte de la regla. Si tienes ese script, agrégalo aparte.
  4. git commit y git push van en ask: ves el mensaje y la rama antes de que salgan.
  5. npm install y npm i son reglas distintas: las reglas de Bash comparan texto y no conocen alias.
  6. rm y curl te preguntan en vez de bloquearse, porque borrar .next o probar localhost son tareas normales.
  7. Read(**/.env) y Read(**/.env.*) bloquean .env, .env.local y .env.production a cualquier profundidad; Read(!.env.example) deja leer la plantilla, que no tiene valores reales.
  8. Read(secrets/**), al ser deny, bloquea cualquier carpeta secrets del proyecto; Read(**/*.pem) cubre llaves y certificados.
  9. git push --force va en deny aunque git push esté en ask: deny se revisa primero.
  10. npm publish va en deny porque una versión publicada no se puede reemplazar.
reglas para un proyecto Node/Next.jslistareglapor quéallowBash(npm run lint)solo ese comando exactoallowBash(npm run test *)test con cualquier argumentoaskBash(git push *)el modo auto haría push; decides túaskBash(npm install *)una dependencia nuevaaskBash(rm *)borrar archivosdenyRead(**/.env)también bloquea Edit y Write ahídenyRead(**/.env.*).env.local, .env.productiondenyBash(npm publish *)publicar no se deshacelo de todos los días en allow, lo que sale en asksecretos y lo irreversible en deny

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.json ni desde el local; va en ~/.claude/settings.json.
  • Write(.env) o Grep(secrets/**). Las reglas de Write, Glob y Grep con ruta no coinciden con nada; usa Edit(...) o Read(...).
  • /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/curl y sh -c la 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.json a 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.json en git con $schema y las tres listas.
  • allow solo con comandos exactos o con el asterisco después del subcomando.
  • ask para push, commits, dependencias, borrados y red.
  • deny para .env, .env.*, llaves y lo que no se deshace.
  • .claude/settings.local.json fuera de git.
  • defaultMode en auto, si lo quieres, solo en ~/.claude/settings.json.
  • Rutas de usuario con ~/ o //, nunca con una sola /.
  • /permissions y /status muestran lo que esperas.
  • Pediste a Claude leer el .env y lo rechazó.

¿Viste esto en Instagram? Comenta PERMISOS en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 19 de noviembre de 2026

← Blog