BRAND: mejba.me TITLE: 10 Claude Code Features Most Developers Never Find SLUG: claude-code-hidden-features-guide PRIMARY KEYWORD: Claude Code features SECONDARY KEYWORDS: Claude Code commands, Claude Code tips, Claude Code automation META DESCRIPTION: 10 powerful Claude Code features most developers miss -- from /insights reports to parallel agent teams. Real tests, real workflows, real results. TAGS: Claude Code, AI Development, Developer Productivity, Automation, Guide CONTENT TYPE: Deep Dive CONTENT CLUSTER: Claude Code & AI Agents TRANSFORMATION GOAL: After reading, the reader will know how to use 10 advanced Claude Code features that dramatically change their daily workflow -- from automated code reviews to multi-agent orchestration.
Pensaba que conocía Claude Code. Seis meses de uso diario, cientos de sesiones, toda una operación de contenido funcionando a través de él. Había escrito una guía con 50 consejos que cubría todo, desde atajos de teclado hasta ingeniería de contexto. Era al que otros desarrolladores preguntaban cuando se quedaban atascados.
Entonces alguien me mostró /insights y me di cuenta de que había estado dejando la mitad de la herramienta sobre la mesa.
El informe que generó no era un resumen genérico. Era un análisis forense de mis últimos treinta días -- cada esfuerzo duplicado, cada bucle de tokens desperdiciado, cada patrón en el que seguía re-explicando algo que Claude ya debería haber sabido. Un hallazgo me golpeó especialmente fuerte: había estado ejecutando manualmente el mismo proceso de revisión de código en tres pasos en cada PR, cuando un solo comando podría haberlo hecho automáticamente con mejor cobertura. Solo ese descubrimiento me ahorraba aproximadamente cuatro horas a la semana.
Lo que siguió fue una inmersión profunda de dos semanas en cada comando, modo y capacidad que de alguna manera había pasado por alto. Algunas de estas funciones se habían lanzado silenciosamente en actualizaciones cuyos changelogs no había leído. Otras habían estado ahí todo el tiempo, escondidas detrás de comandos slash que nunca había probado. Unas pocas eran tan potentes que genuinamente no podía creer que hubiera estado trabajando sin ellas.
Aquí hay diez funciones que cambiaron cómo uso Claude Code. No son consejos. No son atajos. Son capacidades completas que la mayoría de los desarrolladores o no saben que existen o no han descubierto cómo usarlas correctamente. He probado cada una en proyectos reales, y te diré exactamente qué funcionó, qué me sorprendió y dónde aún se notan las asperezas.
La primera ya reescribió mi flujo de trabajo a los veinte minutos de ejecutarla.
1. El informe de Insights que expone tus puntos ciegos
La mayoría de los desarrolladores tienen cero visibilidad sobre cómo realmente usan Claude Code. Sabes aproximadamente cuántas sesiones ejecutas. Tienes una vaga idea de tu consumo de tokens. Pero los patrones específicos -- dónde pierdes tiempo, qué tareas repites innecesariamente, qué hábitos te están costando dinero -- permanecen invisibles.
El comando /insights cambia eso. Lee los datos de tus sesiones de los últimos treinta días y compila un informe HTML detallado que cubre tus patrones de uso, desglose de costos, utilización de herramientas e ineficiencias del flujo de trabajo. Piensa en ello como una evaluación de rendimiento, excepto que el evaluador tiene acceso a cada interacción que has tenido con la herramienta.
Cuando lo ejecuté por primera vez, el informe reveló tres patrones que nunca habría detectado por mi cuenta.
El primero era duplicación. Había estado pidiendo a Claude que configurara el mismo boilerplate de testing en diferentes proyectos -- configuraciones Vitest idénticas, setups de mocks idénticos, patrones de assertions idénticos. El informe de insights lo señaló y sugirió crear un skill personalizado que lo manejaría en un solo comando. Construí ese skill en quince minutos. Ahora se ejecuta automáticamente en cada proyecto nuevo.
El segundo hallazgo fue agrupamiento de errores. Aproximadamente el 40% de mis errores de sesión provenían de la misma causa raíz: agotamiento de la ventana de contexto durante ediciones de archivos grandes. El informe no solo identificó el problema -- recomendó hooks específicos para auto-compactar el contexto antes de alcanzar el techo. Implementé el hook esa misma tarde, y esos errores cayeron a casi cero.
El tercero fue el que dolió: el informe mostró que estaba gastando un promedio de doce minutos por sesión re-explicando convenciones del proyecto que deberían haber estado en mi archivo CLAUDE.md. Doce minutos. A lo largo de cinco a seis sesiones al día. Eso es más de una hora de desperdicio diario en algo que una adición de veinte líneas a mi archivo de configuración resolvería.
El informe de insights también desglosa tus gastos por nivel de modelo, muestra qué herramientas usas más (y cuáles nunca tocas), e identifica sesiones donde podrías haber usado un modelo más barato sin pérdida de calidad. Para cualquiera que gaste dinero serio en Claude Code -- suscriptores Max quemando tokens en proyectos complejos -- estos datos se pagan solos inmediatamente.
Ejecuta /insights una vez. Lee el informe completo. Luego ejecútalo mensualmente. Los patrones que detecta no son obvios desde dentro de sesiones individuales. Necesitas la vista de treinta días para verlos.
Pero identificar ineficiencias es solo la mitad de la ecuación. La siguiente función te permite controlar exactamente cuánto esfuerzo dedica Claude a pensar en tus problemas -- y la mayoría de las personas lo dejan en la configuración incorrecta.
2. Effort Control: deja de pagar de más por tareas simples
Aquí hay algo que hice mal durante meses: estaba ejecutando cada prompt con la misma intensidad de procesamiento. Un simple renombrado de variable recibía la misma cadena de razonamiento profundo que una refactorización arquitectónica compleja. Eso es como contratar un ingeniero estructural para colgar un cuadro.
El comando /effort te permite ajustar la intensidad de razonamiento de Claude hacia arriba o hacia abajo en cinco niveles: low, medium, high, max y auto. Cada nivel cambia cuán profundamente Claude analiza tu solicitud antes de responder -- y críticamente, cuántos tokens consume en el proceso.
Desde marzo de 2026, Anthropic cambió el nivel de effort predeterminado para suscriptores Max y Team de high a medium. Si no notaste ese cambio, quizás sentiste que Claude se volvió ligeramente menos exhaustivo recientemente. Así fue. Intencionalmente. Porque medium maneja la mayoría de las tareas de desarrollo perfectamente bien, y high estaba quemando tokens innecesariamente en trabajo sencillo.
Así es como he calibrado mi uso después de probar cada nivel extensivamente:
Low effort funciona para búsquedas de archivos, renombrados simples, correcciones de formato y consultas rápidas. Claude escanea la solicitud y responde rápido. El costo de tokens es mínimo. Lo uso aproximadamente el 20% del tiempo.
Medium effort maneja la mayoría de las tareas de codificación: implementar funcionalidades bien definidas, escribir tests contra código existente, refactorizar con patrones claros. Este es mi valor predeterminado, y es el valor predeterminado correcto para probablemente el 60% del trabajo de desarrollo.
High effort es donde Claude empieza a hacer razonamiento profundo genuino. Investigaciones complejas de bugs a través de múltiples archivos. Decisiones arquitectónicas con compensaciones. Revisiones de seguridad. Código que requiere entender interacciones sutiles entre sistemas. Cambio a high para revisiones críticas, despliegues en producción y cualquier cosa donde un caso límite pasado por alto sería costoso. Aproximadamente el 15% de mi trabajo.
Max effort activa el razonamiento más profundo disponible -- pensamiento extendido con cadena de pensamiento completa. Lo reservo para problemas genuinamente difíciles: depurar condiciones de carrera, diseñar sistemas a partir de requisitos ambiguos, revisar código crítico para la seguridad. Usarlo para tareas rutinarias es un desperdicio. Aproximadamente el 5% de mis sesiones.
Auto deja que Claude decida basándose en la complejidad que detecta en tu prompt. He probado esto extensivamente, y es sorprendentemente preciso al emparejar esfuerzo con complejidad de tarea. Si no quieres pensar en niveles de effort, auto es una sólida opción sin intervención.
El impacto práctico es real. Después de cambiar de un high implícito por defecto a gestión deliberada del effort, mi consumo de tokens bajó aproximadamente un 30% sin cambio medible en la calidad del output para tareas rutinarias. El razonamiento costoso solo se activa cuando realmente se necesita.
Un patrón de flujo de trabajo que funciona particularmente bien: comienza una investigación compleja en high, obtén el diagnóstico, luego cambia a medium para la implementación. El trabajo de pensamiento pesado ocurre una vez. La ejecución corre ligera.
La gestión del effort se trata de precisión. Pero la siguiente función se trata de libertad -- específicamente, la libertad de alejarte de tu escritorio sin perder una sesión.
3. Remote Control: tu sesión de terminal, en cualquier lugar
Escribí una inmersión profunda completa sobre Remote Control cuando se lanzó en febrero de 2026, así que no repetiré cada detalle aquí. Pero pertenece a esta lista porque la mayoría de los desarrolladores con los que hablo o no lo han probado o malinterpretan lo que realmente hace.
La versión corta: escribe /rc en cualquier sesión activa de Claude Code. Aparece un código QR. Escanéalo con la app de Claude en tu teléfono. Ahora tienes control bidireccional completo de esa sesión de terminal desde tu dispositivo móvil. Leer mensajes, aprobar ediciones de archivos, enviar nuevas instrucciones -- todo mientras tu entorno local sigue funcionando exactamente como estaba.
La arquitectura importa. Tu sesión permanece local. Tu sistema de archivos, servidores MCP, configuración del proyecto, herramientas personalizadas -- nada se mueve a la nube. Remote Control abre una ventana segura a tu sesión existente sobre TLS, con credenciales de corta duración limitadas a esa conexión. No es un IDE en la nube. Es un viewport remoto.
Donde esto cambió mi flujo de trabajo: tareas de larga duración. Inicio una refactorización compleja o una ejecución completa de la suite de tests, y luego me alejo para almorzar, sacar al perro o moverme a otra habitación. Desde mi teléfono, puedo monitorear el progreso, aprobar o rechazar cambios y enviar instrucciones de seguimiento. Cuando vuelvo a mi escritorio, la sesión está exactamente donde la dejé.
La limitación es real, sin embargo. Tu máquina tiene que permanecer encendida y tu terminal tiene que estar abierta. Cierra la tapa de tu laptop, y la sesión termina. Esto no es "inicia una tarea y vuelve mañana." Es "aléjate de tu escritorio sin romper el flujo." Esa distinción confunde a la gente.
Remote Control requiere una suscripción Max y funciona a través de claude.ai/code y las apps de Claude para iOS/Android. Si estás en un plan Pro, Anthropic ha indicado que el acceso más amplio está en camino, pero a marzo de 2026 sigue siendo solo para Max.
Para quienes sí tienen acceso, sin embargo, elimina silenciosamente uno de los patrones más frustrantes en el desarrollo asistido por IA: la elección forzada entre ser productivo y estar presente en tu escritorio. Lo uso casi a diario, y la libertad que crea es difícil de sobrestimar.
Alejarte de tu escritorio es un tipo de libertad. La siguiente función te da un tipo diferente -- la capacidad de lanzar cantidades masivas de trabajo a Claude de una sola vez.
4. Batch Command: ejecución paralela a escala
El comando /batch es donde Claude Code deja de sentirse como un asistente de codificación y empieza a sentirse como un pipeline de despliegue.
Este es el escenario que me hizo entender su poder. Tenía un codebase con 23 componentes React que necesitaban migrar de un enfoque de estilos antiguo a un nuevo sistema de design tokens. Cada componente era independiente -- sin estado compartido, sin dependencias cruzadas. En el flujo de trabajo antiguo, los habría hecho secuencialmente: abrir componente, explicar el patrón de migración, dejar que Claude refactorice, revisar, pasar al siguiente. A unos diez minutos por componente, son casi cuatro horas de trabajo tedioso y repetitivo.
Con /batch, describí el patrón de migración una vez y le dije a Claude que lo aplicara a los 23 componentes en paralelo. Descompuso el trabajo en unidades independientes, generó agentes aislados en worktrees para cada uno, y ejecutó las migraciones simultáneamente. Cada agente trabajó en su propio git worktree, así que había cero riesgo de ediciones conflictivas. Cuando el batch se completó, tenía 23 pull requests -- uno por componente -- listos para revisión.
Tiempo total: unos dieciocho minutos. No cuatro horas. Dieciocho minutos.
El comando soporta tanto modos de ejecución paralela como secuencial. Paralelo es para tareas independientes como la migración anterior. Secuencial es para tareas con dependencias -- donde el paso 2 necesita la salida del paso 1. Especificas el modo, describes el trabajo, y Claude maneja la orquestación.
Para creadores de contenido, el procesamiento por lotes es igualmente potente. Lo he usado para generar múltiples borradores de blog posts simultáneamente, cada uno dirigido a un clúster de palabras clave diferente, con contextos de investigación separados para cada uno. Los agentes no comparten contexto, así que no hay contaminación cruzada entre temas.
La integración con GitHub es la parte que lo hace listo para producción. Cada unidad de batch puede crear automáticamente una rama, hacer commit de cambios y abrir un PR. Para una migración que afecta docenas de archivos, esto significa que obtienes un PR limpio por unidad lógica de trabajo en lugar de un pull request masivo e irrevisable. Los revisores de código aprecian esto más de lo que podrías pensar.
El procesamiento por lotes tiene asperezas. Las tareas complejas con interdependencias sutiles a veces necesitan intervención manual cuando la detección de dependencias de Claude falla en alguna conexión. Y el costo de tokens escala linealmente -- lanzar 23 agentes significa pagar por 23 agentes. Pero para trabajo que es genuinamente paralelizable, el ahorro de tiempo es transformador.
Batch maneja la cantidad. La siguiente función maneja la calidad -- y lo hace ejecutando tres críticos en tu código simultáneamente.
5. Simplify: revisión de código con tres agentes en un solo comando
Yo hacía las revisiones de código de la forma manual: leer los cambios, buscar duplicaciones, buscar bugs, pensar en el rendimiento. Requería esfuerzo cognitivo real, y seré honesto -- se me escapaban cosas. A todos nos pasa. La atención humana es inconsistente, especialmente en la tercera revisión del día.
/simplify reemplaza ese proceso con un pipeline de tres agentes que se ejecutan simultáneamente. Cada agente tiene un enfoque distinto:
Agente 1: Detección de duplicación. Escanea lógica repetida, patrones copiados y oportunidades de extraer funciones compartidas. Este agente detectó algo en mi codebase que había pasado por alto durante semanas -- tres manejadores de rutas API separados que cada uno implementaba su propia lógica de rate-limiting en lugar de usar el middleware que ya había construido.
Agente 2: Análisis de bugs y errores. Busca errores de lógica, casos límite, riesgos de referencia nula y suposiciones incorrectas. Opera más como un revisor orientado a la seguridad que como un linter -- no verifica sintaxis, verifica razonamiento. En un proyecto reciente, señaló una condición de carrera en mi manejador de transacciones de base de datos que solo se manifestaría bajo escrituras concurrentes. Eso nunca lo habría detectado en una revisión manual.
Agente 3: Revisión de eficiencia. Evalúa características de rendimiento, identifica cálculos innecesarios, detecta consultas N+1 y sugiere mejoras estructurales. Este agente recomendó convertir un pipeline de procesamiento de archivos sincrónico a streaming, lo que redujo el uso de memoria en cargas grandes en aproximadamente un 70%.
Los tres agentes se ejecutan en paralelo, compilan sus hallazgos, y entonces -- esta es la parte clave -- /simplify aplica las correcciones automáticamente. No solo sugerencias. Cambios de código reales. Revisas los diffs después, lo cual es mucho más eficiente que leer una lista de recomendaciones e implementarlas tú mismo.
He integrado /simplify en mi flujo de trabajo pre-PR. Antes de abrir cualquier pull request, lo ejecuto una vez. Los agentes encuentran consistentemente problemas que se me escaparon. No siempre críticos -- a veces es solo una función auxiliar que podría extraerse, o un nombre de variable que es engañoso. Pero el efecto acumulativo es código más limpio y mantenible llegando a producción.
Una advertencia: /simplify está diseñado como una puerta de calidad antes de los PRs, no como una herramienta durante el desarrollo. Ejecutarlo a mitad de la implementación crea ruido innecesario porque revisa código que aún no está terminado. Espera hasta que estés listo para hacer commit, luego ejecútalo. Los hallazgos son más significativos contra trabajo completado.
Tres agentes revisando tu código es impresionante. La siguiente función lleva la automatización más lejos -- convierte Claude Code en un trabajador programado que funciona sin ti.
6. Loop: cron jobs dentro de tu terminal
El comando /loop convirtió Claude Code de una herramienta que uso en una herramienta que trabaja para mí mientras hago otras cosas.
El concepto es simple: le das a Claude un prompt y un intervalo de tiempo, y ejecuta ese prompt repetidamente según el horario mientras tu sesión permanezca activa. Es esencialmente un cron job que se ejecuta dentro de tu terminal de Claude Code.
/loop 3h check my email inbox via the Gmail MCP and summarize any new messages from clients
Eso se ejecuta cada tres horas. Claude revisa los correos nuevos, los resume y presenta los resultados. Lo configuro los lunes por la mañana y captura mensajes de clientes a los que de otra forma no llegaría en horas.
Pero los casos de uso más potentes están orientados al desarrollo. Estos son los loops que ejecuto regularmente:
Monitoreo de despliegue: /loop 30m check the production error logs for any new 500 errors and summarize the stack traces. Esto se ejecuta cada treinta minutos durante horario laboral. Cuando un error llega a producción, lo sé antes de que los clientes lo reporten.
Recordatorio de revisión de PR: /loop 2h check our GitHub repo for any open PRs that have been waiting for review for more than 24 hours and list them. Esto evita que nuestra cola de revisiones se estanque. El equipo se ha vuelto notablemente más rápido revisando desde que configuré esto.
Verificaciones de dependencias: /loop 6h scan package.json for any dependencies with known security vulnerabilities using the npm audit tool. Una vez al día probablemente es suficiente para la mayoría de los equipos, pero lo ejecuto más frecuentemente en proyectos con cambios rápidos de dependencias.
La limitación crítica: los loops solo se ejecutan mientras tu sesión está activa. Cierra la terminal, y el loop se detiene. Esto no es un servicio en segundo plano. Es una automatización con alcance de sesión. Para tareas programadas persistentes, necesitas cron jobs reales o una herramienta como el comando /schedule para triggers remotos. Pero para automatización durante la jornada laboral -- las ocho a diez horas que estás desarrollando activamente -- /loop es notablemente útil.
También he encadenado loops con hooks (que cubriremos a continuación) para crear flujos de trabajo automatizados. Un loop verifica una condición, y cuando la condición se cumple, un hook dispara una acción. Loop detecta un nuevo PR, hook ejecuta /simplify automáticamente. Esa combinación convirtió la revisión de código de un proceso manual en uno semi-automatizado.
Hay un comportamiento a tener en cuenta: los loops consumen tokens en cada ejecución. Un prompt que usa 5,000 tokens por ejecución, ejecutado cada treinta minutos durante un día de ocho horas, cuesta 80,000 tokens. Eso se acumula. Mantengo mis prompts de loop ligeros y enfocados para evitar facturas sorpresa.
Los loops automatizan según horario. La siguiente función automatiza según eventos -- y es una de las capacidades más infrautilizadas de toda la plataforma.
7. Hooks: la capa de automatización que la mayoría ignora
Los hooks son acciones configurables que se disparan antes o después de que Claude Code use herramientas específicas. Se definen en tu archivo .claude/settings.json, y pueden cambiar fundamentalmente cómo opera todo tu flujo de trabajo.
Piensa en los hooks como Git hooks, pero para el uso de herramientas de IA. Puedes disparar comandos shell, aplicar reglas, ejecutar validaciones o realizar acciones automatizadas cada vez que Claude lee un archivo, escribe código, ejecuta un comando o interactúa con cualquiera de sus diecinueve eventos de herramientas soportados.
Aquí hay un ejemplo práctico. Tengo un hook que se ejecuta antes de cada escritura de archivo:
{
"hooks": {
"preToolUse": [
{
"matcher": "write",
"command": "echo 'Checking file size and backup...'"
}
]
}
}
Esa es una versión simplificada. Mi hook real verifica el tamaño del archivo destino, crea una copia de seguridad con marca de tiempo en un directorio .backups, y valida que la escritura no exceda una longitud máxima de archivo configurada. Todo esto sucede automáticamente antes de que Claude escriba una sola línea.
Los hooks que he encontrado más valiosos en la práctica:
Aplicación de voz de marca. Para mi flujo de trabajo de contenido, tengo un hook post-write que escanea el contenido generado en busca de frases prohibidas (las que suenan a IA como "in today's fast-paced world" o "it's important to note") y las marca antes de guardar el archivo. Esto captura inconsistencias de estilo que de otra forma requerirían edición manual.
Gestión de costos de tokens. Un hook pre-tool que estima el costo de tokens de la operación actual y me advierte si excede un umbral. Esto previene el consumo descontrolado de tokens durante operaciones batch grandes. Configuré el umbral en 50,000 tokens por llamada de herramienta individual -- cualquier cosa por encima de eso recibe un prompt de confirmación.
Formato automático. Un hook post-write que ejecuta Prettier en cualquier archivo TypeScript o JavaScript que Claude modifique. El código sale formateado sin que yo piense en ello.
Validación de tests. Un hook post-write en archivos de test que ejecuta automáticamente la suite de tests relevante después de que Claude escribe o modifica tests. Si los tests fallan, el hook alimenta la salida del fallo de vuelta a la conversación para que Claude pueda arreglar el problema inmediatamente. Esto crea un ciclo apretado de escribir-testear-corregir sin intervención manual.
El enfoque de sistemas auto-mejorantes sobre el que escribí anteriormente puede implementarse parcialmente solo con hooks. Un hook que registra las decisiones clave de cada sesión, combinado con un loop que revisa periódicamente esos registros en busca de patrones, crea un sistema de retroalimentación ligero que mejora continuamente tu flujo de trabajo.
Los hooks son poderosos precisamente porque son invisibles durante el uso normal. Una vez configurados, se ejecutan silenciosamente en segundo plano, aplicando tus reglas y automatizando tus procesos sin requerir ningún pensamiento. El costo de configuración es una inversión única. El retorno es permanente.
Hablando de invisible -- la siguiente función es tan sutil que la mayoría de los desarrolladores ni siquiera saben que el comando existe.
8. Rewind Mode: deshacer sin pánico
Todo desarrollador que usa codificación asistida por IA ha tenido este momento: Claude hace una serie de cambios a través de múltiples archivos, te das cuenta a mitad de camino de que el enfoque es incorrecto, y ahora estás mirando un desorden de archivos modificados intentando averiguar qué cambió dónde.
Git puede ayudar. Pero revertir commits individuales cuando Claude hizo cambios a lo largo de un solo turno de conversación es tedioso. Y si aún no has hecho commit, git checkout se convierte en un instrumento contundente que podría deshacer cosas que querías mantener.
Rewind Mode ofrece una alternativa quirúrgica. Pulsa Esc dos veces para abrir el menú de rewind, y obtienes dos opciones:
Solo rebobinar conversación -- retrocede la conversación a un estado anterior manteniendo todos los cambios de código. Útil cuando Claude tomó un camino de explicación incorrecto pero las modificaciones de código reales estaban bien.
Solo rebobinar código -- revierte los cambios de archivos preservando el historial de conversación. Esta es la que más uso. Claude intentó un enfoque, el código no funcionó, pero el contexto de la conversación (la descripción del problema, las restricciones, el intento fallido) es valioso para el siguiente intento. Rebobino el código, mantengo el contexto y redirijo: "Ese enfoque tuvo el problema X. Intenta Y en su lugar."
La combinación es poderosa para el desarrollo experimental. Le digo a Claude que intente una refactorización arriesgada, sabiendo que si no funciona, puedo rebobinar los cambios de código en segundos. Esto cambia cómo abordas el trabajo especulativo -- el costo de intentar algo cae a casi cero cuando deshacerlo es instantáneo.
Antes de que existiera rewind, hacía esto manualmente: hacía commit antes de cada operación importante de Claude, y luego cherry-pick o revert si las cosas salían mal. Eso funcionaba, pero llenaba mi historial de git con commits de checkpoint que no tenían razón de estar ahí. Rewind mantiene los experimentos completamente fuera de tu historial de versiones.
Una cosa a entender: rewind opera sobre turnos de conversación, no sobre cambios individuales de archivos. Si Claude modificó cinco archivos en un solo turno, rewind revierte los cinco. No puedes rebobinar selectivamente el archivo tres mientras mantienes los archivos uno, dos, cuatro y cinco. Para esa granularidad, todavía necesitas git.
Pero para el caso común -- "todo ese enfoque estaba mal, intentemos algo diferente" -- rewind es exactamente la herramienta correcta. Rápido, limpio y mucho menos estresante que los rollbacks manuales.
Rewind maneja los errores después de que ocurren. La siguiente función maneja las preguntas que surgen mientras estás en medio de otra cosa.
9. El comando /btw: preguntas laterales sin descarrilar tu sesión
Este se lanzó el 10 de marzo de 2026, con Claude Code v2.1.72, y resolvió una frustración con la que había vivido durante meses sin darme cuenta de que había solución.
El escenario: estás en lo profundo de una sesión de depuración. Claude está rastreando una cadena compleja de llamadas a funciones a través de múltiples archivos. Has acumulado quince turnos de contexto, y la conversación está enfocada y productiva. Entonces te surge un pensamiento -- "espera, ¿cuántos tokens de contexto me quedan?" o "¿cuál es el enfoque recomendado para X?" -- pero hacer esa pregunta en el hilo principal descarrilaría todo el flujo de depuración.
Antes de /btw, tenías dos opciones malas. Hacer la pregunta y aceptar que la atención de Claude se desviaría para responderla, potencialmente perdiendo el hilo de la sesión de depuración. O abrir una nueva terminal, iniciar una sesión nueva y preguntar allí -- perdiendo contexto y pagando por toda una nueva inicialización de sesión.
/btw crea un canal lateral. Haces tu pregunta, Claude la responde, y la conversación principal continúa desde exactamente donde estaba. La pregunta lateral no se convierte en parte del hilo principal. No influye en el razonamiento de Claude sobre la tarea principal. Es un verdadero paréntesis -- reconocido, respondido y dejado a un lado.
/btw how many context tokens are remaining in this session?
Claude responde. Luego tu siguiente prompt continúa la sesión de depuración como si la pregunta lateral nunca hubiera ocurrido.
Uso /btw consistentemente para tres cosas:
Monitoreo de contexto. Verificar tokens restantes a mitad de sesión sin interrumpir el flujo. Esto es especialmente importante durante sesiones largas donde necesito saber si debo compactar o continuar.
Aclaraciones rápidas. "¿Cuál es la sintaxis para X en este framework?" cuando necesito una respuesta rápida pero no quiero romper la cadena de resolución de problemas.
Meta-preguntas sobre la sesión. "¿Estás rastreando las tres restricciones que mencioné antes?" -- una verificación de cordura de que el contexto de Claude está intacto, sin contaminar el hilo principal con meta-discusión.
Es una función pequeña. Del tipo que no genera titulares. Pero elimina un punto de fricción genuino de las sesiones largas, y las sesiones largas son donde ocurre el trabajo más valioso. Cualquier cosa que proteja la integridad de una conversación profunda y enfocada vale la pena conocerla.
Hemos cubierto nueve funciones hasta ahora. La décima es la más grande. No es un comando -- es un cambio de paradigma en cómo funciona Claude Code. Y si has estado usando Claude como asistente individual, esto cambiará tu modelo mental por completo.
10. Equipos de agentes paralelos: de asistente individual a equipo de desarrollo completo
Todo hasta ahora trata a Claude Code como una entidad única. Un agente, una conversación, un flujo de trabajo. Los agentes paralelos rompen ese modelo por completo.
Cuando lanzas equipos de agentes, Claude Code no ejecuta solo una sesión. Lanza múltiples sesiones independientes -- cada una con su propia ventana de contexto, su propio rol y su propia porción del trabajo. Un agente líder coordina el equipo, delega tareas y sintetiza resultados. Los agentes compañeros ejecutan independientemente, reportan y hasta se comunican entre sí.
Esto no es lo mismo que sub-agents. La distinción importa, y yo me confundí al principio, así que déjame ser preciso.
Sub-agents operan dentro de una sola sesión de Claude Code. El agente padre los genera para manejar tareas específicas, pero comparten el contexto general de la sesión y operan dentro de sus restricciones. Son útiles para paralelizar trabajo dentro de un alcance acotado -- como la arquitectura agent swarm que cubrí anteriormente.
Los equipos de agentes paralelos son fundamentalmente diferentes. Cada compañero de equipo es una sesión de Claude Code completamente independiente con su propia ventana de contexto de 200K tokens. No comparten contexto con el agente líder ni entre sí -- se comunican mediante paso de mensajes explícito. Esto significa que un compañero puede mantener el contexto de todo un codebase para su dominio específico sin consumir tokens de la ventana de nadie más.
Probé esto en un proyecto que necesitaba tres cosas simultáneamente: un rediseño de API backend, una refactorización de componentes frontend y una actualización exhaustiva de la suite de tests. En el modelo anterior, habría abordado esto secuencialmente -- API primero, luego frontend, luego tests -- porque un solo agente no podía mantener suficiente contexto para los tres simultáneamente.
Con agentes paralelos, lancé tres compañeros:
- Agente Backend: Contexto completo sobre la capa de API, esquemas de base de datos y manejadores de rutas
- Agente Frontend: Contexto completo sobre el árbol de componentes React, gestión de estado y patrones de UI
- Agente de Tests: Contexto completo sobre la infraestructura de tests existente, configuración de mocks y requisitos de cobertura
El agente líder coordinó: "Backend está rediseñando el endpoint de usuario. Frontend, espera al nuevo contrato de API antes de actualizar el componente de perfil de usuario. Agente de tests, comienza a escribir stubs de tests de integración basados en la especificación actual -- llenaremos las assertions una vez que la API esté finalizada."
Cada agente trabajó en su propio worktree. Sin conflictos de merge. Sin contaminación de contexto. El agente backend pudo cargar toda la capa de API en su ventana de contexto porque no estaba también sosteniendo código frontend. El agente de tests pudo analizar la suite de tests completa sin desplazar el contexto de implementación.
El resultado fue aproximadamente 3x de rendimiento comparado con trabajo secuencial de agente único. No porque cada agente individual fuera más rápido, sino porque tres agentes trabajando simultáneamente con contexto completo en sus dominios respectivos es categóricamente diferente de un agente cambiando de contexto entre dominios.
El modelo de comunicación es lo que lo hace funcionar. Los compañeros no tienen acceso directo al contexto de los demás, pero pueden enviar mensajes estructurados a través del agente líder. Cuando el agente backend finalizó el nuevo contrato de API, envió las especificaciones de endpoints al líder, quien las reenvió a los agentes de frontend y tests. Cada agente incorporó la información en su propio contexto sin perder el conocimiento específico del dominio que ya había construido.
Esta es la función que me hizo reconsiderar qué es realmente Claude Code. Ya no es un asistente. Es una plataforma para ejecutar equipos de desarrollo con IA. El cambio de modelo mental -- de "tengo un ayudante muy inteligente" a "estoy gestionando un equipo de especialistas" -- cambia cómo planificas el trabajo, cómo descompones problemas y qué consideras factible para una sola sesión de desarrollo.
Si prefieres que alguien configure este tipo de flujo de trabajo multi-agente desde cero, acepto encargos de automatización de Claude Code y arquitectura de agentes. Puedes ver lo que he construido en fiverr.com/s/EgxYmWD.
El costo de tokens escala con el número de agentes, obviamente. Tres compañeros significan aproximadamente tres veces el consumo de tokens. Pero para proyectos complejos donde la alternativa es trabajo secuencial a lo largo de múltiples sesiones de todas formas, el costo total es frecuentemente comparable -- solo lo estás gastando en paralelo en lugar de repartido a lo largo de días.
Lo que comparten estas funciones: una filosofía de rendimientos compuestos
Individualmente, cada una de estas diez funciones resuelve un problema específico. Insights muestra dónde estás desperdiciando esfuerzo. Effort control previene el gasto excesivo en tareas simples. Remote Control te libera de tu escritorio. El procesamiento por lotes paraleliza el trabajo repetitivo. Simplify detecta bugs que pasarías por alto. Loop automatiza verificaciones recurrentes. Hooks aplican reglas silenciosamente. Rewind elimina el costo de experimentar. /btw protege la concentración profunda. Los agentes paralelos multiplican tu rendimiento.
Apilados juntos, transforman Claude Code de un autocompletado inteligente en algo más cercano a un departamento de ingeniería.
El efecto compuesto es donde vive el valor real. Los hooks se disparan ante condiciones detectadas por loops. Los datos de insights informan tu calibración de effort. Las operaciones batch se benefician de simplify como paso de post-procesamiento. Los agentes paralelos usan rewind independientemente cuando los enfoques individuales fallan. Cada función amplifica a las demás.
La mayoría de los desarrolladores con los que hablo usan quizás tres o cuatro comandos de Claude Code regularmente. Saben cómo hacer prompts, revisar y aprobar ediciones. Eso es como comprar una cámara profesional y solo usar el modo automático. Las capacidades están ahí. La inversión para aprenderlas se mide en horas. El retorno se mide en semanas de tiempo recuperado.
Mi desafío para ti: elige una función de esta lista que no hayas usado. Pruébala en tu próximo proyecto. No en un ejemplo de juguete -- en trabajo real. Dale un intento honesto y mira qué cambia.
Basándome en lo que he visto de mi propio flujo de trabajo -- y del informe de insights que inició todo este viaje -- no vas a querer volver a trabajar sin ella.
Preguntas frecuentes
¿Cómo ejecuto el informe de insights de Claude Code?
Escribe /insights en cualquier sesión activa de Claude Code. Analiza tu uso de los últimos 30 días y genera un informe HTML que cubre patrones, costos, uso de herramientas e ineficiencias del flujo de trabajo. No requiere configuración -- lee automáticamente tu historial de sesiones existente.
¿Cuál es la diferencia entre sub-agents de Claude Code y equipos de agentes paralelos?
Los sub-agents operan dentro de una sola sesión y comparten contexto con el agente padre. Los equipos de agentes paralelos lanzan sesiones completamente independientes, cada una con su propia ventana de contexto de 200K tokens, comunicándose mediante paso de mensajes explícito. Los equipos manejan proyectos más grandes y complejos donde el aislamiento de dominio importa.
¿Funciona Claude Code Remote Control en móvil?
Sí. Remote Control funciona a través de claude.ai/code y las apps de Claude para iOS y Android. Tu sesión sigue ejecutándose localmente en tu máquina mientras interactúas a través de la interfaz móvil. Requiere una suscripción Max a marzo de 2026.
¿Cuánto cuestan los agentes paralelos en tokens?
El costo de tokens escala linealmente con el número de agentes. Tres agentes paralelos consumen aproximadamente tres veces los tokens de un solo agente. Sin embargo, el costo total del proyecto es frecuentemente comparable al trabajo secuencial ya que estás consolidando lo que de otra forma serían múltiples sesiones separadas.
¿Puedo ejecutar comandos /loop en segundo plano permanentemente?
No. Los comandos loop solo se ejecutan mientras tu sesión de Claude Code está activa. Cerrar la terminal detiene todos los loops. Para automatización programada persistente, usa el comando /schedule que crea triggers remotos que se ejecutan en un horario cron independientemente de tu sesión local.
Let's Work Together
Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.
- Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise solutions): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (security services): xcybersecurity.io
