Automação de Fluxo de Trabalho: o Script que Decide o Que Você Deve Fazer Primeiro

Automação de fluxo de trabalho não é sobre transformar sua vida em um painel bonito cheio de cards coloridos. É sobre parar de abrir dez abas, três aplicativos, dois repositórios e um bloco de notas só para responder uma pergunta ridiculamente simples: qual é a próxima coisa que eu devo fazer agora?

Eu demorei mais tempo do que gostaria para admitir isso. Durante anos, tratei produtividade como se fosse jardinagem: toda segunda-feira eu podava tarefas, reorganizava listas, trocava etiquetas, ajustava prioridades e saía me sentindo uma pessoa adulta funcional. Na terça, a realidade passava com um caminhão por cima do canteiro. Cliente chamando. Pull request parado. Build quebrado. Reunião que poderia ser um e-mail, mas escolheu ser um sequestro de 45 minutos.

Foi aí que eu parei de tentar “organizar melhor” e comecei a automatizar o fluxo. Não para virar um robô. Para deixar o robô fazer a parte robótica: coletar sinais, cruzar evidências e montar uma fila honesta de prioridades. A automação de fluxo de trabalho que vou mostrar aqui é um script pequeno, feio na medida certa, que lê tarefas locais, commits recentes e eventos manuais simples para gerar um plano diário. Nada de SaaS mágico prometendo foco com gradiente roxo. Só arquivos texto, Python e um pouco de vergonha na cara.

O problema real: prioridade inventada no grito

A maioria das pessoas não sofre por falta de ferramenta. Sofre por excesso de entrada e pouca triagem. A lista de tarefas cresce, o Slack/Telegram/email grita, o Git registra atividade, o calendário finge que é neutro e você, pobre mamífero com cafeína, tenta fazer arbitragem mental em tempo real.

O resultado é previsível: você escolhe a tarefa mais barulhenta, não a mais importante. Responde o que chegou por último. Corrige o bug que parece mais vergonhoso. Refatora um trecho inútil porque dá sensação de controle. No fim do dia, trabalhou bastante e avançou pouco. Produtividade performática: suada, cansativa e quase decorativa.

A proposta deste artigo é construir uma automação de fluxo de trabalho com três objetivos:

• Capturar sinais de trabalho sem depender da memória: tarefas, commits, bloqueios e prazos.
• Calcular uma prioridade simples, baseada em urgência, impacto, esforço e idade da tarefa.
• Gerar uma fila diária em Markdown, pronta para abrir no terminal, Obsidian, VS Code ou qualquer editor que não tente vender mindfulness.

Isso não substitui julgamento humano. Ainda bem. O objetivo é entregar um rascunho inteligente para você revisar em dois minutos, não um oráculo corporativo usando blazer.

Arquitetura: três arquivos e nenhuma religião

Vamos manter a arquitetura ofensivamente simples. Você terá uma pasta chamada workflow/ com estes arquivos:

workflow/
├── tasks.yml
├── signals.jsonl
├── daily-plan.py
└── output/
    └── 2026-05-13.md

O arquivo tasks.yml guarda tarefas estruturadas. O signals.jsonl recebe eventos soltos: bloqueios, interrupções, commits importantes, mensagens que viraram trabalho. O script daily-plan.py junta tudo e gera o plano do dia.

Eu sei: dá para colocar banco SQLite, API REST, interface web, autenticação, fila, cache, observabilidade, tracing distribuído e um dashboard que consome 600 MB para renderizar três cards. Também dá para não fazer isso. A automação começa ganhando quando ela fica simples o bastante para você confiar e mexer sem cerimônia.

O modelo de tarefas: YAML sem frescura

Crie um tasks.yml assim:

tasks:
  - id: wp-cache-headers
    title: "Corrigir cache agressivo no endpoint de posts"
    area: "automente"
    status: "open"
    impact: 5
    effort: 2
    due: "2026-05-14"
    created: "2026-05-10"
    tags: [wordpress, performance, bug]

  - id: backup-verify
    title: "Validar restauração do backup em ambiente limpo"
    area: "infra"
    status: "open"
    impact: 5
    effort: 4
    due: "2026-05-20"
    created: "2026-05-01"
    tags: [seguranca, infra]

  - id: newsletter-outline
    title: "Rascunhar pauta da newsletter sobre automação"
    area: "conteudo"
    status: "open"
    impact: 3
    effort: 2
    due: null
    created: "2026-05-12"
    tags: [conteudo]

Repare nos campos impact e effort. Eles usam escala de 1 a 5. Impacto alto e esforço baixo sobem. Prazo próximo sobe. Tarefa velha sobe um pouco, porque tarefas antigas viram mofo mental. Tarefa bloqueada cai, porque fingir que algo bloqueado é prioridade é só cosplay de gestão.

Esse formato é deliberadamente manual. Você pode integrar com GitHub Issues, Trello, Linear, Notion ou WordPress depois. Mas começar com YAML tem uma vantagem enorme: você entende exatamente o que está acontecendo. Automação opaca vira mais uma fonte de ansiedade.

O arquivo de sinais: logs para a sua atenção

O segundo arquivo é signals.jsonl. Cada linha é um JSON independente. Isso permite adicionar eventos com um simples echo, sem abrir editor nem reformatar uma estrutura inteira.

{"time":"2026-05-13T09:14:00-03:00","type":"blocker","task":"wp-cache-headers","text":"Cloudflare parece servir versão velha do JSON"}
{"time":"2026-05-13T10:22:00-03:00","type":"commit","task":"wp-cache-headers","text":"test: reproduz header incorreto em staging"}
{"time":"2026-05-13T11:03:00-03:00","type":"interrupt","task":"backup-verify","text":"pedido para confirmar se backup roda antes do deploy"}

Por que isso importa? Porque o dia real não cabe no seu gerenciador de tarefas. Ele vaza por conversas, commits, erros, alertas e pequenas promessas feitas no impulso. O signals.jsonl é uma espécie de caixa de entrada técnica. Você não precisa classificar tudo na hora; só registra o sinal.

Se quiser capturar um sinal pelo terminal, adicione uma função no shell:

wf_signal() {
  local type="$1"
  local task="$2"
  shift 2
  local text="$*"
  python3 - <<PY
import json, datetime
print(json.dumps({
  "time": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
  "type": "$type",
  "task": "$task",
  "text": "$text"
}, ensure_ascii=False))
PY
}

wf_signal blocker wp-cache-headers "Nginx pode estar sobrescrevendo Cache-Control" >> workflow/signals.jsonl

É tosco? Um pouco. Funciona? Muito. E, diferentemente de várias ferramentas “AI-first”, não precisa de 14 permissões para anotar que você está irritado com um header HTTP.

O algoritmo de prioridade: simples, explícito e ajustável

Agora vem a parte que transforma lista em fila. Vamos calcular uma pontuação:

• Impacto: quanto mais alto, mais importante.
• Esforço: quanto mais baixo, mais atraente.
• Prazo: tarefas com vencimento próximo sobem rápido.
• Idade: tarefas abertas há muitos dias ganham pressão.
• Sinais: bloqueios, commits e interrupções ajustam a ordem.

O código abaixo não é ciência espacial, e essa é justamente a virtude. Quando um sistema de priorização fica complexo demais, você para de discutir trabalho e começa a discutir fórmula. Aí a planilha venceu.

from datetime import date, datetime
import json
import math
import pathlib
import yaml

ROOT = pathlib.Path(__file__).parent
TODAY = date.today()


def parse_date(value):
    if not value:
        return None
    return date.fromisoformat(str(value))


def load_tasks():
    data = yaml.safe_load((ROOT / "tasks.yml").read_text())
    return data.get("tasks", [])


def load_signals():
    path = ROOT / "signals.jsonl"
    if not path.exists():
        return []
    signals = []
    for line in path.read_text().splitlines():
        if line.strip():
            signals.append(json.loads(line))
    return signals


def days_until(due):
    if not due:
        return 999
    return (due - TODAY).days


def score_task(task, signals):
    impact = int(task.get("impact", 1))
    effort = max(int(task.get("effort", 3)), 1)
    created = parse_date(task.get("created")) or TODAY
    due = parse_date(task.get("due"))

    age_days = max((TODAY - created).days, 0)
    due_days = days_until(due)

    score = 0
    score += impact * 12
    score += (6 - effort) * 5
    score += min(age_days, 30) * 0.7

    if due_days < 0:
        score += 40
    elif due_days == 0:
        score += 35
    elif due_days <= 2:
        score += 25
    elif due_days <= 7:
        score += 10

    related = [s for s in signals if s.get("task") == task.get("id")]
    for signal in related:
        if signal.get("type") == "blocker":
            score -= 8
        elif signal.get("type") == "interrupt":
            score += 6
        elif signal.get("type") == "commit":
            score += 4

    return round(score, 2), related

A fórmula é opinativa, mas não sagrada. Se seu mundo tem SLA pesado, aumente o peso do prazo. Se você vive apagando incêndio, reduza o bônus de interrupção para não premiar gritaria. Se sua equipe sofre com tarefas antigas, aumente o fator de idade. O ponto é: a regra está no código, não escondida na cabeça de alguém.

Gerando o plano diário em Markdown

Agora adicionamos a saída. O plano precisa ser curto o suficiente para ser lido antes do primeiro café esfriar. Se ele virar um romance, você só criou outro problema.

def render_plan(scored):
    lines = []
    lines.append(f"# Plano do dia — {TODAY.isoformat()}
")
    lines.append("## Top 3 prioridades
")

    for rank, item in enumerate(scored[:3], start=1):
        score, task, related = item
        lines.append(f"### {rank}. {task['title']}")
        lines.append(f"- ID: `{task['id']}`")
        lines.append(f"- Área: {task.get('area', 'sem área')}")
        lines.append(f"- Score: {score}")
        lines.append(f"- Impacto/esforço: {task.get('impact')}/{task.get('effort')}")
        if task.get("due"):
            lines.append(f"- Prazo: {task['due']}")
        if related:
            lines.append("- Sinais recentes:")
            for signal in related[-3:]:
                lines.append(f"  - [{signal.get('type')}] {signal.get('text')}")
        lines.append("")

    lines.append("## Estacionamento
")
    for score, task, _ in scored[3:]:
        lines.append(f"- {task['title']} — score {score}")

    return "
".join(lines)


def main():
    tasks = [t for t in load_tasks() if t.get("status") == "open"]
    signals = load_signals()
    scored = []
    for task in tasks:
        score, related = score_task(task, signals)
        scored.append((score, task, related))

    scored.sort(key=lambda item: item[0], reverse=True)
    out_dir = ROOT / "output"
    out_dir.mkdir(exist_ok=True)
    out_file = out_dir / f"{TODAY.isoformat()}.md"
    out_file.write_text(render_plan(scored), encoding="utf-8")
    print(out_file)


if __name__ == "__main__":
    main()

Instale a dependência mínima e rode:

python3 -m pip install pyyaml
python3 workflow/daily-plan.py
cat workflow/output/$(date +%F).md

Pronto. Você acabou de criar uma automação de fluxo de trabalho que não tenta prever sua personalidade, não pede cartão de crédito e não manda relatório motivacional com emoji de foguete. Ela só ordena o caos.

Colocando Git no circuito sem virar refém do Git

Um truque útil é transformar commits recentes em sinais. Não para medir produtividade por quantidade de commit — isso é uma ideia ruim fantasiada de métrica. Mas commits mostram onde houve movimento. Se uma tarefa teve atividade ontem, talvez faça sentido empurrá-la até o fim hoje, em vez de abrir outra frente e aumentar o cemitério de coisas quase prontas.

git log --since="24 hours ago" --pretty=format:'%h %s' | while read line; do
  case "$line" in
    *wp-cache*) task="wp-cache-headers" ;;
    *backup*) task="backup-verify" ;;
    *) task="" ;;
  esac

  if [ -n "$task" ]; then
    python3 - <<PY >> workflow/signals.jsonl
import json, datetime
print(json.dumps({
  "time": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
  "type": "commit",
  "task": "$task",
  "text": "commit recente: $line"
}, ensure_ascii=False))
PY
  fi
done

Sim, o mapeamento por texto é frágil. E tudo bem. Comece frágil e visível. Quando doer, evolua para branch naming, issue IDs ou integração com API. A ordem correta é essa: primeiro prove utilidade, depois adicione engenharia. Fazer o contrário é como construir garagem subterrânea antes de saber se você tem carro.

Box perrengue: quando a automação escolhe a tarefa errada

A correção foi separar tarefas bloqueadas de ações de desbloqueio. Em vez de só subtrair pontos, o script passou a adicionar uma recomendação:

if signal.get("type") == "blocker":
    score -= 8
    task.setdefault("next_actions", []).append(
        f"Desbloquear: {signal.get('text')}"
    )

Isso muda a conversa. A tarefa grande pode cair, mas a ação pequena de desbloqueio aparece no plano. É uma diferença sutil entre “não consigo trabalhar nisso” e “posso remover o obstáculo”. Produtividade real mora nesses detalhes chatos, não em trocar a cor da etiqueta.

Automação de fluxo de trabalho não é piloto automático

Existe uma tentação perigosa quando a automação começa a funcionar: entregar mais decisão para ela do que deveria. Não faça isso. O script não sabe que você dormiu mal. Não sabe que uma conversa delicada precisa acontecer antes de uma mudança técnica. Não sabe que uma tarefa pequena pode ter valor político enorme porque destrava alguém. Ele só calcula sinais que você deu.

Por isso, minha regra é simples: o script sugere, eu assino. Todo dia, olho o Top 3 e faço três perguntas:

1. Isso realmente move algo importante?
2. Existe algum bloqueio humano que o script não entendeu?
3. Estou escolhendo isso por coragem ou por fuga?

A terceira pergunta dói, então é boa. Muitas vezes a tarefa mais “produtiva” é só a mais confortável. Automatizar prioridade ajuda justamente porque expõe esse teatro. Quando o script coloca um bug crítico no topo e você sente vontade de “só organizar umas pastas antes”, parabéns: você encontrou o dragão.

Como agendar sem criar mais uma coisa para manter

Você pode rodar manualmente, mas o ideal é gerar o plano todo dia de manhã. No Linux, um cron simples resolve:

15 8 * * 1-5 cd /home/alisson/workflow && /usr/bin/python3 daily-plan.py >> workflow.log 2>&1

Se quiser receber no Telegram, email ou Slack, dá para acoplar depois. Eu só recomendo uma regra: primeiro gere o arquivo local por uma semana. Ajuste pesos, campos e formato. Depois pense em notificação. Notificação cedo demais vira spam com autoestima.

Também vale versionar a pasta:

git init workflow
echo "output/" >> workflow/.gitignore
git add tasks.yml daily-plan.py .gitignore
git commit -m "cria automacao de fluxo de trabalho"

Não versione sinais sensíveis se eles contêm nomes de clientes, incidentes ou informações internas. Automação útil não precisa virar vazamento acidental. Um arquivo local inocente hoje pode ser um anexo constrangedor amanhã.

Integrações futuras: onde vale investir

Depois que o núcleo estiver funcionando, aí sim faz sentido integrar. Algumas extensões boas:

• GitHub Issues: buscar issues atribuídas a você e preencher tasks.yml automaticamente.
• Calendário: reduzir ambição em dias lotados de reunião. Heresia necessária.
• CI/CD: subir prioridade de tarefas com pipeline vermelho.
• WordPress: transformar ideias de posts em tarefas editoriais com prazo e status.
• Relatório semanal: comparar plano gerado com tarefas concluídas para enxergar padrões.

O cuidado é não transformar automação de fluxo de trabalho em mais uma plataforma paralela. O script deve puxar dados de onde o trabalho já acontece. Se você precisa alimentar cinco campos antes de começar, a automação perdeu. Ela virou chefe.

Links internos para continuar cavando

Se você curte esse tipo de automação pragmática, vale ler também o artigo sobre stand-up automatizado com Git logs, que resolve outro ritual corporativo com um pouco de Bash e sanidade. Para a parte de observabilidade caseira, o texto sobre robô de monitoramento com Shell Script e GitOps mostra como tirar tarefas repetitivas da cabeça e colocar num pipeline. E, se o seu gargalo está mais perto de incidentes e mensagens confusas, leia como decodificar logs de erro com Python.

Também recomendo acompanhar a categoria Produtividade Aumentada, porque o objetivo ali não é vender a fantasia de que você vai virar uma máquina. É o oposto: deixar a máquina carregar o peso repetitivo para você poder pensar melhor.

Conclusão: produtividade boa deixa rastro

A melhor automação de fluxo de trabalho não é a mais elegante. É a que você usa quando está cansado. É a que continua compreensível depois de uma semana ruim. É a que transforma sinais espalhados em uma próxima ação concreta.

O script deste artigo é pequeno de propósito. Ele não tenta vencer a complexidade com uma catedral de software. Ele cria um trilho mínimo: registrar tarefas, capturar sinais, calcular prioridade e gerar um plano diário. A partir daí, você ajusta. Talvez adicione GitHub. Talvez calendário. Talvez uma integração com IA para resumir sinais. Mas a espinha dorsal continua a mesma: menos decisão repetitiva, mais atenção para o que importa.

Minha recomendação prática: implemente a versão feia hoje. Não espere o sistema perfeito. Coloque três tarefas reais no YAML, registre cinco sinais durante o dia e rode o plano amanhã cedo. Se o Top 3 estiver meio errado, ótimo: você ganhou uma conversa objetiva com seu próprio processo. Antes isso do que continuar obedecendo a aba mais barulhenta do navegador.

CTA: qual automação você quer ver destrinchada no próximo artigo: triagem de email, relatório de deploy, priorização de bugs, revisão de pull requests ou agenda inteligente? Manda a dor real. Lista genérica a internet já tem demais.