Un agente de IA que “aprende” a hacer tareas en la web no necesita memoria perfecta: necesita instrucciones claras, probadas y guardadas. La técnica consiste en registrar, en archivos Markdown, los pasos exactos que funcionaron para completar una acción —por ejemplo, redactar un post, buscar perfiles o enviar un mensaje— y reutilizarlos como “skills”. Con ese enfoque, un proceso que al inicio requiere intentos y errores pasa a ejecutarse en un único intento, con menos uso de tokens y menos intervención humana.

El procedimiento parte de un entorno estable, macOS, un navegador con control vía protocolo y un asistente de código— y avanza por iteraciones:  descubrir cómo resolver la tarea, validar el flujo, anotarlo en un skill.md y volver a ejecutar desde cero usando solo lo aprendido. El resultado es un repositorio de habilidades concretas que el agente puede combinar para encargos abiertos: redactar, publicar, buscar, clasificar, contactar.

La “memoria” operativa del agente no es magia: se escribe en Markdown, se valida con pruebas y se reutiliza como workflow.

El caso práctico más directo es LinkedIn: abrir la página, crear un borrador de post, localizar perfiles de una empresa y enviar un mensaje a una conexión. Todo se logra con JavaScript inyectado en el navegador mediante el Chrome DevTools Protocol (CDP) y orquestado desde el entorno de trabajo. La clave no es el truco puntual, sino el documento skill.md que conserva el paso a paso ganador para el próximo run.

De habilidades en Markdown a workflows reutilizables

El principio operativo es simple: cada habilidad se guarda en un archivo Markdown con título, propósito, prerrequisitos, pasos, scripts y criterios de éxito. Ese archivo se convierte en una “pieza” que el agente puede cargar y ejecutar sin volver a explorar el espacio de prueba.

  • Estructura sugerida del archivo:
  • Título y objetivo (“Publicar borrador en LinkedIn”).
  • Dependencias (navegador con puerto CDP, sesión iniciada).
  • Pasos con selectores y comandos CDP (abrir editor, insertar texto, adjuntar).
  • Script(s) temporales y versión “estable” una vez validada.
  • Criterios de validación (campo con texto no vacío, botón habilitado).
  • Observaciones (fallos comunes, variaciones de UI).
La imagen presenta una composición sobre un fondo negro. En el centro, un diseño
Agente AI multifuncional aprendiendo nuevas tareas

Operativamente, el primer ciclo suele fallar por selectores frágiles o editores ricos que no aceptan un “type” convencional. El segundo ciclo agrega comandos CDP más apropiados —por ejemplo, Input.insertText para escribir en un editor complejo— y el tercero asienta el flujo. Cuando se bloquea por un detalle de la interfaz, se ajusta el selector y se actualiza el skill.md. La próxima ejecución parte desde el procedimiento que ya funcionó una vez.

Este enfoque convierte el intento y error en inversión: cada paso depurado se “capitaliza” en el archivo. El efecto es medible en tiempo —pasar de varios minutos a menos de un minuto— y en costo computacional: menos llamadas, menos contexto, más precisión. Todo ello sin “enseñar” al modelo de forma opaca: solo se le entrega un guion concreto para repetir.

El beneficio adicional es la composabilidad. Si “Publicar borrador” y “Enviar mensaje” son skills independientes, el agente puede ejecutarlos en serie como un workflow mayor. La misma idea se aplica a otras plataformas con editores ricos: X, GitHub o Gmail, siempre que sea posible operar con CDP y respetar sus políticas de uso.

Infraestructura y método: macOS, Cursor y CDP

La práctica descrita se apoya en tres piezas estables:

Un Mac mini dedicado (o cualquier host siempre encendido) que mantiene sesiones iniciadas de los servicios web que el agente usará. La persistencia de sesión evita fricción de login y reduce fallos.

Un asistente de código para iterar más rápido sobre scripts y selectores. En este flujo se usa el editor Cursor de Anysphere, que integra chat, edición asistida y tooling local, útil para probar JavaScript que orquesta el navegador y para mantener el repositorio de skills.

El Chrome DevTools Protocol (CDP) como interfaz de control del navegador. Con CDP, el agente puede abrir páginas, evaluar scripts y, cuando el “type” clásico falla en un editor no estándar, usar métodos como Input.insertText para escribir de forma programática en el campo de redacción. Documentación oficial: Chrome DevTools Protocol – Input.insertText.

La pieza que completa el conjunto es el “intérprete” del agente. Aquí resulta útil Claude Code de Anthropic, que ofrece un CLI y tooling para coordinar lectura de archivos, ejecución de comandos y edición de código. La guía de instalación indica requisitos como Node.js 18+ y sistemas macOS, Linux o Windows con WSL; con ello, el CLI puede operar proyectos locales y automatizar tareas repetibles.

El método práctico se resume así:

  1. Documentar el objetivo en un skill.md nuevo.
  2. Probar acciones básicas (abrir, localizar, enfocar, escribir).
  3. Migrar de selectores “frágiles” a comandos CDP robustos cuando el editor sea complejo.
  4. Consolidar los pasos y scripts que funcionaron.
  5. Reiniciar el contexto y ejecutar solo siguiendo el skill.md. Si pasa, el skill es utilizable; si no, se corrige y se vuelve al paso anterior.
Cada workflow probado y documentado ahorra tokens y minutos en la siguiente ejecución; la memoria del sistema es el archivo, no el intento repetido.

Caso LinkedIn: publicación, búsqueda y mensajes

LinkedIn es un buen caso de uso porque combina tres operaciones útiles: redactar un borrador, localizar perfiles y enviar un mensaje directo a una conexión. En los tres casos se parte de la misma base: sesión iniciada, navegador con puerto CDP disponible y un archivo linkedin.skill.md que registra el “cómo”.

Publicar un borrador de post:

  • Abrir linkedin.com y enfocar el editor de publicaciones.
  • Si un “type” simple no funciona, usar CDP para inyectar texto con Input.insertText en el editor rico.
  • Verificar que el campo contenga el payload indicado y que el botón de publicar esté activo. No publicar sin revisión manual.

Buscar perfiles de una empresa:

  • Enfocar la barra de búsqueda, enviar la query y filtrar por “People”.
  • Extraer nombre, rol y ubicación visible para una tabla temporal y depurar selectores si la UI cambia.

Enviar un mensaje a una conexión:

  • Abrir “Messaging”, seleccionar la conversación y escribir un texto breve en el editor.
  • Cuando el editor no acepte keystrokes, caer a CDP Input.insertText. Validar que el mensaje aparezca en la conversación y, solo en cuentas de prueba o con autorización, enviar.

A continuación, el ejemplo de tabla que el agente puede producir tras una búsqueda pública (nombres y cargos deben verificarse manualmente antes de cualquier acción; la tabla sirve como estructura de salida para revisión humana):

Resultados estructurados de una búsqueda pública (ejemplo)

# name role location
1 Tyler Lacroix Ingeniero de investigación @ Anthropic Mountain View, CA
2 Qing Wang Miembro del staff técnico, Anthropic San Francisco, CA
3 Aiza Usman IA aplicada @ Anthropic San Francisco, CA
4 Ivan Sichmann Freitas Ingeniero de software @ Anthropic Dublín
5 Matt Gallivan Investigador de usuarios en Anthropic San Francisco, CA

Para mensajería, el editor de LinkedIn también puede requerir inserción programática. A continuación se muestra una pieza típica de orquestación: conexión WebSocket local para notificar eventos y un texto estandarizado para pruebas. Debe ejecutarse solo en cuentas de prueba y cumpliendo políticas de la plataforma.

// linkedin_notification.cjs
const WebSocket = require('websocket').client;

const SOCKET_URL = 'ws://localhost:8080';
const NOTIFICATION = 'thanks for connecting';

let notificationId = 1;
function transmit(socket, action, payload) {
 return new Promise((resolve, reject) => {
 const currentId = notificationId++;

Explicación en lenguaje llano:

  • La línea require('websocket') carga un cliente WebSocket para enviar señales locales (por ejemplo, “mensaje enviado”).
  • SOCKET_URL apunta a un servicio de apoyo en la misma máquina.
  • NOTIFICATION define el texto que se usará como payload en pruebas (no debe enviarse a terceros sin revisión).
  • El agente usa CDP para enfocarse en el editor de mensajes y luego invoca Input.insertText con el texto preparado; al detectarse el cambio en la UI, la función transmit puede avisar a la terminal que el paso se completó.

En términos prácticos, LinkedIn es un buen campo de entrenamiento porque reúne UI dinámicas y editores ricos; cualquier selector o comando que funcione aquí suele generalizarse a otros sitios con editores similares. Siempre es recomendable validar manualmente las acciones antes de automatizar con conexiones reales.

Instalación básica y puesta en marcha

El siguiente procedimiento permite replicar el entorno de trabajo para entrenar skills con un agente y navegador controlado por CDP. Se indican pasos concisos, con comandos claros y en orden lógico.

Instalar Node.js 18+ y comprobar versión

  • Descargar e instalar la versión LTS desde nodejs.org para el sistema operativo de uso.
  • Verificar en terminal:
    node -v
    npm -v
  • Node.js es necesario para el CLI del agente y para scripts auxiliares

Instalar el CLI de Claude Code

  • El CLI facilita edición, ejecución de comandos y coordinación de archivos de proyecto.
  • Instalación global:
    npm install -g @anthropic-ai/claude-code
  • Requisitos y sistemas compatibles (macOS, Linux, Windows con WSL) están documentados por Anthropid; se recomienda ejecutar un diagnóstico rápido:
    claude doctor
  • Claude Code require Node.js 18+ y conexión a internet para autenticación.

Preparar el navegador con puerto CDP

  • Iniciar Chrome/Chromium con el puerto de depuración remoto (ejemplo 9222):
    /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
    --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-skill
  • Mantener esta instancia para que el agente pueda conectar y enviar comandos CDP (abrir páginas, evaluar JavaScript, usar Input.insertText).

Verificar CDP activo (opcional, para usuarios avanzados)

  • Abrir DevTools y habilitar el “Protocol monitor” para observar y enviar comandos CDP de forma manual en una pestaña de prueba. Es útil para depurar parámetros de métodos como Input.insertText.

Crear el directorio de skills y el primer skill.md

  • Estructura mínima:
    mkdir -p skills/linkedin
    touch skills/linkedin/skill.md
  • En el archivo:
- Objetivo: “Redactar borrador de post en LinkedIn”.
- Pasos: abrir linkedin.com, abrir editor, insertar texto, validar botón de publicar.
- Comandos: secuencia CDP para enfoque e inserción con `Input.insertText`.
- Validación: esperar el nodo del editor con contenido no vacío.

Probar y refinar

  • Ejecutar la tarea con el agente usando únicamente el contenido del skill.md.
  • Si falla por un cambio de UI, actualizar selectores y anotar la solución en el archivo.
  • Repetir hasta que el proceso pase en un intento con un contexto limpio.

Añadir skills complementarios

  • “Buscar perfiles por empresa” (query, filtros, extracción a tabla).
  • “Enviar mensaje a conexión” (abrir conversación, insertar texto, confirmar envío en cuenta de prueba).
  • Registrar cada flujo en su propio skill.md para poder componerlos en un workflow mayor (“preparar post”, “publicar cuando el usuario apruebe”, “compartir en X”).

Buenas prácticas, límites y escalado

Respeto de políticas y consentimiento

  • Automatizar interacciones en plataformas de terceros exige respetar términos de servicio y pedir autorización explícita antes de enviar mensajes o realizar acciones en nombre de un usuario. Las pruebas deben realizarse en cuentas de test o entornos de ensayo.

Selectores y resiliencia

  • Los selectores CSS/XPath quebradizos son la principal fuente de fallos. En editores ricos, es mejor apoyarse en CDP y, cuando proceda, en métodos como Input.insertText. Para campos estándar, un “type” convencional puede bastar; para cajas con composición IME o QL-editor, CDP suele ser más fiable.

Versionado de skills

  • Tratar cada skill.md como código: un commit por cambio relevante, descripción clara, y un pull request cuando implique modificar el comportamiento observable del agente. Mantener un branch por feature y fusionar con merge solo tras pasar pruebas.

Observabilidad mínima

  • Registrar el inicio y fin de cada paso, con capturas o snapshots de DOM si es pertinente. Cuando el agente use un callback (por ejemplo, al terminar de insertar texto), notificar con WebSocket local o logs, de modo que la terminal muestre un estado inequívoco (“borrador listo”, “mensaje en cola”).

Plantillas y reutilización

  • A medida que crezca la colección, crear plantillas de skill para plataformas con UI similares. Estandarizar secciones: prerrequisitos, comandos, validación, rollback.

Seguridad operativa

  • Mantener perfiles del navegador separados para pruebas y producción; nunca mezclar cookies de cuentas reales con entornos de test. El runtime del agente debe ejecutarse en un usuario del sistema con permisos mínimos.

Evitar “overfitting” a una UI

  • Un skill demasiado ajustado a una clase o atributo efímero fallará al primer cambio visual. Priorizar roles, ARIA labels, atributos estables y, cuando sea posible, endpoints internos expuestos por la propia aplicación (si está permitido).

Escalado por workflows

  • La potencia aparece al encadenar: “investigar” → “redactar borrador” → “solicitar aprobación humana” → “publicar” → “compartir en otros canales”. Cada paso debe tener entrada/salida claras. Un pipeline predecible es más útil que un agente que “lo intenta todo”.
La autonomía útil no proviene de más intentos, sino de mejores protocolos y de guardar lo que ya funcionó como skill reutilizable.

Conclusiones

Documentar habilidades en Markdown y operarlas con un navegador controlado por CDP es un método sobrio y eficaz para dotar de competencias a un agente de IA. El ciclo “probar–validar–anotar–reutilizar” reduce tiempo, uso de tokens y errores, y convierte la experiencia puntual en un activo permanente: el skill.md.

El caso LinkedIn demuestra el patrón: el primer borrador requiere ensayo; el segundo, con Input.insertText, ya funciona; el tercero, guiado solo por el archivo, pasa a la primera. A partir de ahí, buscar perfiles y enviar un mensaje de prueba siguen el mismo esquema y se documentan en su propio skill. La combinación de un editor con tooling de agente —como Claude Code de Anthropic—, un entorno de trabajo como Cursor de Anysphere y el uso riguroso del Chrome DevTools Protocol aporta el andamiaje técnico necesario para que el agente ejecute workflows completos con control y trazabilidad.

Conforme crece la biblioteca de skills, el agente puede encargarse de tareas abiertas —“investigar, crear, publicar y anunciar”— sin improvisar cada vez: busca el skill adecuado, lo ejecuta y reporta. Esa es la diferencia entre “tener un modelo capaz” y “tener un sistema útil”: lo segundo se construye, paso a paso, en archivos claros que cualquier equipo puede entender, verificar y mejorar.

Comparte esta publicación