AI Engineering Academy · Pelajaran

Koreksi Mandiri dan Pemberian Prompt Reflektif

Terapkan langkah refleksi ketika agen meninjau keluarannya sendiri berdasarkan tujuan awal, mengidentifikasi kekurangan atau kesalahan, lalu membuat rencana yang telah dikoreksi sebelum mencoba lagi.

Koreksi Mandiri dan Pemberian Prompt Reflektif adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa Itu Prompting Reflektif

Prompting reflektif adalah teknik yang meminta agen mengevaluasi keluarannya sendiri sebelum menyelesaikannya. Alih-alih menghasilkan jawaban lalu berhenti, agen meninjau responsnya berdasarkan tujuan awal, mengidentifikasi kekurangan atau kesalahan, dan menghasilkan versi yang telah diperbaiki. Teknik ini meniru cara manusia mengoreksi pekerjaannya sendiri dan secara signifikan meningkatkan kualitas keluaran pada tugas kompleks tanpa memerlukan model pengkritik terpisah.

Perulangan Refleksi dan Revisi

Perulangan reflektif dasar memiliki tiga langkah: Hasilkan respons awal, lakukan Critique terhadap respons tersebut berdasarkan kriteria yang jelas, lalu Revisi berdasarkan kritik tersebut. Perulangan ini dapat dijalankan satu kali atau lebih. Setiap iterasi meningkatkan respons hingga kritik menyatakan bahwa respons tersebut sudah memadai atau jumlah revisi maksimum tercapai. Langkah kritik itu sendiri merupakan pemanggilan LLM dengan prompt refleksi khusus.

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

Menulis Prompt Kritik yang Efektif

Prompt kritik harus menetapkan kriteria evaluasi yang konkret, bukan sekadar meminta model untuk “memperbaiki” respons. Cantumkan hal-hal spesifik yang perlu diperiksa: Apakah setiap klaim akurat? Apakah semua bagian pertanyaan sudah dijawab? Apakah ada langkah yang terlewat? Apakah terdapat uraian tambahan yang tidak perlu? Prompt kritik dengan item daftar periksa yang jelas menghasilkan umpan balik yang dapat ditindaklanjuti dan langsung digunakan oleh langkah revisi.

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.
'''

Mengurai Respons Kritik

Susun keluaran kritik sebagai model Pydantic agar Anda dapat menentukan secara terprogram apakah perlu melakukan revisi. Kolom is_satisfactory menentukan keluarnya proses pengulangan. Daftar issues memberi tahu langkah revisi secara tepat apa yang harus diperbaiki. Kolom severity memungkinkan Anda melewati revisi untuk masalah gaya yang kecil, tetapi selalu melakukan revisi untuk kesalahan faktual.

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

Prompt Revisi

Prompt revisi menerima tugas asli, respons awal, dan umpan balik kritik. Minta model menghasilkan versi yang lebih baik dengan secara khusus menangani setiap masalah yang diidentifikasi oleh kritik, sekaligus mempertahankan bagian yang benar dari respons asli. Selalu sertakan kata 'only' untuk mencegah model melakukan perubahan yang tidak perlu pada hal-hal yang sudah disetujui oleh kritik.

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.
'''

Koreksi Mandiri untuk Pembuatan Kode

Koreksi mandiri sangat efektif untuk pembuatan kode. Setelah membuat kode, jalankan linter atau pemeriksa tipe pada kode tersebut, kirimkan keluaran kesalahan kembali ke model, lalu minta model memperbaiki kesalahan itu. Refleksi berbasis eksekusi ini lebih andal daripada kritik yang hanya berbasis bahasa karena umpan baliknya berasal dari alat objektif, bukan penilaian LLM lain.

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

Menghindari Koreksi Berlebihan

Kegagalan yang umum dalam sistem reflektif adalah koreksi berlebihan: model membuat masalah awal menjadi lebih buruk saat mencoba memperbaiki hal lain. Kurangi risiko ini dengan membatasi cakupan revisi: prompt revisi harus secara eksplisit menyatakan 'do not change anything that was not flagged.' Bandingkan juga respons yang telah direvisi dengan respons asli menggunakan pemeriksaan perbedaan — jika versi revisi sangat berbeda, berarti terjadi kesalahan dan Anda harus mempertahankan versi asli.

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

Refleksi dalam Tugas Agen Multi-Langkah

Dalam agen multi-langkah, tambahkan checkpoint refleksi setelah menyelesaikan serangkaian langkah — misalnya, setelah mengumpulkan semua riset tetapi sebelum menulis laporan akhir. Agen meninjau hal-hal yang telah dikumpulkannya, mengidentifikasi kekurangan, lalu memutuskan apakah harus mengumpulkan lebih banyak informasi atau melanjutkan. Refleksi di tengah tugas ini mencegah agen melanjutkan ke langkah sintesis dengan bukti yang tidak lengkap atau bertentangan.

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)

Mencatat Hasil Refleksi

Catat setiap putaran refleksi: skor kritik, masalah yang diidentifikasi, dan apakah revisi benar-benar menyelesaikan masalah tersebut. Data ini menunjukkan apakah prompt refleksi Anda efektif. Jika respons yang direvisi terus-menerus memunculkan kembali masalah yang ditandai oleh kritik, prompt revisi Anda belum cukup spesifik. Jika sebagian besar kritik menyatakan 'APPROVE' pada putaran pertama, kualitas pembuatan awal sudah tinggi dan biaya tambahan refleksi mungkin tidak sepadan.

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'
    )

Kapan Menggunakan Refleksi

Refleksi menambah latensi dan biaya — proses reflect-and-revise dua putaran setidaknya melipatgandakan jumlah panggilan LLM untuk tugas tersebut. Gunakan refleksi secara selektif: selalu untuk keluaran berisiko tinggi (kode yang akan dijalankan, jawaban atas pertanyaan bisnis yang berdampak besar), secara opsional untuk respons yang ditampilkan kepada pengguna, dan jangan pernah untuk langkah perantara internal yang akan segera diverifikasi oleh alat. Biaya ini sepadan ketika kualitas lebih penting daripada kecepatan.

# 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'}

Mengukur Efektivitas Refleksi

Lacak apakah refleksi benar-benar meningkatkan keluaran Anda dengan menjalankan pengujian A/B: proses 50% tugas secara acak dengan refleksi dan 50% tanpa refleksi, lalu nilai kedua kelompok tersebut menggunakan penilai LLM Anda. Jika skor kelompok reflektif jauh lebih tinggi (dan peningkatannya melebihi latensi serta biaya tambahan), berarti refleksi memberikan manfaat. Jika skornya serupa, kualitas pembuatan awal Anda sudah cukup tinggi dan refleksi hanya menambah beban tanpa manfaat.

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'])
    }

Pemeriksaan Singkat

Uji pemahaman Anda tentang koreksi mandiri dan pemberian prompt reflektif pada agen.

Ringkasan Pelajaran

Dalam pelajaran ini Anda telah mempelajari bahwa: pengulangan reflect-and-revise meningkatkan kualitas keluaran dengan meminta agen mengkritik dan memperbaiki responsnya sendiri, rubrik kritik yang konkret menghasilkan umpan balik yang dapat ditindaklanjuti alih-alih saran perbaikan yang samar, dan refleksi berbasis eksekusi dengan alat objektif seperti linter sangat efektif untuk pembuatan kode. Selanjutnya, kita akan menerapkan checkpoint agen dan pelanjutan tugas.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Koreksi Mandiri dan Pemberian Prompt Reflektif” gratis?

Ya — teks lengkap “Koreksi Mandiri dan Pemberian Prompt Reflektif” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Koreksi Mandiri dan Pemberian Prompt Reflektif”?

Terapkan langkah refleksi ketika agen meninjau keluarannya sendiri berdasarkan tujuan awal, mengidentifikasi kekurangan atau kesalahan, lalu membuat rencana yang telah dikoreksi sebelum mencoba lagi. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Koreksi Mandiri dan Pemberian Prompt Reflektif” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengklasifikasikan Mode Kegagalan Agen
Koreksi Mandiri dan Pemberian Prompt Reflektif
Pembuatan Titik Pemeriksaan dan Melanjutkan Tugas
Eskalasi dengan Keterlibatan Manusia

← Kembali ke AI Engineering Academy