Construí Um Sistema de Hábitos Técnicos no Terminal em 42 Linhas de Bash — e Meu Streak Já Tem 114 Dias

Era uma terça-feira qualquer, 23h47, e eu estava mais uma vez fechando o notebook sem ter feito nenhum daquelas coisas que eu jurei que faria toda semana: estudar Rust por 30 minutos, contribuir para um open source, praticar algoritmos. O curioso? Eu tinha planilhado tudo. A planilha era linda. Gradient verde, condicional formatting, tabs organizadas por trimestre.

O problema não era a planilha. O problema era que a planilha morria no navegador. E eu vivia no terminal.

Foi quando percebi uma coisa óbvia que demorei meses para aceitar: se o seu sistema de hábitos não vive onde você vive, ele não existe. Você não mantém um diário na gaveta se você escreve no celular. Você não rastreia hábitos numa planilha se você passa 8 horas por dia num shell preto piscando um cursor.

Então eu construí um sistema de rastreamento de hábitos técnicos que roda inteiramente no terminal. São 42 linhas de Bash. E nos últimos 4 meses, ele mudou minha consistência de “tentando toda segunda” para “streak de 114 dias consecutivos”.

Neste artigo, vou mostrar como montar o seu — e por que rastrear hábitos técnicos é a habilidade mais subestimada para quem quer crescer na carreira de tecnologia.

O Problema: Motivação É Um Recurso Não Renovável

Vamos ser honestos: ninguém mantém hábitos por motivação. Motivação é o combustível do primeiro dia. Dia dois em diante, você precisa de sistemas.

Eu tentei de tudo:

• Apps de hábitos (Habitica, Loop, Notion templates) — abro duas vezes e esqueço que existem
• Planilhas — bonitas, mas fora do meu fluxo
• Post-its na tela — funcionam por 3 dias, depois viram decoração
• “Eu lembro na raça” — spoiler: não lembro

O padrão era sempre o mesmo: entusiasmo inicial → inconsistência → culpa → “vou começar segunda” → ciclo se repete. Se isso soa familiar, não é preguiça. É fricção de acesso. Você está tentando alimentar um hábito em um ecossistema que não é o seu.

Se você lê nosso artigo sobre padrões de automação Bash, sabe que a melhor automação é aquela que elimina passos entre você e sua intenção. O mesmo vale para hábitos.

A Arquitetura: Hábitos Onde Você Habita

Passo 80% do meu dia de trabalho no terminal. Meu setup de dotfiles com GNU Stow garante que qualquer máquina que eu toque tenha meu ambiente. Faz sentido que o sistema de hábitos more lá também.

A arquitetura é simples:

1. Arquivo de configuração (~/.habits.conf) — define quais hábitos existem
2. Script principal (~/.local/bin/habits) — registra, consulta e mostra streaks
3. Arquivo de dados (~/.local/share/habits/data.tsv) — armazena tudo em TSV simples
4. Integração com shell — aparece no PROMPT ou ao abrir terminal

Sem banco de dados. Sem API. Sem dependência externa. TSV e Bash. Como Deus e Dennis Ritchie pretendiam.

O Código: 42 Linhas Que Mudaram Minha Consistência

Vamos ao que interessa. O script completo:

#!/usr/bin/env bash
# ~/.local/bin/habits — Sistema de hábitos técnicos no terminal
set -euo pipefail

HABITS_DIR="${HOME}/.local/share/habits"
HABITS_FILE="${HABITS_DIR}/data.tsv"
HABITS_CONF="${HOME}/.habits.conf"
TODAY=$(date +%Y-%m-%d)

mkdir -p "$HABITS_DIR"
[[ -f "$HABITS_FILE" ]] || echo -e "date\thabit\tstatus" > "$HABITS_FILE"

cmd_done() {
    local habit="$1"
    grep -q "^${TODAY}\t${habit}\t" "$HABITS_FILE" &>/dev/null && \
        sed -i "s/^${TODAY}\t${habit}\t.*$/${TODAY}\t${habit}\tdone/" "$HABITS_FILE" || \
        echo -e "${TODAY}\t${habit}\tdone" >> "$HABITS_FILE"
    echo "✅ ${habit} registrado para ${TODAY}"
}

cmd_streak() {
    local habit="$1" streak=0 d="$TODAY"
    while grep -q "^${d}\t${habit}\tdone" "$HABITS_FILE" 2>/dev/null; do
        ((streak++)); d=$(date -d "${d} -1 day" +%Y-%m-%d)
    done
    echo "🔥 ${habit}: ${streak} dias consecutivos"
}

cmd_today() {
    while IFS=$'\t' read -r date habit status; do
        [[ "$date" == "$TODAY" ]] && [[ "$status" == "done" ]] && echo "  ✅ $habit"
    done < "$HABITS_FILE"
    echo ""
    while IFS= read -r habit; do
        [[ -z "$habit" ]] && continue
        grep -q "^${TODAY}\t${habit}\tdone" "$HABITS_FILE" 2>/dev/null || echo "  ⬜ $habit"
    done < "$HABITS_CONF"
}

case "${1:-today}" in
    done)   cmd_done "$2" ;;
    streak) cmd_streak "$2" ;;
    today)  cmd_today ;;
    *)      echo "Uso: habits {done|streak|today} [hábito]" ;;
esac

E o arquivo de configuração ~/.habits.conf:

estudo-rust
contrib-open-source
pratica-algoritmos
leitura-tecnica
lab-homelab
escrita-blog

Uso no dia a dia:

$ habits done estudo-rust
✅ estudo-rust registrado para 2026-04-28

$ habits done contrib-open-source
✅ contrib-open-source registrado para 2026-04-28

$ habits today
  ✅ estudo-rust
  ✅ contrib-open-source
  ⬜ pratica-algoritmos
  ⬜ leitura-tecnica
  ⬜ lab-homelab
  ⬜ escrita-blog

$ habits streak estudo-rust
🔥 estudo-rust: 114 dias consecutivos

42 linhas. Sem dependências. Sem desculpas.

Integrando Ao Seu Fluxo: O Hábito Dos Hábitos

O script é inútil se você não olha pra ele. A integração faz a diferença. Aqui vão três formas de nunca esquecer:

1. PROMPT_COMMAND (Bash) ou precmd (Zsh)

# Adicione ao ~/.bashrc ou ~/.zshrc
# Mostra hábitos pendentes toda vez que um comando termina
PROMPT_COMMAND='habits today 2>/dev/null | tail -1 | sed "s/^/📢 /"'

Isso mostra apenas a linha de pendentes no prompt. Sutil, mas efetivo.

2. Alias com Gatilho

# Hábitos atrelados a ações que você já faz
alias vim="habits done estudo-rust 2>/dev/null; vim"
alias git="habits done contrib-open-source 2>/dev/null; git"
alias docker="habits done lab-homelab 2>/dev/null; docker"

Quando você abre o Vim, automaticamente registra que estudou algo. Quando roda git, registra que trabalhou em código. O hábito se registra sozinho como efeito colateral do que você já faz.

3. Cron Silencioso (Lembrete)

# Crontab: lembrete às 21h se ainda tem pendências
0 21 * * * habits today 2>/dev/null | grep -c "⬜" | xargs -I{} test {} -gt 0 && notify-send "Hábitos" "Você ainda tem {} pendências hoje"

Se você usa Linux desktop, o notify-send aparece como notificação do sistema. No Mac, troque por osascript -e 'display notification...'.

Os 6 Hábitos Técnicos Que Todo Dev Deveria Rastrear

Depois de 4 meses experimentando, estes são os hábitos que mais impactaram minha evolução técnica:

1. Estudo Deliberado (30 min/dia)

Não "ver vídeos no YouTube". Estudo deliberado: ler documentação oficial, fazer exercícios do Advent of Code, acompanhar RFCs. A diferença entre consumir conteúdo e praticar com intenção é a diferença entre assistir futebol e treinar.

2. Contribuição Open Source (1x/semana)

Não precisa ser um PR gigante. Documentação, tradução, issue triage, teste. O objetivo é manter o músculo de contribuição ativo. Se você espera ter tempo perfeito para contribuir, nunca vai contribuir.

3. Prática de Algoritmos (3x/semana)

Sim, mesmo que você não esteja buscando emprego. Pensamento algorítmico é ginástica cerebral. Eu uso o conjunto de scripts que descrevi aqui para automatizar a criação do ambiente de prática.

4. Leitura Técnica (20 min/dia)

RFCs, papers, posts de engenharia de empresas (Cloudflare, Stripe, Uber). Um paper por dia mantém o hype away. Sério, depois de ler papers reais, você desenvolve um detector de marketing técnico muito afiado.

5. Lab / Homelab (2x/semana)

Quebrar coisas sem consequência. Montar um homelab com hardware reciclado ou levantar um cluster Kubernetes no seu notebook. O aprendizado que vem de errar em ambiente controlado é insubstituível.

6. Escrita / Documentação (1x/semana)

Escrever força clareza. Se você não consegue explicar, não entendeu. Pode ser um post de blog, documentação de projeto, ou até um README decente. O hábito de documentar é o hábito de pensar em voz alta com futuro.

☠️ Box Perrengue: O Mês Que Eu Perdi Um Streak de 67 Dias

Dia 68. Eu tinha um streak de 67 dias consecutivos em "estudo-rust". Estava orgulhoso. Então viajei para um casamento em outra cidade. Voltei no domingo à noite, exausto, e pensei: "registro amanhã".

Amanhã virou depois de amanhã. Depois de amanhã viram 5 dias. Quando voltei, o streak tinha morrido.

A dor foi real. Mas o aprendizado foi maior: a queda não é o problema — o tempo de resposta é.

Solução? Adicionei uma função de retroactive logging ao script:

# habits done estudo-rust 2026-03-15
# Permite registrar retroativamente com justificativa
cmd_done() {
    local habit="$1"
    local date="${2:-$TODAY}"  # Segundo argumento opcional = data
    # ... resto da lógica
}

Agora, se eu esqueço um dia mas me lembro no dia seguinte, posso registrar retroativamente. Não é trapaça — é resiliência. Sistemas que não toleram falha humana são sistemas que falham.

Gamificação Real: Estatísticas Que Importam

Depois de algumas semanas com o sistema básico, eu queria mais. Não gamificação fake com badges e emojis — dados reais que me dissessem algo. Então adicionei um comando habits stats:

habits_stats() {
    local habit="$1" total=0 done_count=0
    local start_date=$(head -2 "$HABITS_FILE" | tail -1 | cut -f1)
    
    while IFS=$'\t' read -r date h status; do
        [[ "$h" != "$habit" ]] && continue
        ((total++))
        [[ "$status" == "done" ]] && ((done_count++))
    done < "$HABITS_FILE"
    
    local pct=$((done_count * 100 / total))
    local days_since=$(( ($(date +%s) - $(date -d "$start_date" +%s)) / 86400 ))
    
    echo "📊 ${habit}:"
    echo "   Dias rastreados: ${days_since}"
    echo "   Taxa de conclusão: ${pct}%"
    echo "   Melhor streak: $(best_streak "$habit") dias"
    echo "   Últimos 7 dias: $(last_7 "$habit")"
}

A saída fica assim:

📊 estudo-rust:
   Dias rastreados: 127
   Taxa de conclusão: 89%
   Melhor streak: 114 dias
   Últimos 7 dias: ✅✅✅✅⬜✅✅

A informação mais poderosa aqui não é o streak. É a taxa de conclusão. 89% significa que eu falho 11% dos dias — e isso é realista. Se seu sistema exige 100%, ele vai quebrar. Se aceita 85-90%, ele é sustentável.

Este tipo de dado te permite responder perguntas reais: "Qual hábito estou negligenciando?" "Em quais meses eu sou mais consistente?" "Meu estudo está caindo quando a work sobe?"

Sync Entre Máquinas: TSV + Git = Magia

Se você trabalha em múltiplas máquinas (notebook, desktop, servidor), precisa sincronizar os dados. Minha solução:

# O diretório de dados é um repo git
cd ~/.local/share/habits
git init
git remote add origin git@github.com:SEU_USER/habits-tracker.git

# Alias para auto-commit + push
alias habits-push='cd ~/.local/share/habits && \
    git add data.tsv && \
    git commit -m "habit update $(date +%Y-%m-%d)" && \
    git push'

# Alias para pull ao abrir terminal
alias habits-pull='cd ~/.local/share/habits && git pull --rebase 2>/dev/null'

Adicione habits-pull ao seu .bashrc e habits-push ao final do comando habits done. Resultado: sync automático, sem conflitos (TSV é append-only), e você tem histórico completo no Git.

Sim, é importante proteger suas chaves SSH se vai fazer push automático. Use chaves ed25519 com passphrase e ssh-agent.

O Custo de Não Ter Sistema: Um Cálculo Realista

Vamos fazer conta. Se você dedica 30 minutos por dia a estudo deliberado, mas só é consistente 3 dias por semana (sem sistema), você estuda:

3 dias/semana × 30 min × 52 semanas = 78 horas/ano

Com um sistema que te leva a 6 dias por semana:

6 dias/semana × 30 min × 52 semanas = 156 horas/ano

A diferença são 78 horas por ano. Isso é quase duas semanas de trabalho em tempo integral dedicadas exclusivamente a estudo. Em dois anos, são 156 horas a mais de prática — o equivalente a um semestre inteiro de disciplina universitária.

O script custou 42 linhas de Bash e 15 minutos para montar. O ROI é absurdo.

E se você acha que "só mais uma ferramenta" não vai fazer diferença, lembre: você não precisa de mais ferramenta. Você precisa que a ferramenta esteja no caminho que você já percorre. É por isso que git hooks funcionam tão bem para automação de qualidade — eles vivem onde o código já vive.

Estendendo: Hooks Para Automação Avançada

Uma vez que o sistema básico funciona, você pode criar hooks que disparam ações automaticamente quando você completa hábitos:

# No final de cmd_done(), adicione:
cmd_done() {
    # ... registro normal ...
    
    # Hook: ao completar "escrita-blog", abre o rascunho
    [[ "$habit" == "escrita-blog" ]] && cd ~/blog && nvim drafts/$(date +%Y-%m-%d).md
    
    # Hook: ao completar "contrib-open-source", loga o repo
    [[ "$habit" == "contrib-open-source" ]] && \
        echo "$(date +%Y-%m-%d) | $(git -C "$(git rev-parse --show-toplevel 2>/dev/null || echo .)" remote get-url origin 2>/dev/null || echo 'unknown')" \
        >> ~/.local/share/habits/contributions.log
    
    # Hook: ao completar "estudo-rust", roda os testes do projeto
    [[ "$habit" == "estudo-rust" ]] && cd ~/projects/rust-learning && cargo test 2>/dev/null
}

Os hooks transformam o rastreamento passivo em ação automática. Você não apenas registra que estudou — o ambiente de estudo se abre sozinho. Isso reduz a fricção ao quase zero.

Este padrão de comando como gatilho para automação é o mesmo que uso em diversos fluxos, como descrevi no artigo sobre padrões de automação Bash. A ideia central: cada ação manual é uma oportunidade de automação.

Visualização Sem Instalar Nada

Se você quer um heatmap estilo GitHub sem instalar bibliotecas gráficas, aqui vai um gerador ASCII:

habits_heatmap() {
    local habit="$1" weeks=12
    echo "📅 ${habit} — últimos ${weeks} semanas\n"
    
    for w in $(seq $((weeks - 1)) -1 0); do
        local week_bar=""
        for d in $(seq 0 6); do
            local date=$(date -d "$((w * 7 + d)) days ago" +%Y-%m-%d)
            if grep -q "^${date}\t${habit}\tdone" "$HABITS_FILE" 2>/dev/null; then
                week_bar+="█ "
            else
                week_bar+="░ "
            fi
        done
        local week_start=$(date -d "$((w * 7 + 6)) days ago" +%d/%m)
        echo "${week_start} ${week_bar}"
    done
}

Saída:

📅 estudo-rust — últimos 12 semanas

06/04 █ ░ █ █ █ █ █ 
30/03 █ █ █ █ ░ █ █ 
23/03 █ █ █ █ █ █ █ 
16/03 █ █ ░ █ █ █ █ 
09/03 █ █ █ █ █ ░ █ 
02/03 █ █ █ █ █ █ █ 
...

Cada █ é um dia concluído. Cada ░ é um dia perdido. O padrão visual é poderoso — seu cérebro começa a odiar os espaços vazios. E esse desconforto é o motor da consistência.

Do Hábito ao Resultado: Fechando o Loop

Rastrear hábitos sem conectar a resultados é como ter um velocímetro sem destino. O fechamento do loop acontece quando você conecta seus dados de hábitos a resultados tangíveis:

A cada mês, faça uma revisão:

# Gere um relatório mensal
habits_monthly() {
    local month="${1:-$(date +%Y-%m)}"
    echo "📋 Relatório ${month}"
    echo "========================"
    
    while IFS= read -r habit; do
        [[ -z "$habit" ]] && continue
        local count=$(grep "^${month}" "$HABITS_FILE" | grep -c "${habit}\tdone")
        echo "  ${habit}: ${count}/$(days_in_month "${month}") dias"
    done < "$HABITS_CONF"
}

days_in_month() {
    local ym="$1"
    local year="${ym:0:4}" month="${ym:5:2}"
    case "$month" in
        04|06|09|11) echo 30 ;;
        02) (( year % 4 == 0 && ( year % 100 != 0 || year % 400 == 0 ) )) && echo 29 || echo 28 ;;
        *) echo 31 ;;
    esac
}

Quando você revisa os dados mensalmente, padrões emergem. Você percebe que "contrib-open-source" cai toda vez que tem sprint no trabalho. Que "leitura-tecnica" é mais consistente no fim de semana. Que "lab-homelab" sempre morre em dezembro.

Esses insights são impossíveis sem rastreamento. E com 42 linhas de Bash, você tem tudo que precisa para começar.

Conclusão: Consistência Compound Interest

Não existe hack. Existe sistema. O segredo dos 1% que evoluem consistentemente na carreira técnica não é talento — é consistência. E consistência não é característica de personalidade. É produto de sistema.

Se você vai montar um homelab, quebre o monstro em pedaços — como mostrei no guia de homelab com hardware reciclado. Se você vai aprender Rust, não tente ler o Book inteiro — faça 30 minutos por dia. Se você vai contribuir para open source, não espere ter "conhecimento suficiente" — comece traduzindo um README.

O sistema de hábitos no terminal elimina a última desculpa: "esqueci". Porque o esquecimento é um bug, e bugs se resolvem com automação.

42 linhas de Bash. Zero dependências. Streak de 114 dias. Funciona.

E você? Qual hábito técnico você quer automatizar no seu terminal? Comenta aqui embaixo — se eu receber 10 pedidos diferentes, eu transformo isso num repositório open source com installer via curl.