Claude Architect · Pelajaran

Penguraian Multi-Lintasan

Lintasan lokal per berkas, lalu lintasan integrasi lintas berkas.

Pelajaran 2 dari 413 langkah

Penguraian Multi-Lintasan adalah pelajaran Claude Architect 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 Claude Architect, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Claude Architect mencakup 4 pelajaran total.

Mengapa Satu Pass Tidak Cukup

Saat Anda meminta Claude meninjau changeset yang mencakup banyak berkas dalam satu pass, fokus menjadi encer. Model membagi perhatian terbatasnya ke semua berkas sekaligus, sehingga bug halus per berkas terlewat dan masalah lintas berkas yang nyata tertimbun.

Jawaban arsitek adalah dekomposisi multi-pass: bagi pekerjaan menjadi pass lokal per berkas terlebih dahulu, lalu pass integrasi lintas berkas yang terpisah. Setiap pass memiliki satu tugas yang jelas, sehingga fokus tetap tajam.

Dua Pertanyaan yang Berbeda

Kedua pass mengajukan pertanyaan yang pada dasarnya berbeda, dan itulah alasan keduanya tidak boleh digabungkan:

  • Pass lokal: "Apakah berkas INI benar secara internal?" — kesalahan logika, penanganan nilai null, penamaan, kode mati, dan gaya dalam batas berkas itu sendiri.
  • Pass integrasi: "Apakah berkas-berkas ini bekerja TOGETHER?" — tanda tangan fungsi yang tidak cocok, kontrak yang rusak, dan asumsi yang tidak konsisten di antara batas modul.

Peninjauan satu pass memaksa kedua pertanyaan masuk ke satu perintah yang fokusnya encer. Dua pass menjaga masing-masing tetap fokus.

Pass 1 — Temukan Berkasnya

Pass lokal dimulai dengan penemuan. Gunakan alat bawaan Claude Code secara bertahap: Glob untuk menemukan berkas berdasarkan pola, lalu Read setiap berkas secara terpisah.

Meninjau satu berkas per permintaan membuat konteks tetap kecil dan perhatian tetap terkonsentrasi. Ini kebalikan dari memasukkan seluruh diff ke dalam satu perintah.

# Discover changed source files, review each on its own
glob '**/*.py'  | grep -Ff <(git diff --name-only main)

# Then, per file, a focused review request:
claude -p "Review ONLY src/billing/refund.py for local correctness: \
  logic errors, null handling, edge cases. Do not assume anything \
  about other files." --output-format json

Satu Berkas, Satu Permintaan

Dalam pass lokal, berikan batas yang jelas dan tegas kepada Claude: tinjau hanya berkas ini, dan nilai berdasarkan isinya sendiri. Instruksi samar seperti "bersikap menyeluruh" memberikan hasil yang kurang baik; kriteria eksplisit lebih efektif.

Nyatakan dengan tepat hal yang dianggap sebagai temuan agar model tidak beralih ke spekulasi tentang berkas yang belum dilihatnya.

from anthropic import Anthropic
client = Anthropic()

def local_pass(path, source):
    return client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1500,
        system=("You review ONE file in isolation. Flag a finding ONLY "
                "when the code is internally wrong, never on guesses "
                "about unseen files."),
        messages=[{"role": "user",
                   "content": f"File: {path}\n\n{source}"}],
    )

Temuan Terstruktur per Berkas

Minta setiap pass lokal menghasilkan keluaran terstruktur agar temuan dapat digabungkan oleh mesin untuk pass berikutnya. Gunakan tool_choice dengan alat yang didukung skema untuk menjamin JSON yang terbentuk dengan benar.

Penting: tandai suatu bidang sebagai required hanya jika bidang itu selalu ada. Jangan pernah mewajibkan bidang yang mungkin tidak ada — model akan mengarang nilai untuk memenuhi skema.

tools = [{
    "name": "report_findings",
    "description": "Record local-pass findings for a single file.",
    "input_schema": {
        "type": "object",
        "properties": {
            "file": {"type": "string"},
            "findings": {"type": "array", "items": {"type": "string"}},
        },
        "required": ["file", "findings"],  # always present
    },
}]
# force structured output -> no free-text parsing
resp = client.messages.create(model="claude-sonnet-4-5", max_tokens=1500,
    tools=tools, tool_choice={"type": "tool", "name": "report_findings"},
    messages=[{"role": "user", "content": file_blob}])

Pass 2 — Integrasi Lintas Berkas

Setelah setiap berkas melewati peninjauan lokalnya, jalankan pass integrasi yang terpisah. Kini tujuannya beralih: Anda sengaja memuat berkas-berkas yang relevan secara bersamaan dan menanyakan apakah kontraknya selaras.

Cacat integrasi yang umum:

  • Pemanggil meneruskan tiga argumen; fungsi yang dipanggil kini mengharapkan empat.
  • Satu modul mengembalikan None saat "tidak ditemukan"; konsumen memperlakukannya sebagai daftar kosong.
  • Nilai enum yang diganti namanya masih dirujuk oleh berkas saudara.

Menelusuri Sambungan

Pass integrasi meniru investigasi bertahap. Mulailah dari batas-batas dan ikuti penghubungnya: gunakan Grep untuk mencari setiap lokasi pemanggilan nama fungsi yang diubah, lalu gunakan Read pada konsumen tersebut.

Dengan cara ini, pass integrasi berfokus pada sambungan antarberkas — tepat di tempat yang cenderung terlewat dalam peninjauan satu pass.

# Find everyone who calls the changed function, then read them
claude -p "Cross-file pass. process_refund() signature changed in \
  refund.py. Grep its call sites, Read each consumer, and report \
  ONLY mismatched arguments, return-type assumptions, or broken \
  contracts across files." --output-format json

Mengapa Urutan Itu Penting

Jalankan lokal sebelum integrasi, bukan sebaliknya. Jika suatu berkas rusak secara internal, temuan integrasi tentang berkas itu hanyalah gangguan — Anda akan menandai ketidakcocokan kontrak yang hilang setelah bug lokal diperbaiki.

Bersihkan setiap berkas secara terpisah terlebih dahulu. Setelah itu, pass integrasi dapat mempercayai bahwa setiap berkas benar secara lokal dan berfokus sepenuhnya pada cara berkas-berkas tersebut bekerja bersama.

Alur Tetap, Bukan Improvisasi

Karena langkah-langkahnya sudah diketahui dan berurutan — menemukan, pass lokal, pass integrasi, melaporkan — pekerjaan ini cocok untuk alur tetap (pengaitan perintah), bukan eksplorasi adaptif yang terbuka.

Simpan dekomposisi adaptif untuk investigasi yang benar-benar terbuka ("mengapa ini tidak stabil?"). Peninjauan multi-pass memiliki bentuk yang jelas, jadi kodifikasikan bentuk tersebut.

def review_changeset(files):
    # Stage 1: local pass, one request per file
    local = {f: local_pass(f, read(f)) for f in files}
    # Stage 2: integration pass over the seams
    integration = cross_file_pass(files, local)
    return merge(local, integration)

Jalankan dalam Sesi Terisolasi

Jalankan setiap pass peninjauan dalam sesi baru yang terisolasi, terpisah dari sesi yang menghasilkan kode. Peninjauan independen lebih baik daripada peninjauan mandiri dalam sesi yang sama: pembuat kode tetap terikat pada penalarannya sendiri dan tidak akan menantang asumsinya sendiri.

Dalam CI, jalankan ini tanpa interaksi dengan -p / --print dan --output-format json agar hasilnya dapat diurai. Saat menjalankan ulang, masukkan hasil sebelumnya dan laporkan hanya masalah baru atau yang masih belum diperbaiki.

# CI: isolated, non-interactive, machine-readable
claude -p "$LOCAL_PASS_PROMPT" --output-format json > local.json
claude -p "$INTEGRATION_PROMPT" --output-format json > integ.json
# fresh process each pass -> no generation-context bias

Menskalakan dengan Subagen

Untuk changeset berukuran besar, sebarkan pass lokal ke beberapa subagen dalam pola hub-and-spoke: koordinator membagi berkas di antara pekerja paralel, lalu menjalankan pass integrasi sendiri setelah hasilnya kembali.

Ingat aturannya: subagen tidak mewarisi riwayat koordinator. Setiap perintah subagen harus memuat semua konteks yang dibutuhkannya secara eksplisit. Beberapa pemanggilan Task dalam satu respons berjalan secara paralel.

# Coordinator: parallel local passes, then one integration pass
# (each Task gets full context — subagents inherit no history)
Task(subagent="reviewer", prompt=local_prompt_for("refund.py"))
Task(subagent="reviewer", prompt=local_prompt_for("ledger.py"))
# ...both run in parallel; coordinator aggregates, then integrates

Pemeriksaan Singkat

Seorang arsitek harus meninjau pull request yang terdiri dari 9 berkas dan menginginkan temuan dengan kualitas setinggi mungkin. Apa dekomposisi yang paling tepat?

Rangkuman

Dekomposisi multi-pass, diringkas:

  • Dua pass, dua pertanyaan: lokal = apakah setiap berkas benar secara internal; integrasi = apakah berkas-berkas tersebut bekerja bersama.
  • Lokal terlebih dahulu, lalu integrasi — berkas yang rusak membuat temuan integrasi menjadi gangguan.
  • Satu berkas per permintaan lokal untuk menjaga fokus tetap tajam; hasilkan keluaran terstruktur agar mudah digabungkan.
  • Alur tetap (menemukan → lokal → integrasi → melaporkan), bukan improvisasi adaptif.
  • Sesi terisolasi/baru lebih baik daripada peninjauan mandiri dalam sesi yang sama; dalam CI gunakan -p dan --output-format json.
  • Skalakan pass lokal ke beberapa subagen paralel — masing-masing memerlukan konteks yang diteruskan secara eksplisit.

Peninjauan multi-berkas satu pass adalah pola anti. Lakukan dekomposisi agar peninjauan Anda menjadi lebih tajam, bukan sekadar lebih panjang.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
26
Pelajaran
104

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penguraian Multi-Lintasan” gratis?

Ya — teks lengkap “Penguraian Multi-Lintasan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Claude Architect, upgrade ke CoddyKit PRO. Kursus Claude Architect mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penguraian Multi-Lintasan”?

Lintasan lokal per berkas, lalu lintasan integrasi lintas berkas. Kamu berlatih Claude Architect 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 Claude Architect?

Tidak diperlukan pengalaman sebelumnya. Claude Architect 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 “Penguraian Multi-Lintasan” 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 Claude Architect ini?

Ya. Setiap pelajaran Claude Architect 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

  1. Alur Tetap vs Penguraian Adaptif
  2. Penguraian Multi-Lintasan
  3. Manajemen Sesi
  4. Konteks Kedaluwarsa dan Memulai dari Awal
← Kembali ke Claude Architect