> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Elige un modo de permisos
> Controla si Claude pregunta antes de editar archivos o ejecutar comandos. Cicla entre modos con Shift+Tab en la CLI o usa el selector de modo en VS Code, Desktop y claude.ai.
Cuando Claude quiere editar un archivo, ejecutar un comando de shell o hacer una solicitud de red, se detiene y te pide que apruebes la acción. Los modos de permisos controlan con qué frecuencia ocurre esa pausa. El modo que elijas forma el flujo de una sesión: el modo predeterminado te hace revisar cada acción a medida que llega, mientras que los modos más flexibles permiten que Claude trabaje en tramos más largos sin interrupciones e informe cuando haya terminado. Elige más supervisión para trabajo sensible, o menos interrupciones cuando confías en la dirección.
Modos disponibles
Cada modo hace un compromiso diferente entre conveniencia y supervisión. La tabla a continuación muestra qué puede hacer Claude sin un aviso de permisos en cada modo.
| Modo | Lo que se ejecuta sin preguntar | Mejor para |
| :------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------- | :---------------------------------------------- |
| `default` | Solo lecturas | Comenzar, trabajo sensible |
| [`acceptEdits`](#auto-approve-file-edits-with-acceptedits-mode) | Lecturas, ediciones de archivos y comandos comunes del sistema de archivos (`mkdir`, `touch`, `mv`, `cp`, etc.) | Iterar en código que estás revisando |
| [`plan`](#analyze-before-you-edit-with-plan-mode) | Solo lecturas | Explorar una base de código antes de cambiarla |
| [`auto`](#eliminate-prompts-with-auto-mode) | Todo, con verificaciones de seguridad de fondo | Tareas largas, reducir fatiga de avisos |
| [`dontAsk`](#allow-only-pre-approved-tools-with-dontask-mode) | Solo herramientas preaprobadas | CI bloqueado y scripts |
| [`bypassPermissions`](#skip-all-checks-with-bypasspermissions-mode) | Todo | Solo contenedores y máquinas virtuales aisladas |
En todos los modos excepto `bypassPermissions`, las escrituras en [rutas protegidas](#protected-paths) nunca se aprueban automáticamente, protegiendo el estado del repositorio y la configuración propia de Claude contra corrupción accidental.
Los modos establecen la línea base. Superpón [reglas de permisos](/es/permissions#manage-permissions) encima para preaprobación o bloqueo de herramientas específicas. Las reglas de denegación y las reglas de solicitud explícita se aplican en todos los modos, incluido `bypassPermissions`. Las reglas de permiso no tienen efecto en ese modo porque todo lo demás ya está aprobado.
Cambiar modos de permisos
Puedes cambiar modos en medio de una sesión, al inicio o como predeterminado persistente. El modo se establece a través de estos controles, no pidiendo a Claude en el chat. Selecciona tu interfaz a continuación para ver cómo cambiarlo.
**Durante una sesión**: presiona `Shift+Tab` para ciclar `default` → `acceptEdits` → `plan`. El modo actual aparece en la barra de estado. No todos los modos están en el ciclo predeterminado:
* `auto`: aparece cuando tu cuenta cumple los [requisitos del modo auto](#eliminate-prompts-with-auto-mode); ciclar hacia él cambia modos sin un aviso de confirmación
* `bypassPermissions`: aparece después de que inicies con `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, o `--allow-dangerously-skip-permissions`; la variante `--allow-` añade el modo al ciclo sin activarlo
* `dontAsk`: nunca aparece en el ciclo; establécelo con `--permission-mode dontAsk`
Los modos opcionales habilitados se insertan después de `plan`, con `bypassPermissions` primero y `auto` último. Si tienes ambos habilitados, ciclarás a través de `bypassPermissions` en el camino a `auto`.
**Al inicio**: pasa el modo como una bandera.
```bash theme={null}
claude --permission-mode plan
```
**Como predeterminado**: establece `defaultMode` en [settings](/es/settings#settings-files).
```json theme={null}
{
"permissions": {
"defaultMode": "acceptEdits"
}
}
```
La misma bandera `--permission-mode` funciona con `-p` para [ejecuciones no interactivas](/es/headless).
**Durante una sesión**: haz clic en el indicador de modo en la parte inferior del cuadro de solicitud.
**Como predeterminado**: establece `claudeCode.initialPermissionMode` en la configuración de VS Code, o usa el panel de configuración de la extensión Claude Code.
El indicador de modo muestra estas etiquetas, asignadas al modo que cada una aplica:
| Etiqueta de interfaz de usuario | Modo |
| :------------------------------ | :------------------ |
| Pedir antes de editar | `default` |
| Editar automáticamente | `acceptEdits` |
| Modo de planificación | `plan` |
| Modo automático | `auto` |
| Omitir permisos | `bypassPermissions` |
El modo automático aparece en el indicador de modo cuando tu cuenta cumple todos los requisitos listados en la [sección de modo auto](#eliminate-prompts-with-auto-mode). La configuración `claudeCode.initialPermissionMode` no acepta `auto`. Para comenzar en modo auto por defecto, establece `defaultMode` en tu [configuración de usuario](/es/settings#settings-files) en su lugar. Claude Code ignora `defaultMode: "auto"` en la configuración del proyecto y local.
Omitir permisos requiere el interruptor **Permitir omitir permisos peligrosamente** en la configuración de la extensión antes de que aparezca en el indicador de modo.
Consulta la [guía de VS Code](/es/vs-code) para detalles específicos de la extensión.
El plugin de JetBrains ejecuta Claude Code en la terminal del IDE, por lo que cambiar modos funciona igual que en la CLI: presiona `Shift+Tab` para ciclar, o pasa `--permission-mode` al lanzar.
Usa el selector de modo junto al botón de envío. Auto y Omitir permisos aparecen solo después de que los habilites en la configuración de Desktop. Consulta la [guía de Desktop](/es/desktop#choose-a-permission-mode).
Usa el menú desplegable de modo junto al cuadro de solicitud en [claude.ai/code](https://claude.ai/code) o en la aplicación móvil. Los avisos de permisos aparecen en claude.ai para aprobación. Qué modos aparecen depende de dónde se ejecute la sesión:
* **Sesiones en la nube** en [Claude Code en la web](/es/claude-code-on-the-web): Aceptar ediciones, Modo de planificación y Modo automático. Aceptar ediciones corresponde al modo `default`: el entorno en la nube aprueba previamente las ediciones de archivos independientemente del modo, por lo que el menú desplegable muestra Aceptar ediciones en lugar de Pedir permisos. `defaultMode: "acceptEdits"` de la configuración sigue siendo respetado. El modo automático aparece solo cuando tu organización lo permite y el modelo seleccionado lo admite. Omitir permisos no está disponible.
* **Sesiones de [Control remoto](/es/remote-control)** en tu máquina local: Pedir permisos, Aceptar ediciones automáticamente y Modo de planificación. Automático y Omitir permisos no están disponibles.
Para Control remoto, también puedes establecer el modo de inicio al lanzar el host:
```bash theme={null}
claude remote-control --permission-mode acceptEdits
```
Auto-aprobar ediciones de archivos con modo acceptEdits
El modo `acceptEdits` permite que Claude cree y edite archivos en su directorio de trabajo sin solicitar confirmación. La barra de estado muestra `⏵⏵ accept edits on` mientras este modo está activo.
Además de ediciones de archivos, el modo `acceptEdits` auto-aprueba comandos Bash comunes del sistema de archivos: `mkdir`, `touch`, `rm`, `rmdir`, `mv`, `cp`, y `sed`. Estos comandos también se auto-aprueban cuando se prefijan con variables de entorno seguras como `LANG=C` o `NO_COLOR=1`, o envoltorios de procesos como `timeout`, `nice`, o `nohup`. Como las ediciones de archivos, la auto-aprobación se aplica solo a rutas dentro de su directorio de trabajo o `additionalDirectories`. Las rutas fuera de ese alcance, escrituras en [rutas protegidas](#protected-paths), y todos los demás comandos Bash aún solicitan confirmación.
Cuando la [herramienta PowerShell](/es/tools-reference#powershell-tool) está habilitada, el modo `acceptEdits` también auto-aprueba `Set-Content`, `Add-Content`, `Clear-Content`, y `Remove-Item` en rutas dentro del alcance, junto con sus alias comunes. Se aplican las mismas reglas de alcance y rutas protegidas.
Utilice `acceptEdits` cuando desee revisar cambios en su editor o a través de `git diff` después del hecho en lugar de aprobar cada edición en línea. Presione `Shift+Tab` una vez desde el modo predeterminado para entrar en él, o comience directamente con él:
```bash theme={null}
claude --permission-mode acceptEdits
```
Analizar antes de editar con modo de planificación
El modo de planificación le dice a Claude que investigue y proponga cambios sin hacerlos. Claude lee archivos, ejecuta comandos de shell para explorar, y escribe un plan, pero no edita su fuente. Los avisos de permisos aún se aplican igual que en el modo predeterminado.
Entra en modo de planificación presionando `Shift+Tab` o prefijando una solicitud única con `/plan`. También puede comenzar en modo de planificación desde la CLI:
```bash theme={null}
claude --permission-mode plan
```
Presione `Shift+Tab` de nuevo para salir del modo de planificación sin aprobar un plan.
Revisar y aprobar un plan
Cuando el plan está listo, Claude lo presenta y pregunta cómo proceder. Desde ese aviso puede:
* Aprobar e iniciar en modo automático
* Aprobar y aceptar ediciones
* Aprobar y revisar cada edición manualmente
* Continuar planificando con retroalimentación
* Refinar con [Ultraplan](/es/ultraplan) para revisión basada en navegador
Aprobando un plan se sale del modo de planificación y se cambia la sesión al modo de permisos que describe cada opción de aprobación, por lo que Claude comienza a editar. Para planificar de nuevo, vuelva al modo de planificación con `Shift+Tab`, o prefije su siguiente solicitud con `/plan`.
Presione `Ctrl+G` para abrir el plan propuesto en su editor de texto predeterminado y editarlo directamente antes de que Claude continúe. Cuando [`showClearContextOnPlanAccept`](/es/settings#available-settings) está habilitado, cada opción de aprobación también ofrece borrar el contexto de planificación primero.
Aceptar un plan también nombra la sesión a partir del contenido del plan automáticamente, a menos que ya haya establecido un nombre con `--name` o `/rename`.
Establecer el modo de planificación como predeterminado
Para hacer que el modo de planificación sea el predeterminado para un proyecto, establezca `defaultMode` en `.claude/settings.json`:
```json theme={null}
{
"permissions": {
"defaultMode": "plan"
}
}
```
Eliminar avisos de permisos con modo automático
El modo automático requiere Claude Code v2.1.83 o posterior.
El modo automático permite que Claude ejecute sin avisos de permisos rutinarios. Un modelo clasificador separado revisa las acciones antes de que se ejecuten, bloqueando cualquier cosa que escale más allá de su solicitud, apunte a infraestructura no reconocida, o parezca impulsada por contenido hostil que Claude leyó. Las [reglas de solicitud](/es/permissions#manage-permissions) explícitas aún fuerzan un aviso.
El modo automático también instruye a Claude para continuar trabajando sin detenerse para hacer preguntas aclaratorias, aunque Claude aún pregunta cuando su solicitud o una skill depende explícitamente de ello. Para obtener un comportamiento autónomo más fuerte mientras mantiene avisos de permisos, establezca el [estilo de salida proactivo](/es/output-styles) en su lugar.
El modo automático es una vista previa de investigación. Reduce avisos pero no garantiza seguridad. Úselo para tareas donde confía en la dirección general, no como reemplazo para revisión en operaciones sensibles.
El modo automático está disponible solo cuando su cuenta cumple todos estos requisitos:
* **Plan**: Todos los planes.
* **Propietario**: en Team y Enterprise, un Propietario debe habilitarlo en [configuración de administrador de Claude Code](https://claude.ai/admin-settings/claude-code) antes de que los usuarios puedan activarlo. Los administradores también pueden bloquearlo estableciendo `permissions.disableAutoMode` a `"disable"` en [configuración administrada](/es/permissions#managed-settings).
* **Modelo**: en la API de Anthropic, Claude Opus 4.6 o posterior, o Sonnet 4.6 o posterior. En Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry, y sesiones de [puerta de enlace de aplicaciones Claude](/es/claude-apps-gateway) con sesión iniciada, solo Claude Sonnet 5, Opus 4.7 y Opus 4.8. Los modelos más antiguos, incluyendo Sonnet 4.5, Opus 4.5, Haiku, y modelos claude-3, no son compatibles en ningún proveedor.
* **Proveedor**: disponible por defecto en la API de Anthropic. En Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry, y sesiones de puerta de enlace de aplicaciones Claude con sesión iniciada, el modo automático está desactivado hasta que [establezca `CLAUDE_CODE_ENABLE_AUTO_MODE`](#enable-auto-mode-on-bedrock-vertex-ai-or-foundry).
Si Claude Code reporta el modo automático como no disponible, uno de estos requisitos no se cumple; esto no es una interrupción transitoria. Un mensaje separado que nombra un modelo y dice que el modo automático "no puede determinar la seguridad" de una acción es una interrupción transitoria del clasificador; consulte la [referencia de errores](/es/errors#auto-mode-cannot-determine-the-safety-of-an-action).
Si establece `defaultMode: "auto"` en [configuración](/es/settings#available-settings) y la sesión comienza en modo `default` sin error, la configuración probablemente esté en `.claude/settings.json` o `.claude/settings.local.json`. Claude Code v2.1.142 y posterior ignoran `auto` de esos archivos para que un repositorio no pueda otorgarse a sí mismo modo automático. Muévalo a `~/.claude/settings.json`.
Habilitar modo automático en Bedrock, Vertex AI, o Foundry
En [Amazon Bedrock](/es/amazon-bedrock), [Google Cloud Vertex AI](/es/google-vertex-ai), [Microsoft Foundry](/es/microsoft-foundry), y sesiones de [puerta de enlace de aplicaciones Claude](/es/claude-apps-gateway) con sesión iniciada, el modo automático no aparece en el ciclo `Shift+Tab` hasta que `CLAUDE_CODE_ENABLE_AUTO_MODE` se establezca en `1`. La variable funciona en Claude Code v2.1.158 y posterior. Solo Claude Sonnet 5, Opus 4.7 y Opus 4.8 son compatibles en estos proveedores.
Para habilitarlo para un desarrollador, añada la variable al bloque `env` en `~/.claude/settings.json`:
```json theme={null}
{
"env": {
"CLAUDE_CODE_ENABLE_AUTO_MODE": "1"
}
}
```
Para habilitarlo para su organización, añada el mismo bloque `env` a [configuración administrada](/es/settings#settings-files).
Una vez que la variable se establece, el modo automático aparece en el ciclo `Shift+Tab` para cada sesión. Para hacerlo el modo de inicio predeterminado, también establezca `"permissions": {"defaultMode": "auto"}` en configuración de usuario o administrada. En estos proveedores, Claude Code ignora `defaultMode: "auto"` a menos que `CLAUDE_CODE_ENABLE_AUTO_MODE` también se establezca.
Para evitar que los desarrolladores habiliten el modo automático, establezca `disableAutoMode` a `"disable"` en configuración administrada. Esto anula la variable de habilitación.
Si se conecta a través de una [puerta de enlace LLM](/es/llm-gateway) configurada con `ANTHROPIC_BASE_URL`, el modo automático puede ya ser alcanzable sin la variable de habilitación, porque la puerta de enlace enruta solicitudes a través de la API de Anthropic. Esto no se aplica a una sesión de [puerta de enlace de aplicaciones Claude](/es/claude-apps-gateway) con sesión iniciada, que es su propia clase de proveedor y requiere la variable de habilitación. La configuración `disableAutoMode` se aplica de la misma manera en cualquiera de las dos configuraciones.
Qué bloquea el clasificador por defecto
El clasificador confía en su directorio de trabajo y en los remotos configurados de su repositorio. Todo lo demás se trata como externo hasta que [configure infraestructura confiable](/es/auto-mode-config).
**Bloqueado por defecto**:
* Descargar y ejecutar código, como `curl | bash`
* Enviar datos sensibles a puntos finales externos
* Despliegues y migraciones de producción
* Eliminación masiva en almacenamiento en la nube
* Otorgar permisos de IAM o repositorio
* Modificar infraestructura compartida
* Destruir irreversiblemente archivos que existían antes de la sesión
* Push forzado, o empujar directamente a `main`
* {/* min-version: 2.1.182 */}`git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -fd`, `git stash drop`, o `git stash clear`, que el clasificador presume que descartaría cambios sin confirmar
* `git commit --amend` cuando la confirmación en HEAD no fue creada en esta sesión
* `terraform destroy`, `pulumi destroy`, `cdk destroy`, o `terragrunt destroy`, y aplicar un plan que destruye recursos
Claude Code v2.1.195 y posterior bloquean más categorías por defecto. Varias dependen de entradas de [entorno](/es/auto-mode-config#define-trusted-infrastructure), como objetivos remotos sensibles y alcances de IaC protegidos, que puede reducir a nombres concretos.
* Escribir en un gestor de secretos, o cambiar registros DNS o certificados TLS
* Fusionar una solicitud de extracción que ningún humano ha aprobado, aprobar la propia solicitud de extracción de Claude, o deshabilitar verificaciones de CI
* Publicar un comentario que es en sí mismo un comando para automatización, como `atlantis apply` o `/deploy` o `/merge` de un bot
* Alternar, ramificar, o eliminar una bandera de característica de producción
* Aplicar cambios de infraestructura a un alcance de IaC protegido, o drenar y eliminar nodos de clúster
* Escrituras en un clúster de cómputo compartido que van más allá del recurso que nombró, como un selector de etiqueta o `--all` que captura trabajos de otros usuarios
* Crear recursos de Kubernetes que se ejecutan en cada nodo o interceptan tráfico de clúster, como DaemonSets y webhooks de admisión
* Shells interactivos o port-forwards en un objetivo remoto sensible
* Abrir un túnel o shell inverso que hace que un servicio local sea alcanzable desde internet pública
* Imprimir una credencial o token en vivo en la transcripción o un archivo
* Acceder a una ubicación de PII o datos regulados, o copiar datos fuera de una
* Enrutar una instalación de paquete alrededor de su registro de paquetes interno a un registro público
* Ejecutar un comando con una bandera que desactiva una protección de seguridad, como `--insecure`
* Acciones del navegador de [Claude en Chrome](/es/chrome) que podrían enviar contenido de página, cookies, o credenciales fuera de origen
**Permitido por defecto**:
* Operaciones de archivos locales en su directorio de trabajo
* Instalar dependencias declaradas en sus archivos de bloqueo o manifiestos
* Leer `.env` y enviar credenciales a su API coincidente
* Solicitudes HTTP de solo lectura
* Empujar a la rama en la que comenzó o una que Claude creó
Claude Code v2.1.195 y posterior también permiten estos por defecto:
* Eliminar los trabajos exactos que Claude creó anteriormente en la misma sesión
* Leer, revisar, o escribir código relacionado con seguridad, configuraciones, y modelos de amenaza como parte de su tarea
* Mensajes entre agentes trabajando juntos en la misma sesión multiagente
* Enviar datos a los dominios confiables, depósitos, y servicios que lista en [`environment`](/es/auto-mode-config#define-trusted-infrastructure). Esto cubre solo el flujo de datos, no operaciones destructivas o de credenciales en la misma infraestructura
* Navegación de [Claude en Chrome](/es/chrome) a un dominio interno confiable, localhost, o una URL que nombró
Las solicitudes de acceso de red de sandbox se enrutan a través del clasificador en lugar de permitirse por defecto. Ejecute `claude auto-mode defaults` para ver las listas de reglas completas. Si las acciones rutinarias se bloquean, un administrador puede añadir repositorios confiables, depósitos y servicios a través de la configuración `autoMode.environment`: consulte [Configurar modo automático](/es/auto-mode-config).
Límites que establece en la conversación
El clasificador trata los límites que establece en la conversación como una señal de bloqueo. Si le dice a Claude "no empuje" o "espere hasta que revise antes de desplegar", el clasificador bloquea acciones coincidentes incluso cuando las reglas predeterminadas las permitirían. Un límite permanece en vigor hasta que lo levante en un mensaje posterior. El propio juicio de Claude de que se cumplió una condición no lo levanta.
Los límites no se almacenan como reglas. El clasificador los relee de la transcripción en cada verificación, por lo que un límite puede perderse si [la compactación de contexto](/es/costs#reduce-token-usage) elimina el mensaje que lo estableció. Para una garantía dura, añada una [regla de denegación](/es/permissions#permission-rule-syntax) en su lugar.
Cuándo el modo automático retrocede
Cada acción denegada muestra una notificación y aparece en `/permissions` bajo la pestaña Recientemente denegado, donde puede presionar `r` para reintentar con una aprobación manual.
Si el clasificador bloquea una acción 3 veces seguidas o 20 veces en total, el modo automático se pausa y Claude Code reanuda la solicitud. Aprobar la acción solicitada reanuda el modo automático. Estos umbrales no son configurables. Cualquier acción permitida reinicia el contador consecutivo, mientras que el contador total persiste para la sesión y se reinicia solo cuando su propio límite desencadena un retroceso.
En [modo no interactivo](/es/headless) con la bandera `-p`, los bloqueos repetidos abortan la sesión ya que no hay usuario para solicitar.
Los bloqueos repetidos generalmente significan que el clasificador carece de contexto sobre su infraestructura. Use `/feedback` para reportar falsos positivos, o haga que un administrador [configure infraestructura confiable](/es/auto-mode-config).
Cada acción pasa por un orden de decisión fijo. El primer paso coincidente gana:
1. Las acciones que coinciden con sus [reglas de permitir o denegar](/es/permissions#manage-permissions) se resuelven inmediatamente, excepto escrituras en [rutas protegidas](#protected-paths), que se enrutan al clasificador incluso cuando una regla de permitir coincide
2. Las acciones de solo lectura y ediciones de archivos en su directorio de trabajo se auto-aprueban, excepto escrituras en [rutas protegidas](#protected-paths)
3. Todo lo demás va al clasificador
4. Si el clasificador bloquea, Claude recibe la razón e intenta una alternativa
Al entrar en modo automático, se descartan las reglas de permitir amplias que otorgan ejecución de código arbitrario:
* `Bash(*)` sin restricciones
* Intérpretes con comodín como `Bash(python*)`
* Comandos de ejecución del gestor de paquetes
* Reglas `Agent` de permitir
Las reglas estrechas como `Bash(npm test)` se mantienen. Las reglas descartadas se restauran cuando sale del modo automático.
El clasificador ve mensajes de usuario, llamadas de herramientas, y su contenido de CLAUDE.md. Los resultados de herramientas se eliminan, por lo que el contenido hostil en un archivo o página web no puede manipularlo directamente. Una sonda separada del lado del servidor escanea los resultados de herramientas entrantes y marca contenido sospechoso antes de que Claude lo lea. Para más sobre cómo funcionan estas capas juntas, consulte el [anuncio del modo automático](https://claude.com/blog/auto-mode) y la [inmersión profunda de ingeniería](https://www.anthropic.com/engineering/claude-code-auto-mode).
El clasificador verifica el trabajo de [subagentes](/es/sub-agents) en tres puntos:
1. Antes de que un subagente comience, la descripción de tarea delegada se evalúa, por lo que una tarea que se ve peligrosa se bloquea en el momento de generación.
2. Mientras el subagente se ejecuta, cada una de sus acciones pasa por el clasificador con las mismas reglas que la sesión principal, y cualquier `permissionMode` en el frontmatter del subagente se ignora.
3. Cuando el subagente termina, el clasificador revisa su historial de acciones completo; si esa verificación de retorno marca una preocupación, se antepone una advertencia de seguridad a los resultados del subagente.
El paso 1 requiere Claude Code v2.1.178 o posterior. Las versiones anteriores aplicaban el clasificador en los pasos 2 y 3, pero no evaluaban la descripción de tarea antes de que el subagente comenzara.
El clasificador se ejecuta en un modelo configurado por servidor que es independiente de su selección de `/model`, por lo que cambiar modelos no cambia la disponibilidad del clasificador. Las llamadas del clasificador cuentan hacia su uso de tokens. Cada verificación envía una porción de la transcripción más la acción pendiente, añadiendo un viaje de ida y vuelta antes de la ejecución. Las lecturas y ediciones de directorio de trabajo fuera de rutas protegidas omiten el clasificador, por lo que la sobrecarga proviene principalmente de comandos de shell y operaciones de red.
El modo `dontAsk` auto-deniega cada llamada de herramienta que de otro modo solicitaría. Solo las acciones que coinciden con tus reglas `permissions.allow` y [comandos Bash de solo lectura](/es/permissions#read-only-commands) pueden ejecutarse; las reglas [`ask` explícitas](/es/permissions#manage-permissions) se deniegan en lugar de solicitar. Esto hace que el modo sea completamente no interactivo para tuberías de CI o entornos restringidos donde predefines exactamente qué puede hacer Claude. Las sesiones en la nube en [Claude Code en la web](/es/claude-code-on-the-web) ignoran `defaultMode: "dontAsk"`; consulta [bypassPermissions](#skip-all-checks-with-bypasspermissions-mode) para obtener más detalles.
Establécelo al inicio con la bandera:
```bash theme={null}
claude --permission-mode dontAsk
```
Omitir todas las verificaciones con modo bypassPermissions
El modo `bypassPermissions` desactiva los avisos de permisos y las verificaciones de seguridad para que las llamadas de herramientas se ejecuten inmediatamente. A partir de v2.1.126, esto incluye escrituras en [rutas protegidas](#protected-paths), que las versiones anteriores aún solicitaban. Las [reglas ask](/es/permissions#manage-permissions) explícitas aún fuerzan un aviso en este modo, y las eliminaciones dirigidas al directorio raíz del sistema de archivos o al directorio de inicio, como `rm -rf /` y `rm -rf ~`, aún solicitan como un cortacircuitos contra errores del modelo. Use este modo solo en entornos aislados como contenedores, máquinas virtuales, o dev containers sin acceso a internet, donde Claude Code no puede dañar su sistema anfitrión.
No puede entrar en `bypassPermissions` desde una sesión que se inició sin una de las banderas de habilitación; reinicie con una para habilitarlo:
```bash theme={null}
claude --permission-mode bypassPermissions
```
La bandera `--dangerously-skip-permissions` es equivalente.
En Linux y macOS, Claude Code se niega a iniciarse en este modo cuando se ejecuta como root o bajo `sudo`:
```text theme={null}
--dangerously-skip-permissions cannot be used with root/sudo privileges for security reasons
```
La verificación se omite automáticamente dentro de un sandbox reconocido. Para ejecutarse de forma autónoma en un contenedor, use la configuración de [dev container](/es/devcontainer), que ejecuta Claude Code como un usuario no root.
[Claude Code en la web](/es/claude-code-on-the-web) no respeta `defaultMode: "bypassPermissions"` o `"dontAsk"` de sus archivos de configuración, por lo que la configuración registrada en un repositorio no puede iniciar una sesión en la nube en modo bypass-permissions. La configuración se ignora silenciosamente y la sesión se inicia en el modo mostrado en el menú desplegable de modo en su lugar. Consulte [Cambiar modos de permisos](#switch-permission-modes) para ver qué modos ofrecen las sesiones en la nube.
`bypassPermissions` no ofrece protección contra inyección de solicitud o acciones no intencionadas. Para verificaciones de seguridad de fondo con muchos menos avisos, use [modo automático](#eliminate-prompts-with-auto-mode) en su lugar. Los administradores pueden bloquear este modo estableciendo `permissions.disableBypassPermissionsMode` en `"disable"` en [configuración administrada](/es/permissions#managed-settings).
Rutas protegidas
Las escrituras en un pequeño conjunto de rutas nunca se auto-aprueban, en cada modo excepto `bypassPermissions`. Esto previene la corrupción accidental del estado del repositorio y la configuración propia de Claude.
| Modo | Escrituras en rutas protegidas |
| :------------------------------- | :----------------------------- |
| `default`, `acceptEdits`, `plan` | Solicitadas |
| `auto` | Enrutadas al clasificador |
| `dontAsk` | Denegadas |
| `bypassPermissions` | Permitidas |
Las reglas de [`permissions.allow`](/es/permissions#manage-permissions) en archivos de configuración no pre-aprueban escrituras en rutas protegidas. La verificación de seguridad se ejecuta antes de que Claude Code evalúe las reglas de permitir desde la configuración, por lo que una entrada como `Edit(.claude/**)` en `~/.claude/settings.json` o `.claude/settings.json` no cambia el resultado por modo en la tabla anterior. En modos que solicitan, la solicitud para una escritura en `.claude/` ofrece **Sí, y permitir que Claude edite su propia configuración para esta sesión**, lo que aprueba escrituras posteriores en `.claude/` en esa sesión sin solicitar de nuevo.
Directorios protegidos:
* `.git`
* `.config/git`
* `.vscode`
* `.idea`
* `.husky`
* `.cargo`
* `.devcontainer`
* `.yarn`
* `.mvn`
* `.claude`, excepto para `.claude/worktrees` donde Claude almacena sus propios git worktrees
Archivos protegidos:
* `.gitconfig`, `.gitmodules`
* `.bashrc`, `.bash_profile`, `.bash_login`, `.bash_aliases`, `.bash_logout`, `.zshrc`, `.zprofile`, `.zshenv`, `.zlogin`, `.zlogout`, `.profile`, `.envrc`
* `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `.pnp.loader.mjs`, `.pnpmfile.cjs`, `bunfig.toml`, `.bunfig.toml`
* `.bazelrc`, `.bazelversion`, `.bazeliskrc`
* `.pre-commit-config.yaml`, `lefthook.yml`, `lefthook.yaml`, `.lefthook.yml`, `.lefthook.yaml`
* `gradle-wrapper.properties`, `maven-wrapper.properties`
* `.devcontainer.json`
* `.ripgreprc`, `pyrightconfig.json`
* `.mcp.json`, `.claude.json`
Ver también
* [Permissions](/es/permissions): reglas de permitir, preguntar y denegar; políticas administradas
* [Configure auto mode](/es/auto-mode-config): dile al clasificador qué infraestructura confía tu organización
* [Hooks](/es/hooks): lógica de permisos personalizada a través de hooks `PreToolUse` y `PermissionRequest`
* [Ultraplan](/es/ultraplan): ejecuta modo de planificación en una sesión de Claude Code en la web con revisión basada en navegador
* [Security](/es/security): salvaguardas y mejores prácticas
* [Sandboxing](/es/sandboxing): aislamiento de sistema de archivos y red para comandos Bash
* [Non-interactive mode](/es/headless): ejecuta Claude Code con la bandera `-p`