Tudo começou quando percebi que escrever código Python não era mais o suficiente para tirar o máximo de uma IA.
Trabalhando com APIs da OpenAI e modelos como o GPT-4, notei que a forma como eu escrevia o prompt mudava completamente o resultado.
Era curioso: o mesmo código, a mesma API… mas com um texto ligeiramente diferente, a resposta da IA podia ser incrível — ou completamente inútil.
Foi aí que caiu a ficha: eu precisava aprender a conversar com o modelo.
E foi assim que comecei a mergulhar no que hoje chamam de Engenharia de Prompt.
O que é Engenharia de Prompt
De forma simples, Engenharia de Prompt é a arte (e um pouco de ciência) de escrever instruções para modelos de linguagem de um jeito que
eles realmente entendam o que você quer.
Mas, para quem programa em Python, isso vai muito além de “escrever bonito”.
É sobre projetar o comportamento do modelo, quase como definir a lógica de uma função.
Quando eu crio um prompt, estou basicamente dizendo para o modelo:
-
Quem ele é (ex: “Você é um especialista em Python”).
-
O que ele precisa fazer.
-
Como eu quero que ele me responda.
-
Quais são as restrições do contexto.
No fundo, o prompt é uma espécie de código conversacional.
A diferença é que ele é lido por um modelo de linguagem em vez de um interpretador Python.
Aplicações práticas em Python
Com o tempo, fui descobrindo que trabalhar com prompts no Python é quase uma extensão natural da linguagem.
Hoje, existem várias ferramentas que facilitam isso — como a OpenAI API, LangChain, LlamaIndex e até bibliotecas menores para estruturar prompts.
Com elas, dá pra montar desde um simples assistente técnico até sistemas complexos que lembram contexto, analisam documentos e tomam decisões.
O fluxo é mais ou menos assim:
-
Escrevo o prompt (manual ou dinâmico).
-
Envio via API do modelo (ex: GPT, Claude, Mistral, etc).
-
Recebo a resposta.
-
Trato essa resposta e uso no restante do código.
No fundo, é o mesmo ciclo de desenvolvimento Python de sempre — só que com uma parte “conversacional” no meio.
Boas práticas e padrões que aprendi
Depois de testar muito (e errar bastante), cheguei a algumas boas práticas que sempre aplico:
-
Divida o prompt em partes — contexto, instrução e entrada do usuário.
-
Não cole o prompt direto no código — use templates com placeholders e mantenha-os versionados.
-
Teste os prompts — mude pequenas palavras e veja como o modelo reage. Isso é parte do desenvolvimento.
-
Documente o comportamento esperado — como se fosse um contrato da função.
-
Controle o formato da resposta — JSON, markdown, texto delimitado. Isso evita dores de cabeça no parsing.
Basicamente, comecei a tratar meus prompts como se fossem funções Python declarativas — com input, output e um propósito bem definido.
Exemplos reais em Python
1. Um prompt básico usando a API da OpenAI
from openai import OpenAI
client = OpenAI()
prompt = """
Você é um especialista em Python.
Explique o que o código abaixo faz, de forma técnica e clara:
```
def soma(a, b):
return a + b
```
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)
2. Criando um assistente que lembra do histórico com LangChain
from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
template = """
Você é um consultor Python.
Histórico da conversa:
{history}
Usuário: {input}
Responda de forma técnica e direta.
"""
prompt = PromptTemplate(input_variables=["history", "input"], template=template)
memory = ConversationBufferMemory(memory_key="history")
llm = OpenAI(temperature=0.4)
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)
print(chain.run(input="Como posso otimizar um dicionário grande em Python?"))
Referência: LangChain Docs
Essa estrutura usa PromptTemplate e Memory — dois conceitos essenciais para criar assistentes contextuais com comportamento consistente.
3. Buscando conhecimento em documentos com LlamaIndex
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.llms.openai import OpenAI
docs = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(docs)
query_engine = index.as_query_engine(llm=OpenAI(model="gpt-4o"))
resposta = query_engine.query("Explique o que o projeto aborda sobre otimização de código.")
print(resposta)
Referência: LlamaIndex Documentation
Aqui, a Engenharia de Prompt se mistura com Retrieval-Augmented Generation (RAG) — a técnica que faz o modelo buscar informações antes de responder.
Erros que cometi e o que aprendi
Durante os testes, cometi vários erros clássicos — que muita gente repete sem perceber:
-
Prompts longos demais — o modelo fica confuso.
→ Hoje eu deixo o prompt direto, curto e focado. -
Instruções vagas — respostas genéricas.
→ Sempre especifico papel, formato e intenção. -
Saída sem estrutura — dificulta o parsing.
→ Sempre peço para o modelo devolver JSON, listas ou markdown. -
Temperatura errada — muito alta gera criatividade demais.
→ Usotemperature=0quando quero respostas precisas. -
Hardcode de prompt — difícil manter e ajustar.
→ Hoje todos os meus prompts ficam em templates separados e versionados.
Essas práticas simples mudaram completamente a qualidade dos resultados.
Reflexão final — o futuro da Engenharia de Prompt para devs Python
Aprender Engenharia de Prompt me fez mudar a forma de pensar sobre programação.
Antes, o código era o centro de tudo. Agora, percebo que o raciocínio do modelo faz parte do sistema.
Escrever um bom prompt é quase como escrever testes unitários para a IA: se você não for claro, o comportamento será imprevisível.
Acredito que no futuro vamos versionar prompts como versionamos código — com revisão, teste e documentação.
E quem domina Python tem uma vantagem natural: sabe transformar raciocínio em automação.
Hoje, para mim, a Engenharia de Prompt é mais uma extensão do Python — uma forma de transformar linguagem natural em lógica aplicada.
E é justamente aí que mora a mágica:
não é mais só o código que executa a ideia,
é a conversa que dá forma ao código.