AI Engineering Academy · Aula

Autocorreção e criação de prompts reflexivos

Implemente uma etapa de reflexão na qual o agente revise a própria saída em relação ao objetivo original, identifique lacunas ou erros e gere um plano corrigido antes de tentar novamente.

Aula 2 de 413 etapas

Autocorreção e criação de prompts reflexivos é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.

O que é Criação de Instruções Reflexivas?

A criação de instruções reflexivas é uma técnica na qual se pede ao agente que avalie a própria saída antes de finalizá-la. Em vez de produzir uma resposta e parar, o agente revisa sua resposta em relação ao objetivo original, identifica lacunas ou erros e gera uma versão corrigida. Isso imita a maneira como as pessoas revisam o próprio trabalho e melhora significativamente a qualidade das saídas em tarefas complexas sem exigir um modelo crítico separado.

O Loop de Reflexão e Revisão

O loop reflexivo básico tem três etapas: Generate uma resposta inicial, Critique essa resposta com base em critérios claros e Revise com base na crítica. Esse loop pode ser executado uma ou mais vezes. Cada iteração melhora a resposta até que a crítica a considere satisfatória ou até que seja atingida uma contagem máxima de revisões. A etapa de crítica é, por si só, uma chamada de LLM com uma instrução de reflexão especializada.

async def reflect_and_revise(task: str, max_rounds: int = 2) -> str:
    response = await generate_initial(task)
    for round_num in range(max_rounds):
        critique = await critique_response(task, response)
        if critique.is_satisfactory:
            break
        response = await revise_response(task, response, critique.feedback)
    return response

Escrevendo uma Instrução de Crítica Eficaz

A instrução de crítica deve especificar critérios concretos de avaliação, em vez de pedir simplesmente que o modelo “melhore” a resposta. Liste os aspectos específicos a verificar: Todas as afirmações estão corretas? A resposta abordou todas as partes da pergunta? Falta alguma etapa? Há conteúdo desnecessário? Uma instrução de crítica com itens de verificação explícitos produz comentários acionáveis que a etapa de revisão pode usar diretamente.

CRITIQUE_PROMPT = '''
You are reviewing an AI-generated response to this task: {task}

Response to evaluate:
{response}

Check each criterion and provide specific feedback:
1. COMPLETENESS: Does it address all parts of the task?
2. ACCURACY: Are all factual claims correct?
3. CONCISENESS: Is there unnecessary padding or repetition?
4. FORMAT: Does it match the requested output format?
5. ACTIONABILITY: Can the user act on this response?

For each issue found, state exactly what to fix.
If the response is satisfactory on all criteria, say APPROVE.
'''

Analisando a Resposta da Crítica

Estruture o resultado da crítica como um modelo Pydantic para que possa decidir programaticamente se deve revisar. O campo is_satisfactory determina a saída do ciclo. A lista issues informa exatamente o que a etapa de revisão deve corrigir. O campo severity permite ignorar a revisão de problemas estilísticos menores, mantendo sempre a revisão de erros factuais.

from pydantic import BaseModel
from typing import List, Literal

class Issue(BaseModel):
    criterion: str
    description: str
    severity: Literal['critical', 'moderate', 'minor']

class Critique(BaseModel):
    is_satisfactory: bool
    issues: List[Issue]
    overall_verdict: str

# is_satisfactory=True means no revision needed
# is_satisfactory=False means issues must be addressed

O prompt de revisão

O prompt de revisão recebe a tarefa original, a resposta inicial e o feedback da crítica. Peça ao modelo que produza uma versão aprimorada que trate especificamente cada problema identificado pela crítica, preservando as partes corretas da resposta original. Inclua sempre a palavra 'only' para impedir que o modelo faça alterações desnecessárias em aspectos que a crítica já aprovou.

def build_revision_prompt(task: str, response: str, critique: Critique) -> str:
    issues_text = '\n'.join(
        f'- [{i.severity.upper()}] {i.criterion}: {i.description}'
        for i in critique.issues
    )
    return f'''
Original task: {task}

Your previous response:
{response}

Issues to fix:
{issues_text}

Write an improved response that fixes ONLY the issues listed above.
Do not change parts that were not flagged as problems.
'''

Autocorreção na geração de código

A autocorreção é especialmente poderosa na geração de código. Depois de gerar o código, execute nele um analisador estático ou verificador de tipos, envie o resultado dos erros de volta ao modelo e peça que ele corrija os erros. Essa reflexão fundamentada na execução é mais confiável do que uma crítica baseada apenas na linguagem, pois o feedback vem de uma ferramenta objetiva, e não do julgamento de outro LLM.

import subprocess
import sys

async def self_correct_code(task: str, max_rounds: int = 3) -> str:
    code = await generate_code(task)
    for _ in range(max_rounds):
        # Write code to temp file and run mypy
        with open('/tmp/agent_code.py', 'w') as f:
            f.write(code)
        result = subprocess.run(
            [sys.executable, '-m', 'mypy', '/tmp/agent_code.py', '--ignore-missing-imports'],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            break  # No type errors
        code = await fix_code(code, result.stdout + result.stderr)
    return code

Como evitar correções excessivas

Uma falha comum em sistemas reflexivos é a correção excessiva: o modelo piora o problema original ao tentar corrigir outra coisa. Reduza esse risco limitando o escopo da revisão: o prompt de revisão deve dizer explicitamente 'do not change anything that was not flagged.' Compare também a resposta revisada com a original usando uma verificação de diferenças — se a versão revisada for radicalmente diferente, algo deu errado e deverá manter a original.

from difflib import SequenceMatcher

def safe_revision(original: str, revised: str, max_change_ratio: float = 0.7) -> str:
    similarity = SequenceMatcher(None, original, revised).ratio()
    if similarity < (1 - max_change_ratio):
        print(f'Revision changed too much (similarity: {similarity:.2f}). Keeping original.')
        return original
    return revised

Reflexão em tarefas de agentes com várias etapas

Em um agente com várias etapas, adicione um ponto de verificação de reflexão depois de concluir um conjunto de etapas — por exemplo, depois de reunir toda a pesquisa, mas antes de escrever o relatório final. O agente revisa o que coletou, identifica lacunas e decide se deve reunir mais informações ou prosseguir. Essa reflexão durante a tarefa impede que os agentes avancem para a etapa de síntese com evidências incompletas ou contraditórias.

async def research_with_reflection(question: str) -> str:
    # Phase 1: gather evidence
    evidence = await gather_evidence(question)

    # Reflection checkpoint
    assessment = await assess_evidence_completeness(question, evidence)
    if not assessment.is_complete:
        for gap in assessment.gaps:
            more_evidence = await targeted_search(gap.search_query)
            evidence.extend(more_evidence)

    # Phase 2: synthesize
    return await synthesize_answer(question, evidence)

Registro dos resultados da reflexão

Registre cada rodada de reflexão: as pontuações da crítica, os problemas identificados e se a revisão realmente os resolveu. Esses dados revelam se os prompts de reflexão são eficazes. Se a resposta revisada reintroduzir consistentemente os mesmos problemas apontados pela crítica, o prompt de revisão não é específico o suficiente. Se a maioria das críticas disser 'APPROVE' na primeira rodada, a qualidade da geração inicial já será alta, e o custo adicional da reflexão talvez não compense.

import structlog

log = structlog.get_logger()

def log_reflection_round(task_id: str, round_num: int, critique: Critique, action: str):
    log.info(
        'reflection_round',
        task_id=task_id,
        round=round_num,
        is_satisfactory=critique.is_satisfactory,
        issue_count=len(critique.issues),
        critical_issues=sum(1 for i in critique.issues if i.severity == 'critical'),
        action=action  # 'approved', 'revised', 'max_rounds_reached'
    )

Quando usar reflexão

A reflexão aumenta a latência e o custo — um processo de reflexão e revisão em duas rodadas pelo menos triplica o número de chamadas ao LLM para essa tarefa. Use a reflexão de forma seletiva: sempre para resultados de alto risco (código que será executado e respostas a questões empresariais relevantes), opcionalmente para respostas voltadas ao usuário e nunca para etapas intermediárias internas que serão verificadas imediatamente por uma ferramenta. O custo compensa quando a qualidade é mais importante do que a velocidade.

# Reflection decision matrix:
# Task type:              Use reflection?
# SQL query generation    YES (run+verify)
# Final report writing    YES (review before delivery)
# Tool argument prep      NO  (tool result verifies it)
# Short factual answer    MAYBE (if accuracy is critical)
# Internal agent thought  NO   (intermediate, not final)
# Code generation         YES  (run linter/tests)

USE_REFLECTION = {'report', 'code', 'email', 'analysis'}

Medindo a eficácia da reflexão

Acompanhe se a reflexão realmente melhora seus resultados realizando testes A/B: processe aleatoriamente 50% das tarefas com reflexão e 50% sem reflexão e, em seguida, avalie os dois conjuntos com seu avaliador baseado em LLM. Se o grupo reflexivo obtiver uma pontuação significativamente maior (e a melhoria superar a latência e o custo adicionais), a reflexão estará compensando. Se as pontuações forem semelhantes, a qualidade da geração inicial já será suficientemente alta, e a reflexão estará apenas adicionando custo sem benefício.

async def reflection_ab_test(tasks: list) -> dict:
    import random
    results = {'with_reflection': [], 'without_reflection': []}
    for task in tasks:
        if random.random() < 0.5:
            response = await reflect_and_revise(task, max_rounds=2)
            group = 'with_reflection'
        else:
            response = await generate_initial(task)
            group = 'without_reflection'
        score = await judge(task, response)
        results[group].append(score.overall)
    return {
        'mean_with': sum(results['with_reflection']) / len(results['with_reflection']),
        'mean_without': sum(results['without_reflection']) / len(results['without_reflection'])
    }

Verificação rápida

Teste sua compreensão sobre autocorreção e prompts reflexivos em agentes.

Recapitulação da lição

Nesta lição, você aprendeu que: os ciclos de reflexão e revisão melhoram a qualidade do resultado fazendo o agente criticar e corrigir as próprias respostas; critérios concretos de crítica produzem feedback acionável, em vez de sugestões vagas de melhoria; e a reflexão fundamentada na execução, com ferramentas objetivas como analisadores estáticos, é especialmente poderosa para a geração de código. A seguir, implementaremos pontos de verificação de agentes e retomada de tarefas.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Autocorreção e criação de prompts reflexivos” é grátis?

Sim — o texto completo de “Autocorreção e criação de prompts reflexivos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.

O que vou aprender em “Autocorreção e criação de prompts reflexivos”?

Implemente uma etapa de reflexão na qual o agente revise a própria saída em relação ao objetivo original, identifique lacunas ou erros e gere um plano corrigido antes de tentar novamente. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Engineering Academy?

Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Autocorreção e criação de prompts reflexivos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Engineering Academy?

Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Classificando modos de falha de agentes
  2. Autocorreção e criação de prompts reflexivos
  3. Criação de pontos de verificação e retomada de tarefas
  4. Escalonamento com participação humana
← Voltar para AI Engineering Academy