Autocorrezione e prompting riflessivo
Implementi un passaggio di riflessione in cui l’agente esamina il proprio output rispetto all’obiettivo originale, individua lacune o errori e genera un piano corretto prima di riprovare.
Autocorrezione e prompting riflessivo è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Che cos'è il prompting riflessivo?
Il prompting riflessivo è una tecnica in cui si chiede all'agente di valutare il proprio output prima di finalizzarlo. Invece di produrre una risposta e fermarsi, l'agente esamina la propria risposta rispetto all'obiettivo originale, individua lacune o errori e genera una versione corretta. Questo riproduce il modo in cui le persone rileggono il proprio lavoro e migliora significativamente la qualità dell'output nelle attività complesse senza richiedere un modello critico separato.
Il ciclo di riflessione e revisione
Il ciclo riflessivo di base prevede tre passaggi: Generare una risposta iniziale, Criticare quella risposta sulla base di criteri chiari e Rivedere la risposta in base alla critica. Il ciclo può essere eseguito una o più volte. Ogni iterazione migliora la risposta finché la critica non la giudica soddisfacente oppure non viene raggiunto il numero massimo di revisioni. Il passaggio di critica è a sua volta una chiamata LLM con un prompt di riflessione specializzato.
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 responseScrivere un prompt di critica efficace
Il prompt di critica deve specificare criteri di valutazione concreti, invece di chiedere semplicemente al modello di "migliorare" la risposta. Elenchi gli aspetti specifici da verificare: ogni affermazione è accurata? La risposta copre tutte le parti della domanda? Manca qualche passaggio? Ci sono contenuti superflui? Un prompt di critica con elementi espliciti in una checklist produce feedback utilizzabile direttamente dal passaggio di revisione.
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.
'''Analizzare la risposta alla critica
Strutturi l'output della critica come modello Pydantic, così potrà decidere programmaticamente se effettuare una revisione. Il campo is_satisfactory determina l'uscita dal ciclo. L'elenco issues indica con precisione al passaggio di revisione che cosa correggere. Il campo severity consente di saltare la revisione per problemi stilistici minori, eseguendola invece sempre in presenza di errori fattuali.
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 addressedIl prompt di revisione
Il prompt di revisione riceve l'attività originale, la risposta iniziale e il feedback della critica. Chieda al modello di produrre una versione migliorata che affronti specificamente ogni problema identificato dalla critica, preservando al contempo le parti corrette della risposta originale. Includa sempre la parola 'only' per impedire al modello di apportare modifiche non necessarie agli elementi già approvati dalla critica.
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.
'''Autocorrezione per la generazione di codice
L'autocorrezione è particolarmente efficace per la generazione di codice. Dopo aver generato il codice, esegua su di esso un linter o un type checker, passi l'output degli errori al modello e gli chieda di correggerli. Questa riflessione basata sull'esecuzione è più affidabile di una critica basata solo sul linguaggio, perché il feedback proviene da uno strumento obiettivo anziché dal giudizio di un altro 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 codeEvitare le correzioni eccessive
Un errore comune nei sistemi riflessivi è la correzione eccessiva: nel tentativo di correggere un aspetto, il modello peggiora il problema originale. Per limitarla, riduca l'ambito della revisione: il prompt di revisione dovrebbe specificare esplicitamente «non modifichi nulla che non sia stato segnalato». Confronti inoltre la risposta revisionata con quella originale usando un diff-check: se la versione revisionata è radicalmente diversa, significa che qualcosa è andato storto e dovrebbe mantenere l'originale.
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 revisedRiflessione nelle attività degli agenti a più passaggi
In un agente a più passaggi, aggiunga un checkpoint di riflessione dopo aver completato un insieme di passaggi, ad esempio dopo aver raccolto tutte le informazioni necessarie, ma prima di scrivere il rapporto finale. L'agente esamina ciò che ha raccolto, individua le lacune e decide se ottenere ulteriori informazioni o procedere. Questa riflessione durante l'attività impedisce agli agenti di passare alla fase di sintesi con prove incomplete o contraddittorie.
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)Registrazione degli esiti della riflessione
Registri ogni ciclo di riflessione: i punteggi della critica, i problemi identificati e l'effettiva risoluzione di tali problemi da parte della revisione. Questi dati mostrano se i prompt di riflessione sono efficaci. Se la risposta revisionata reintroduce sistematicamente gli stessi problemi segnalati dalla critica, il prompt di revisione non è abbastanza specifico. Se la maggior parte delle critiche restituisce 'APPROVE' già al primo ciclo, la qualità della generazione iniziale è già elevata e il sovraccarico della riflessione potrebbe non valere il costo.
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 usare la riflessione
La riflessione aggiunge latenza e costi: un processo di riflessione e revisione in due cicli almeno triplica il numero di chiamate LLM per quell'attività. Usi la riflessione in modo selettivo: sempre per gli output ad alto impatto (codice che verrà eseguito, risposte a domande aziendali rilevanti), facoltativamente per le risposte destinate agli utenti e mai per passaggi intermedi interni che verranno verificati immediatamente da uno strumento. Il costo è giustificato quando la qualità conta più della velocità.
# 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'}Misurare l'efficacia della riflessione
Verifichi se la riflessione migliora davvero gli output eseguendo test A/B: elabori casualmente il 50% delle attività con la riflessione e il 50% senza, quindi valuti entrambi i gruppi con il proprio LLM judge. Se il gruppo con la riflessione ottiene punteggi significativamente più alti e il miglioramento supera la latenza e il costo aggiuntivi, la riflessione è vantaggiosa. Se i punteggi sono simili, la qualità della generazione iniziale è già sufficiente e la riflessione aggiunge sovraccarico senza apportare benefici.
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 rapida
Verifichi la propria comprensione dell'autocorrezione e del prompting riflessivo negli agenti.
Riepilogo della lezione
In questa lezione ha imparato che i cicli di riflessione e revisione migliorano la qualità degli output facendo sì che l'agente critichi e corregga le proprie risposte, che i criteri di valutazione concreti producono feedback utilizzabile anziché suggerimenti vaghi per il miglioramento e che la riflessione basata sull'esecuzione con strumenti obiettivi come i linter è particolarmente efficace per la generazione di codice. Ora implementeremo il checkpointing degli agenti e la ripresa delle attività.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Autocorrezione e prompting riflessivo» è gratuita?
Sì — il testo completo di «Autocorrezione e prompting riflessivo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Autocorrezione e prompting riflessivo»?
Implementi un passaggio di riflessione in cui l’agente esamina il proprio output rispetto all’obiettivo originale, individua lacune o errori e genera un piano corretto prima di riprovare. Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Autocorrezione e prompting riflessivo»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?
Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Classificazione delle modalità di errore degli agenti
- Autocorrezione e prompting riflessivo
- Checkpoint e ripresa delle attività
- Escalation con intervento umano