A complete guide to go from "I use Claude Code for specific things" to running an agent system that works for you, remembers what it did, and wakes up on its own.
I'm going to throw out a lot of terms. I'm not going to stop and explain every one. When something sounds like Chinese, copy-paste the slide or term into ChatGPT/Claude and ask it to explain. That's literally what it exists for. Don't be shy — do it in real time if you want.
I'm not going to drill into every tool — that's what docs and YouTube are for. What I'm sharing is my personal and professional experience after many hours of real usage — what actually works for me day to day.
My setup is based on what I follow on Twitter / X: developers from Anthropic, OpenAI, people building on top of the models, tooling founders. I learn in real-time from those pushing limits. I don't invent this — I distill it.
I hope this presentation helps — but you have to put in the work. Everything you see today: research it, try it yourself, break it, build it back. The only way to learn agents is by using them.
Anatomy, levels of agency, CLI zoo, routing.
CLAUDE.md/AGENTS.md, slash commands, hooks, skills, sub-agents, MCPs, memory, /goal, loops.
/morning, /loop, parallel multi-agent.
Hermes vs Claude Code, open-source models.
Vault as memory, KB + RAG + MCP.
PR review, fix-it agents, workflows.
Hardening (10 rules), prompt injection, supply chain.
Backend vs frontend, stack, languages, advice.
What to do on Monday. Exercises from 30 min to 1 weekend.
Terms that appear throughout the presentation. If you already know them, skip this.
An LLM with tools, memory, and a goal. Not a chat — a worker with hands.
Ej: Claude Code, Codex CLI, Cursor agent, Hermes, Devin.
The whole system around the model: prompts, hooks, tools, memory, flows. 70% of the value.
Ej: CLAUDE.md + skills + hooks + slash commands + MCPs configured together.
A capability the agent can invoke. Each tool is a "verb".
Ej: Read, Write, Bash, Grep, WebFetch, query_bigquery, send_slack.
Model Context Protocol. Open standard to connect agents with external systems. "USB for LLMs".
Ej: dbt MCP, BigQuery MCP, Snowflake MCP, Atlassian, Slack, Postgres MCP.
Retrieval-Augmented Generation. Search docs first, then answer using them as context.
Ej: chatbot that reads your Confluence. ChatGPT with "search". Cursor reading your repo.
Convert text to numeric vectors for semantic search (not exact-word match).
Ej: OpenAI text-embedding-3, Voyage AI, BGE, stored in Qdrant / pgvector.
Maximum number of tokens the model processes at once.
Ej: Sonnet 200K, Opus 200K, Gemini 2.5 Pro 1M+, Kimi K2 128K-2M.
A chunk of text (~4 characters). What you pay for. What the model consumes.
Ej: "data engineer" ≈ 3 tokens. 10-page PDF ≈ 5K. Long session: 100K+.
We'll see each of these on its own slide. This is just the cheat sheet.
Script triggered automatically on agent events. Your personal CI/CD.
Ej: SessionStart shows #blocker. PostToolUse runs pytest after editing a .py.
Prompt saved in a .md, invokable with /name. For recurring tasks.
Ej: /morning, /eod, /cost-review, /security-review, /new-component.
Reusable behavior the agent invokes only when it applies to the context.
Ej: tdd, brainstorming, verification-before-completion, debugging.
Another instance of the model, with its own context, launched by the main agent.
Ej: Explore, Planner, Critic, Tester, Document-specialist.
A copy of the repo in another folder and branch. Lets N agents run in parallel without conflict.
Ej: git worktree add ../repo-feature-x feature/x.
Definition of Done. Objective checklist so the agent knows when to stop iterating.
Ej: tests pass + lint clean + coverage >80% + conventional commit.
Compress a model so it uses less memory. You lose some quality but it runs locally.
Ej: Qwen 14B Q4_K_M (4-bit), Llama 70B GPTQ, Gemma 4 + TurboQuant.
Systematic quality test of the model output. The opposite of "vibes".
Ej: 20 real cases with expected output. RAGAS, Promptfoo, LangSmith.
Vault sync, weekly agent memory snapshots, 10:00 morning briefing. Without touching anything.
4 sub-bases (current job, parent company, ex-job, personal) cross-linked, each with its own CLAUDE.md.
A persistent agent runs in the homelab, has memory versioned in git, and writes to you on its own when needed.
It's not a team. It's just me. Everything you'll see you can copy this week.
Compares AWS costs vs yesterday, reads my work-log from yesterday, scans Slack overnight, reviews #blocker in the vault, proposes focus for the day.
An alias opens 4 simultaneous tabs: notes vault, main repo, finops repo, client repo. Each with its context loaded.
Big task → split. Codex runs tests. Claude Sonnet plans. Sub-agent Explore traces code while you write.
Chains: daily snapshot → compare with last 7 days → flag anomalies → look up context in vault → executive summary. What used to be 90 min is now 5.
Iterates all repos, detects commits of the day, updates work-log with what was done, leaves "context for tomorrow", commits the vault.
Weekly memory snapshot, summary of the week's sessions, automatic push to repo. You're not there.
"Compara coste de un servicio últimos 30 días vs Q anterior, atribuye por sub-servicio, dame 3 hipótesis del aumento del 18%". El agente usa el MCP de Cost Explorer, lee el snapshot del vault y correla con métricas.
"De los proyectos abiertos en las 2 empresas, cuáles tienen blocker hace >2 semanas y a quién hay que pinchar". Lee STATUS.md, contacts.md, last-modified de cada uno.
"Dame un MCP en Python que exponga 4 tools sobre Cost Explorer". Plan + scaffold + tests + README, en un goal de 30 min sin interacción.
"Convierte estas notas de 3 meetings en un report de 1 página para finance". Output con frontmatter, links a fuentes, cifras citadas.
"DD vs Grafana vs Datadog para nuestro caso, costes a 12 meses, riesgos por servicio crítico". Saca info del vault, completa con web fetch.
"Immich no arranca, qué pasó". Lee el runbook, hace SSH al server, mira logs, propone fix. Como un SRE de bolsillo.
La pieza no obvia: todo se reproduce con un script. Si me roban el Mac, en 1h tengo otro idéntico. El agente hereda esto como "memoria operativa".
| Before (chat) | Now (agent) |
|---|---|
| Question → answer | Goal → loop until done |
| Plain text | Tools, file system, MCPs, shell |
| You do the copy-paste work | Reads/writes files, runs tests, opens PRs |
| No memory | MEMORY.md, hooks, RAG persistente |
| One model | Routing: Haiku executes, Opus reasons |
| You open the session | Lives on its own and writes to you |
| Linear | Parallel sub-agents, worktrees |
| Blind to the world | Knows who you are, what projects you run, what you decided yesterday |
Chat with the ability to read and write files. You drive step by step. This is where 90% of people who "use Claude Code" are.
Le das un objetivo + criterio de éxito ("tests pasan") y se mete en bucle. /loop (Claude Code nativo), /goal (oh-my-claudecode), /autopilot (oh-my-claudecode). Tú sólo revisas el resultado.
N agentes, N worktrees, N tareas. Tú orquestas. Patrón típico: 1 humano + 4 agentes en tmux (terminal con varios paneles simultáneos en una pantalla). Productividad multiplicativa, no aditiva.
Vive 24/7. Tiene cron, memoria, identidad y proactividad. Te escribe él: "AWS billing +12% hoy, ¿investigo?". El nivel donde el agente deja de ser herramienta y pasa a ser colega.
Salto Level 1 → 2 = aprender 1 comando. Salto Level 2 → 3 = aprender git worktrees. Salto Level 3 → 4 = montar infraestructura. Cada salto cuesta menos de lo que parece.
| CLI | Modelo | Fuerte en | Débil en |
|---|---|---|---|
| Claude Code | Sonnet 4.6 · Opus 4.7 · Haiku | Razonar, refactor grande, planning | Caro en sesiones largas |
| Codex CLI | gpt-5.5-codex | Velocidad, full-auto, "ejecuta ya" | Razonar arquitectura compleja |
| Gemini CLI | Gemini 2.5 Pro | Context window 1M+, multimodal, tier gratis | Tools menos pulidos |
| Kimi CLI | Kimi K2 · Moonshot | Barato, contexto largo, fallback | Calidad inferior en código complejo |
| Aider · Cline · Cursor agent | cualquiera | Diff-based, dentro del IDE | Menos hands-off |
El secreto no es elegir el mejor — es tener instalados los 3-4 y que cada uno haga lo suyo.
Cada CLI tiene su pool de créditos. Combinándolos, multiplicas tu rate limit y bajas coste medio significativamente.
Es lo que mejor programa hoy. Más rápido, más fiable en ejecución de tareas concretas (refactors, tests, full-auto). Mi default para "implementa esto".
Mejor en frontend (sentido del diseño, accesibilidad, copy) y en code review (encuentra bugs sutiles, explica trade-offs). Default para "razona esto" o "revisa esto".
Lanzo Codex para implementar, Claude para revisar el diff y para todo lo de UI. Las dos suscripciones se amortizan solas.
| Modelo | Quién lo hace | Para qué |
|---|---|---|
| Kimi K2 | Moonshot AI | Contexto largo, fallback, ~5x más barato que Sonnet |
| Qwen 3.6 / Coder | Alibaba | Coding fuerte, open-weights → corre local con Ollama |
| MiniMax M2 / abab | MiniMax | Razonamiento fuerte, agentes, precio bajísimo |
| DeepSeek V3 / R1 | DeepSeek | Razonamiento + coding, super-barato, open-weights |
| GLM-5 | Zhipu | Open-source, supera a Opus 4.6 en algunos benchmarks |
My rule: tarea importante de coding → Codex o Claude. Tarea importante de UI / review → Claude. Tarea de bulk / batch / extracción → modelo chino vía API barata. Tarea con datos sensibles → Qwen local.
Hub que enchufa a cualquier modelo (open y propietario). Tiene tier gratis con Llama, Qwen, DeepSeek, Mixtral. Una sola API key para probarlos todos.
CLI open-source tipo Claude Code/Codex. Tiene modelos gratis ocasionalmente (rotando promociones de proveedores). Buen plan B cuando los demás te dan rate limit.
IDE con agente. A veces tiene modelos gratis (Claude Sonnet, Gemini Flash, GPT-4o-mini limitados). Útil para sesiones rápidas sin gastar de tu suscripción principal.
Inferencia gratuita de modelos open-source (Llama 3, Qwen, Gemma). Velocidades brutales. Perfecto para experimentar y para tu agente persistente sin coste.
El 95% de la gente se queda en nivel 1. La diferencia con nivel 4 no se mide en %, se mide en órdenes de magnitud. Una semana de tu trabajo = una mañana del de ellos.
Cada nivel se construye encima del anterior. No te saltes ninguno. El prompt sigue importando aunque tengas hooks.
Un fichero markdown en la raíz que el agente lee siempre al empezar. Es el "qué somos, cómo trabajamos, qué no tocar".
CLAUDE.md. Codex y Cursor leen AGENTS.md. Otros como Cline, Continue o Aider tienen sus propios nombres. Truco: escribe AGENTS.md y haz un CLAUDE.md que sea un symlink o que diga "see AGENTS.md" — así sirves a todos.
# Pipeline ABC
## Stack
- dbt 1.8 (BigQuery)
- Airflow 2.10
- Python 3.12, uv
## Convenciones
- staging: stg_*, mart: fct_/dim_*
- snake_case, sin acentos
- tests: not_null + unique en PK
## Comandos
- dbt run: dbt build --select +tag:daily
- tests: pytest tests/ -x
- lint: sqlfluff lint models/
## NO TOCAR
- models/legacy/* (deprecated 2025)
- archived/* (audit only)Un slash command es un prompt guardado que ejecuta una secuencia. En vez de teclear 500 palabras, tecleas /cost-review.
# ~/.claude/commands/morning.md
You are running my morning routine.
### Step 1: Cost Snapshot
- Run compare-costs.py --text
- Summarize in 3 lines
### Step 2: Work Log
- Read most recent file in
~/notes/work-log/
- Extract "context for tomorrow"
### Step 3: Slack Check
- DMs + mentions overnight
- relevant channels' headlines
### Step 4: Present Briefing
Format: cost · ayer · projects ·
slack · suggested focus.Es un .md normal. Lo metes en ~/.claude/commands/, lo invocas con /morning. Eso es todo.
Scripts que se disparan automáticamente en eventos del agente. Funcionan como middlewares o git hooks.
SessionStart: al abrir Claude CodePreToolUse: antes de cada tool callPostToolUse: después de cada tool callUserPromptSubmit: antes de procesar tu mensajeStop: al terminar la sesión#blocker tags pendientesUn JSON en ~/.claude/settings.json mapea evento → comando shell. El comando puede ser cualquier cosa: bash, python, node. Output va al contexto del agente.
Un skill es un conjunto de instrucciones + checklists empaquetado. El agente lo invoca cuando aplica al contexto.
verification-before-completionUse when about to claim work is
complete or passing, before
committing or creating PRs.
Required:
- Run verification commands
- Confirm output before any
success claims
- Evidence before assertions
Checklist:
[ ] Tests passed (paste output)
[ ] Lint clean
[ ] Build succeeds
[ ] Manual UI check (if frontend)Hay repos enteros de skills + slash commands + hooks + agents listos para instalar — para Claude Code, para Codex, o agnósticos. Plug-and-play.
Skills, comandos y agentes empaquetados (/autopilot, /team, /trace…), TDD-style "superpowers" curados por Anthropic, y listas curadas de la comunidad. Sólo si usas Claude Code.
Repos con system prompts pulidos, recetas de full-auto bien configuradas, ejemplos de scripting con codex exec, y workflows reutilizables. Comunidad creciendo rápido.
MCPs funcionan en Claude, Codex, Cursor, Cline y otros. Lista oficial + curated. El más universal — empieza por aquí.
Componentes y design systems listos. Funcionan con cualquier agente que sepa generar JSX. Para que tu UI no parezca de 2018.
Un sub-agente es otra instancia del modelo, con su propio contexto, que tu agente principal lanza para una tarea concreta.
→ Explore agent. Tú no quieres ese contexto.
→ Plan agent. Output: pasos numerados.
→ Critic agent. Independiente, sin sesgo.
→ Sub-agente con su propio contexto largo.
The trick mental: tratar al agente principal como un lead, no como un operario. Su trabajo es decidir y delegar, no leer.
Model Context Protocol: estándar abierto que conecta agentes con sistemas externos (DBs, APIs, ficheros) de forma uniforme.
Cost Explorer, S3, Lambda, EC2, CloudWatch.
PRs, issues, actions, releases, search.
Deploys, projects, env vars, logs.
Query, schema, RLS policies.
Issues, comments, search, pages.
Mensajes, canales, búsqueda, DMs.
Query, schema, costs (data).
Métricas, errores, anomalías.
No memory, el agente es un becario nuevo cada lunes. Con memoria, es un colega que te conoce.
Markdown plano. Cada memoria un fichero. Un MEMORY.md index que se carga al inicio de cada sesión. Versionado en git → auditable, restaurable.
---
name: integration-tests-no-mocks
description: tests integración deben
usar BD real, no mocks
type: feedback
---
Integration tests must hit a real
database, not mocks.
Why: incidente Q4 2025 — los mocks
pasaron, la migración a prod falló.
How to apply: cuando veas tests en
tests/integration/, asume BD real.
Para unit tests sí mocks.Lo que convierte un agente en un trabajador: iterar hasta cumplir un criterio objetivo.
# Tarea
Add edge case test for X.
# Definition of Done
[ ] Test exists in tests/X/
[ ] Test fails on current main
[ ] Implementation makes it pass
[ ] All other tests still pass
[ ] Lint clean
[ ] Coverage >80%
[ ] Conventional commit messageNo es un slash command cualquiera. Es la pieza que convierte una sesión en una misión.
Sin /goal, las sesiones largas se desvían. Empiezas pidiendo "arregla el bug" y acabas refactorizando 3 módulos sin razón. El goal es ancla.
$ /goal Migrar el endpoint /users
de la versión v1 a v2 sin breaking
changes. DoD: tests v1 + v2 pasan,
docs actualizadas, deprecation header
en v1 con sunset 2026-12.
[goal saved]
$ ahora arregla este typo
en el README
⚠ Desviación detectada.
El typo no avanza el objetivo de
migración. ¿Procedo igual o lo
dejo en el TODO post-migration?El agente te corrige a ti. Es lo más cerca de "tener un PM detrás" sin contratar uno.
/goal. Termínala con verificación contra ese goal. Cero scope creep.
El error #1. El agente termina y tú confías. Pregúntale siempre: "qué has hecho exactamente, qué archivos has tocado, por qué". Mira el diff. Si no entiendes algo, pregunta.
El modelo tiende a decir "listo" sin haber comprobado. Siempre exige evidencia: output de tests, screenshot, comando con su salida. "Demuéstramelo, no me lo digas".
Un /loop o /goal sin límite puede gastarte 5-50€ sin verlo. Siempre dale max steps o un budget. Y revisa la factura semanal de la API.
Le pides cosas sin decir en qué proyecto, qué stack, qué has probado ya. La calidad de la respuesta sale de ahí. Si no tienes CLAUDE.md, escríbelo antes de pedirle nada serio.
Si algo sale mal a la primera, no lo abandones — corrígelo. "No, eso no es lo que quería, vuelve a hacerlo así". La IA aprende dentro de la sesión. Trátala como un junior nuevo.
Si el agente usa una librería o pattern que no conoces, pregúntale o búscalo. Si dejas que el agente sepa más que tú de tu propio código, se acabó tu carrera.
Tres demos cortas. Si una sola se entiende, el resto del lunes lo dedicas a copiar el patrón.
Agent como rutina diaria. Quita 20 min al café.
Agent como bucle TDD. Lo que explota cabezas.
Agent como equipo paralelo. Productividad multiplicativa.
Lo hace mientras hago café. Sin tocar Slack, sin abrir AWS, sin leer notas.
work-log/YYYY-MM-DD.md y extrae la sección "context for tomorrow"#blocker en el vault enteroUn humano + 4 agentes = startup de 5 personas a coste de 1.
Un agente que no muere al cerrar el terminal. Vive en un servidor, tiene memoria propia, tareas programadas y proactividad para escribirte.
@shannholmberg en X. Una carpeta vps-agents/ accesible desde cualquier sitio, con runbooks. "Algo se rompió — ¿qué hago?" respondido en menos de 30s.
No compiten — se complementan. Y de hecho, Hermes puede invocar a Claude Code (o a Codex) por dentro.
| Claude Code | Hermes (agente persistente) | |
|---|---|---|
| Vida | Sesión efímera, abres tú | 24/7, vive en un servidor |
| Memoria | MEMORY.md por proyecto | Memoria global versionada en git, evoluciona |
| Quién inicia | Tú siempre | Cron, webhooks, o tú |
| Comunicación | Terminal | WhatsApp, Telegram, Slack, email… |
| Mejor para | Coding hands-on, refactors, planning | Vigilancia, rutinas, recordatorios, proactividad |
| Coste | Tu suscripción | Hardware + tu suscripción |
| Setup | 1 minuto | 1 weekend |
My recommendation: domina Claude Code primero (3-6 meses). Cuando ya estés cómodo con slash commands, hooks y skills, monta tu Hermes. Sin lo primero, lo segundo es ruido.
| Modelo | Para qué sirve hoy | Hardware mínimo |
|---|---|---|
| Qwen 3.6 + vLLM + TurboQuant | Reemplazo decente de Sonnet local | GPU 24GB |
| Qwen3.5-27B Opus-Distilled | Terraform · infra · ya en producción real | GPU 24-48GB |
| Gemma 4 + TurboQuant | ~20 t/s en Mac Mini, código simple | Apple Silicon 16GB+ |
| GLM-5 | Open-source > Opus 4.6 en bench | Cluster (VRAM bestial) |
| Kimi K2 | Bate Opus 4.6 · > 1TB VRAM | Cluster (Exo Labs) |
| Llama 3.3 / 3.5 | Meta · ecosistema enorme · fine-tunes | GPU 16-48GB |
Más fácil. ollama run qwen2.5:7b y listo.
Más rápido, batch, production-grade. Requiere GPU buena.
Empieza por 7B. Si va bien, sube.
Conecta Claude Code → endpoint local con la misma API.
Si me quitas todo y me dejas una sola cosa, dejadme el vault. Es el activo que más uso al día y lo que hace que mis agentes parezcan magia.
git pull && commit && push 2 veces/día. Si añado nota, está versionada en horas.Personal/sessions/ con tags y decisiones tomadas./eod detecta commits de todos mis repos del día, escribe work-log/YYYY-MM-DD.md, deja "context for tomorrow".compare-costs.py compara contra los últimos 7-30 días.Antes: rebuscar en Slack, en mails, en notas sueltas. Ahora: agente lee contacts.md, busca el nombre, encuentra meeting-notes, decisiones, action items pendientes. 5 segundos.
Agent compara snapshots de cost diarios, identifica el servicio que sube, busca en projects/ si hay un proyecto reciente que lo justifica, lee contacts.md para saber a quién pingar. Output: un Slack listo para enviar.
Cada decisión grande la dejo en decisions/YYYY-MM-DD-titulo.md con contexto, alternativas y por qué. 6 meses después el agente lo recupera en una pregunta. Antimemoria del equipo nueva → vault.
Lunes, abro /morning. El agente lee work-log/viernes.md, me dice qué dejé, qué prometí entregar, qué reuniones tengo. 0 fricción de "¿en qué estaba?".
/predict-cost lee perfiles de clientes existentes (projects/client-X/usage.md), calcula promedio por feature, aplica al nuevo cliente. Antes era una tarde de Excel, ahora 3 minutos.
Cuando algo de mi empresa actual se relaciona con mi ex-empleo (patrones de Terraform, lecciones aprendidas), el vault tiene los dos. El agente une los puntos automáticamente con cross-links.
mkdir ~/notes && cd ~/notes && git init. Crea CLAUDE.md raíz con 5 líneas: quién eres, en qué trabajas, qué proyectos llevas, qué NO tocar, dónde vive cada cosa.
Ojo: el vault no necesita Obsidian. Es markdown plano. Pero Obsidian te da grafo, búsqueda, links automáticos. No uses Notion para esto — el agente no lo lee bien.
Una carpeta por contexto principal: work/, personal/, learning/. En cada una un CLAUDE.md. Mete tus 5-10 proyectos activos, cada uno con un STATUS.md.
Symlink desde tu home: ln -s ~/notes ~/.claude/notes. En tu CLAUDE.md global del agente, mete instrucciones para leer ese vault al arrancar.
Cron simple: cd ~/notes && git add . && git commit -m "auto" && git push 2 veces al día. Slash command /save-session que resume y guarda. Crece desde aquí.
Indexar Java/C++ con call graphs en graph DB tipo Kuzu. 500 tokens por query vs 200K+ para que un agente "explore" a mano. Cuando el código es millones de líneas, esto importa.
Markdown plano + CLAUDE.md por carpeta. El agente lee con Read · Grep. No hace falta vector DB para empezar — un buen grep cubre el 80%. Sólo añade embeddings cuando duela.
El cuello de botella en cualquier equipo no es escribir código — es revisarlo. Aquí los agentes son brutales.
GitHub Action que dispara un agente al abrir/actualizar PR. Comenta inline: bugs, edge cases, código muerto, malas prácticas. Antes de que lo vea un humano.
El agente lee el diff y aplica labels: area/data, breaking-change, needs-migration, security-review. Routing automático al reviewer adecuado.
Auto-genera descripción del PR a partir del diff: qué cambia, por qué, cómo testear, breaking changes. Mantiene CHANGELOG.md sin esfuerzo.
Mira qué líneas nuevas no tienen cobertura, propone tests. En algunos repos directamente los escribe y los empuja al PR.
Issue nuevo → agente lo lee, busca duplicados, asigna prioridad, sugiere owner basado en git blame del área tocada.
Mencionas @claude en un comment del PR con la indicación. El agente abre commits en la branch del PR. Lo que antes era ping-pong, ahora es delegar.
.github/workflows/ que escucha pull_request.github/agents/review.md — convenciones, criterios, qué priorizarNo necesitas reinventarlo — los productos ya existen. Sólo aprende qué hace cada uno y elige.
# .github/workflows/pr-review.yml
name: AI Review
on:
pull_request:
types: [opened, synchronize]
jobs:
review:
runs-on: ubuntu-latest
permissions:
pull-requests: write
contents: read
steps:
- uses: actions/checkout@v4
- uses: anthropics/claude-code-action@v1
with:
api_key: ${{ secrets.ANTHROPIC_API_KEY }}
mode: review
prompt: .github/agents/review.mdY al revés: si los configuras mal, son una superficie de ataque enorme. Las dos caras importan.
package.json / pyproject.toml y reporta CVEs nuevasEmpieza con allowlist explícita de comandos. Bash sólo lo que necesitas. Sube permisos a medida que confíes.
Operaciones que tocan prod o filesystem global → contenedor / VM / sandbox. Nunca ejecuciones libres con tu cuenta de AWS.
Usa managers (Bitwarden, 1Password, Vault). El agente recibe referencias, no valores. Hooks que detectan y bloquean.
Pin a versión exacta. Lee el código antes. Si es de un autor random sin reputación → no lo enchufes a un agente con tools potentes.
Mandar Slack, abrir PRs, transferir dinero, modificar prod → el agente propone, tú confirmas. Sin excepciones al principio.
Webs, PRs de fuera, emails: pueden contener "ignore previous instructions". Sanitiza antes de pasar al modelo.
Logs estructurados de qué tool se llamó, con qué args, qué output. Sin esto no puedes investigar un incidente.
PII / financiero / cliente → cifrado o local. Las TOS de los proveedores cambian. Lee qué se entrena con tu data.
Si el agente puede hacer requests salientes, allowlist de dominios. Bloqueo por defecto.
Documenta en el runbook: cómo revocas la API key, cómo paras el cron, cómo cierras el agente persistente. Antes de necesitarlo.
"Lee este endpoint Y la doc API, dime los 5 vectores más probables y cómo probarlos sin romper nada". El agente razona sobre auth flows, IDOR, rate limits.
"Revisa cómo se firman los JWTs en este servicio y si hay flujos donde el secret se puede filtrar". Encuentra cosas que un humano cansado no ve.
Cualquier PR a Terraform → agente comenta sobre security groups, IAM, S3 bucket policies, KMS, encryption at rest.
Agent lee email reportado, clasifica: phishing, spam, legítimo. Adjunta evidencia (URL reputation, header analysis, similitud con dominios reales).
"Aquí 50K líneas de log. Algo raro pasó entre las 14:00 y las 14:30. Construye la línea de tiempo y dame las hipótesis ranked".
"Lee este código y dime qué controles GDPR / SOC2 / PCI no se están cumpliendo, con citas a líneas concretas".
Esto no es hype de Twitter. Es presión estructural y top-down en todas las empresas grandes.
Mandate público: 100% del eng team usando IA semanalmente. 20% sin escribir código a mano para octubre. Auditado.
"AI usage" forma parte de las performance reviews desde 2025. Quien no lo usa, justifica.
30%+ del código nuevo asistido por IA. Métricas internas de aceptación de sugerencias.
Cualquier reunión con board en 2026 incluye "AI productivity uplift". Es una métrica como churn o ARR.
Estudios internos muestran 30-50% más velocidad en tareas concretas (refactors, tests, docs). Imposible ignorarlo.
Si un eng con IA hace el trabajo de 2, ahí va el headcount. Quien adopta tarde paga más por menos output.
Las top hires de 2026 ya entran asumiendo que la IA es parte del flujo. Si tu compañero junior va más rápido que tú, te toca aprender.
El frontend "de meter componentes" se acabó. Sólo el frontend especializado paga bien.
El "razonamiento sobre el sistema" sigue siendo más humano que la generación de código — pero la IA mejora rápido aquí también. La ventana para entrar todavía está abierta, no para siempre. Aprovéchala ahora.
EC2, S3, IAM, VPC, RDS. Aprende a montar una webapp simple a mano. Después automatízalo. La cert SAA-C03 (Solutions Architect Associate) cubre lo justo y es la más respetada para empezar.
Serverless básico. La mayoría de side-projects modernos viven aquí. Súper barato, escala solo, perfecto para la primera SaaS.
Pipeline mínimo: lint + test + build + deploy a tu cuenta AWS. Aprende secrets, environments, OIDC con AWS (sin keys hardcoded). Esto sale en TODA entrevista.
Reescribe tu infra clickeada en código. Aprende módulos, estado, workspaces. Después terragrunt si trabajas con varias cuentas. Casi ninguna empresa seria opera ya sin IaC.
Docker sí, siempre. K8s sólo si vas a empresas que lo usan en serio. Para 90% de side-projects, ECS Fargate es más sencillo y suficiente.
Cuando AWS te suene fluido. No aprendas las 3 a la vez. Profundidad > amplitud. Conceptos se transfieren bien.
A partir de mid/senior, el technical interview no es algoritmos — es diseñar un sistema. Si no lo entrenas, no pasas.
system-design-primer en GitHub, casos en Pramp / Hello Interview"Hazme una entrevista de system design para un Twitter clone, y critícame al final". Hazlo 20 veces.
Python para data, AI, scripting, backend rápido. TypeScript para todo lo web (front + back). Con estos 2 cubres el 80% de las ofertas y el 100% de side-projects.
Go: K8s ecosystem, microservicios sencillos, compañías cloud-native. Rust: systems, performance crítica, sale-tier. Java/Kotlin: enterprise, fintech, Android.
SQL en serio — joins, ventanas, EXPLAIN. Bash para automatizar tu vida. YAML porque vas a vivir en él (CI, K8s, Terraform Cloud, dbt).
No están muertos pero el mercado es estrecho. Aprende uno cuando un trabajo lo pida, no antes. Ruby on Rails sí si te toca alguna scaleup concreta.
Si llevas >3 años de experiencia, la IA bien usada te convierte en alguien que hace el trabajo de 3-5 personas. Esto cambia tu carrera.
Tu valor es decidir: arquitectura, qué construir, cuándo confiar en el agente, cuándo vetar. Tratar al agente como un ingeniero junior infinito y barato.
Slash commands compartidos, MCPs internos, hooks de seguridad, workflows de PR review. Multiplica el throughput de tus compañeros, no sólo el tuyo.
Refactors que daban pereza, migraciones, audits. La IA reduce el coste 10x. Lo que antes era "sprint épico" ahora es "tarde de viernes".
Presentaciones internas, demos, PRs ejemplares. Los managers buscan "AI champion" que pueda guiar a otros — no quien lo use a escondidas. Tu próximo ascenso depende de esto.
PRs/semana, bugs cerrados, features shipped, dollar saved. Compáralo con tu yo de hace 6 meses. Si no estás 2x, algo va mal.
Si la IA hace todo, te atrofias. Mantén un ratio: 80% delegado · 20% a mano (algoritmos, debugging duro, lectura de papers). El día que el modelo se cae no puedes paralizarte.
No es un módulo aparte. Cada capa que aprendes tiene su componente de seguridad. Integrarlo desde el principio te diferencia del 80% de devs.
→ OWASP Top 10. SQL injection, XSS, CSRF, SSRF. Auth flows (OAuth2, OIDC). Mira Web Security Academy de PortSwigger (gratis).
→ IAM de verdad: least privilege, role chaining. Bucket policies, KMS, security groups, VPC endpoints. Lee flaws.cloud (CTF gratis sobre AWS).
→ Pre-commit hooks con tfsec, checkov, terrascan. Detección de drift. Secrets en SSM/Secrets Manager, nunca en code.
→ OIDC con cloud (sin long-lived keys). Pinned actions con SHA. Dependabot. Branch protection. Signed commits.
→ Prompt injection, output validation, allowlist de tools, sandbox para agentes destructivos. Sección 08 de esta presentación.
→ NUNCA .env en git. Bitwarden / 1Password CLI. Rotación de keys. Backups cifrados. Tu primer leak es cuestión de tiempo.
The trick no es dedicar 100h a una cosa — es tener señal en todas. Con 25h en cada bloque ya sabes la lengua. Después escoges 2-3 donde profundizas según trabajo.
Tu CV son tus proyectos, no las empresas en las que estuviste. 1 side-project terminado pesa más que 5 a medias. Termínalos · enséñalos · sigue.
No pierdas tardes maquetando. Pide a Claude/ChatGPT un CV en HTML, exporta a PDF. Aplica en masa: incluso jobs "que no son para ti" — la conversación misma te enseña dónde estás.
Saber preguntar bien (a humanos y a IA) es la skill más infravalorada. Pregunta con contexto, hipótesis y qué has probado.
Meetups, conferencias, ex-compañeros. El 80% de los trabajos buenos vienen por contacto, no por aplicar a ofertas.
Lleva un work-log (al final lo hace tu agente por ti). Tu yo de hace 6 meses te sorprenderá. Mejora lo que mides.
La IA cambia cada mes. Lo que aprendiste hace 6 meses está medio obsoleto. Sigue X (Twitter) y reserva 2-3h/semana para ver qué hay nuevo. Cuentas obligatorias: @simonw, @swyx, @AnthropicAI, @OpenAIDevs, @karpathy, @hwchase17, @sama, @amasad. Lee newsletters: Latent Space, Import AI, Simon Willison's Weblog. Sin esto te sale del tren — con esto vas siempre 3 meses por delante.
El proyecto que cubre frontend + backend + DB + cloud + CI/CD + IA + cybersec en una semana. Lo terminas, lo enseñas, te contratan.
Un URL shortener tipo bit.ly: pegas una URL larga, la app te da una URL corta del estilo tu-dominio.com/abc123. Cuando alguien la abre, redirige a la original y registras el click. Dashboard de analytics: clicks por día, país, dispositivo, navegador, top URLs, links activos. Es simple en concepto, pero toca cada pieza del stack — por eso es perfecto para aprender.
short_id, GSI por userx.tu-dominio.comabc123, llamas a un LLM (vía OpenRouter — tiene tier gratis con Llama, Qwen, Mixtral) para sugerir un slug con sentido (/mi-cv, /oferta-q4)Cuenta AWS, Terraform inicial, S3 backend para state, OIDC con GitHub. Output: terraform apply crea VPC + IAM. Pídele al agente que te genere los módulos base.
API REST con 3 endpoints: POST /links, GET /:id, GET /links/:id/stats. Tests unitarios y de integración. Agent escribe + tú revisas.
GitHub Actions: lint + test + plan + apply (manual approval). OIDC para que no haya keys. Branch protection. Pídele al agente que te haga el workflow desde cero.
Next.js + shadcn. Página landing, dashboard auth con Clerk, formulario que llama a la API. Despliegue en Vercel. Aquí el agente brilla — déjale hacer.
Protege endpoints. CloudWatch alarms. Logs estructurados. Una métrica custom (clicks/s). Alerta a tu email si sube.
Pídele al agente que audite: IAM, secrets, CORS, rate limiting, headers. Implementa lo crítico. Documenta lo conocido pendiente.
README con arquitectura. Loom de 3 min. Post en LinkedIn / X / blog. Repo público con etiquetas. Sin esto el proyecto vale 0.
7 días serios > 7 meses tibios. La gente contrata a quien envía cosas, no a quien aprende eternamente.
Si vas a sacar UNA conclusión hoy, que sea esta: cada configuración, cada script, cada prompt, cada slash command que escribas, va a un repo de git que es tuyo.
~/.claude/CLAUDE.md, commands/, skills/, settings.json, hooks/cd ~/.claude && git init && git add . && git commit -m "init" && gh repo create --private --push. 30 segundos. Tu yo de dentro de 6 meses te lo agradecerá.
AGENTS.md + CLAUDE.md en tu repo principalMismo contenido en ambos archivos (o un symlink). 5 cosas: stack, convenciones, comandos clave (test/lint/build), dónde viven las cosas, qué NO tocar. Result: tanto Claude Code como Codex/Cursor paran de hacerte preguntas obvias y dejan de cometer errores típicos del primer día.
Si solo tienes uno, instala el otro. Crea un slash command tuyo que automatice algo recurrente de tu día (generar boilerplate de un módulo, abrir un PR con template, escribir tests para un archivo). Prueba /loop en un test que sabes que falla → ver al agente iterar hasta que pase.
Opción barata: en tu propio Mac/PC con un cron. Opción gratis: usa APIs gratuitas de Groq, NVIDIA NIM, Cerebras u OpenRouter. Opción privada: Ollama + Qwen 7B local. Tarea inicial: resumir cada PR de tu repo y mandarlo a Slack/Telegram. Cuando funcione → memoria persistente versionada + cron.
10 ejercicios concretos. Cada uno te lleva 30 min - 4 horas. Empieza por el 1, sáltate los que ya hagas.
Ejercicios 1, 2, 3
Ejercicios 4, 5, 6, 7
Ejercicios 8, 9
Ejercicio 10
Ve al repo que más uses. Crea un CLAUDE.md con: stack, 3 convenciones, comandos test/lint/build, "no tocar". Compáralo con Claude antes y después.
Coge un test que falla en tu repo. Pide a Claude Code que lo arregle. Sin tocar nada tú. Observa cuántas iteraciones hace y dónde se atasca.
Crea ~/.claude/commands/dbt-doc.md: "lee este modelo dbt y genera la sección description + columns en YAML". Pruébalo en 3 modelos.
Instala Codex CLI. La misma tarea (refactor pequeño) hazla con Claude y con Codex. Compara: tiempo, calidad, qué cambió. Decide cuándo usar cada uno.
Lánzalo con "busca todos los modelos que usan la tabla X y dime si hay duplicación". Que tú no leas los archivos. Confirma que la respuesta es correcta.
Elige uno: AWS MCP (Cost Explorer, S3, Lambda), Vercel MCP (deploys, projects, logs), GitHub MCP (PRs, issues, actions), Supabase / Postgres MCP, BigQuery MCP. Pídele cosas tipo "dime los 3 últimos deploys que han fallado y por qué" o "qué Lambda gasta más este mes". Sin abrir UIs.
Configura un hook que al abrir Claude Code muestre: branch actual, último commit, tests rotos en CI, tareas con due-date hoy. Que el sistema te entrene a ti.
Crea 2 worktrees (copias del repo en otro branch) del repo. Lanza 2 Claudes en paralelo con tmux (terminal de 2 paneles), cada uno con una tarea independiente. Tú haces de "lead": revisas y mergeas.
Carpeta ~/notes/ con tu propio CLAUDE.md, contactos, proyectos, decisiones. Conecta Claude Code a esa carpeta. Pídele cosas que requieran cross-reference.
Opción A · cero coste: instálalo en tu propio ordenador (el Mac/PC que ya tienes). Un cron en macOS launchd o en Windows Task Scheduler dispara el agente a las horas que quieras. Opción B · API gratis: usa modelos públicos de Groq, NVIDIA NIM, Cerebras, Together AI o OpenRouter — tienen tier gratuito con Llama 3, Qwen, Mixtral. Opción C · privado: Ollama + Qwen 7B local. La tarea inicial: cada noche resume tus PRs y mándalos a Slack/Telegram. Próximo paso: memoria persistente versionada en git.
Estos son los que te llevan al siguiente nivel. Cada uno es un proyecto de portfolio.
Coge una API que uses (Notion, Trello, Strava, lo que sea) y exponla como MCP. Tutorial oficial Anthropic + 200 líneas de Python. Result: Claude Code puede leer tu Notion personal o trackear tus carreras.
Coge 50 PDFs (libros, papers, notes). Embeddings con text-embedding-3, almacenas en pgvector o Chroma local. Slash command /biblio "qué dice X sobre Y". Tu segundo cerebro literal.
Coge un prompt que uses mucho. Crea 30 casos test (input + output esperado). Mete Promptfoo o RAGAS. Compara 3 modelos (Sonnet vs Haiku vs Qwen). Dashboard con métricas. Cambia cómo eliges modelo para siempre.
Bot que escucha issues con tag good-first-bug, los lee, intenta resolver, abre PR. Webhook + Claude Code SDK. Empieza en tu repo. Bonus: añade verificación con tests antes de pushear.
Une todo: agente persistente en tu Mac/PC → memoria git versionada → routing entre 3 modelos → MCP custom → bridges (WhatsApp/Telegram/Slack) → cron + webhooks → guardrails de seguridad → dashboard simple para verlo trabajar. Output: un compañero digital que te escribe él por la mañana, te recuerda meetings, hace deploys cuando le pides desde el bus, y aprende de tus correcciones cada semana. Esto en CV vale más que cualquier curso.
"We've spent years treating the LLM as a search engine with sentences. It's a cheap, persistent, parallel coworker.
The difference between using it as chat and using it as an agent is the difference between Excel and Excel with macros — the second one scales, the first one doesn't.
You already have Claude Code. All you're missing is giving it hands, memory, and a goal."
Click en cualquier slide para saltar. Cierra con Esc o el botón ×.