Una guia completa per passar de "uso Claude Code per a coses concretes" a operar un sistema d'agents que treballa per tu, recorda què va fer i es desperta sol.
Tiraré molts termes. No pararé per explicar-los tots. Quan alguna cosa et soni a xinès, copia-enganxa la slide o el terme a ChatGPT/Claude i demana-li que t'ho expliqui. És literalment per al que existeix. No tinguis vergonya, fes-ho en directe si vols.
No entraré en detall en cada eina — per això hi ha docs i YouTube. El que comparteixo és la meva experiència personal i professional després de moltes hores d'ús real, el que a mi em funciona al dia a dia.
El meu setup es basa en el que segueixo a Twitter / X: developers d'Anthropic, OpenAI, gent que construeix sobre els models, founders de tooling. Aprenc en real-time de qui està empenyent els límits. No m'ho invento — ho destil·lo.
Espero que aquesta presentació t'ajudi — però cal treballar-s'ho. Cada cosa que vegis avui: investiga-la, prova-la tu mateix, trenca-la, torna-la a muntar. L'única manera d'aprendre agents és fent-los servir.
Anatomia, nivells d'agència, zoo de CLIs, routing.
CLAUDE.md/AGENTS.md, slash commands, hooks, skills, sub-agents, MCPs, memòria, /goal, loops.
/morning, /loop, multi-agent paral·lel.
Hermes vs Claude Code, models open-source.
Vault com a memòria, KB + RAG + MCP.
PR review, fix-it agents, workflows.
Hardening (10 regles), prompt injection, supply chain.
Backend vs frontend, stack, llenguatges, consells.
Què fer dilluns. Exercicis de 30 min a 1 cap de setmana.
Termes que apareixen a tota la presentació. Si ja et sonen, salta-ho.
LLM amb tools, memòria i un objectiu. No és un xat — és un treballador amb mans.
Ej: Claude Code, Codex CLI, Cursor agent, Hermes, Devin.
Tot el sistema que envolta el model: prompts, hooks, tools, memòria, fluxos. El 70% del valor.
Ej: CLAUDE.md + skills + hooks + slash commands + MCPs configurats junts.
Capacitat que l'agent pot invocar. Cada tool és un "verb".
Ej: Read, Write, Bash, Grep, WebFetch, query_bigquery, send_slack.
Model Context Protocol. Estàndard obert per connectar agents amb sistemes externs. "USB per a LLMs".
Ej: dbt MCP, BigQuery MCP, Snowflake MCP, Atlassian, Slack, Postgres MCP.
Retrieval-Augmented Generation. Buscar docs primer, contestar després amb ells com a context.
Ej: chatbot que llegeix el teu Confluence. ChatGPT amb "search". Cursor llegint el teu repo.
Convertir text a vectors numèrics per a cerca semàntica (no per paraula exacta).
Ej: OpenAI text-embedding-3, Voyage AI, BGE, emmagatzemats a Qdrant / pgvector.
Quantitat màxima de tokens que el model processa d'un cop.
Ej: Sonnet 200K, Opus 200K, Gemini 2.5 Pro 1M+, Kimi K2 128K-2M.
Tros de text (~4 caràcters). El que pagues. El que consumeix el model.
Ej: "data engineer" ≈ 3 tokens. PDF de 10 pàg ≈ 5K. Sessió llarga: 100K+.
Aquests els veurem cadascun amb la seva slide a part. Aquí només la xuleta.
Script que es dispara automàticament en esdeveniments de l'agent. El teu CI/CD personal.
Ej: SessionStart mostra #blocker. PostToolUse corre pytest després d'editar un .py.
Prompt guardat en un .md, invocable amb /nom. Per a tasques recurrents.
Ej: /morning, /eod, /cost-review, /security-review, /new-component.
Comportament reutilitzable que l'agent invoca només quan aplica al context.
Ej: tdd, brainstorming, verification-before-completion, debugging.
Una altra instància del model, amb el seu propi context, llançada per l'agent principal.
Ej: Explore, Planner, Critic, Tester, Document-specialist.
Còpia del repo en una altra carpeta i un altre branch. Permet N agents en paral·lel sense trepitjar-se.
Ej: git worktree add ../repo-feature-x feature/x.
Definition of Done. Checklist objectiu perquè l'agent sàpiga quan parar d'iterar.
Ej: tests passen + lint clean + coverage >80% + commit convencional.
Comprimir un model perquè ocupi menys memòria. Perds una mica de qualitat però corre local.
Ej: Qwen 14B Q4_K_M (4-bit), Llama 70B GPTQ, Gemma 4 + TurboQuant.
Test sistemàtic de qualitat de l'output del model. L'oposat a "vibes".
Ej: 20 casos reals amb output esperat. RAGAS, Promptfoo, LangSmith.
Sincronització de vault, snapshots setmanals de memòria de l'agent, briefing matinal a les 10:00. Sense tocar res.
4 sub-bases (feina actual, parent company, ex-feina, personal) cross-linkades, cadascuna amb el seu CLAUDE.md.
Un agent persistent corre al homelab, té memòria versionada en git i t'escriu ell quan cal.
No és un equip. Sóc jo sol. El que veuràs ho pots copiar tu aquesta setmana.
Compara costos AWS vs ahir, llegeix el meu work-log d'ahir, escaneja Slack overnight, revisa #blocker al vault, proposa focus del dia.
Un alias obre 4 tabs simultanis: vault de notes, repo principal, repo de finops, repo del client. Cadascuna amb el seu context carregat.
Tasca gran → es divideix. Codex executa tests. Claude Sonnet planifica. Sub-agent Explore rastreja codi mentre tu escrius.
Encadena: snapshot diari → comparar amb últims 7 dies → flag anomalies → buscar context al vault → resum executiu. El que abans eren 90 min, són 5.
Itera tots els repos, detecta commits del dia, actualitza work-log amb el fet, deixa "context for tomorrow", fa commit al vault.
Snapshot setmanal de memòria, summary de les sessions de la setmana, push automàtic al repo. Tu no hi ets davant.
"Compara cost d'un servei últims 30 dies vs Q anterior, atribueix per sub-servei, dóna'm 3 hipòtesis de l'augment del 18%". L'agent fa servir l'MCP de Cost Explorer, llegeix el snapshot del vault i correla amb mètriques.
"Dels projectes oberts a les 2 empreses, quins tenen blocker fa >2 setmanes i a qui cal punxar". Llegeix STATUS.md, contacts.md, last-modified de cadascun.
"Dóna'm un MCP en Python que exposi 4 tools sobre Cost Explorer". Pla + scaffold + tests + README, en un goal de 30 min sense interacció.
"Converteix aquestes notes de 3 meetings en un report d'1 pàgina per a finance". Output amb frontmatter, links a fonts, xifres citades.
"DD vs Grafana vs Datadog per al nostre cas, costos a 12 mesos, riscos per servei crític". Treu info del vault, completa amb web fetch.
"Immich no arrenca, què va passar". Llegeix el runbook, fa SSH al server, mira logs, proposa fix. Com un SRE de butxaca.
La peça no òbvia: tot es reprodueix amb un script. Si em roben el Mac, en 1h en tinc un altre d'idèntic. L'agent hereta això com a "memòria operativa".
| Abans (xat) | Ara (agent) |
|---|---|
| Pregunta → resposta | Objectiu → bucle fins complir-lo |
| Text pla | Tools, file system, MCPs, shell |
| Tu fas la feina d'enganxar | Llegeix/escriu fitxers, corre tests, obre PRs |
| Sense memòria | MEMORY.md, hooks, RAG persistent |
| Un model | Routing: Haiku executa, Opus raona |
| Tu obres la sessió | Viu sol i t'escriu ell |
| Lineal | Sub-agents en paral·lel, worktrees |
| Cec al món | Sap qui ets, quins projectes portes, què vas decidir ahir |
Xat amb capacitat de llegir i escriure arxius. Tu dirigeixes pas a pas. És on està el 90% de la gent que "fa servir Claude Code".
Li dones un objectiu + criteri d'èxit ("tests passen") i es fica en bucle. /loop (Claude Code natiu), /goal (oh-my-claudecode), /autopilot (oh-my-claudecode). Tu només revises el resultat.
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.
Viu 24/7. Té cron, memòria, identitat i proactivitat. T'escriu ell: "AWS billing +12% avui, investigo?". El nivell on l'agent deixa de ser eina i passa a ser company.
Salto Nivell 1 → 2 = aprender 1 comando. Salto Nivell 2 → 3 = aprender git worktrees. Salto Nivell 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 |
La meva regla: 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.
El truc 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.
Sense memòria, 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 índex 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 cap de setmana |
La meva recomanació: 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. Llegeix 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. Llegeix 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.
"Llegeix 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".
"Llegeix 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. Aprèn 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. Aprèn secrets, environments, OIDC con AWS (sin keys hardcoded). Esto sale en TODA entrevista.
Reescribe tu infra clickeada en código. Aprèn 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. Aprèn 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. Llegeix 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.
El truc 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. Llegeix 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. Resultat: 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.
Instal·la 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. Resultat: 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.
"Fa anys que tractem l'LLM com un cercador amb frases. És un company de feina barat, persistent i paral·lel.
La diferència entre qui el fa servir com a xat i qui el fa servir com a agent és la diferència entre Excel i Excel amb macros — el segon escala, el primer no.
Ja tens Claude Code. L'únic que et falta és donar-li mans, memòria i un objectiu."
Click en cualquier slide para saltar. Cierra con Esc o el botón ×.