Herramientas para Linuxeros Vagos

0:00 / 0:00

Hay dos tipos de personas en este mundo. Las que se memorizan veinte flags de rsync, treinta comandos de git, once formas distintas de hacer un SELECT en PostgreSQL… y las que usamos herramientas que hacen todo eso por nosotros con una sola tecla. Yo soy del segundo grupo. Vago, confeso, y orgulloso de serlo. Porque la cuestión es que cuanto menos escribes, menos errores cometes. Y hoy te voy a hablar de un ecosistema entero de herramientas escritas para gente como nosotros. Para vagos. Para los que pensamos esto debería ser más fácil y en lugar de memorizar, buscamos una herramienta que lo haga por nosotros. Se llaman las lazy tools, y después de leer esto, vas a instalarte al menos una. Te lo apuesto.

La filosofía lazy: por qué menos comandos son más aciertos

Todo esto empieza con un tío que se llama Jesse Duffield. Un desarrollador que un día dijo estoy harto de escribir comandos de git. Y en lugar de quejarse, se puso a escribir lazygit. Ochenta mil novecientas estrellas en GitHub a día de hoy. No está mal para un fin de semana de frustración, ¿verdad?

Después escribió lazydocker. Cincuenta y dos mil trescientas estrellas. Y luego lazynpm, que bueno, lo archivó porque no funciona con npm moderno. Pero dos de tres no está nada mal.

La filosofía es simple: cada acción común debería ser una tecla. No un comando de veinte caracteres. No una combinación de flags que tienes que buscar en el manual cada vez. Una tecla. Y esto cuela, porque ha nacido todo un ecosistema. Gente que ha visto el patrón y ha dicho voy a hacer lo mismo pero para bases de datos, para rsync, para SSH…

Y no te creas que es una tontería. El movimiento lazy tiene una base sólida: las TUIs reducen la carga cognitiva. Cuando estás haciendo un rebase interactivo, lo último que necesitas es estar pendiente de si el flag se escribe con guión o con dos guiones, o si el commit que quieres squash es el HEAD~3 o el HEAD~4. La interfaz te guía, te muestra las opciones disponibles, te da feedback visual. Es como conducir un coche con GPS: puedes centrarte en la carretera en lugar de estar mirando el mapa constantemente.

El ecosistema lazy se divide en dos grandes familias tecnológicas. Por un lado están las herramientas escritas en Go con librerías como gocui, Bubble Tea o tview: lazygit, lazydocker, lazysql, lazyssh. Por otro lado están las escritas en Rust con ratatui: lazyrsync, lazyprune. La nueva generación tiende a Rust por su rendimiento y seguridad de memoria, pero Go sigue siendo el rey en madurez y comunidad.

Una cosa importante antes de meternos en harina: casi todas estas herramientas son TUIs — Terminal User Interfaces. No son webs, no son GUIs con botones bonitos. Son interfaces que se ejecutan en tu terminal. Están escritas en Go o en Rust, con librerías como Bubble Tea, gocui, tview o ratatui. Funcionan en servidores remotos por SSH, en tu Raspberry Pi, en tu servidor sin escritorio. Eso es lo que las hace tan potentes.

Vamos con la primera. Y esta es la herramienta. La que si te instalas una sola, tiene que ser esta.

LazyGit: el rey indiscutible de las TUIs

lazygit es, sin discusión, la herramienta más popular de todo el ecosistema lazy. Ochenta mil novecientas estrellas en GitHub, más de ocho mil commits, y una comunidad que no para de crecer. Está en los repos de Debian 13, en Arch, en Homebrew, y si no, siempre puedes compilarlo con Go.

La instalación es trivial en la mayoría de distribuciones:

# Debian 13+ / Ubuntu moderno
sudo apt install lazygit

# Arch Linux
sudo pacman -S lazygit

# Homebrew
brew install lazygit

# Universal con Go
go install github.com/jesseduffield/lazygit@latest

Una vez instalado, abres un repo con lazygit y ya estás dentro. La interfaz tiene tres paneles principales: a la izquierda los archivos del working directory, a la derecha el diff del archivo seleccionado, y abajo los mensajes de git.

Stage, commit y push en tres teclas

El flujo básico es tan sencillo que cuesta creerlo. Tienes un archivo modificado. Para stagearlo, una tecla: space. No git add, no git add -p, no historias. Space y ya está staged. ¿Que te has arrepentido? Space otra vez y lo desstageas.

Pero la joya de la corona es el stage línea a línea. Entras en el archivo con enter, ves el diff completo, navegas a una línea concreta con las flechas, pulsas space y solo esa línea se stagedea. El resto se queda sin stage. ¿Cuánto tiempo has perdido tú haciendo git add -p y respondiendo y, n, y, n, y? Con lazygit, flechas y espacio.

Vale, tienes los cambios staged. Ahora: c. Se abre un editor para el mensaje de commit. Escribes, enter. Commit hecho. ¿Que quieres subirlo? P mayúscula. Push directo al remoto.

space, c, P. Tres teclas. Status, add, commit, push. Todo en segundos.

Rebase interactivo sin traumas

Aquí es donde lazygit brilla con luz propia. Porque seamos sinceros: el rebase interactivo de git en línea de comandos es traumático. Tienes que contar commits, usar git rebase -i HEAD~5, luego entrar en un editor con instrucciones en comentarios, cambiar pick por squash… y si algo sale mal, a llorar al reflog.

Con lazygit es otro mundo. Pulsas l para ver el log. Ahí están todos tus commits. Quieres juntar los últimos tres en uno solo. Seleccionas el commit más antiguo de los tres y pulsas r. Esto inicia un rebase interactivo desde ese commit hacia arriba. Te salen los commits listados con opciones.

Ahora: bajas al primer commit que quieres fusionar. Pulsas s de squash. Ese commit se fusionará con el anterior y te pedirá que edites el mensaje. ¿Que quieres descartar un commit directamente? d de drop. Se va, como si nunca hubiera existido. ¿Que quieres quedarte con los cambios pero sin el mensaje? f de fixup. Es como squash pero usando el mensaje del commit anterior.

Y lo mejor de todo: si metes la pata, z minúscula. Undo. lazygit hace un commit en el reflog por cada acción, así que puedes deshacer. Z mayúscula para redo. Es como Ctrl+Z en el IDE, pero en git. Y no, no es una función nativa de git, es lazygit gestionando el reflog por ti.

Te pongo un caso real: ¿sabes cuando has hecho quince commits de prueba y quieres dejarlos en uno solo? Pues l para log, seleccionas el primer commit de ese grupo, r para rebase, y luego f en todos excepto el primero. En diez segundos tienes un solo commit limpio. En terminal, esa misma operación te lleva cinco minutos y tres sustos.

Bisect desde la UI

Otra funcionalidad que mola: el bisect. Si nunca has hecho un git bisect, te explico rápido: es una búsqueda binaria sobre el historial de commits para encontrar cuándo se introdujo un bug. Es utilísimo, pero el flujo nativo es un tostón: git bisect start, git bisect bad, git bisect good, y luego vas probando commits manualmente, comprobando, marcando…

En lazygit pulsas b para iniciar bisect. Marcas el commit actual como bad. Luego navegas a un commit que sabes que era bueno y marcas good. Lazygit te lleva automáticamente al commit intermedio. Miras el código, ves si el bug está presente. Si está, pulsas b otra vez y marcas bad; si no, good. Sigues hasta que encuentra el commit culpable.

Y te dice: commit XXXX introdujo este bug, con autor, fecha y mensaje. Sin tener que acordarte de la sintaxis de git bisect.

Trucos que te harán la vida más fácil

Dos cositas más antes de pasar a la siguiente herramienta.

Primero, el nuke. ¿Tienes el working tree hecho un desastre? d para abrir el menú de diff, y luego seleccionas Reset working tree. Es como cuando en el Kid Pix de los 90 apretabas la calavera y se limpiaba todo. Catártico.

Segundo, los custom commands. Puedes configurar comandos personalizados en ~/.config/lazygit/config.yml. Por ejemplo, si usas conventional commits, te creas un comando que abra un prompt para el tipo de commit, el scope y el mensaje.

Y tercero, la función lg() para tu .zshrc:

lg() {
    lazygit
    cd "$(git rev-parse --show-toplevel 2>/dev/null)" || true
}

Así, cuando sales de lazygit, te lleva al directorio raíz del repo. Por si habías navegado a subdirectorios. Una maravilla.

Para que te hagas una idea del poderío: lazygit tiene patrocinadores de la talla de David Heinemeier Hansson (DHH, el creador de Ruby on Rails) y Tobias Lütke (CEO de Shopify). Cuando los pesos pesados del desarrollo lo apoyan, por algo será. Y el proyecto acumula más de ocho mil commits y tres mil forks. La comunidad es tan activa que cada pocas semanas hay release nuevo con mejoras. La versión actual, la v0.63.1, incluye desde integración con PRs de GitHub (si tienes el CLI gh instalado) hasta gestión de worktrees, pasando por comparación visual entre commits y un montón de custom commands configurables.

Si trabajas con git a diario —y quién no hoy en día—, lazygit no es un lujo, es una necesidad. Te cambia el flujo de trabajo de una forma que no aprecias hasta que lo has usado una semana y luego intentas volver a la línea de comandos. Es como cuando pruebas un editor con buena integración de git: luego no hay quien vuelva al git add manual.

LazySQL: gestión de bases de datos en la terminal

Segunda herramienta. Esta no es de Jesse Duffield, es de Jorge Rojas, un desarrollador JavaScript que se animó con Go como primer proyecto. Cuatro mil doscientas estrellas. Se llama lazysql.

¿Cuántas veces has abierto DataGrip, DBeaver o MySQL Workbench para hacer una consulta rápida? Una consulta de dos líneas que te lleva diez segundos escribir, pero tienes que esperar un minuto a que se abra el IDE, cargue el esquema, conecte… Y si estás en un servidor remoto sin X11, ni siquiera puedes.

lazysql soluciona esto. Se conecta a MySQL, PostgreSQL, SQLite, MSSQL, MongoDB y Oracle. Desde la terminal, con una interfaz limpia y navegable con teclado.

La instalación es sencilla:

# Con Go (universal)
go install github.com/jorgerojas26/lazysql@latest

# Homebrew
brew install lazysql

# AUR (Arch)
yay -S lazysql

Arrancas con la conexión directamente:

# SQLite
lazysql sqlite3:/ruta/a/mi.db

# PostgreSQL
lazysql postgres://usuario:pass@localhost:5432/midb

# MySQL
lazysql mysql://usuario:pass@localhost:3306/midb

Y ya estás dentro. Ves las tablas a la izquierda. Navegas con las flechas, seleccionas una tabla y ves sus datos. Sin escribir una línea de SQL.

El editor SQL y el filtro en vivo

Lo que mola de verdad: el editor SQL integrado. Pulsas Ctrl+E y se abre un editor en la mitad inferior de la pantalla. Escribes tu consulta:

SELECT c.nombre AS cliente, p.nombre AS producto, v.cantidad, v.fecha
FROM ventas v
JOIN clientes c ON v.cliente_id = c.id
JOIN productos p ON v.producto_id = p.id
ORDER BY v.fecha DESC;

Ctrl+R para ejecutar. Los resultados aparecen arriba, en una tabla formateada. Navegas con las flechas, ordenas por columnas… Es como tener DataGrip en la terminal, pero sin el peso.

¿Que quieres guardar la consulta para después? Ctrl+S. Se guarda en el histórico.

Y luego está el filtro en vivo. Pulsas / dentro de una tabla y escribes cualquier texto. lazysql añade automáticamente un WHERE a la consulta. Estás viendo una tabla de usuarios y quieres solo los de España: /España y te filtra al vuelo. No es un filtro del lado del cliente, es un WHERE real en la base de datos.

La bandera de seguridad: –read-only

Esto es importante, así que presta atención. Si vas a conectar a una base de datos de producción, usa el flag --read-only:

lazysql --read-only postgres://usuario:pass@produccion:5432/midb

Así no puedes hacer DELETE, UPDATE ni DROP aunque quieras. Protección contra el ay, se me ha olvidado el WHERE.

Configuración por proyecto

Otro truco que me encanta: puedes configurar conexiones por proyecto con un archivo .lazysql.toml en la raíz del repo:

# .lazysql.toml
[connections.local]
driver = "sqlite3"
dsn = "./dev.db"

[connections.prod]
driver = "postgres"
dsn = "${env:DB_URL}"

Fíjate que puedes usar variables de entorno en el DSN con ${env:VARIABLE}. Ideal para no poner contraseñas en el archivo de configuración. Las passwords van en variables de entorno, nunca en texto plano, que estamos en 2026 ya.

Y para los que trabajáis con bases de datos en servidores remotos, lazysql soporta túneles SSH a través de un bastion host. Te puedes conectar a una base de datos que está en una red privada montando un túnel SSH automáticamente:

# .lazysql.toml
[connections.remota]
driver = "postgres"
dsn = "postgres://user@localhost:5433/mydb"
ssh_tunnel = "user@bastion.example.com"

Y luego está la exportación a CSV. Seleccionas los datos que quieres, pulsas la combinación correspondiente y te exporta a CSV. Para mandarle a tu jefe eso de mira, estos son los datos que me pediste sin tener que escribir un script. O para importarlos a Excel y hacer la grafica de turno.

lazysql está en fase alpha, según su propio README. Pero ojo, no te asustes: funciona de maravilla para el día a día. El autor, Jorge Rojas, es desarrollador JavaScript y este era su primer proyecto en Go. Que conste, que con cuatro mil doscientas estrellas, no se puede decir que sea un proyecto fallido.

LazyRsync: rsync sin miedo a borrar datos

Tercera herramienta. Esta me toca la fibra sensible. lazyrsync. Quinientas dieciocho estrellas a fecha de hoy —ha crecido un 31% en el último mes—, escrita en Rust con ratatui. Es de las más nuevas del ecosistema, pero para mí de las más útiles.

rsync es la herramienta de backup definitiva. Es rápida, incremental, puede ir por SSH, respeta enlaces simbólicos, permisos, todo. Pero tiene un problema: sus flags son una trampa mortal. Un --delete mal puesto y puff, tus datos se han ido. No a la papelera. No a un backup. Se han ido para siempre.

A mí me pasó. Bueno, casi. Una vez configuré un backup nocturno, y sin querer puse --delete en la dirección equivocada. Por suerte hice un dry-run antes y vi que iba a borrar el origen en lugar del destino. Desde entonces, rsync me da respeto. Pero lazyrsync me ha devuelto la confianza.

La instalación es con Cargo:

cargo install lazyrsync

O si prefieres binarios precompilados:

cargo binstall lazyrsync

Perfiles YAML con dry-run visual

Arrancas lazyrsync y te encuentras una interfaz limpia. Lo primero que ves son perfiles. Los defines en un archivo YAML en ~/.config/lazyrsync/profiles.toml:

[[profile]]
name = "backups"
description = "nightly"

[[profile.task]]
label  = "photos"
source = "/home/me/Pictures/"
dest   = "/mnt/nas/pics/{now:%Y-%m-%d}/"
action = "sync"

[profile.task.flags]
archive = true
compress = true
verbose = true
progress = true
partial = true
delete = false

Seleccionas un perfil con las flechas, pulsas enter y te muestra la previsualización. Pero no cualquier previsualización: un dry-run con diff estructurado. Aparecen tres columnas. Los archivos nuevos con un + delante. Los modificados con ~. Los eliminados con -. Es como un git status pero para rsync. Los archivos que se van a borrar aparecen en rojo. Los nuevos, en verde. Los modificados, en amarillo. Ves exactamente qué va a pasar antes de que pase.

Protección –delete y snapshots

Si tu perfil tiene --delete, lazyrsync te lo muestra con una advertencia enorme: ¡OJO! –delete activado. Y antes de ejecutar, te pide confirmación explícita. Tienes que escribir yes completo. No vale solo y. Quieren asegurarse de que no estás dormido.

Y luego está lo de los snapshots. lazyrsync puede usar --link-dest para crear snapshots incrementales. El primer backup es completo. El segundo backup, con --link-dest apuntando al primero, solo guarda lo que ha cambiado. Los archivos sin cambios son enlaces duros al snapshot anterior. Ocupas muy poco espacio extra y tienes instantáneas completas del pasado.

lazyrsync también tiene modo headless para usar con cron o systemd:

lazyrsync list                              # listar perfiles
lazyrsync run backups                       # ejecutar perfil
lazyrsync run backups -n                    # dry-run
lazyrsync run backups --yes                 # saltar confirmación

Puedes montarte un timer de systemd para backups automáticos diarios:

# ~/.config/systemd/user/lazyrsync-backups.service
[Service]
Type=oneshot
ExecStart=/usr/bin/lazyrsync run backups

Si haces backups con rsync a mano —y deberías hacer backups—, instálate lazyrsync. Te ahorrará un disgusto, te lo aseguro.

LazyDocker: gestiona contenedores desde la terminal

Cuarta herramienta. Y esta es la hermana pequeña de lazygit, creada por el mismo Jesse Duffield. lazydocker. Cincuenta y dos mil trescientas estrellas en GitHub, escrito en Go.

¿Qué hace? Exactamente lo que suena: una interfaz en terminal para gestionar Docker. Contenedores, imágenes, volúmenes, redes, docker-compose… todo desde un solo panel, con teclas directas.

Porque seamos sinceros: los comandos de Docker están bien cuando los usas una vez al día. Pero cuando estás desarrollando y estás todo el rato haciendo docker ps, docker logs -f, docker exec -it, docker compose up, docker images, docker system prune… acabas harto. Y además, siempre tienes que acordarte de los flags. ¿Era docker ps -a o docker container ls -a? Con lazydocker, todo es una tecla.

La instalación es igual de sencilla:

# Debian/Ubuntu
sudo apt install lazydocker

# Homebrew
brew install jesseduffield/lazydocker/lazydocker

# Universal con Go
go install github.com/jesseduffield/lazydocker@latest

La interfaz de cuatro paneles

lazydocker y ya estás dentro. La interfaz tiene cuatro paneles principales. Arriba a la izquierda, los contenedores (running y stopped). Arriba a la derecha, la información del contenedor seleccionado. Abajo a la izquierda, las imágenes. Abajo a la derecha, los logs en vivo.

Navegas con las flechas entre contenedores. Seleccionas uno que está corriendo y pulsas space. ¿Qué ha pasado? Has abierto una terminal interactiva dentro del contenedor. Es como hacer docker exec -it, pero sin acordarte de la sintaxis.

Pulsas Ctrl+D para salir. Ahora seleccionas otro contenedor y pulsas s. Stats. Ves el uso de CPU, memoria y red en tiempo real. Es como docker stats pero integrado en el panel, sin tener que abrir otra terminal.

Logs, compose y limpieza

Los logs en vivo son una pasada. Seleccionas un contenedor, pulsas enter y se abre el panel de logs. Cada nueva línea aparece al instante. Navegas con las flechas arriba y abajo para ver el histórico. ¿Que quieres buscar algo en los logs? Pulsas / y escribes error.

Para docker-compose: si estás en un directorio con docker-compose.yml, lazydocker lo detecta automáticamente. Pulsas p y levanta todos los servicios. s para pararlos. Y ves los logs de todos los servicios combinados, cada uno con su color.

Y luego está la gestión de imágenes y volúmenes. En el panel de imágenes, seleccionas las que ya no usas y pulsas d. Las borra. ¿Imágenes huérfanas? lazydocker te las marca. Los volúmenes también están ahí: ves los que están en uso, los huérfanos, el tamaño que ocupan. Con una tecla los limpias. Es como docker system prune pero selectivo: tú eliges qué borrar.

lazydocker no es tan conocido como lazygit, pero tiene cincuenta y dos mil trescientas estrellas, que no está nada mal, y la misma filosofía: cada acción común, una tecla. Además, comparte el mismo autor, lo que significa que los atajos y la experiencia de usuario son muy similares. Si ya usas lazygit, aprender lazydocker te llevará cinco minutos.

Y una cosa que mola: lazydocker funciona también con Podman. Si eres de los que ha migrado a Podman por temas de seguridad o porque no quieres usar el demonio de Docker, lazydocker te vale igual. Bueno, y también funciona con Docker, obviamente. En mi caso, lo uso a diario para los proyectos que tengo en casa, y te puedo asegurar que el tiempo que me ahorro en teclear comandos se nota. Sobre todo cuando estás debuggeando algo y entras y sales de contenedores constantemente.

El resto del ecosistema lazy

Hasta aquí las cuatro herramientas con demo. Pero hay muchas más en el ecosistema lazy. Te las cuento rápido, que la filosofía vaga también aplica a los artículos.

lazyssh (3.800 ⭐) — Te lee el ~/.ssh/config y te muestra todos tus servidores en una interfaz navegable con fuzzy search. Haces Ctrl+F, escribes prod, y te muestra solo los servidores de producción. También puedes hacer port forwarding desde la UI. En el episodio 818 hablamos de SSHub, que es otra aproximación al mismo problema. lazyssh es más simple, más directo.

lazyjj (1.200 ⭐) — ¿Usas Jujutsu? ¿No? Bueno, si algún día te animas con jj —el VCS alternativo a git creado por el mismo tipo de Mercurial—, existe lazyjj, un TUI escrito en Rust. Para los aventureros.

lazykube (583 ⭐) — Existe. Pero seamos sinceros: si gestionas Kubernetes, usa k9s. Es muy superior. lazykube es una alternativa ligera, pero k9s es el rey indiscutible.

lazyprune (2 ⭐) — Escrito en Rust con ratatui. Escanea tu disco en busca de node_modules, target, .gradle, Pods… todos esos directorios que ocupan gigas de proyectos que ya no tocas. Y te deja limpiarlos. ¿Cuántos GB tienes muertos en node_modules de proyectos que no has abierto en dos años?

lazynpm (851 ⭐, archivado) — Lo hizo Jesse Duffield, pero lo archivó. No funciona con npm moderno. Mención honorífica por la intención.

lazyollama (1 ⭐) — Un wrapper TUI para Ollama. Si te gusta chatear con modelos locales desde la terminal con una interfaz mona, existe. Muy verde todavía.

lazyide (86 ⭐) — Un IDE en terminal con syntax highlighting, LSP, tree de archivos… pero si quieres un editor en terminal, usa Helix o Micro. Son mejores y más maduros.

lazycrate (13 ⭐) y lazygradle (6 ⭐) — Gestión de crates de Rust y proyectos Gradle desde TUI. Dos proyectos muy tempranos. Si eres desarrollador Rust o Java, échales un ojo, pero no esperes milagros.

Y ojo: no confundas con lazy.nvim. Eso es un gestor de plugins para Neovim, veintiún mil estrellas, pero no es una herramienta CLI independiente. Es otro tema completamente distinto.

Sé un vago inteligente

La filosofía de las lazy tools es simple: cuanto menos escribes, menos errores cometes. Cada flag que no tienes que recordar, cada comando que no tienes que teclear, cada confirmación antes de hacer algo peligroso… eso es tiempo que dedicas a pensar en lo importante, no en la sintaxis de una herramienta.

Herramienta	Estrellas	Para qué	Instalación
lazygit	80.900 ⭐	Git en TUI — stage, commit, rebase, bisect	`apt install lazygit`
lazysql	4.200 ⭐	Bases de datos en TUI — SQL, filtros, CSV	`go install`
lazyrsync	518 ⭐	rsync con protección — perfiles, snapshots	`cargo install lazyrsync`
lazydocker	52.300 ⭐	Docker TUI — contenedores, logs, stats, compose	`apt install lazydocker`

Así que ya sabes: instálate lazygit. Es la puerta de entrada. Luego, según veas, añade lazysql para las bases de datos, lazyrsync para los backups, lazydocker para gestionar Docker… y si encuentras alguna lazy tool interesante que no haya mencionado, cuéntamelo. En los comentarios del blog, en Mastodon, donde sea.

Mi recomendación personal: empieza por lazygit. Úsalo una semana. Oblígate a no escribir ni un solo comando de git directamente. Solo lazygit y teclas. A la semana siguiente, si trabajas con bases de datos, instálate lazysql. Si haces backups, lazyrsync. Y si usas Docker a diario, lazydocker. No hace falta que te las instales todas de golpe. Ve paso a paso, que la filosofía vaga también aplica a la hora de aprender nuevas herramientas.

Y ojo, que esto no va de ser perezoso. Va de ser estratégicamente perezoso. De delegar en las herramientas lo mecánico para centrarte en lo importante. De no tener que estar mirando el manual cada vez que necesitas hacer un rebase interactivo o conectar a una base de datos remota. De reducir la fricción en tu flujo de trabajo para que puedas concentrarte en lo que realmente importa: resolver problemas, escribir código, crear cosas.

Hay un momento en la vida de todo linuxero en el que te das cuenta de que no necesitas memorizar todos los flags de todas las herramientas. Que puedes usar TUIs que te guíen, que te protejan de tus propios errores, que hagan el trabajo sucio por ti. Ese momento es hoy. Este artículo es esa señal. No la ignores.

Yo soy vago. ¿Y tú?

Recordad: sed vagos, pero sed vagos inteligentes. Usad herramientas que hagan el trabajo sucio por vosotros. 🐧