Python e GitHub Copilot ensina sobre produtividade, qualidade e revisão humana

Assistentes de programação baseados em inteligência artificial já fazem parte do cotidiano de muitos desenvolvedores. Eles sugerem código, explicam funções, ajudam a criar testes e reduzem tarefas repetitivas. Ainda assim, velocidade não é sinônimo de correção. Uma resposta pode parecer convincente, compilar e até passar em alguns testes, mas continuar inadequada ao contrato, à arquitetura ou à segurança do projeto.

Este artigo apresenta um estudo de caso baseado no repositório Python Algorithms Lab with GitHub Copilot. O projeto reúne 11 exercícios algorítmicos, 32 casos de teste e integração contínua nas versões Python 3.11, 3.12 e 3.13. O principal aprendizado foi simples: a IA pode apoiar o desenvolvimento, mas a confiança precisa ser construída com compreensão, revisão humana e validação automatizada.

O QUE A LITERATURA MOSTRA

Estudos científicos apresentam um cenário equilibrado. Peng et al. (2023) observaram ganho de velocidade em uma tarefa controlada com programadores usando GitHub Copilot. O resultado é relevante, mas não deve ser generalizado para qualquer linguagem, equipe ou sistema. Barke, James e Polikarpova (2023) identificaram dois modos de interação. No modo de aceleração, o desenvolvedor já sabe o que precisa fazer e usa a ferramenta para reduzir esforço. No modo de exploração, utiliza as sugestões para investigar alternativas. A diferença é importante para a aprendizagem: receber uma solução não significa compreendê-la ou ser capaz de corrigi-la. Mo et al. (2025) encontraram variação de correção conforme linguagem, dificuldade e tipo de problema. Isso reforça uma regra essencial: sugestões de IA devem ser tratadas como propostas, não como respostas finais.

O PROJETO

O repositório foi organizado em três níveis. No básico estão par ou ímpar, média e tabuada. No intermediário aparecem palíndromo, frequência de palavras, segundo maior valor distinto e validação de senha. No avançado estão busca binária, ordenação, Fibonacci e análise de texto. A lógica foi separada da interface de terminal, permitindo testar cada função de forma independente. O projeto também utiliza type hints, docstrings, tratamento de erros e Ruff para lint e formatação. Os 32 casos de teste verificam resultados esperados, entradas vazias, tipos inadequados, números negativos, repetições e recuperação da CLI diante de erros. O GitHub Actions repete lint, verificação de formatação e pytest em três versões do Python. Assim, uma alteração só é considerada confiável depois de passar por um processo automatizado e reproduzível.

COMO O COPILOT FOI USADO

O Copilot não foi utilizado para aceitar alterações automaticamente. Primeiro, o repositório foi auditado. Depois, as sugestões foram comparadas ao código e à documentação oficial. Uma recomendação foi aceita: adicionar uma matriz de testes para Python 3.11, 3.12 e 3.13. A mudança tinha baixo risco e benefício verificável. Outra sugestão, criar uma CLI não interativa com argparse, foi adiada por ampliar o escopo. Uma terceira foi rejeitada porque tratava incorretamente a configuração target-version do Ruff como uma lista. Esse processo mostra uma competência essencial: saber dizer “não” à IA. Usar um assistente com maturidade não significa aceitar mais sugestões, mas tomar decisões melhores.

UM EXEMPLO PRÁTICO

from collections.abc import Iterable




def segundo_maior(numeros: Iterable[float]) -> float:
  """Retorna o segundo maior número distinto."""


  if isinstance(numeros, (str, bytes)):
      raise TypeError("numeros deve ser uma coleção numérica")


  maior = segundo = None
  encontrou = False


  for numero in numeros:
      if isinstance(numero, bool) or not isinstance(numero, (int, float)):
          raise TypeError("todos os valores devem ser numéricos")


      encontrou = True


      if maior is None or numero > maior:
          if numero != maior:
              segundo, maior = maior, numero


      elif numero != maior and (segundo is None or numero > segundo):
          segundo = numero


  if not encontrou or segundo is None:
      raise ValueError("informe ao menos dois valores distintos")


  return segundo

def test_segundo_maior_distinto_com_repetidos_e_negativos() -> None:
  assert segundo_maior([-5, -1, -1, -3]) == -3




@pytest.mark.parametrize("valores", [[], [2], [2, 2]])
def test_segundo_maior_insuficiente(valores: list[int]) -> None:
  with pytest.raises(ValueError):
      segundo_maior(valores)

Ela funciona em vários cenários, mas cria uma estrutura adicional e ordena toda a coleção. A implementação escolhida percorre os dados uma única vez, mantendo apenas o maior e o segundo maior valores encontrados. Os testes também verificam coleções vazias, repetições e números negativos. O exemplo demonstra que o problema não é apenas “fazer funcionar”, mas definir o contrato: o valor precisa ser distinto? Qual erro deve ocorrer? Qual complexidade é adequada?

DA SUGESTÃO À CONFIANÇA

Um fluxo responsável pode ser resumido assim:

Prompt → sugestão → compreensão → revisão → testes → lint → integração contínua → Pull Request → evidência.

Cada etapa reduz um risco. O prompt define a tarefa. A compreensão impede aceitar código indecifrável. A revisão verifica contrato, arquitetura e segurança. Os testes confrontam comportamentos. A integração contínua repete a validação em ambiente limpo. O Pull Request registra a decisão.

CONCLUSÃO

O GitHub Copilot pode acelerar tarefas conhecidas, apoiar a exploração de soluções e contribuir para a aprendizagem. Entretanto, rapidez não equivale a correção, testes não garantem segurança absoluta e revisão humana não elimina a necessidade de ferramentas automatizadas. O valor deste projeto não está apenas nos 11 algoritmos, mas no processo usado para validá-los. Uma sugestão foi analisada, implementada em uma branch, testada em três versões do Python e registrada em Pull Request. A inteligência artificial entrou em um sistema de engenharia; não substituiu esse sistema.

PROJETO COMPLETO

https://github.com/matheusflorindo32/desafio-python-github-copilot

REFERÊNCIAS

BARKE, S.; JAMES, M. B.; POLIKARPOVA, N. Grounded Copilot: How Programmers Interact with Code-Generating Models. Proceedings of the ACM on Programming Languages, 2023. DOI: https://doi.org/10.1145/3586030.

MO, R. et al. Assessing and Analyzing the Correctness of GitHub Copilot’s Code Suggestions. ACM Transactions on Software Engineering and Methodology, 2025. DOI: https://doi.org/10.1145/3715108.

PENG, S. et al. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. arXiv, 2023. DOI: https://doi.org/10.48550/arXiv.2302.06590.