Guía técnica actualizada · 2026

Domina Claude AI
para Programación
y Ciberseguridad

Aprendé a usar Claude AI para programación, ciberseguridad, investigación técnica y automatización mediante ejemplos reales, prompts avanzados y flujos utilizados por profesionales.

📖 35 min de lectura · ⏱ Actualizado Junio 2026 · 🌐 +200 prompts
8Módulos
+200Prompts
10+Casos reales
MCPIntegrations
claude — terminal
$ claude "Revisá src/auth.ts con criterios OWASP Top 10"
✦ Analizando contexto del proyecto...
✦ Stack: Node.js + Express + TypeScript
⚠ CWE-89 SQL Injection — línea 47 (sin sanitizar)
⚠ CWE-798 Credencial hardcodeada — JWT_SECRET
✓ Generando fixes con severidad CVSS v3...
✓ Reporte exportado → security-report.md

$ claude -p "Flujo completo: arq→código→tests→docs" @src/
✦ Leyendo 42 archivos del proyecto...
✦ Generando arquitectura de componentes...
✓ Tests unitarios: 18 casos con edge cases
✓ README.md y OpenAPI 3.0 generados

$ _
⚡ Comandos esenciales
claudeModo interactivo REPL
claude -p "..."Modo pipe / CI
/memoryEditar CLAUDE.md
@src/ @gitReferencias de contexto
--output-format jsonSalida estructurada

Claude en la Web

Accedé a claude.ai desde cualquier navegador. Es el punto de entrada más completo para análisis de documentos, investigación con web search y flujos que no requieren acceso al código fuente local.

💬

Proyectos y Contexto Persistente

Organizá tu trabajo en Proyectos con instrucciones de sistema propias, archivos adjuntos y historial persistente entre sesiones. Ideal para flujos repetitivos de equipo.

🔍

Web Search & Deep Research

Activá la búsqueda web para respuestas actualizadas. "Deep Research" sintetiza decenas de fuentes y genera informes estructurados. Ideal para threat intel y papers técnicos.

📄

Análisis de Archivos

Subí PDFs, imágenes, CSVs, logs, código fuente. Claude puede comparar múltiples documentos, extraer datos estructurados y generar visualizaciones con Code Execution.

⚙️

System Prompt por Proyecto

Configurá un system prompt que define el rol, tono y restricciones de Claude para toda la sesión. Ejemplo: "Actuás como analista SOC Nivel 1 especializado en SIEM OSSIM..."

🎨

Artifacts Interactivos

Claude puede generar componentes React, diagramas SVG, dashboards HTML y widgets interactivos que se renderizan en tiempo real. Útil para visualizar datos de seguridad.

🧠

Memoria entre Sesiones

Habilitá la memoria en Configuración para que Claude recuerde tus proyectos activos, herramientas favoritas y contexto de trabajo entre conversaciones distintas.

Técnicas de prompting eficiente
Rol + Contexto
Siempre definí el rol al inicio. "Actuás como analista de ciberseguridad con certificación OSCP, especializado en análisis de logs SIEM. Revisá esto..." produce resultados notablemente mejores que preguntas genéricas.
Formato explícito
Pedí el formato de salida. "Respondé en JSON con claves: vulnerability, cwe_id, severity, affected_line, fix" elimina ambigüedades y hace la respuesta inmediatamente usable en pipelines.
Chain-of-thought
Agregá "Pensá paso a paso antes de responder" para análisis complejos. Claude externaliza el razonamiento y produce análisis más precisos y verificables.
Ejemplos few-shot
Incluí 2-3 ejemplos concretos del input/output esperado. Esto calibra el estilo y nivel de detalle mejor que cualquier descripción en prosa.
Restricciones negativas
Decile qué NO hacer. "No incluyas explicaciones genéricas, solo hallazgos concretos con número de línea" acota el espacio de respuesta de forma efectiva.
Tags XML
Estructurá prompts largos con XML. <context>...</context> <task>...</task> <format>...</format> mejora la separación entre instrucciones y reduce alucinaciones.
💡
Truco pro: Instrucciones en XML

Para prompts complejos de seguridad usá <scope>...</scope> <code>...</code> <criteria>OWASP Top 10</criteria> <output>JSON</output>. Claude procesa cada sección de forma aislada y produce salidas más estructuradas.

Claude Desktop para Windows

La app de escritorio une las tres experiencias de Claude en un solo cliente nativo: conversación general, automatización de archivos (Cowork) y la potencia completa de Claude Code con CI/CD integrado.

Sub-sección A

Chat

El chat en Desktop tiene las mismas capacidades que la web, pero con acceso nativo al portapapeles del sistema, hotkeys globales y notificaciones de Windows al terminar tareas largas.

⌨️

Atajo global

Configurá un hotkey (ej. Alt+Space) para invocar Claude desde cualquier app Windows sin perder el foco. Ideal para consultas rápidas durante análisis de seguridad.

📋

Paste inteligente

Copiá cualquier log, stack trace o output de terminal desde otra app y pegalo en el chat. Claude reconoce el contexto automáticamente y ofrece acciones relevantes sin que lo especifiques.

🗂️

Proyectos sincronizados

Todos tus Proyectos de claude.ai están disponibles en Desktop. Continuá conversaciones desde el móvil, web y Desktop de forma transparente.

🔔

Notificaciones nativas

Recibís notificaciones de Windows cuando Claude termina tareas largas. Lanzá un análisis de logs, minimizá la ventana y seguí trabajando: Claude te avisa al terminar.

Sub-sección B

Cowork — Automatización de escritorio

🤖
¿Qué es Cowork?

Automatizá tareas de archivos, procesamiento de documentos y pipelines sin escribir código. Para analistas de seguridad: procesá logs en lote, organizá reportes de auditoría y generá resúmenes automáticos de CVEs.

Cowork — Casos de uso en seguridad
# Consolidar logs de múltiples fuentes en un reporte Cowork: "Leé todos los .log de /var/log/ossim/, filtrá eventos con severity=HIGH o CRITICAL, y generá /Reportes/alerta-diaria.csv con columnas: timestamp, src_ip, event_type, count" # Organizar reportes de pentesting por cliente Cowork: "Procesá los PDFs de /Pentests/2024/, extraé nombre del cliente, fecha y severidad general de cada reporte, y creá un índice en /Reportes/indice-pentests.xlsx" # Renombrar evidencias con formato estándar Cowork: "Renombrá todas las capturas de /Evidencias/ con formato AAAA-MM-DD_cliente_hallazgo-N usando el contenido del archivo."
Sub-sección C

Claude Code — CLI + CI/CD + Docker

Claude Code es el agente de codificación de Anthropic. Entiende tu repositorio completo, ejecuta comandos y trabaja de forma autónoma. Integrable en GitHub Actions y Docker.

PowerShell / Terminal
# Requisito: Node.js 18+ node --version # debe ser v18 o superior # Instalación global via npm npm install -g @anthropic-ai/claude-code # Verificar instalación claude --version # Primer uso — autenticación claude > Iniciá sesión en claude.ai cuando el browser se abra... # Inicio en un proyecto existente cd C:\mis-proyectos\mi-app claude # Modo no-interactivo (para scripts / CI) claude -p "Describí la arquitectura de este proyecto" --output-format json
claude "tarea"
Modo agente completo. Claude analiza el repo, planea, escribe código, ejecuta tests y valida. Ej: claude "Revisá src/ buscando SQL injection y generá fixes"
claude -p "..."
Print mode (no-interactivo). Ejecuta una sola consulta y retorna. Soporta --output-format json para pipelines CI.
claude --continue
Continuá la última sesión. Retoma el contexto anterior sin re-explicar el proyecto.
claude --resume [id]
Retomá una sesión específica por su ID. Listá sesiones con claude sessions list
CLAUDE.md
Archivo de contexto del proyecto. Claude lo lee automáticamente al iniciarse. Documentá la arquitectura, convenciones, comandos críticos y criterios de seguridad.

Los hooks ejecutan scripts automáticamente antes o después de acciones de Claude. Se configuran en .claude/settings.json.

.claude/settings.json — Hooks de seguridad
{ "hooks": { // Lint + security scan ANTES de que Claude escriba archivos "PreToolUse": [{ "matcher": "Write", "hooks": [{ "type": "command", "command": "npx eslint --fix $FILE && npx semgrep --config auto $FILE" }] }], // SAST scan después de cada write "PostToolUse": [{ "matcher": "Write", "hooks": [{ "type": "command", "command": "npx snyk test --file=$FILE 2>> security.log || true" }] }], // Notificación y resumen al finalizar sesión "Stop": [{ "hooks": [{ "type": "command", "command": "powershell -c \"[System.Media.SystemSounds]::Beep.Play()\"" }] }] } }
🔒
Hooks como guardia de seguridad

Los hooks en PreToolUse pueden bloquear acciones antes de que se ejecuten. Usá esto para prevenir que Claude elimine archivos críticos o guarde código sin pasar un SAST scan primero.

Los servidores MCP (Model Context Protocol) extienden Claude Code con herramientas externas: bases de datos, APIs, servicios de seguridad, y más.

Configurar MCP — claude mcp add
# MCP de GitHub claude mcp add github --transport sse "https://mcp.github.com/sse" # MCP de PostgreSQL (local) claude mcp add postgres --transport stdio \ "npx @modelcontextprotocol/server-postgres" \ --env DATABASE_URL="postgresql://user:pass@localhost/db" # MCP de Shodan (inteligencia de amenazas) claude mcp add shodan --transport stdio \ "npx @shodan/mcp-server" \ --env SHODAN_API_KEY="tu-api-key" # Ahora Claude puede usar herramientas en conversación: > "Buscá en Shodan hosts con el puerto 8080 abierto en el rango 192.168.1.0/24" Usando herramienta: shodan.host_search ✓ Encontrados 3 hosts — exportando a hosts-exposed.json

Claude Code puede integrarse en pipelines de GitHub Actions para code review automatizado, análisis de seguridad en PRs y generación de documentación.

.github/workflows/claude-security-review.yml
name: Claude Security Review on: pull_request: types: [opened, synchronize] jobs: claude-review: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Install Claude Code run: npm install -g @anthropic-ai/claude-code - name: Get changed files id: changed run: | echo "files=$(git diff --name-only origin/main HEAD | tr '\n' ' ')" >> $GITHUB_OUTPUT - name: Claude OWASP Review env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} run: | claude -p "Revisá los archivos modificados en este PR: ${{ steps.changed.outputs.files }} Aplicá criterios OWASP Top 10 2023 + principios SOLID. Para cada hallazgo: archivo, línea, CWE, severidad (CRITICAL/HIGH/MEDIUM/LOW), fix. Salida: JSON array." --output-format json > review.json - name: Post Review as PR Comment uses: actions/github-script@v7 with: script: | const fs = require('fs'); const review = JSON.parse(fs.readFileSync('review.json', 'utf8')); const body = review.map(r => `**${r.severity}** · ${r.file}:${r.line} · ${r.cwe}\n> ${r.fix}` ).join('\n\n'); github.rest.issues.createComment({ ...context.repo, issue_number: context.issue.number, body });
Dockerfile — Imagen con Claude Code integrado
FROM node:20-alpine AS base RUN npm install -g @anthropic-ai/claude-code FROM base AS analyzer WORKDIR /app COPY . . # Análisis de seguridad en build time RUN ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \ claude -p "Buscá vulnerabilidades OWASP en src/ y falla el build si encontrás severity=CRITICAL" \ --output-format json | node scripts/fail-on-critical.js # Imagen final de producción (sin Claude Code) FROM node:20-alpine AS production WORKDIR /app COPY --from=base /app/dist ./dist COPY package*.json . RUN npm ci --only=production USER node CMD ["node", "dist/server.js"]
✅
CLAUDE.md para CI/CD

En repos con GitHub Actions, agregá al CLAUDE.md una sección ## CI Rules con las reglas específicas del pipeline: qué archivos no tocar, qué tests correr siempre, y qué severidades bloquean el build.

El archivo CLAUDE.md — System prompt de repositorio

CLAUDE.md — Estructura recomendada
# Mi Proyecto ## Stack - Backend: Node.js 20 + Express + TypeScript - DB: PostgreSQL 16 con Prisma ORM - Tests: Vitest + Testing Library ## Comandos críticos - `npm run dev` → servidor puerto 3000 - `npm run test` → tests (SIEMPRE antes de commit) - `npm run lint` → ESLint + Prettier ## Criterios de seguridad - Todo input del usuario debe pasar validación Zod antes de usarse - Queries a la DB: solo Prisma ORM, nunca SQL crudo - Secretos: siempre en .env, nunca hardcodeados - Auth: JWT con expiración 1h, refresh token en httpOnly cookie ## Convenciones - async/await (nunca .then()) - Errores manejados con Result<T,E> (ver src/types/result.ts) - Toda función pública necesita JSDoc con @throws

Extensión Claude en VS Code

La extensión integra Claude Code directamente en tu editor. Accedés a un agente que entiende todo tu workspace, puede editar archivos, correr comandos y navegar el código sin salir del IDE.

⚡
Instalación rápida

Buscá "Claude Code" en el marketplace de VS Code o instalá con: code --install-extension anthropic.claude-code. Abrí el panel con Ctrl+Shift+C.

Configuración A

Selección de modelo

🚀
MÁS POTENTE
claude-opus-4

Para razonamiento complejo, arquitectura de sistemas, análisis de código legado, threat modeling profundo y tareas que requieren máxima precisión.

RazonamientoSeguridad
⚡
EQUILIBRADO
claude-sonnet-4

El modelo más versátil. Excelente para desarrollo diario, code review, análisis de logs, generación de tests y la mayoría de tareas de codificación.

DefaultDev diario
💨
MÁS RÁPIDO
claude-haiku-4

Para autocompletado, explicaciones rápidas, renombrado de variables, snippets y consultas que no requieren razonamiento profundo.

VelocidadSnippets
Configuración B

Comandos con /

/init
Inicializar el proyecto. Claude analiza el repositorio y genera un CLAUDE.md con arquitectura, stack detectado y convenciones. Hacelo siempre en proyectos nuevos.
/review
Code review completo. Claude revisa los cambios actuales con la profundidad de un senior dev: seguridad (OWASP), rendimiento, mantenibilidad y edge cases.
/test
Generar tests. Analiza el código activo y genera tests unitarios, de integración y edge cases usando el framework detectado. Incluye casos de seguridad.
/explain
Explicar código seleccionado. Descripción detallada de qué hace, por qué y cuáles son las implicaciones de rendimiento y seguridad.
/fix
Fix automático. Seleccioná código roto o el error del terminal y /fix diagnostica, propone la corrección con explicación del root cause.
/compact
Comprimir el contexto. Cuando el contexto se llena, crea un resumen eficiente de la sesión sin perder información clave. Usalo cada ~30 intercambios.
/doctor
Diagnóstico del entorno. Verifica que Claude Code tenga todos los permisos, herramientas y configuraciones necesarias para funcionar correctamente.
Configuración C

Referencias con @

@archivo.ts
Incluye el contenido completo del archivo. Ej: @src/auth.ts Revisá esta función buscando broken auth (OWASP A07)
@carpeta/
Procesa todos los archivos del directorio. Ej: @src/routes/ Añadí rate limiting y validación de input a todos los endpoints
@git
Historial de git / diff actual. Ej: @git staged Revisá estos cambios buscando secrets expuestos antes del commit
@problemas
Errores del panel Problems. Incluye todos los errores de TypeScript, ESLint y otros linters. Ej: @problemas Corregí todos los errores de tipo
@terminal
Output del terminal integrado. Captura stacktraces, logs, errores. Ej: @terminal ¿Por qué falla el build?
@url
Contenido de una URL. Ej: @https://owasp.org/Top10/ Implementá las mitigaciones relevantes en @src/
Configuración D

Agentes, Skills y Subagentes

🤖

Modo Agente Autónomo

Claude toma decisiones, ejecuta comandos y verifica resultados sin intervención. Ideal para tareas bien definidas:

claude "Buscá todas las queries SQL en src/, identificá las vulnerables a SQLi y refactorizalas usando Prisma ORM. Corré los tests al final."
🔀

Multi-agente en paralelo

Lanzá múltiples instancias para tareas independientes:

# Terminal 1: Security audit claude "Auditá src/ con criterios OWASP" # Terminal 2: Test coverage (paralelo) claude "Aumentá coverage a 90%+"

Custom Slash Commands

.claude/commands/security-audit.md
--- description: "Auditoría de seguridad completa del proyecto" --- Realizá una auditoría de seguridad completa: 1. Buscá vulnerabilidades OWASP Top 10 2023 en src/ 2. Verificá que no haya secrets hardcodeados (API keys, passwords, tokens) 3. Revisá dependencias con `npm audit` y reportá las críticas 4. Verificá headers de seguridad HTTP en los endpoints 5. Generá /reports/security-audit-FECHA.md con: - Resumen ejecutivo - Hallazgos por severidad (CRITICAL / HIGH / MEDIUM / LOW) - Fix propuesto para cada hallazgo - Checklist de remediación // Activar con: /security-audit

MCP Servers

Claude Code se conecta con tus herramientas a través de MCP Servers. Aquí las integraciones más importantes, incluyendo herramientas de ciberseguridad.

GitHub
Crear PRs, revisar issues, analizar diffs y gestionar branches desde la conversación
Stripe
Consultar pagos, crear productos, gestionar suscripciones y debuggear webhooks
PostgreSQL
Ejecutar queries, inspeccionar schemas, generar migraciones y optimizar consultas
Shodan
Búsqueda de hosts expuestos, análisis de superficie de ataque y threat intelligence en tiempo real
VirusTotal
Análisis de IPs, dominios, hashes y URLs maliciosas directamente desde Claude Code
MISP / TheHive
Gestión de IOCs, correlación de eventos de seguridad y creación de alertas en plataformas SOAR
AWS / GCP
Gestionar recursos cloud, revisar policies IAM, detectar misconfigurations y costos
Slack
Enviar alertas de seguridad, reportes de deploy y notificaciones de incidentes a canales
Sentry
Consultar errores en producción, analizar stacktraces y correlacionar con cambios de código
.claude/settings.json — MCPs incluyendo ciberseguridad
{ "mcpServers": { "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." } }, "postgres": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost:5432/miapp"] }, // Shodan — threat intelligence y búsqueda de hosts expuestos "shodan": { "command": "npx", "args": ["-y", "@shodan/mcp-server"], "env": { "SHODAN_API_KEY": "tu-shodan-api-key" } }, // VirusTotal — análisis de hashes, IPs y URLs "virustotal": { "command": "npx", "args": ["-y", "mcp-virustotal"], "env": { "VT_API_KEY": "tu-vt-api-key" } }, "slack": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-slack"], "env": { "SLACK_BOT_TOKEN": "xoxb-..." } } } }

Ejemplos de objetivos reales

Flujos completos que combinan Claude Web, Desktop y VS Code con integraciones reales para alcanzar objetivos concretos de desarrollo.

01
Implementar sistema de pagos con Stripe desde cero
VS CodeClaude CodeMCP StripeGitHub
1
Explorar la documentación de Stripe con Claude Web
Web: "Actuás como arquitecto de pagos. Necesito implementar pagos únicos y suscripciones con Stripe en Node.js + TypeScript. Buscá la doc más reciente y dame el flujo con endpoints exactos, webhooks necesarios y errores que debo manejar. Formato: tabla markdown."
2
Scaffold con Claude Code en VS Code
VS Code: "Implementá el sistema de pagos con Stripe. Necesito: - POST /api/checkout — crear Payment Intent - POST /api/subscribe — crear Subscription - POST /api/webhooks/stripe — recibir eventos (payment_succeeded, subscription.updated) - Validar firma del webhook con STRIPE_WEBHOOK_SECRET - Tests para cada endpoint con mocks de Stripe Stack actual: @src/app.ts @CLAUDE.md" ✓ src/routes/checkout.ts · src/routes/webhooks.ts ✓ src/services/stripe.service.ts · src/tests/payments.test.ts (18 tests)
3
Crear PR con MCP de GitHub
VS Code: "/deploy y después creá un PR con título 'feat: Stripe payment system' describiendo endpoints, coverage y breaking changes" ✓ Tests: 18/18 ✓ Build: exitoso ✓ PR creado: github.com/org/repo/pull/42
02
Configurar pipeline CI/CD completo con GitHub Actions
Claude WebVS CodeMCP GitHub
1
Diseñar el pipeline en Claude Web
Web: "Sos un experto en DevOps. Diseñá un pipeline de CI/CD para: - Stack: Node.js + TypeScript + PostgreSQL - Deploy target: AWS ECS con Fargate - Branches: main (producción) + develop (staging) Necesito: lint → test → SAST (Snyk) → build → docker → deploy Con caché de dependencias, notificaciones a Slack y rollback automático."
2
Generar archivos de configuración
VS Code: "Generá el workflow de GitHub Actions con el step de Claude security review integrado. @CLAUDE.md · Incluí Dockerfile multi-stage optimizado y el script de rollback." ✓ .github/workflows/ci.yml ✓ .github/workflows/deploy.yml ✓ Dockerfile (multi-stage, 180MB → 45MB) ✓ scripts/rollback.sh
03
Migrar y optimizar base de datos con MCP SQL
VS CodeMCP PostgresClaude Code
1
Analizar el schema con MCP Postgres
VS Code: "Conectate a la DB y analizá el schema completo. Identificá: - Tablas sin índices en columnas frecuentemente consultadas - FK sin índice, queries lentas (pg_stat_statements) - Columnas nullable que deberían ser NOT NULL" ⚠ orders.user_id — FK sin índice (tabla de 2M rows) ⚠ products.category — 450ms avg query, necesita índice
2
Generar y verificar migración
VS Code: "Generá migración Prisma que agregue índices CONCURRENTES (sin lock). Ejecutá EXPLAIN ANALYZE antes/después y reportá la mejora." ✓ orders JOIN query: 850ms → 12ms (98.6% mejora) ✓ products filter: 450ms → 8ms (98.2% mejora)
04
Refactor masivo de codebase legada a TypeScript
Claude Code CLIMulti-agenteHooks
1
Auditoría con Claude en modo análisis
claude -p "Analizá todos los .js de src/ y generá reporte JSON con: complejidad ciclomática, dependencias entre módulos, funciones sin JSDoc, patrones problemáticos (callbacks anidados, globals)" --output-format json > audit.json
2
Migración en paralelo con hook TypeScript automático
# 3 terminales simultáneos claude "Migrá src/routes/ de JS a TypeScript con tipos de express" claude "Migrá src/services/ de JS a TypeScript con interfaces para DTOs" claude "Migrá src/utils/ de JS a TypeScript con genéricos" // Hook PostToolUse: valida tsc en cada write automáticamente "command": "npx tsc --noEmit $FILE && echo OK || echo FAIL"
05
Construir agente de soporte técnico con Claude API
Claude WebAPI AnthropicVS CodeSlack MCP
1
Diseñar el sistema prompt del agente
Web: "Diseñá un agente de soporte técnico que: 1. Consulte nuestra DB de tickets (Postgres vía MCP) 2. Busque en la doc interna (archivos Markdown) 3. Escale a humanos en Slack si confidence < 0.7 4. Responda en < 2s para casos simples Diseñá el system prompt, esquema de tools y lógica de escalación con few-shot examples."
2
Implementar y testear
VS Code: "Implementá el agente con Anthropic SDK v0.30+. @CLAUDE.md sección 'Agente Soporte'. Testear con 20 tickets reales." ✓ Resolución sin escalación: 78% ✓ Tiempo: 1.3s ✓ Accuracy: 91%

Ciberseguridad con Claude

Claude es un aliado poderoso para analistas de seguridad: code review ofensivo/defensivo, análisis de herramientas, threat modeling, OSINT y detección de anomalías en logs. Todo en contexto educativo y autorizado.

⚠️
Contexto de uso responsable

Claude asiste en análisis de seguridad defensiva, CTFs autorizados, pentesting con scope definido y educación técnica. Para cada prompt de seguridad, especificá siempre el contexto: entorno controlado, plataforma educativa o engagement autorizado. Esto mejora la calidad de las respuestas y mantiene el uso dentro del marco ético.

🔎

Code Review de Seguridad

Análisis exhaustivo de código buscando vulnerabilidades OWASP Top 10, con CWE ID, severidad CVSS v3 y fix concreto para cada hallazgo.

🏴‍☠️

CTF & Análisis de Exploits

Ayuda para entender vulnerabilidades en desafíos CTF, identificar tipos de exploits y comprender flujos de explotación con fines educativos.

🗺️

Threat Modeling

Generación de análisis STRIDE, identificación de actores y superficies de ataque, y redacción de informes de pentesting profesionales.

🔧

Interpretación de Herramientas

Claude analiza outputs de Burp Suite, Nmap, Metasploit y otras herramientas para identificar vectores de ataque y próximos pasos.

📊

Análisis de Logs & OSINT

Detección de patrones de ataque en logs, correlación de IOCs, y soporte para investigaciones OSINT con fuentes públicas.

🛡️

Hardening & Remediación

Guías de hardening específicas por tecnología, listas de verificación de seguridad y priorización de remediaciones por riesgo.

Sub-sección A

Code Review de Seguridad (SAST con IA)

Claude puede actuar como un analizador SAST sofisticado cuando se le provee el código completo con contexto del stack. La clave es especificar los criterios exactos de análisis.

Actuás como un experto en AppSec con certificación OSCP y profundo conocimiento de OWASP Top 10 2023. Analizá el siguiente código buscando ESPECÍFICAMENTE: □ A01 Broken Access Control — verificá que cada endpoint valide permisos □ A02 Cryptographic Failures — datos sensibles en tránsito y en reposo □ A03 Injection — SQL, NoSQL, LDAP, OS command, XSS □ A07 Identification & Authentication Failures — manejo de sesiones, JWT □ A09 Security Logging Failures — qué se loguea y qué no Para cada hallazgo reportá: - Línea exacta afectada en el código - CWE ID y nombre completo - Severidad CVSS v3: CRITICAL / HIGH / MEDIUM / LOW - Explicación del riesgo en términos de impacto al negocio - Fix concreto con código corregido Formato de salida: primero tabla resumen ordenada por severidad, luego sección detallada por hallazgo con el fix. <code> [PEGÁ AQUÍ EL CÓDIGO A ANALIZAR] </code>

Ejemplo de output esperado

CRITICAL
CWE-89 SQL Injection — línea 47: db.query("SELECT * FROM users WHERE id=" + userId)
Fix: db.query("SELECT * FROM users WHERE id = $1", [userId])
HIGH
CWE-798 Hardcoded Credentials — línea 12: const JWT_SECRET = "mi-secreto-123"
Fix: mover a variable de entorno con validación en startup
MEDIUM
CWE-522 Insufficiently Protected Credentials — contraseñas hasheadas con MD5 en lugar de bcrypt/argon2
LOW
CWE-209 Information Exposure — stack traces expuestos en respuestas de error en modo producción
💡
Truco: Claude Code + Semgrep en paralelo

Para proyectos grandes, combiná: npx semgrep --config auto src/ --json | claude -p "Analizá estos hallazgos de Semgrep, priorizalos por riesgo real y descartá falsos positivos". Claude filtra y contextualiza mejor que cualquier herramienta sola.

Sub-sección B

CTF & Análisis de Exploits Educativos

Claude es un excelente compañero para CTFs: ayuda a identificar el tipo de vulnerabilidad, explicar el concepto detrás del exploit y sugerir herramientas. Siempre especificá que es un entorno educativo.

Estoy participando en un CTF educativo en la plataforma [HackTheBox / TryHackMe / PicoCTF]. El desafío es: [descripción del reto] Tengo acceso a: [código fuente / binario / servicio web / puerto abierto] Ayudame a: 1. Identificar el tipo de vulnerabilidad (explicación conceptual) 2. Entender el flujo de explotación paso a paso 3. Seleccionar herramientas apropiadas (gdb, pwndbg, pwntools, Ghidra, etc.) 4. Razonar sobre el payload sin dármelo completo — quiero aprender Contexto: entorno controlado y autorizado, solo con fines educativos.

🔢 Tipos de vuln que Claude explica bien

  • ✓Buffer overflow — stack vs heap, ret2libc, ROP chains
  • ✓Format string — lectura/escritura arbitraria de memoria
  • ✓Web: SQLi, XSS, SSRF, XXE — bypass de filtros, payloads avanzados
  • ✓Crypto: padding oracle, ECB mode — ataques clásicos de criptografía
  • ✓Reversing — análisis de algoritmos en assembler/bytecode

🛠️ Prompt para análisis de binario

Web: "Tengo este output de checksec y el decompilado de Ghidra de un binario CTF. Identificá el tipo de vulnerabilidad, explicá el concepto de explotación y qué secciones del código son el punto de entrada del ataque. <checksec>[OUTPUT]</checksec> <decompiled>[CÓDIGO]</decompiled>"
Sub-sección C

Threat Modeling y Redacción de Informes

Claude puede generar threat models completos usando la metodología STRIDE y redactar informes de pentesting profesionales a partir de tus hallazgos.

Realizá un threat model STRIDE para el siguiente sistema: [Descripción del sistema: componentes, flujos de datos, usuarios, tecnologías] Estructura del análisis: — Actores: internos, externos, adversarios potenciales — Activos críticos: datos, servicios, infraestructura — Por cada categoría STRIDE: S — Spoofing: amenazas de identidad + mitigaciones T — Tampering: integridad de datos + controles R — Repudiation: trazabilidad + logging I — Information Disclosure: confidencialidad + cifrado D — Denial of Service: disponibilidad + resiliencia E — Elevation of Privilege: control de acceso + least privilege — Matriz de riesgo: probabilidad × impacto (1-5) — Top 5 remediaciones priorizadas por ROI de seguridad
Redactá un informe ejecutivo de pentesting basado en los siguientes hallazgos: [Lista de vulnerabilidades encontradas con detalles técnicos] El informe debe tener: — Resumen ejecutivo (para no técnicos, máx. 1 página) — Alcance y metodología (herramientas usadas, período, scope) — Hallazgos por severidad (CRITICAL → LOW), para cada uno: · Descripción técnica del riesgo · Evidencia (capturas/outputs) — marcadores: [VER EVIDENCIA X] · Impacto en el negocio en términos no técnicos · Pasos de remediación con referencias (CVE, CWE, OWASP) · Tiempo estimado de remediación — Tabla de riesgo residual post-remediación — Roadmap de remediación a 30/60/90 días Tono: profesional, concreto, sin jerga innecesaria.
Sub-sección D

Interpretar Outputs: Burp Suite · Nmap · Metasploit

El patrón más potente: ejecutás la herramienta, copiás el output en Claude y pedís análisis, priorización y próximos pasos. Claude conoce profundamente el output de cada herramienta.

🕷️

Burp Suite

Contexto: pentesting autorizado en [URL/sistema]. Intercepté esta request/response HTTP en Burp Suite: <request>[PEGÁ LA REQUEST COMPLETA]</request> <response>[PEGÁ LA RESPONSE]</response> Analizá: ¿Hay parámetros vulnerables a SQLi, XSS, IDOR, CSRF? ¿Los headers de seguridad están correctos? (CSP, HSTS, X-Frame-Options) ¿La cookie tiene los flags httpOnly y Secure? Dame payloads de prueba para cada vector identificado.
📡

Nmap

Escaneo autorizado en [target/scope]. Output de Nmap: <nmap_output>[PEGÁ EL OUTPUT COMPLETO DE NMAP]</nmap_output> Analizá: 1. ¿Qué servicios tienen versiones con CVEs conocidos? (mencioná los CVE ID) 2. ¿Qué puertos/servicios representan mayor superficie de ataque? 3. ¿Qué información sobre el OS/stack podés inferir del fingerprint? 4. Próximos pasos recomendados (scripts NSE, enumeración adicional) Formato: tabla por puerto con servicio/versión/CVEs/riesgo/siguiente paso.
💉

Metasploit

Pentesting autorizado. Scope: [definido en contrato]. Output del módulo Metasploit: <msf_output>[PEGÁ EL OUTPUT DE MSF]</msf_output> Explicá: 1. ¿Qué vulnerabilidad explota este módulo? (CVE + descripción técnica) 2. ¿Qué indica el output sobre el nivel de acceso obtenido? 3. ¿Cuáles son los pasos post-explotación más relevantes para documentar? 4. ¿Qué artefactos y logs deja la explotación que debo documentar para el informe?
Sub-sección E

OSINT, Análisis de Logs y Detección de Anomalías

Claude es especialmente útil para correlacionar eventos en logs y detectar patrones de ataque que serían difíciles de identificar manualmente. Clave para trabajo en SIEM como OSSIM.

📋 Análisis de Logs de Servidor Web

Actuás como analista SOC Nivel 1. Analizá estos logs de Apache/Nginx: <logs>[PEGÁ LOS LOGS AQUÍ]</logs> Identificá: — Patrones de ataque: SQLi, XSS, LFI/RFI, path traversal, brute force, scanners — IPs con comportamiento sospechoso (volumen, user-agents, timing) — Códigos de respuesta que sugieran éxito de ataques (200 en paths sospechosos) — IOCs para bloquear en firewall/WAF Formato: tabla de IPs sospechosas + timeline cronológico + lista de IOCs.

🔍 OSINT — Reconocimiento con fuentes públicas

Investigación OSINT autorizada para [empresa/scope]. A partir de esta información inicial: [dominio / empresa / IP] Sugerí qué información buscar en estas fuentes públicas: — DNS: subdominios, registros MX/TXT, transferencias de zona — Certificate Transparency: crt.sh para certificados expuestos — Shodan/Censys: servicios y puertos expuestos — GitHub: posibles secretos o código interno filtrado — Wayback Machine: versiones anteriores del sitio Objetivo: mapear la superficie de ataque usando SOLO fuentes pasivas.
OSSIM / AlienVault — Prompt para análisis de alertas
Claude: "Tengo estas alertas de OSSIM de las últimas 4 horas: [PEGÁ LAS ALERTAS EN FORMATO CSV O TEXTO] Actuás como analista SOC. Identificá: 1. ¿Hay correlación temporal entre las alertas? ¿Sugiere un ataque coordinado? 2. ¿Cuáles son las fuentes IP únicas y en qué países están? 3. ¿Hay patrones de escalada de privilegios o movimiento lateral? 4. Clasificá las alertas: ruido de fondo vs. amenaza real (P1/P2/P3) 5. ¿Qué reglas de correlación OSSIM recomendás activar?"

Programación Avanzada

Flujos completos de desarrollo con Claude: desde el diseño de arquitectura hasta la documentación, pasando por tests, refactoring y code review con criterios específicos de calidad y seguridad.

Sub-sección A

Flujo completo: Arquitectura → Código → Tests → Refactor → Docs

FLUJO
Implementar una feature completa de forma profesional
Claude WebVS CodeClaude Code
1
Diseño de arquitectura (Claude Web)
Antes de escribir código, usá Claude Web para diseñar.
Web: "Actuás como arquitecto de software senior. Necesito diseñar el módulo de autenticación para [descripción del sistema]. Considerá: scalability, testability, separation of concerns, seguridad. Devolvé: 1. Diagrama de componentes en ASCII 2. Decisiones arquitectónicas con pros/cons de alternativas 3. Interfaces/contratos entre componentes 4. Riesgos identificados y cómo mitigarlos"
2
Implementación guiada (VS Code)
VS Code: "Implementá el módulo de autenticación según la arquitectura definida. @CLAUDE.md · @src/types/auth.ts (interfaces ya definidas) Seguí: async/await, Result<T,E> para errores, JSDoc en funciones públicas. NO implementes la UI todavía." ✓ src/services/auth.service.ts ✓ src/repositories/user.repo.ts
3
Tests exhaustivos
VS Code: "/test @src/services/auth.service.ts Necesito coverage mínimo 90%. Incluí: - Happy path (login exitoso, registro, logout) - Error cases (credenciales inválidas, usuario no existe, token expirado) - Edge cases (SQL injection en inputs, encoding especial, concurrencia) - Mocks para la DB y servicios externos" ✓ 34 tests generados · Coverage: 94.2%
4
Refactoring con SOLID
VS Code: "Revisá @src/services/auth.service.ts aplicando principios SOLID. Identificá code smells y refactorizá sin cambiar el comportamiento externo. Verificá que @src/tests/auth.test.ts siga pasando después del refactor."
5
Documentación automática
VS Code: "Generá documentación técnica para @src/services/auth.service.ts: 1. JSDoc completo con @param, @returns, @throws para cada función 2. Sección en README.md: 'Authentication Module' con ejemplos de uso 3. Entrada en CHANGELOG.md: feat: authentication module v1.0 4. Actualizá CLAUDE.md con la arquitectura del nuevo módulo"
Sub-sección B

CLAUDE.md para Monorepos y Proyectos Grandes

En monorepos, la clave es tener un CLAUDE.md raíz con contexto global y CLAUDE.md por paquete con contexto específico. Claude los lee en cascada.

Monorepo — Estructura recomendada
mi-monorepo/ ├── CLAUDE.md ← Contexto global del monorepo ├── packages/ │ ├── api/ │ │ └── CLAUDE.md ← Contexto específico del API │ ├── web/ │ │ └── CLAUDE.md ← Contexto específico del frontend │ └── shared/ │ └── CLAUDE.md ← Tipos y utils compartidos └── .claude/ ├── settings.json ← MCPs y hooks globales └── commands/ ← Slash commands personalizados
CLAUDE.md raíz — Monorepo
# Monorepo — Mi Plataforma SaaS ## Arquitectura global - Monorepo con Turborepo + pnpm workspaces - packages/api → Express + TypeScript (puerto 4000) - packages/web → Next.js 14 App Router (puerto 3000) - packages/shared → Tipos compartidos, validaciones Zod ## Reglas ABSOLUTAS (aplican a TODO el monorepo) - NUNCA importar desde packages/ usando rutas relativas entre paquetes Usar: @mi-plataforma/shared (workspace alias) - NUNCA hardcodear URLs de API — usar process.env.API_URL - Secretos SOLO en .env.local (nunca en .env commiteado) ## Comandos globales - `pnpm dev` → Levanta todos los servicios en paralelo - `pnpm test` → Tests de todos los paquetes - `pnpm type-check` → TypeScript en todos los paquetes ## Para tareas que afectan múltiples paquetes Siempre verificar: ¿el cambio en shared rompe la API o el web? Ejecutar: `pnpm type-check` antes de commitear cualquier cambio en shared/
Sub-sección C

Debugging Complejo — Cómo Compartir Errores de Forma Efectiva

La diferencia entre "Claude resuelve el bug en 1 turno" y "3 turnos dando vueltas" está en cómo presentás el error. Usá esta plantilla.

## Contexto del error — Qué estaba haciendo: [acción concreta que desencadenó el error] — Comportamiento esperado: [qué debería pasar] — Comportamiento actual: [qué pasa en realidad] — ¿Es reproducible?: siempre / intermitente / solo en prod ## Stack trace completo <error> [PEGÁ AQUÍ EL STACK TRACE COMPLETO — no recortes] </error> ## Entorno — Node.js: v20.10.0 · TypeScript: 5.3.2 — OS: Windows 11 / Ubuntu 22.04 — Paquete que falló: nombre@versión ## Código relevante @src/services/payment.service.ts ← donde ocurre el error @src/routes/checkout.ts ← quien llama a la función ## Lo que ya intenté — Intenté X → resultado Y — Revisé Z → no encontré nada relevante — La función funcionaba hasta el commit [hash corto]
⚡
En VS Code: usá @terminal + @archivo

En el panel de Claude: @terminal @src/services/payment.service.ts El test de la línea 47 falla intermitentemente. Analizá el stack trace y el código. Claude ve el output real del terminal sin que copies nada.

Sub-sección D

Code Review con Criterios Específicos: OWASP + SOLID + Clean Code

OWASP
Seguridad: "/review @src/ — Criterios: OWASP Top 10 2023. Para cada hallazgo: línea, CWE, severidad CVSS, fix."
SOLID
Diseño OOP: "/review @src/services/ — Verificá los 5 principios SOLID. Señalá violaciones con propuesta de refactor."
Clean Code
Legibilidad: "/review @src/ — Criterios Clean Code: nombres significativos, funciones pequeñas, no comentarios obvios, DRY."
Performance
Rendimiento: "/review @src/db/ — Buscá N+1 queries, índices faltantes, queries no paginadas y memory leaks potenciales."
Completo
Review senior-level: "/review @git staged — Aplicá todos los criterios: OWASP + SOLID + Clean Code + Performance + Testabilidad."
Sub-sección E

Integración CI/CD — Claude en GitHub Actions

🔄

Casos de uso en CI/CD

  • ✓Code review automático en PRs — comentarios con hallazgos
  • ✓Security scan — OWASP en cada push a main
  • ✓Generación de release notes — a partir de commits
  • ✓Documentación automática — actualizar README en merges
  • ✓Análisis de coverage — comentar tests faltantes
⚙️

Configuración de secretos

# En GitHub repo Settings → Secrets: ANTHROPIC_API_KEY = sk-ant-... # En el workflow, claudelo con: env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} # Modo no-interactivo obligatorio en CI: claude -p "tarea" --output-format json
.github/workflows/claude-pr-review.yml — Completo
name: Claude PR Review on: pull_request: { types: [opened, synchronize] } permissions: pull-requests: write contents: read jobs: review: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: { fetch-depth: 0 } - uses: actions/setup-node@v4 with: { node-version: '20' } - run: npm install -g @anthropic-ai/claude-code - name: Get diff id: diff run: | git diff origin/${{ github.base_ref }}...HEAD > changes.diff echo "files=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | tr '\n' ' ')" >> $GITHUB_OUTPUT - name: Claude Review env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} run: | cat changes.diff | claude -p \ "Revisá este diff de PR como senior dev. Criterios: OWASP Top 10, SOLID, tests faltantes, performance. Máximo 5 hallazgos priorizados. Formato JSON: [{file, line, severity, issue, suggestion}]" \ --output-format json > review.json - name: Comment on PR uses: actions/github-script@v7 with: script: | const findings = JSON.parse(require('fs').readFileSync('review.json')); const icons = { CRITICAL:'🔴', HIGH:'🟠', MEDIUM:'🟡', LOW:'🟢' }; const body = '## 🤖 Claude Code Review\n\n' + findings.map(f => `${icons[f.severity]} **${f.severity}** · \`${f.file}:${f.line}\`\n${f.issue}\n> ${f.suggestion}`).join('\n\n'); github.rest.issues.createComment({ ...context.repo, issue_number: context.issue.number, body });

Investigación y Análisis

Claude puede sintetizar documentación técnica extensa, comparar frameworks y protocolos, y extraer insights accionables de papers y RFCs en minutos en lugar de horas.

Sub-sección A

Análisis de Papers, RFCs y Documentación Técnica

El truco es proporcionar el documento completo y especificar exactamente qué extraer y para qué audiencia. Un buen prompt de análisis de paper produce un resultado directamente usable.

Actuás como experto técnico en [dominio del paper/RFC]. Analizá el siguiente documento: <document>[PEGÁ EL TEXTO DEL PAPER / RFC / DOC TÉCNICA]</document> O bien: usá Web Search para buscarlo directamente: "Buscá y analizá el RFC 9110 (HTTP Semantics)..." Extraé: 1. Resumen ejecutivo — 3 párrafos, nivel: [experto técnico / manager / non-technical] 2. Hipótesis/Propuesta principal con los argumentos clave 3. Metodología o especificación — los detalles técnicos más relevantes 4. Resultados o cambios propuestos con datos numéricos si los hay 5. Limitaciones y casos edge que el documento reconoce 6. Aplicabilidad a mi contexto: [describí tu proyecto/sistema] 7. Preguntas abiertas que el documento no responde

📖 Para RFCs de protocolos

Web: "Buscá el RFC 8446 (TLS 1.3). Explicame los cambios respecto a TLS 1.2, las implicaciones de compatibilidad, y qué debo cambiar en mi servidor Nginx para cumplirlo."

🔬 Para papers de seguridad

Web: "Subí el PDF del paper. Resumí la técnica de ataque propuesta, el CVE asociado si existe, y cómo implementar las mitigaciones recomendadas en un stack Node.js + Postgres."
Sub-sección B

Síntesis de Información de Múltiples Fuentes

Claude puede recibir varios documentos a la vez (como adjuntos en claude.ai) y generar una síntesis coherente que identifica acuerdos, contradicciones y gaps.

Tengo [N] documentos sobre [tema]. Los adjunto a esta conversación. Realizá una síntesis que incluya: 1. Puntos de acuerdo — qué afirman TODAS las fuentes 2. Contradicciones — dónde las fuentes difieren y por qué (contexto, fecha, metodología) 3. Gaps — qué preguntas importantes ningún documento responde 4. Ranking de fuentes por calidad/relevancia para mi caso de uso: [describí el contexto] 5. Conclusión accionable — qué debería hacer/decidir a partir de esta información Fuentes: [listá brevemente las fuentes para que Claude las referencie en la síntesis]
💡
Para investigación de threat intelligence

Cargá múltiples informes de amenazas (Mandiant, CrowdStrike, CISA) en un Proyecto de Claude y pedile: "Sintetizá los TTPs del grupo APT mencionado en estos informes y mapeálos al framework MITRE ATT&CK". Claude cruza las fuentes automáticamente.

Sub-sección C

Comparativas Técnicas: Frameworks, Herramientas y Protocolos

Generá una comparativa técnica entre [A], [B] y [C] para el caso de uso: [descripción específica de tu contexto y escala] Criterios de evaluación (ajustá según tu caso): | Criterio | Peso | A | B | C | |---|---|---|---|---| | Rendimiento | 25% | ? | ? | ? | | Seguridad | 20% | ? | ? | ? | | Escalabilidad | 20% | ? | ? | ? | | Curva de aprendizaje | 15% | ? | ? | ? | | Ecosistema / comunidad| 10% | ? | ? | ? | | Costo total (TCO) | 10% | ? | ? | ? | Para cada criterio: justificá la puntuación con datos concretos o benchmarks. Terminá con: — Recomendación para mi caso específico con justificación — Cuándo elegir cada opción (trade-offs claros) — Red flags de cada opción que debo conocer antes de decidir

🔒 Comparativas de seguridad

Ej: JWT vs Session Cookies vs OAuth 2.0, WAF vendors, SIEM platforms, EDR solutions

🗄️ Comparativas de infraestructura

Ej: PostgreSQL vs MongoDB vs DynamoDB, Redis vs Memcached, Kubernetes vs ECS

⚡ Comparativas de stack

Ej: Next.js vs Remix vs SvelteKit, Express vs Fastify vs Hono, Prisma vs Drizzle

Escritura Técnica

Claude produce documentación técnica de alta calidad: READMEs profesionales, specs de API en OpenAPI, changelogs estructurados y post-mortems que realmente ayudan a prevenir incidentes futuros.

Sub-sección A

README Profesionales

Generá un README.md profesional para este proyecto. Contexto del proyecto: @CLAUDE.md @package.json @src/ El README debe incluir en este orden: 1. Badges: CI status, coverage, versión npm, licencia 2. Descripción: qué hace, para quién es, qué problema resuelve (3 líneas) 3. Demo / Screenshot: marcador [CAPTURA O GIF] si aplica 4. Features: lista de capacidades principales con íconos 5. Instalación: paso a paso con comandos copiables 6. Uso rápido: ejemplo mínimo funcional en código 7. Configuración: variables de entorno con descripción y valores por defecto 8. API / Endpoints: tabla con método, ruta, descripción, auth required 9. Contributing: cómo contribuir, convenciones de commits, proceso de PR 10. Licencia Tono: técnico pero accesible. Audiencia: developers que van a usar o contribuir.
Sub-sección B

Documentación de APIs (OpenAPI / Swagger)

Generá la especificación OpenAPI 3.0 completa para los siguientes endpoints. Código fuente: @src/routes/ @src/types/ Para cada endpoint incluí: — operationId descriptivo (ej: createPaymentIntent) — summary y description completa con casos de uso — tags para agrupar por módulo — requestBody schema con todos los campos, tipos y validaciones (required, minLength, pattern) — responses: 200/201 con schema de éxito + TODOS los errores posibles (400, 401, 403, 404, 422, 500) — examples reales para cada request/response — security: qué auth requiere (Bearer JWT, API Key, etc.) Formato de salida: YAML válido que pueda importarse directamente en Swagger UI / Redoc.
Fragmento de output esperado
openapi: "3.0.3" info: title: Mi API version: "1.0.0" paths: /api/users/{id}: get: operationId: getUserById summary: Obtener usuario por ID security: [{ BearerAuth: [] }] responses: '200': content: application/json: example: { id: "usr_123", email: "user@example.com" } '401': { $ref: '#/components/responses/Unauthorized' }
Sub-sección C

Changelogs, Post-mortems y Reportes de Incidentes

📋 Changelog desde git log

En VS Code: @git "Generá el CHANGELOG.md para la versión v2.1.0 basado en los commits desde v2.0.0. Clasificá en: — ✨ Features: nuevas funcionalidades — 🐛 Bug Fixes: correcciones — ⚡ Performance: mejoras de rendimiento — 🔒 Security: parches de seguridad (IMPORTANTE: listá al principio) — 💥 Breaking Changes: cambios que rompen compatibilidad — 🔧 Internal: refactoring, deuda técnica Seguí el formato keepachangelog.com. No incluyas commits de merge ni 'fix typo'.

🚨 Post-mortem de incidente de seguridad

Redactá un post-mortem blameless del siguiente incidente: <incident> [Describí el incidente: qué pasó, cuándo, qué sistemas afectó, cuánto duró] [Incluí los logs y alertas relevantes] </incident> Estructura del post-mortem: — Resumen ejecutivo: 3 líneas (qué pasó, impacto, resolución) — Timeline: cronología exacta con timestamps (detección → respuesta → resolución) — Root cause: causa raíz técnica (NO culpar personas) — Contributing factors: factores que lo hicieron posible o lo agravaron — Impact: usuarios afectados, datos, SLA, costo estimado — Resolution: qué se hizo para mitigarlo — Action items: tabla con Owner / Fecha / Prioridad para prevenir recurrencia — Lessons learned: qué salió bien y qué mejorar en el proceso de respuesta

Cheatsheet Completo

Todos los comandos, flags, atajos y prompts esenciales en un solo lugar. Guardá esta sección como referencia diaria.

Claude Code — CLI Flags

ComandoDescripciónEjemplo
claudeModo interactivo (REPL)claude
claude -p "..."Modo no-interactivo (pipe)echo "Fix bug" | claude -p "Arreglá esto"
--output-format jsonSalida estructurada JSONclaude -p "analiza" --output-format json
--continue / -cContinuar última sesiónclaude --continue
--resume <id>Retomar sesión por IDclaude --resume abc123
--modelSeleccionar modeloclaude --model claude-opus-4-5
--max-turns NLimitar turnos de agenteclaude -p "task" --max-turns 10
--allowedToolsWhitelist de herramientas--allowedTools "Bash,Read,Write"
--disallowedToolsBlacklist de herramientas--disallowedTools "WebSearch"
--verboseOutput detalladoclaude --verbose

Slash Commands (Claude Code)

ComandoAcción
/clearLimpiar contexto de la conversación
/compactResumir contexto para liberar tokens
/memoryVer y editar CLAUDE.md del proyecto
/modelCambiar modelo en la sesión
/costVer consumo de tokens de la sesión
/doctorDiagnóstico de instalación
/bugReportar bug con contexto automático
/exitSalir (o Ctrl+C dos veces)

@ References (VS Code / Claude Code)

SímboloQué incluye
@archivo.pyContenido completo del archivo
@src/Todos los archivos de la carpeta (recursivo)
@gitGit diff, commits recientes, estado del repo
@problemsErrores y warnings activos del linter / TypeScript
@CLAUDE.mdInstrucciones del proyecto (system prompt implícito)
@urlContenido de una URL (Claude Code lee la página)
#nombreBuscar y referenciar símbolo (función, clase, variable)

Atajos de Teclado

Claude Code (terminal)

Ctrl+C
Interrumpir acción actual
Ctrl+C×2
Salir de Claude Code
Ctrl+L
Limpiar pantalla
↑ ↓
Navegar historial de prompts
Esc
Cancelar prompt actual (modo vim)

VS Code Extension

Ctrl+Shift+C
Abrir panel Claude
Ctrl+I
Inline edit en selección
Ctrl+Enter
Aceptar sugerencia
Ctrl+K
Modo comando rápido
Esc
Rechazar sugerencia

🔒 Ciberseguridad — Prompts Rápidos

TareaPrompt base
Code review de seguridad"Revisá @archivo.py con criterios OWASP Top 10 2023"
Análisis de log sospechoso"Analizá este log: [LOG]. ¿Qué técnica MITRE ATT&CK detectás?"
Threat modeling STRIDE"Aplicá STRIDE a: [descripción del sistema]"
Análisis de CVE"Explicame CVE-XXXX-XXXX y cómo mitigarlo en [stack]"
Config de seguridad"Revisá esta config de Nginx/Apache/SSH para hardening"
OSINT de dominio"¿Qué info pública existe sobre el dominio [dominio]?"
Script de análisis"Escribí un script Python para parsear logs de [herramienta] y detectar [patrón]"
Reporte de vulnerabilidad"Redactá un reporte de vuln en formato CVE para: [descripción técnica]"

⚡ Programación — Prompts Rápidos

TareaPrompt base
Arquitectura de componente"Diseñá la arquitectura de [componente] con estas restricciones: [lista]"
Generar tests"Escribí tests unitarios con [Jest/pytest] para @función.py con edge cases"
Refactor con patrón"Refactorizá @archivo.ts aplicando el patrón [Strategy/Observer/etc]"
Debug complejo"Analizá @git problems. Usá rubber duck debugging: explicame el flujo"
Code review SOLID"Revisá @src/ con principios SOLID y OWASP. Listá violaciones con severidad"
Generar OpenAPI"Generá spec OpenAPI 3.0 YAML para @src/routes/"
GitHub Actions CI/CD"Creá workflow GH Actions para [Node/Python/Docker] con lint+test+build+deploy"
Optimizar query SQL"Optimizá esta query SQL para [Postgres/MySQL]: [QUERY]"

MCP — Config Rápida

~/.claude/settings.json — Estructura base
{ "mcpServers": { "shodan": { "command": "npx", "args": ["-y", "@shodan/mcp-server"], "env": { "SHODAN_API_KEY": "your-key" } }, "virustotal": { "command": "npx", "args": ["-y", "@virustotal/mcp-server"], "env": { "VT_API_KEY": "your-key" } }, "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/ruta/segura"] } }, "hooks": { "PreToolUse": [{ "command": "python log_tool_use.py" }], "PostToolUse": [{ "command": "python save_output.py" }] } }

Sobre el Autor

El profesional detrás de esta guía

xavimape

Analista de Ciberseguridad · Enthusiasta de Claude AI

Analista de seguridad nivel 1 con foco en análisis de datos y automatización. Creo esta guía documentando flujos reales que uso a diario con Claude AI — desde code reviews OWASP hasta scripts de análisis de logs.

¿Te resultó útil esta sección?

⭐ Guardar repositorio