Atareao con Linux

¿Sigues usando find y grep como en los 90? Hace unas semanas me puse a buscar un archivo en un repositorio con git, lancé el find de toda la vida, y cuando volví de tomarme un café —literalmente— todavía seguía buscando. El problema es que find se mete en el .git, en los binarios, en sitios donde no debería. Y grep, pues lo mismo, sobre todo si trabajas con Unicode o con repositorios grandes. Así que llevo un tiempo usando fd y ripgrep, dos herramientas escritas en Rust que son órdenes de magnitud más rápidas. Pero lo mejor no es solo la velocidad: es que puedes combinarlas para crear pipelines que alimenten directamente a tu IA local.
fd (44.1k estrellas en GitHub) es un reemplazo directo de find. En los benchmarks oficiales, buscar archivos con fd -u tarda 0.8 segundos donde find necesita 11 segundos con -iname y casi 20 segundos con -iregex. 23 veces más rápido. Y no solo es velocidad: fd respeta .gitignore por defecto, soporta expresiones regulares directamente, y tiene placeholders como {}, {.}, {/} y {//} que te permiten ejecutar comandos sobre cada resultado con -x o pasarlos en lote con -X.
ripgrep (67.4k estrellas) es lo mismo pero para buscar texto. En el kernel de Linux, rg tarda 0.08 segundos donde grep tarda 2.67 segundos. 32 veces más rápido. Y tiene superpoderes que grep ni sueña: salida en JSON con --json, búsqueda en archivos comprimidos con -z, soporte PCRE2 con -P para lookaheads, y un flag --passthru que te muestra también las líneas que no coinciden. Desde la versión 15 también soporta hyperlinks OSC 8 y respeta repositorios de Jujutsu.
Pero lo que realmente me tiene enganchado es combinarlos. El patrón es sencillo: fd encuentra los archivos que te interesan, ripgrep extrae el contexto relevante, y todo eso se lo pasas a Ollama para que lo procese. Te enseño la función aresumen que me he montado en Bash, y su equivalente en Fish, para preguntarle a mi documentación local sin salir de la terminal. Cosas como "resume todo lo que he escrito sobre Ollama en el último mes" se resuelven con un pipeline de tres comandos. Sin RAG, sin bases de datos vectoriales, sin complicaciones. Solo con un pipe bien puesto y el modelo adecuado.
También te cuento cómo usar jq para procesar la salida JSON de ripgrep, cómo montar un buscador interactivo con fzf y bat, y los errores más comunes al construir estos pipelines. Si alguna vez has pensado "ojalá pudiera preguntarle a mis propias notas desde la terminal", este episodio te va a gustar. Y si todavía usas find y grep, te aseguro que después de oír los benchmarks no vuelves atrás.
Capítulos del episodio:
0:00 — Introducción: fd y ripgrep para alimentar a tu IA
2:30 — El problema con find y grep tradicionales
5:00 — fd: el find que siempre quisiste tener
8:00 — Placeholders y expresiones regulares en fd
11:00 — ripgrep: el grep con superpoderes
14:00 — Salidas estructuradas con JSON y jq
16:30 — La combinación estrella: fd + ripgrep con -x
19:00 — Pipelines avanzados para filtrar archivos
21:30 — Integración con IA local: fd + rg + Ollama
24:30 — Alias, funciones y trucos del día a día
27:00 — Despedida y conclusiones
Recursos mencionados:
- fd (sharkdp/fd): https://github.com/sharkdp/fd
- ripgrep (BurntSushi/ripgrep): https://github.com/BurntSushi/ripgrep
- Ollama: https://ollama.com
- jq: https://jqlang.github.io/jq/
- fzf: https://github.com/junegunn/fzf
- bat: https://github.com/sharkdp/bat

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Hoy toca dar un paso más. Hasta ahora usabas OpenCode como un asistente personal, le pedías algo y lo hacía. Pero, ¿y si necesitas algo más potente? ¿Alguien que investigue, alguien que escriba, alguien que lo optimice para SEO y alguien que lo revise todo? La respuesta no es un agente, es un equipo de agentes. En este episodio te cuento cómo he montado un sistema multi agente con OpenCode usando el patrón supervisor, y cómo coordino cinco agentes especializados sin que se pisen.
Te explico el pipeline completo de cinco fases. Primero la planificación, donde el coordinador define la estructura y los pasos a seguir. Luego la investigación, que corre a cargo del bibliotecario, un agente que solo busca información, no escribe, no opina, solo trae datos con sus fuentes. Después viene el redactor, que coge esos datos y escribe el artículo en Markdown con el tono de la casa. La cuarta fase es el SEO, donde un agente especializado pone el título, la meta descripción y las etiquetas sin tocar el fondo del artículo. Y por último la revisión, donde el editor verifica que todo está correcto y, si algo falla, lo devuelve al coordinador para que repita la fase que haya fallado. Todo esto forma un bucle de retroalimentación que diferencia un sistema multi agente bien hecho de cualquier otro.
Cada agente tiene su propio modelo, su propia temperatura y sus propios permisos. El investigador usa un modelo pequeño y barato porque solo necesita buscar. El redactor necesita un modelo más grande porque tiene que escribir con calidad. El revisor usa temperatura muy baja para ser lo más objetivo posible.
También te cuento los errores que me he encontrado. El más común es que el coordinador no delega. Le pides algo y en lugar de llamar al investigador, investiga él. En lugar de llamar al redactor, escribe él. Y el resultado es lo peor, porque el coordinador no es especialista en nada. La solución pasa por describirlo muy claro, con exclusiones en mayúscula: NO PUEDES HACER NADA, SOLO PUEDES DELEGAR. Otro error es dar permisos de más. Si todos pueden invocar Task, el investigador llama al revisor, este al SEO y se monta un follón.
Además hago una demo en vivo creando un artículo sobre FD, una herramienta en Rust que sustituye a find. Ves cómo el coordinador recibe la petición, planifica, lanza al investigador, luego al redactor, luego al SEO, luego al revisor, y en una sola iteración el artículo está aprobado. Con su título SEO, su meta descripción, sus etiquetas y su estructura en Markdown. Y todo esto no es programación. Es escribir artículos, preparar presentaciones o lo que se te ocurra. OpenCode no es solo un asistente para programar, es mucho más que eso. Y al final te cuento cuándo merece la pena usar multi agente y cuándo no. Porque para cambiar una bombilla no necesitas un equipo de cinco personas, necesitas un electricista.
Capítulos del episodio:
0:00 - Introducción: de ChatGPT a los agentes multi-propósito
2:28 - De asistente personal a equipo de agentes especializados
3:52 - Patrón supervisor: el jefe de obra que coordina sin ejecutar
4:50 - Pipeline de 5 fases: planificación, investigación, redacción, SEO y revisión
6:37 - La herramienta Task: delegación, contexto aislado y ventajas9:17 - Demo en vivo: creando un artículo sobre FD con subagentes
13:07 - Agentes especializados: investigador, redactor y SEO
18:56 - Control de calidad: el revisor y el bucle de retroalimentación
23:22 - El coordinador: la no ejecución como clave del éxito
24:58 - Errores comunes, cuándo usar multi-agente y despedida
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Hace unos meses empecé a usar presentaciones para grabar el podcast, y enseguida me di cuenta de que el verdadero problema no es pensar el contenido, sino maquetarlo. Pasaba más tiempo ajustando fuentes, colores y transiciones que preparando lo que realmente quería contar. Así que me puse a buscar una solución, y lo que encontré me ha cambiado el flujo de trabajo por completo.
En este episodio te cuento cómo he montado typst-ia, un script en Python que genera presentaciones completas en segundos. Le dices un tema, la inteligencia artificial se encarga del contenido, y Typst lo convierte en un PDF impecable. Todo desde la terminal, sin abrir PowerPoint ni Google Slides, sin suscripciones mensuales, y con un control total sobre el resultado.
Typst es un sistema de composición moderno escrito en Rust que compila en milisegundos. Sí, has leído bien, milisegundos. Comparado con LaTeX Beamer, que tarda 5 o 10 segundos en compilar, Typst es un antes y un después. Además, su sintaxis es mucho más limpia y fácil de aprender. En el episodio lo comparo con LaTeX y con Markdown, y te cuento por qué creo que Typst se está convirtiendo en el estándar para presentaciones técnicas.
La clave del proceso está en el system prompt. Incrusto el template real de la presentación dentro del prompt que le envío a OpenRouter, y la IA genera código Typst válido sin necesidad de retoques. Uso DeepSeek Chat por defecto —cuesta unos 14 céntimos por millón de tokens de entrada, que vienen a ser cientos de presentaciones por menos de un euro—, pero también puedes usar Claude Sonnet, Gemini Flash o Llama 3.3 si necesitas más calidad o prefieres un modelo concreto.
El script completo son unas 200 líneas de Python sin frameworks, solo con la librería requests. Te explico paso a paso cómo funciona el pipeline: lee el template, construye el prompt, llama a OpenRouter, limpia la respuesta, escribe el archivo .typ, lo compila a PDF y lo abre en el visor. Y todo con flags para personalizar el número de diapositivas, el modelo, el nombre del archivo y hasta los reintentos si la compilación falla.
Para rematar, hago una demo en vivo generando una presentación desde cero. Ves cómo en cuestión de segundos pasamos de una idea a un PDF listo para proyectar. Y lo mejor es que el resultado es texto plano, versionable con Git, editable con cualquier editor, y sin ningún tipo de lock-in. Si mañana quieres cambiar algo, abres el .typ y lo tocas.
Si eres de los que hacen presentaciones técnicas, charlas, workshops, o simplemente quieres automatizar una tarea tediosa, este episodio te va a gustar. Y si nunca has oído hablar de Typst, te vas a llevar una sorpresa.
Capítulos del episodio:
0:00 - Introducción: presentaciones con Typst e IA
2:52 - El problema de las presentaciones tradicionales
5:20 - Typst: el sistema de composición moderno
7:34 - Typst vs LaTeX vs Markdown
8:31 - Instalación de Typst
9:28 - Plantillas para presentaciones con Typst
12:52 - OpenRouter y el prompt para la IA
15:28 - El script Python: el pipeline completo
17:41 - Demo en vivo: generando una presentación
24:17 - Conclusiones y despedida

¿Alguna vez te has dado cuenta de que la búsqueda exacta se queda corta cuando tu base de conocimiento crece? Buscar por palabras exactas con grep o FTS5 es rápido y preciso, pero es literal y no entiende contexto ni sinónimos. Por otro lado, la búsqueda semántica pura con embeddings a veces falla con términos muy específicos como rutas de archivos o comandos exactos.
En este episodio te muestro cómo solucionar este problema combinando lo mejor de ambos mundos mediante tres técnicas avanzadas de RAG:
Búsqueda Híbrida (Hybrid Search): Cómo combinar FTS5 y embeddings semánticos utilizando un equilibrio ponderado (parámetro alpha).

Re-ranking con Cross-Encoder: Refinamiento de resultados pasando de un bi-encoder rápido a un cross-encoder preciso para priorizar la máxima relevancia.

HyDE (Hypothetical Document Embeddings): La técnica de generar un documento hipotético con un LLM local (Ollama) para encontrar notas mediante conceptos abstractos.

Además, repasamos cómo integrar todo esto en tu flujo de trabajo diario mediante herramientas CLI creadas en Python y Rust, así como la integración en Neovim con sqlite.lua.
Enlaces y recursos del episodio:
Gist con los scripts en Python (Hybrid Search, Reranker y HyDE)

Gist con la implementación del CLI en Rust (cerebro-cli)

Notas completas del episodio en: atareao.es

Este episodio va de ser vago. Pero vago en el buen sentido, eh. De esos que prefieren que una herramienta haga el trabajo pesado mientras tú te quedas con lo divertido. Resulta que hay todo un ecosistema de herramientas TUI con el prefijo "lazy" que te evitan tener que memorizar cientos de flags y opciones de comandos como git, docker, rsync o SQL. Y no, no es cutrez: son interfaces de terminal que funcionan a golpe de tecla, sin ratón, sin salir de la terminal, y encima molan.
Te cuento cómo nació todo esto, quién es Jesse Duffield (el creador de lazygit y lazydocker, con más de 80K y 52K estrellas en GitHub respectivamente) y por qué esta filosofía de "una tecla, una acción" ha enganchado a tanto linuxero. Y lo mejor: te hago demo de las cuatro herramientas principales para que veas cómo funcionan en vivo y en directo, con sus paneles, sus atajos y sus trucos.
Empezamos con lazygit, el rey indiscutible del ecosistema. 80.900 estrellas en GitHub, escrito en Go, y con una comunidad que no para de crecer. Desde stage línea a línea hasta rebase interactivo, pasando por undo/redo vía reflog. Te enseño cómo hacer commits, gestionar ramas, stash y hasta cherry-pick sin tener que acordarte de los flags raros de git.
Seguimos con lazysql, el gestor de bases de datos en terminal de Jorge Rojas. Soporta MySQL, PostgreSQL, SQLite, MongoDB, MSSQL y Oracle. Navegación por teclado, autocompletado de queries, exportación a CSV y configuración por proyecto. Ideal para cuando no te apetece abrir DataGrip o DBeaver solo para hacer una consulta rápida.
Luego viene lazyrsync, escrito en Rust con ratatui, y con una filosofía muy clara: que no se te olvide el flag ese que evita que borres todo. Perfiles reutilizables, dry-run con previsualización, protección contra --delete accidentales y paths dinámicos con variables. Perfecto para backups sin sustos.
Y cerramos con lazydocker, también de Jesse Duffield. Cuatro paneles: contenedores, métricas, imágenes y logs en vivo. Con un vistazo ves qué contenedor consume más CPU, entras en el terminal de uno con una tecla, o ejecutas docker-compose sin acordarte del comando. Y sí, también funciona con Podman.
Además te menciono otras herramientas del ecosistema: lazyssh, lazyjj para Jujutsu, lazykube, lazyprune para limpiar node_modules olvidados... Vamos, que hay lazy para todo.
Capítulos del episodio:
0:00 — Introducción: el problema de memorizar comandos
2:05 — La filosofía lazy: scripts, TUIs y el ecosistema lazy
4:30 — LazyGit: historia, filosofía "una tecla una acción" y +80K estrellas
6:45 — LazyGit: demo de paneles, stage, commits, ramas y stash
9:10 — LazySQL: Jorge Rojas, 4K estrellas y soporte multi-base de datos11:30 — LazySQL: demo con autocompletado, consultas y exportación CSV
14:00 — LazyRsync: dry-run, perfiles y protección contra errores
16:30 — LazyRsync: demo con columnas de estado y confirmación de borrado
19:10 — LazyDocker: Jesse Duffield, 52K estrellas y soporte para Podman
21:45 — Otras herramientas lazy: lazy-ssh, lazy-jj, lazy-kube, lazy-npm
23:15 — Cierre: sé un vago inteligente, valoración y despedida
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao