A utilização de modelos de linguagem para geração de código acelerou significativamente o desenvolvimento de software. No entanto, ao solicitar a criação de funções ou classes, a resposta padrão costuma misturar explicações textuais com blocos de código. Isso exige que o desenvolvedor faça a limpeza manual do output, reduzindo a eficiência do fluxo de trabalho. Além disso, o código gerado frequentemente ignora o contexto do projeto, como convenções de nomenclatura, tipagem e assinaturas de métodos específicas da base de código existente.

Para resolver esses problemas, é possível integrar a API do modelo diretamente ao ambiente de execução, utilizando técnicas de engenharia de prompt para forçar a entrega de código puro e aplicando decoradores do Python para injeção dinâmica de lógica.

Engenharia de Prompt para Output Exclusivo de Código

O primeiro passo é configurar a chamada da API para restringir a resposta apenas ao bloco de código. Isso é feito definindo um prompt de sistema rigoroso e instruindo o modelo a formatar a saída de maneira estrita.

import openai

openai.api_key = "sua_chave_api_aqui"

def obter_codigo_fonte(assinatura_funcao, descricao_tarefa):
    instrucao_sistema = "Você é um engenheiro de software sênior em Python. Forneça apenas o código Python solicitado, sem nenhuma explicação ou texto adicional."
    
    prompt_usuario = (
        f"Complete a seguinte função Python:\n"
        f"```python\n{assinatura_funcao}\n```\n"
        f"Instrução: {descricao_tarefa}\n"
        f"Retorne estritamente o bloco de código formatado com ```python."
    )
    
    resposta = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        temperature=0.0,
        max_tokens=512,
        messages=[
            {"role": "system", "content": instrucao_sistema},
            {"role": "user", "content": prompt_usuario}
        ]
    )
    
    conteudo = resposta.choices[0].message.content
    
    # Extrair apenas o código do bloco markdown
    if "```python" in conteudo:
        codigo_limpo = conteudo.split("```python")[1].rsplit("```", 1)[0].strip()
    else:
        codigo_limpo = conteudo.strip()
        
    return codigo_limpo

Ao fornecer a assinatura da função e a descrição da tarefa como parâmetros, o modelo é forçado a respeitar a estrutura de entrada e saída definida pelo desenvolvedor, eliminando a subjetividade na escolha de nomes de variáveis ou tipos de retorno.

Automação via Decoradores Python

Para tornar a integração transparente e eliminar a necessidade de chamadas manuais à função de API, podemos utilizar o módulo inspect junto com decoradores. Essa abordagem permite extrair automaticamente a assinatura e a docstring da função alvo, solicitar o código à API, compilá-lo em tempo de execução e retornar o resultado.

import inspect
from functools import wraps

def gerar_e_executar_com_ia(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Extrair parâmetros da assinatura da função
        params = ", ".join(inspect.signature(func).parameters.keys())
        assinatura = f"{func.__name__}({params}):"
        
        # Obter a descrição da tarefa a partir da docstring
        doc = func.__doc__.strip() if func.__doc__ else "Sem descrição."
        
        # Solicitar código à API
        codigo_gerado = obter_codigo_fonte(assinatura, doc)
        
        # Executar o código gerado em um namespace isolado para segurança
        namespace = {}
        exec(codigo_gerado, namespace)
        
        # Recuperar e executar a função gerada
        funcao_ia = namespace[func.__name__]
        return funcao_ia(*args, **kwargs)
        
    return wrapper

Aplicação Prática em Cenários Reais

Com o decorador implementado, a definição da lógica de negócio se resume a declarar a assinatura da função e sua documentação. O modelo de linguagem assume a responsabilidade de implementar o corpo da função.

if __name__ == '__main__':
    
    @gerar_e_executar_com_ia
    def calcular_media(valores: list):
        """
        Calcula e retorna a média aritmética de uma lista de números.
        Retorne 0 se a lista estiver vazia.
        """

    print("Média:", calcular_media([15, 25, 35, 45]))

    @gerar_e_executar_com_ia
    def verificar_palindromo(texto: str):
        """
        Verifica se a string fornecida é um palíndromo.
        A verificação deve ignorar maiúsculas, minúsculas e espaços em branco.
        """

    print("É palíndromo:", verificar_palindromo("A base do teto desaba"))

Durante a execução, o decoardor intercepta a chamada, consome a API, injeta a implementação gerada no namespace local e retorna o valor processado. Esse padrão de design permite que a inteligência artificial atue como um provedor de implementação sob demanda, mantendo o controle total sobre a arquitetura e os contratos de interface do sistema hospedeiro.