Como Vibe Coding com Python Está Transformando a Programação

Descubra Vibe Coding com Python usando Cursor e IA para gerar código, comparar métodos e extrair XMLs em Excel com eficiência programando com IA.

Introdução ao Vibe Coding com Python

Se você já imaginou programar pedindo para a IA escrever o código por você, então você precisa conhecer o Vibe Coding com Python.

Essa abordagem vem ganhando espaço justamente porque muda a lógica tradicional da programação: em vez de se preocupar com cada detalhe técnico, você descreve o que quer em linguagem natural e a inteligência artificial constrói a solução.

Parece mágico, né? Mas será que funciona mesmo na prática? É isso que vamos explorar aqui.

Neste artigo, você vai acompanhar um projeto real: a extração de dados de notas fiscais em XML para um arquivo Excel, algo que muita gente faz como freela ou demanda no trabalho.

Primeiro, vamos entender como esse problema era resolvido de forma “tradicional” em Python. Depois, você vai ver como a mesma solução foi criada usando uma ferramenta de IA chamada Cursor, seguindo o conceito de vibe coding.

Vamos ver o que realmente funciona quando unimos Python e IA. No final, você vai saber quando vale a pena usar inteligência artificial para programar, quando é melhor escrever o código na mão e, principalmente, como tirar o melhor dos dois mundos para trabalhar de forma mais rápida e inteligente.

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Estudo de Caso: Projeto de Extração de XML em Excel com Python

Para compararmos o desempenho do Vibe Coding com Python com um código feito manualmente, vamos analisar um projeto prático de extração de XML para Excel. Algo muito comum em freelas e também em rotinas de trabalho no dia a dia.

Temos uma pasta cheia de arquivos XML de notas fiscais (NF-e) e precisamos transformar tudo isso em um único arquivo Excel. O objetivo é extrair informações como número da nota, empresa emissora, nome do cliente, endereço completo e peso bruto de cada documento.

No material disponível para download, existe uma pasta chamada nfs com vários arquivos .xml dentro. Cada arquivo representa uma nota fiscal diferente. A ideia é criar e rodar um script em Python que percorre essa pasta, lê cada XML, extrai os dados necessários e salva tudo em uma planilha consolidada.

Como exemplo de um código feito “na mão”, vamos usar um script em Python que desenvolvemos em outra publicação aqui do blog, baseada em um freela real de R$500. Esse código também estará detalhado abaixo e disponível no material para download.

import xmltodict
import os
import pandas as pd

def pegar_infos(nome_arquivo, valores):
    # print(f"Pegou as informações {nome_arquivo}")
    with open(f'nfs/{nome_arquivo}', "rb") as arquivo_xml:
        dic_arquivo = xmltodict.parse(arquivo_xml)

        if "NFe" in dic_arquivo:
            infos_nf = dic_arquivo["NFe"]['infNFe']
        else:
            infos_nf = dic_arquivo['nfeProc']["NFe"]['infNFe']
        numero_nota = infos_nf["@Id"]
        empresa_emissora = infos_nf['emit']['xNome']
        nome_cliente = infos_nf["dest"]["xNome"]
        endereco = infos_nf["dest"]["enderDest"]
        if "vol" in infos_nf["transp"]:
            peso = infos_nf["transp"]["vol"]["pesoB"]
        else:
            peso = "Não informado"
        valores.append([numero_nota, empresa_emissora, nome_cliente, endereco, peso])

lista_arquivos = os.listdir("nfs")

colunas = ["numero_nota", "empresa_emissora", "nome_cliente", "endereco", "peso"]
valores = []
for arquivo in lista_arquivos:
    pegar_infos(arquivo, valores)

tabela = pd.DataFrame(columns=colunas, data=valores)
tabela.to_excel("NotasFiscais.xlsx", index=False)

1. Leitura dos arquivos XML

O primeiro passo é listar todos os arquivos da pasta:

import os

lista_arquivos = os.listdir("nfs")

Aqui estamos dizendo: “Python, me devolve todos os arquivos que estão dentro da pasta nfs”.

2. Extração das informações

Para ler os XMLs, foi usada a biblioteca xmltodict, que transforma o XML em um dicionário Python. Isso facilita muito a navegação nos dados.

import xmltodict

with open(f"nfs/{nome_arquivo}", "rb") as arquivo_xml:
    dic_arquivo = xmltodict.parse(arquivo_xml)

Depois disso, o código identifica onde começam os dados da nota fiscal. Algumas vêm em NFe, outras em nfeProc. O script trata os dois casos.

if "NFe" in dic_arquivo:
    infos_nf = dic_arquivo["NFe"]["infNFe"]
else:
    infos_nf = dic_arquivo["nfeProc"]["NFe"]["infNFe"]

Agora vem a parte principal: extrair os campos pedidos.

numero_nota = infos_nf["@Id"]
empresa_emissora = infos_nf["emit"]["xNome"]
nome_cliente = infos_nf["dest"]["xNome"]
endereco = infos_nf["dest"]["enderDest"]

Para o peso, existe uma validação. Nem toda nota tem esse campo.

if "vol" in infos_nf["transp"]:
    peso = infos_nf["transp"]["vol"]["pesoB"]
else:
    peso = "Não informado"

Isso evita erro e deixa o resultado mais profissional.

3. Armazenando os dados

Cada nota vira uma linha em uma lista:

valores.append([
    numero_nota,
    empresa_emissora,
    nome_cliente,
    endereco,
    peso
])

Depois transformamos tudo em uma tabela com pandas:

import pandas as pd

tabela = pd.DataFrame(columns=colunas, data=valores)
tabela.to_excel("NotasFiscais.xlsx", index=False)

Pronto. Em poucos segundos, surge o Excel consolidado.

4. Resultado final

O arquivo gerado contém:

• Número da nota
• Empresa emissora
• Nome do cliente
• Endereço
• Peso bruto

Se existirem 3 XMLs, o Excel terá 3 linhas. Simples assim.

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Usando Cursor para Vibe Coding com Python

Agora entra em cena o protagonista da aula: o Cursor. Ele é, basicamente, um VS Code turbinado com inteligência artificial. A grande diferença é que, em vez de você começar escrevendo código, a tela principal já é um chat. Ou seja, você descreve o que quer em linguagem natural e a IA constrói o código para você.

Essa é a essência do Vibe Coding com Python: menos digitação, mais intenção. Você explica o problema. A IA sugere a solução. Você acompanha, ajusta e refina.

Como o Cursor funciona na prática

O processo começa bem simples. Primeiro, você abre o Cursor e cria um novo projeto, apontando para a pasta onde terá somente uma pasta com os arquivos XML (nfs). Nesse momento, o projeto ainda está vazio, sem nenhum script em Python.

Você pode verificar os arquivos do projeto clicando no botão Toggle Primary Sidebar.

Depois, você escreve no chat algo parecido com:

“Preciso extrair informações em massa de arquivos XML para Excel.
Os arquivos estão na pasta nfs.
Quero pegar número da nota, empresa emissora, nome do cliente, endereço e peso.
Use Python.”

Só isso. A partir desse prompt, o Cursor começa a “pensar” e planejar o código. Ele define:

• Quais bibliotecas usar
• Como ler os arquivos XML
• Como organizar as funções
• Como gerar o Excel final

Em poucos segundos, ele cria um arquivo .py automaticamente. Um exemplo do código que a IA gera:

"""Extrai campos principais das NF-e em XML e gera um Excel consolidado.

Campos exportados:
- numero_nota (ide/nNF)
- empresa_emissora (emit/xNome)
- nome_cliente (dest/xNome)
- endereco_cliente (dest/enderDest concatenado)
- peso_bruto (soma de transp/vol/pesoB, se houver; senão usa pesoL)

Uso:
    python scripts/extrair_nfes.py [pasta_com_xmls] [arquivo_saida.xlsx]

Defaults:
- pasta_com_xmls: "nfs"
- arquivo_saida.xlsx: "consolidado.xlsx"

Requer: pandas (com openpyxl como engine de escrita de xlsx).
"""
from __future__ import annotations

import sys
from pathlib import Path
from typing import Dict, List, Optional
import xml.etree.ElementTree as ET

import pandas as pd


NS = {"nfe": "http://www.portalfiscal.inf.br/nfe"}


def _text(element: Optional[ET.Element], path: str) -> str:
    """Busca texto em path relativo usando namespace padrão."""
    if element is None:
        return ""
    value = element.findtext(path, default="", namespaces=NS)
    return value.strip() if value else ""


def _monta_endereco(ender_dest: Optional[ET.Element]) -> str:
    """Monta endereço completo a partir de enderDest."""
    if ender_dest is None:
        return ""

    partes = [
        _text(ender_dest, "nfe:xLgr"),
        _text(ender_dest, "nfe:nro"),
        _text(ender_dest, "nfe:xCpl"),
        _text(ender_dest, "nfe:xBairro"),
        _text(ender_dest, "nfe:xMun"),
        _text(ender_dest, "nfe:UF"),
        _text(ender_dest, "nfe:CEP"),
    ]
    return ", ".join(p for p in partes if p)


def _extrai_peso(inf_nfe: ET.Element) -> float:
    """Soma peso bruto (pesoB) dos volumes; se vazio usa peso líquido (pesoL)."""
    peso_total = 0.0
    for vol in inf_nfe.findall("./nfe:transp/nfe:vol", NS):
        peso_text = vol.findtext("nfe:pesoB", default="", namespaces=NS) or ""
        if not peso_text:
            peso_text = vol.findtext("nfe:pesoL", default="", namespaces=NS) or ""
        try:
            if peso_text:
                peso_total += float(peso_text.replace(",", "."))
        except ValueError:
            continue
    return peso_total


def extrai_xml(xml_path: Path) -> Optional[Dict[str, object]]:
    """Extrai campos desejados de um XML de NF-e."""
    tree = ET.parse(xml_path)
    root = tree.getroot()

    # infNFe pode estar em <NFe> ou <nfeProc><NFe>
    inf_nfe = root.find(".//nfe:infNFe", NS)
    if inf_nfe is None:
        return None

    ide = inf_nfe.find("nfe:ide", NS)
    emit = inf_nfe.find("nfe:emit", NS)
    dest = inf_nfe.find("nfe:dest", NS)

    # Algumas vezes o usuário precisa da chave completa (Id/chNFe) e não só nNF.
    chave_nfe = inf_nfe.attrib.get("Id", "")  # ex: NFe3510...
    if not chave_nfe:
        chave_nfe = _text(root.find(".//nfe:protNFe/nfe:infProt", NS), "nfe:chNFe")
    numero_nota = chave_nfe or _text(ide, "nfe:nNF")
    empresa_emissora = _text(emit, "nfe:xNome")
    nome_cliente = _text(dest, "nfe:xNome")
    endereco_cliente = _monta_endereco(dest.find("nfe:enderDest", NS) if dest is not None else None)
    peso_bruto = _extrai_peso(inf_nfe)

    return {
        "arquivo": xml_path.name,
        "numero_nota": numero_nota,
        "empresa_emissora": empresa_emissora,
        "nome_cliente": nome_cliente,
        "endereco_cliente": endereco_cliente,
        "peso_bruto": peso_bruto,
    }


def processa_pasta(pasta_xml: Path) -> List[Dict[str, object]]:
    """Percorre a pasta e coleta dados dos XMLs."""
    resultados: List[Dict[str, object]] = []
    for xml_file in sorted(pasta_xml.glob("*.xml")):
        try:
            info = extrai_xml(xml_file)
        except ET.ParseError:
            continue  # ignora XML inválido
        if info:
            resultados.append(info)
    return resultados


def salvar_excel(dados: List[Dict[str, object]], destino: Path) -> None:
    df = pd.DataFrame(dados)
    df.to_excel(destino, index=False)


def main() -> None:
    pasta = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("nfs")
    destino = Path(sys.argv[2]) if len(sys.argv) > 2 else Path("consolidado.xlsx")

    if not pasta.exists():
        raise SystemExit(f"Pasta não encontrada: {pasta}")

    dados = processa_pasta(pasta)
    if not dados:
        raise SystemExit("Nenhum XML válido encontrado.")

    salvar_excel(dados, destino)
    print(f"Planilha gerada em: {destino.resolve()}")


if __name__ == "__main__":
    main()

Você não escreveu uma linha disso. Isso é programar com IA na prática.

Além disso o Cursor também te mostra quais bibliotecas você precisa ter e como executar o script corretamente, caso vá utilizá-lo fora do ambiente dele.

Rodando o código

Depois que o Cursor gera o script, basta executar pelo terminal integrado.

python script.py

Ou clicar no botão de run dentro do editor.

Resultado? Um arquivo chamado consolidado.xlsx aparece na pasta do projeto.

Quando abrimos o Excel, lá estão:

• Número da nota
• Empresa emissora
• Nome do cliente
• Endereço
• Peso

Ou seja, o código funcionou.

Aqui fica claro o poder do Vibe Coding com Python. Em minutos, você tem uma solução pronta pra usar.

O erro (e como corrigir usando IA)

Mas é importante ficar atento. No primeiro teste, o número da nota veio errado. O script estava puxando um identificador interno do XML, e não o número real da NF-e.

Em vez de abrir o código manualmente e sair editando linha por linha, você pode fazer esse ajuste diretamente pelo chat do Cursor:

“O número da nota está errado.
No primeiro arquivo, o valor correto é: 3508059999.
Ajuste o código para pegar esse campo corretamente.”

Esse detalhe faz toda a diferença. Aqui você está dando uma referência real para a IA. Com isso, ela consegue identificar o padrão correto dentro do XML e entender exatamente onde deve buscar a informação.

A partir disso, o Cursor:

• Atualiza a lógica
• Muda o caminho do campo
• Ajusta a função

Depois disso, basta executar o script novamente.

Resultado? Agora o número da nota vem corretamente no Excel.

Esse trecho deixa um aprendizado muito claro sobre programar com IA: quanto mais contexto você fornece, melhor será a resposta da ferramenta.

E mais importante ainda: o papel do programador continua sendo essencial. É você quem identifica erros, entende o problema e sabe orientar a IA para chegar na solução correta. A ferramenta ajuda, mas quem pensa ainda é você.

O que o Cursor criou por trás

Um ponto que já podemos observar é que o código gerado pelo Cursor é bem mais longo do que o manual.

Ele separa tudo em funções:

• Função para ler XML
• Função para montar endereço
• Função para extrair peso
• Função para salvar Excel
• Função principal (main)

Isso deixa o código mais organizado, mas também mais verboso.
Saiu de aproximadamente 30 linhas para mais de 130.

Funciona? Funciona, mas já começamos a ver um trade-off:

• Mais estrutura
• Mais complexidade
• Mais linhas de código

Esse ponto vai ficar ainda mais claro na comparação da próxima seção.

Comparação: Código Manual vs Código Gerado por IA

Agora vem a parte mais interessante: colocar os dois códigos lado a lado e entender, na prática, o que muda quando usamos Vibe Coding com Python em vez de escrever tudo manualmente.

De um lado, temos o script feito “na mão”. Do outro, o código gerado pelo Cursor com ajuda da inteligência artificial.

Ambos funcionam. Ambos entregam o Excel corretamente. Mas a forma como cada um chega ao resultado é bem diferente.

Tamanho do código

A primeira grande diferença entre eles é o número de linhas.

• Código manual: 32 linhas
• Código gerado por IA: 140 linhas

Ou seja, o script criado com Vibe Coding tem quase 4x mais código.

Isso acontece porque a IA tende a:

• Criar várias funções
• Separar tudo em blocos
• Fazer validações extras
• Ser mais “verbosa”

O código não está errado, ele resolve o problema proposto, mas é bem mais complexo.

Leitura e manutenção

Aqui entra um ponto muito importante.

O código manual:

• É mais curto
• Mais fácil de ler
• Mais rápido de entender
• Qualquer dev júnior consegue manter

Já o código da IA:

• Tem muitas funções
• Mais camadas de lógica
• Exige mais atenção
• Pode confundir quem está começando

Isso não quer dizer que o código da IA é ruim. Ele é bom e funciona. Mas para um problema simples, talvez seja complexidade demais.

Performance e eficiência

Na prática, os dois fazem a mesma coisa:

• Leem arquivos XML
• Extraem dados
• Geram um Excel

A diferença está no caminho.

O código manual usa:

• xmltodict
• Menos processamento
• Navegação direta nos dados

O código da IA usa:

• ElementTree
• Percorre a árvore XML
• Faz várias validações

Resultado?

Ambos são rápidos para poucos arquivos.

Mas o código manual tende a ser:

• Mais leve
• Mais performático
• Mais direto

Isso mostra algo importante ao usar Python e IA juntos: saber escolher a biblioteca certa faz toda a diferença.

Quando o Vibe Coding faz mais sentido?

Aqui o Vibe Coding com Python brilha:

• Prototipagem rápida
• Scripts simples
• Automação pontual
• Testar ideias

Você descreve. e a IA constrói. Você ajusta o que for necessário e pronto. Você ganha velocidade e produtividade.

Quando o código manual é melhor?

• Projetos maiores
• Código que será mantido por muito tempo
• Times de desenvolvimento
• Sistemas em produção

Além disso, um código mais conciso costuma ser melhor:

• Mais fácil de debugar
• Mais fácil de manter
• Menos risco

O equilíbrio ideal

O cenário perfeito é unir os dois mundos:

• Usar IA para acelerar
• Usar seu conhecimento para orientar
• Revisar tudo
• Simplificar quando possível

Ou seja: Vibe Coding não substitui programação. Ele potencializa. Você continua sendo o cérebro do processo.

Boas Práticas ao Programar com IA

Depois de ver o projeto rodando com Vibe Coding com Python, fica claro que a IA ajuda muito.
Mas para ter bons resultados, é importante seguir algumas boas práticas.

Caso contrário, você pode acabar com códigos que até funcionam, mas são difíceis de entender, manter ou escalar.

Aqui a ideia é simples: usar a IA como aliada, não como muleta. Então siga essas boas práticas e garanta o melhor da programação em Python com IA:

• Seja específico no prompt: Explique exatamente o que você quer: linguagem, dados de entrada, resultado esperado e formato da saída.
• Use referências reais: Sempre que possível, informe valores corretos (como fizemos com o número da nota). Isso ajuda a IA a identificar padrões.
• Revise tudo que a IA gera: Confira bibliotecas usadas, lógica, variáveis e estrutura do código antes de rodar em produção.
• Questione as escolhas da IA: Pergunte se aquela biblioteca é a melhor opção ou se existe algo mais simples.
• Simplifique quando possível: IA tende a criar código mais verboso. Veja se dá para reduzir linhas e tornar tudo mais direto.
• Entenda o que está rodando: Nunca use um código que você não consegue explicar. Você continua sendo responsável pelo resultado.
• Use a documentação: Sempre que a IA sugerir algo novo, que você não conhece, confira a documentação oficial da biblioteca. Isso ajuda a ganhar base técnica e usar a IA com mais consciência.

Conclusão: Futuro do Vibe Coding com Python

Depois de todo esse projeto, fica claro que o Vibe Coding com Python é uma ferramenta poderosa para ganhar velocidade e produtividade.

A IA ajuda muito, principalmente em tarefas repetitivas e scripts simples. Mas também vimos que o resultado só ficou realmente bom quando houve intervenção humana: identificar erros, fornecer referências corretas e orientar a ferramenta. Ou seja, a IA acelera, mas quem pensa continua sendo você.

E é exatamente por isso que dominar Python faz toda a diferença. Quanto mais base você tem, melhor consegue usar a inteligência artificial a seu favor, tomando decisões mais inteligentes e criando soluções mais eficientes.

Se você quer aprender Python do jeito certo e usar IA como aliada no seu dia a dia, vale muito a pena conhecer nosso Curso Completo Python Impressionador.

Além disso, se preferir esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.