Como o Gum Acelerou Meu Fluxo de Desenvolvimento

Trabalhar com aplicações web modernas muitas vezes significa lidar com vários processos ao mesmo tempo. Para o desenvolvimento de uma feature básica no meu trabalho, preciso de cinco janelas de terminal rodando simultaneamente: o backend principal, o serviço de autenticação, a aplicação web, a feature que estou desenvolvendo e uma extra para comandos avulsos.

Toda sessão de trabalho começa da mesma forma. Abro o terminal. cd no primeiro repo, lembro o comando, rodo. Nova aba. cd no segundo repo, lembro aquele comando, rodo. Repito cinco vezes. Entre vários repos com comandos de inicialização diferentes, ambientes com suas próprias particularidades e watchers distintos, são pelo menos cinco minutos de trabalho mecânico antes de escrever uma linha de código.

Parece pouco, mas vai acumulando, e mais do que o tempo em si, é o overhead mental de acertar todos os comandos antes mesmo de começar a trabalhar de verdade.

Foi aí que o Gum mudou tudo pra mim.

Antes de falar do Gum: o que é um shell script?

Se você já tem familiaridade com bash, pode pular para a próxima seção. Mas se você só digitou comandos um de cada vez até agora, aqui vai a mágica: dá pra salvar uma sequência de comandos em um arquivo e rodar tudo de uma vez!

Aquele arquivo .sh que você vê espalhado pelos repos? É exatamente isso, um arquivo de texto simples que executa seus comandos de cima pra baixo.

Então em vez de fazer isso toda sessão de trabalho:

cd ~/projects/backend && npm run dev
# nova aba...
cd ~/projects/auth-service && npm run start
# nova aba...
cd ~/projects/web-app && npm run dev

Você escreve uma vez em um arquivo chamado start.sh, deixa ele executável com chmod +x start.sh, e a partir daí é só rodar ./start.sh.

Só isso já economiza bastante tempo. Mas ainda é meio bruto, um script que sobe tudo sem nenhuma interatividade e sem feedback. O que me leva ao que realmente elevou isso a outro nível pra mim: o Gum.

O que é o Gum?

O Gum é uma ferramenta que permite escrever shell scripts com muito mais estilo. Ela oferece prompts interativos, menus de seleção, texto estilizado, spinners e campos de input, tudo acessível direto do bash. Sem precisar construir uma aplicação CLI completa em Go ou Python. Se você consegue escrever um shell script, consegue usar o Gum.

É direto ao ponto: quer um menu de seleção? Uma linha. Precisa de uma confirmação? Uma linha. Quer que pareça polido e profissional? Já vem assim por padrão.

Construindo um Gerenciador de Scripts

Em vez de memorizar qual comando vai em qual lugar ou manter um mapa mental das abas do terminal, construí um pequeno gerenciador de scripts que funciona como minha central de controle diária. Quando sento pra trabalhar, rodo um único comando e escolho o que preciso em um menu interativo.

O resultado final ficou assim:

O core do script é mais ou menos assim:

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

# ── Constantes ─────────────────────────────
readonly SCRIPTS_DIR="$HOME/scripts"
readonly COLOR_PRIMARY="#40CAC2"
readonly COLOR_ACCENT="#00b8ad"
readonly COLOR_HEADER="#FBA0B1"
readonly COLOR_BORDER="#FFBFCB"

# ── Helpers ────────────────────────────────
styled_text() {
  gum style --foreground "$COLOR_PRIMARY" "$1"
}

print_header() {
  gum style \
    --foreground 212 \
    --border-foreground "$COLOR_BORDER" \
    --border rounded \
    --align center \
    --margin "1 1" \
    --padding "1 1" \
    "$(styled_text " ") Script Launcher"
}

get_choice() {
  gum choose \
    --height 5 \
    --header "Escolha um script para rodar:" \
    --cursor.foreground "$COLOR_ACCENT" \
    --header.foreground "$COLOR_HEADER" \
    "script-1" \
    "script-2" \
    "script-3" \
    "script-4"
}

run_script() {
  local name="$1"
  local script_path="$SCRIPTS_DIR/${name}.sh"

  if [[ ! -f "$script_path" ]]; then
    gum style --foreground "#FF5555" "Erro: script '$name' não encontrado em $script_path"
    exit 1
  fi

  gum spin --spinner dot --title "Iniciando $name..." -- sleep 0.5
  bash "$script_path"
}

# ── Main ───────────────────────────────────
main() {
  print_header

  local choice
  choice=$(get_choice) || { echo "Até! 👋"; exit 0; }

  [[ -z "$choice" ]] && { echo "Até! 👋"; exit 0; }

  run_script "$choice"
}

main "$@"

A Abordagem Modular

O verdadeiro poder aqui está na modularidade. Cada opção do menu aponta para um arquivo de script independente. Quer adicionar um novo fluxo? Cria um novo arquivo .sh e adiciona uma linha no menu. Quer mudar como o seu frontend sobe? É só editar aquele script sem precisar mexer no launcher.

Essa separação mantém o launcher limpo e simples enquanto a lógica real fica em arquivos dedicados. Você pode versionar cada um de forma independente, compartilhar scripts específicos com o time, ou trocar implementações sem quebrar nada.

Por que o Gum Funciona Tão Bem

A força do Gum está na sua simplicidade e na forma como ele se compõe com outras ferramentas. Como todo comando do Gum retorna texto puro, ele se integra naturalmente com pipes, variáveis e o restante do seu toolkit de shell. A curva de aprendizado se resume a conhecer bash básico, e os padrões visuais já são polidos o suficiente para que seus scripts pareçam ferramentas de verdade, não apenas gambiarras rápidas.

As opções de estilo são surpreendentemente ricas também. Cores personalizadas para cursor, cabeçalho e bordas permitem combinar com o tema do seu terminal ou criar hierarquia visual em menus mais complexos. O gum spin por exemplo dá um toque profissional enquanto os serviços sobem, transformando um script cru em algo que parece intencional.

Para times, essa abordagem tem um benefício a mais: em vez de documentar longos procedimentos de setup ou esperar que novos membros memorizem comandos, você codifica o fluxo diretamente no script. Qualquer pessoa pode rodar o mesmo menu e obter os mesmos resultados sem precisar conhecer as particularidades do projeto. Algo muito útil quando pessoas não técnicas precisam rodar o projeto localmente

O Resultado

Minha sessão de trabalho agora começa com um único comando. Seleciono o que preciso no menu, os serviços sobem na ordem certa, e estou pronto pra trabalhar. Sem mais ficar alternando entre abas tentando lembrar qual tem os logs. Sem mais perder tempo lembrando comandos específicos.

Se você se vê afogado em janelas de terminal ou travado tentando lembrar comandos específicos de cada projeto, vale a pena dar uma chance ao Gum. Às vezes as melhorias mais impactantes na experiência de desenvolvimento vêm das ferramentas mais simples.