Do Prompt ao Deploy: Construindo um Projeto Python Automatizado com GPT-5 e GitHub Copilot

Um relato em primeira pessoa sobre como usei IA para criar, refinar e automatizar um projeto Python do zero, incluindo scripts e um pipeline de CI/CD com GitHub Actions. Fins educacionais.

A Motivação: Um Projeto Open Source que sempre acesso

Eu sou um grande fã do agenda-tech-brasil, um projeto open source que centraliza uma vasta lista de eventos de tecnologia no Brasil. É uma iniciativa fantástica, mas notei que o README.md do repositório nem sempre refletia as atualizações mais recentes do banco de dados JSON.

Em vez de apenas lamentar, decidi agir. A ideia era simples: criar um projeto "wrapper" que consumisse o database.json original, processasse os dados e gerasse um README.md sempre atualizado, focado nos eventos do ano corrente. E para tornar as coisas mais interessantes, decidi fazer isso de uma forma diferente: usando o GitHub Copilot com o gpt-5-codex (preview) para guiar todo o processo.

O Experimento: "Vibe Coding" com IA

Minha abordagem foi o "vibe coding". Em vez de escrever cada linha, eu descreveria o que queria em alto nível e deixaria a IA traduzir isso em código funcional. O processo se resumiu a dois prompts principais.

Prompt 1: A Estrutura Completa

Comecei com um prompt ambicioso, descrevendo todo o projeto de uma vez:

"Crie um projeto que, faça um scraping no endereço X, baixe o json para o diretório db utilizando o script scraping.py. Crie um segundo script, build_readme.py, que processa esse db e preencha um README.md com uma lista de eventos formatada por mês. Por fim, crie um workflow do GitHub Actions (main.yml) que, semanalmente, executa os scripts e atualiza o repositório."

O resultado foi excelente.

Prompt 2: Refinando os Detalhes

O código inicial funcionava, mas precisava de ajustes. Usei um segundo prompt para refinar a lógica:

"O script de construção do readme deve atualizar/adicionar apenas eventos do ano atual. Utilize emojis para as etiquetas de modalidade e crie um segundo readme para o projeto explicando o funcionamento."

Com isso, a IA ajustou o script Python para filtrar os eventos por ano e substituir as strings [presencial], [online] e [híbrido] por ícones, tornando a leitura mais agradável.

Um Mergulho no Código Gerado

Vamos analisar o que a IA produziu.

O Script de Scraping

O scraping.py é responsável por baixar o banco de dados. O código gerado foi robusto, incluindo tratamento de erros e validação do JSON antes de salvá-lo.

# src/scripts/scraping.py
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path
from typing import Final
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

DEFAULT_SOURCE_URL: Final[str] = (
    "https://raw.githubusercontent.com/agenda-tech-brasil/agenda-tech-brasil/main/src/db/database.json"
)
DEFAULT_OUTPUT_PATH: Final[Path] = Path(__file__).resolve().parents[1] / "db" / "database.json"

def fetch_remote_json(url: str) -> str:
    """Return the remote JSON payload as a string, raising for HTTP issues."""
    request = Request(url, headers={"User-Agent": "Mozilla/5.0"})
    try:
        with urlopen(request, timeout=30) as response:
            charset = response.headers.get_content_charset() or "utf-8"
            payload = response.read().decode(charset)
    except (HTTPError, URLError) as exc:
        raise RuntimeError("Failed to download database") from exc

    # Validate JSON before writing to disk
    json.loads(payload)
    return payload

# ... (código para persistir o arquivo e parsear argumentos)

O Construtor do README

O build_readme.py é onde a mágica acontece. Ele carrega o JSON local, filtra os eventos do ano corrente e monta o README.md usando marcadores HTML para delimitar as seções.

# src/scripts/build_readme.py
from __future__ import annotations

import argparse
import json
from datetime import date
from pathlib import Path

# ... (constantes de formatação)

EVENT_TYPE_EMOJI = {
    "presencial": "🏢",
    "online": "💻",
    "hibrido": "🔀",
}

def pick_target_year(database: dict, requested_year: int | None) -> dict:
    """Filtra o ano alvo (ano corrente por padrão)."""
    target_year_num = requested_year if requested_year is not None else date.today().year
    for year_data in database.get("eventos", []):
        if year_data.get("ano") == target_year_num:
            return year_data
    raise ValueError(f"Ano {target_year_num} não encontrado no banco de dados.")

def build_month_section(month: dict) -> str:
    """Formata a seção de um mês específico para o Markdown."""
    month_name = month.get("mes", "").strip().lower()
    if not month_name or not month.get("eventos"):
        return ""

    comment_label = month_name.upper()
    header = f"### {month_name.capitalize()}"
    lines = [header, f"<!-- {comment_label}:START -->"]

    for event in sort_events(month.get("eventos", [])):
        # ... (lógica de formatação do evento)
        badge = EVENT_TYPE_EMOJI.get(event.get("tipo", "").lower(), "❓")
        bullet = f"- {days}: [{name}]({url}){location} {badge}"
        lines.append(bullet)

    lines.append(f"<!-- {comment_label}:END -->")
    return "\n".join(lines) + "\n"

# ... (função main que orquestra a leitura e escrita)

Automação Contínua com GitHub Actions

A peça final foi o pipeline de CI/CD. O main.yml gerado usa uma ação da comunidade (stefanzweifel/git-auto-commit-action) para commitar as alterações feitas pelos scripts diretamente no repositório.

O gatilho é duplo: schedule para rodar semanalmente e workflow_dispatch para permitir a execução manual.

# .github/workflows/main.yml
name: Update Agenda Tech Database

on:
  schedule:
    - cron: "0 9 * * 1" # Toda segunda-feira às 9h
  workflow_dispatch:

jobs:
  refresh:
    runs-on: ubuntu-latest
    permissions:
      contents: write

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Download latest database
        run: python src/scripts/scraping.py

      - name: Rebuild README
        run: python src/scripts/build_readme.py

      - name: Commit updated files
        uses: stefanzweifel/git-auto-commit-action@v5
        with:
          commit_message: "chore: update database and README"
          file_pattern: "src/db/database.json README.md"

Lições Aprendidas

1. Prompts é nova habilidade fundamental: A qualidade do resultado é diretamente proporcional à qualidade do prompt. Ser específico sobre tecnologias, nomes de arquivos e objetivos economiza muito tempo de refatoração.
2. A IA é uma parceira de brainstorming: Pude "conversar" com a IA para refinar a lógica, como o filtro por ano e a substituição por emojis.
3. Foco no estratégico: A IA eliminou o trabalho repetitivo de criar a estrutura de arquivos e o boilerplate. Meu tempo foi gasto pensando na lógica de negócio e na arquitetura da automação, não em sintaxe.
4. O desenvolvedor ainda é o piloto: A IA acelera, mas não substitui o conhecimento técnico. Validar o código, entender o que ele faz e saber como ajustá-lo continua sendo nossa responsabilidade.

Conclusão

Se você ainda não experimentou essa abordagem, eu recomendo fortemente. Comece com um projeto pequeno, descreva seu objetivo em detalhes e veja a mágica acontecer. Excelente e diferente forma de estudar programação e desenvolvimento de projetos, abrace a ideia como facilitador, auxiliador e se desenvolva.

O repositório completo está disponível no meu GitHub. Fique à vontade para explorar o código, o README_PROJETO.md (também gerado pela IA) e, claro, a lista de eventos sempre atualizada! Reitero que é um projeto de cunho educacional e de teste.