Productividad para desarrolladores: VS Code, Git avanzado, gestión ágil y scripts de automatización

La productividad de un desarrollador no depende de escribir más rápido, sino de perder menos tiempo en lo que no es programar: buscar archivos, deshacer un merge mal hecho, recordar qué tarea seguía o repetir a mano el mismo respaldo cada semana.

Estas son las herramientas y hábitos que más tiempo me han ahorrado.

Mi setup de VS Code

Extensiones que sí aportan valor

La regla es simple: si una extensión no la uso al menos una vez por semana, la desinstalo. Cada extensión activa consume memoria y tiempo de arranque.

Un truco poco usado: los perfiles de VS Code. Tengo uno para PHP/Laravel, otro para Flutter y otro para Node, cada uno con sus extensiones. El editor carga solo lo que necesita.

Atajos imprescindibles

Mi settings.json

{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit",
    "source.organizeImports": "explicit"
  },
  "editor.fontFamily": "'JetBrains Mono', monospace",
  "editor.fontLigatures": true,
  "editor.minimap.enabled": false,
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active",
  "editor.stickyScroll.enabled": true,
  "files.trimTrailingWhitespace": true,
  "files.insertFinalNewline": true,
  "files.autoSave": "onFocusChange",
  "explorer.confirmDragAndDrop": false,
  "workbench.editor.enablePreview": false,
  "git.autofetch": true,
  "terminal.integrated.scrollback": 10000
}

Git más allá de commit y push

git rebase -i: historial limpio antes del pull request

Antes de abrir un PR, junto los commits de "fix typo" y "ahora sí" en commits con sentido:

git fetch origin
git rebase -i origin/develop

En el editor cambias pick por squash (o s) para fusionar, reword para cambiar el mensaje o drop para eliminar. Si aparece un conflicto:

# resuelves los archivos y luego
git add .
git rebase --continue
# o, si te arrepientes
git rebase --abort

Regla de oro: no hagas rebase de ramas que otras personas ya descargaron. Si ya publicaste la rama, usa git push --force-with-lease, que se niega a sobrescribir cambios ajenos que no tengas localmente.

git cherry-pick: llevar un solo commit a otra rama

Clásico de Gitflow: arreglaste un bug en develop y necesitas ese mismo arreglo en un hotfix.

git switch hotfix/1.4.1
git cherry-pick a1b2c3d
git cherry-pick a1b2c3d..f6e7d8c   # un rango de commits
git cherry-pick -x a1b2c3d         # agrega "cherry picked from" al mensaje

git bisect: encontrar el commit exacto que rompió algo

Funcionaba hace dos semanas y hoy no. Hay 80 commits entremedio. bisect hace búsqueda binaria y lo encuentra en unos 7 pasos.

git bisect start
git bisect bad                 # el commit actual está malo
git bisect good v2.3.0         # este tag funcionaba
# Git te deja en un commit intermedio: pruebas y marcas
git bisect good   # o git bisect bad
# ...repites hasta que Git te dice cuál es el primer commit malo
git bisect reset

Y si tienes un test que detecta el problema, lo automatizas por completo:

git bisect start HEAD v2.3.0
git bisect run npm test -- tests/calculo-totales.test.ts

Otros comandos que salvan el día

git switch -c feature/nueva          # crear rama y cambiarse
git stash push -m "a medias"         # guardar cambios sin commit
git stash pop
git reflog                           # recuperar commits "perdidos"
git log --oneline --graph --all      # ver el árbol completo
git commit --amend --no-edit         # agregar algo al último commit

git reflog merece mención aparte: casi nada se pierde en Git. Si un reset --hard se llevó tu trabajo, el reflog te muestra dónde estaba HEAD antes.

Gestión de proyectos sin burocracia

En proyectos pequeños o freelance el riesgo no es la falta de proceso, sino tener tanto proceso que gestionar toma más tiempo que programar. Lo que me funciona:

• Un solo tablero con cuatro columnas: Pendiente, En curso, En revisión, Listo. Nada más.
• Límite de trabajo en curso: máximo dos tarjetas en "En curso". Si quieres empezar otra, termina una.
• Tarjetas pequeñas: si una tarea toma más de un día, se divide.
• Sprints de una o dos semanas con una revisión de 15 minutos al final: qué se entregó, qué pasa al siguiente.
• Cada tarjeta enlazada a su rama o PR, para que el tablero y el código cuenten la misma historia.

¿Qué herramienta usar?

Con GitHub Projects, además, puedes cerrar tarjetas automáticamente desde el commit:

git commit -m "fix(facturas): corrige redondeo del IVA

Closes #42"

Automatización con scripts

Todo lo que haces más de tres veces merece un script.

Respaldo de PostgreSQL con rotación

#!/usr/bin/env bash
set -euo pipefail

DB_NAME="${DB_NAME:-app}"
BACKUP_DIR="${BACKUP_DIR:-/var/backups/postgres}"
RETENTION_DAYS="${RETENTION_DAYS:-14}"
STAMP="$(date +%Y%m%d_%H%M%S)"
FILE="${BACKUP_DIR}/${DB_NAME}_${STAMP}.dump"

mkdir -p "$BACKUP_DIR"

pg_dump -Fc -d "$DB_NAME" -f "$FILE"
echo "Respaldo creado: $FILE ($(du -h "$FILE" | cut -f1))"

find "$BACKUP_DIR" -name "${DB_NAME}_*.dump" -mtime +"$RETENTION_DAYS" -delete
echo "Respaldos con más de ${RETENTION_DAYS} días eliminados"

Programado con cron todos los días a las 03:15:

15 3 * * * DB_NAME=app /opt/scripts/backup-pg.sh >> /var/log/backup-pg.log 2>&1

Un respaldo que nunca restauraste no es un respaldo: prueba de vez en cuando con pg_restore -d app_prueba archivo.dump.

Limpieza de carpetas pesadas

#!/usr/bin/env bash
# Elimina node_modules de proyectos sin cambios en 30 días
find ~/proyectos -name node_modules -type d -prune -mtime +30 -print -exec rm -rf {} +

# Libera espacio de Docker (imágenes y caché sin usar)
docker system prune -f

Despliegue en un comando

#!/usr/bin/env bash
set -euo pipefail

SERVER="deploy@mi-servidor"
APP_DIR="/srv/miapp"

ssh "$SERVER" bash -s <<EOF
  set -e
  cd "$APP_DIR"
  git pull --ff-only
  docker compose pull
  docker compose up -d --build
  docker image prune -f
EOF

echo "Despliegue terminado"

Una tarea en Node.js: avisar cuando algo falla

// notify.mjs: envía un mensaje a un webhook (ntfy, Slack, Discord...)
const [, , titulo, mensaje] = process.argv;

await fetch(process.env.WEBHOOK_URL, {
  method: "POST",
  headers: { Title: titulo },
  body: mensaje,
});

/opt/scripts/backup-pg.sh || node notify.mjs "Respaldo falló" "Revisar servidor de producción"

Conclusión

Ninguna de estas ideas es espectacular por sí sola. La diferencia aparece cuando se suman: un editor que trabaja para ti, un Git que sabes usar cuando algo sale mal, un tablero que no te roba la tarde y scripts que hacen solos lo repetitivo. Eso es tiempo que vuelve a lo que importa: construir.