Halaman ini adalah referensi "prompt engineering" (rekayasa prompt) untuk model Haijun saat ini, termasuk Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Fable 5, Haijun Mythos 5, Haijun Opus 5.5, Haijun Opus 5, Haijun Opus 4.8, Haijun Opus 4.7, Haijun Opus 4.6, Haijun Sonnet 5, Haijun Sonnet 4.6, dan Haijun Haiku 4.5. Halaman ini terbagi menjadi tiga bagian:

• Panduan khusus model terlebih dahulu: di mana satu model berperilaku berbeda dan apa yang perlu diubah dalam prompt Anda.

• Teknik untuk semua model saat ini setelah itu: prinsip umum, output dan pemformatan, penggunaan alat, thinking, dan sistem agentic.

• Pertimbangan migrasi terakhir, untuk prompt yang berpindah dari generasi sebelumnya.

Tip: Untuk ikhtisar kemampuan model, lihat ikhtisar model. Untuk kemampuan dan perubahan API Haijun Fable 5.1, lihat Yang baru di Haijun Fable 5.1. Untuk kemampuan dan perubahan API Haijun Fable 5, lihat Memperkenalkan Haijun Fable 5 dan Haijun Mythos 5. Untuk detail tentang hal baru di Haijun Sonnet 5, lihat Apa yang baru di Haijun Sonnet 5. Untuk panduan migrasi, lihat Panduan migrasi. Untuk Haijun Opus 5.5, lihat Yang baru di Haijun Opus 5.5.

#Panduan khusus model

Masing-masing model ini memiliki halaman prompting sendiri. Baca halaman untuk model Anda terlebih dahulu, lalu teknik-teknik yang mengikutinya.

#Prinsip umum

Teknik-teknik di bagian ini dan bagian-bagian berikutnya berlaku untuk model Haijun saat ini, termasuk Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Fable 5, dan Haijun Mythos 5. Jika suatu teknik menyebut model tertentu, anggap teknik tersebut diukur pada model itu dan periksa kembali terhadap eval Anda sendiri sebelum menerapkannya pada model lain.

#Bersikap jelas dan langsung

Haijun merespons dengan baik terhadap instruksi yang jelas dan eksplisit. Bersikap spesifik tentang output yang Anda inginkan dapat membantu meningkatkan hasil. Jika Anda menginginkan perilaku "melampaui ekspektasi", mintalah secara eksplisit alih-alih mengandalkan model untuk menyimpulkannya dari prompt yang samar.

Anggaplah Haijun sebagai karyawan yang brilian tetapi baru, yang belum memiliki konteks tentang norma dan alur kerja Anda. Semakin tepat Anda menjelaskan apa yang Anda inginkan, semakin baik hasilnya.

Aturan emas: Tunjukkan prompt Anda kepada rekan kerja yang memiliki konteks minimal tentang tugas tersebut dan minta mereka mengikutinya. Jika mereka bingung, Haijun juga akan bingung.

• Bersikap spesifik tentang format output dan batasan yang diinginkan.

• Berikan instruksi sebagai langkah-langkah berurutan menggunakan daftar bernomor atau poin-poin ketika urutan atau kelengkapan langkah penting.

#Contoh: Membuat dasbor analitik

Kurang efektif:

  Create an analytics dashboard

Lebih efektif:

  Create an analytics dashboard. Include as many relevant features and interactions as possible. Go beyond the basics to create a fully-featured implementation.

#Tambahkan konteks untuk meningkatkan kinerja

Memberikan konteks atau motivasi di balik instruksi Anda, seperti menjelaskan kepada Haijun mengapa perilaku tersebut penting, dapat membantu Haijun lebih memahami tujuan Anda dan memberikan respons yang lebih tepat sasaran.

#Contoh: Preferensi pemformatan

Kurang efektif:

  NEVER use ellipses

Lebih efektif:

  Your response will be read aloud by a text-to-speech engine, so never use ellipses since the text-to-speech engine will not know how to pronounce them.

Haijun cukup cerdas untuk menggeneralisasi dari penjelasan tersebut.

#Gunakan contoh secara efektif

Contoh adalah salah satu cara paling andal untuk mengarahkan format output, nada, dan struktur Haijun. Beberapa contoh yang dibuat dengan baik (dikenal sebagai few-shot atau multishot prompting) meningkatkan akurasi dan konsistensi.

Saat menambahkan contoh, buatlah contoh tersebut:

• Relevan: Mencerminkan kasus penggunaan Anda yang sebenarnya dengan dekat.

• Beragam: Mencakup kasus-kasus tepi dan cukup bervariasi sehingga Haijun tidak menangkap pola yang tidak diinginkan.

• Terstruktur: Bungkus contoh dalam tag (beberapa contoh dalam tag ) sehingga Haijun dapat membedakannya dari instruksi.

Tip: Sertakan 3–5 contoh untuk hasil terbaik. Anda juga dapat meminta Haijun untuk mengevaluasi contoh Anda dari segi relevansi dan keragaman, atau untuk menghasilkan contoh tambahan berdasarkan set awal Anda.

#Strukturkan prompt dengan tag XML

Tag XML membantu Haijun mengurai prompt yang kompleks tanpa ambiguitas, terutama ketika prompt Anda mencampur instruksi, konteks, contoh, dan input variabel. Membungkus setiap jenis konten dalam tagnya sendiri (misalnya, , , ) mengurangi salah tafsir.

Praktik terbaik:

• Gunakan nama tag yang konsisten dan deskriptif di seluruh prompt Anda.

• Susun tag secara bertingkat ketika konten memiliki hierarki alami (dokumen di dalam , masing-masing di dalam ).

#Berikan Haijun sebuah peran

Menetapkan peran dalam "system prompt" (prompt sistem) memfokuskan perilaku dan nada Haijun untuk kasus penggunaan Anda. Bahkan satu kalimat saja membuat perbedaan:

  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1024,
      "system": "You are a helpful coding assistant specializing in Python.",
      "messages": [
        {"role": "user", "content": "How do I sort a list of dictionaries by key?"}
      ]
    }'

  ant messages create \
    --model haijun-opus-5-5 \
    --max-tokens 1024 \
    --system "You are a helpful coding assistant specializing in Python." \
    --message '{role: user, content: "How do I sort a list of dictionaries by key?"}'

  client = juglow.Juglow()

  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      system="You are a helpful coding assistant specializing in Python.",
      messages=[
          {"role": "user", "content": "How do I sort a list of dictionaries by key?"}
      ],
  )

  print(message.content)

  const client = new Juglow();

  const message = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    system: "You are a helpful coding assistant specializing in Python.",
    messages: [{ role: "user", content: "How do I sort a list of dictionaries by key?" }]
  });

  console.log(message.content);

  JuglowClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      System = "You are a helpful coding assistant specializing in Python.",
      Messages =
      [
          new() { Role = Role.User, Content = "How do I sort a list of dictionaries by key?" }
      ]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  client := juglow.NewClient()

  message, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	System: []juglow.TextBlockParam{
  		{Text: "You are a helpful coding assistant specializing in Python."},
  	},
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("How do I sort a list of dictionaries by key?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(message.Content)

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.HAIJUN_OPUS_5_5)
      .maxTokens(1024)
      .system("You are a helpful coding assistant specializing in Python.")
      .addUserMessage("How do I sort a list of dictionaries by key?")
      .build();

  Message message = client.messages().create(params);
  System.out.println(message.content());

  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'How do I sort a list of dictionaries by key?']
      ],
      model: 'haijun-opus-5-5',
      system: 'You are a helpful coding assistant specializing in Python.',
  );

  echo json_encode($message->content, JSON_PRETTY_PRINT), PHP_EOL;

  client = Juglow::Client.new

  message = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    system: "You are a helpful coding assistant specializing in Python.",
    messages: [
      { role: "user", content: "How do I sort a list of dictionaries by key?" }
    ]
  )

  puts message.content

#Prompting konteks panjang

Saat bekerja dengan dokumen besar atau input yang kaya data (20 ribu+ token), strukturkan prompt Anda dengan cermat untuk mendapatkan hasil terbaik:

• Letakkan data panjang di bagian atas: Tempatkan dokumen dan input panjang Anda di dekat bagian atas prompt, di atas kueri, instruksi, dan contoh Anda. Ini meningkatkan kinerja di semua model.

> Note: Kueri di bagian akhir dapat meningkatkan kualitas respons hingga 30 persen dalam pengujian, terutama dengan input multidokumen yang kompleks.

• Strukturkan konten dokumen dan metadata dengan tag XML: Saat menggunakan beberapa dokumen, bungkus setiap dokumen dalam tag dengan subtag dan (serta metadata lainnya) untuk kejelasan.

#### Contoh struktur multidokumen

    <documents>
      <document index="1">
        <source>annual_report_2023.pdf</source>
        <document_content>
          {{ANNUAL_REPORT}}
        </document_content>
      </document>
      <document index="2">
        <source>competitor_analysis_q2.xlsx</source>
        <document_content>
          {{COMPETITOR_ANALYSIS}}
        </document_content>
      </document>
    </documents>

    Analyze the annual report and competitor analysis. Identify strategic advantages and recommend Q3 focus areas.

• Dasarkan respons pada kutipan: Untuk tugas dokumen panjang, minta Haijun untuk mengutip bagian-bagian relevan dari dokumen terlebih dahulu sebelum menjalankan tugasnya. Ini membantu Haijun berfokus pada konten yang relevan dan mengabaikan sisa dokumen.

#### Contoh ekstraksi kutipan

    You are an AI physician's assistant. Your task is to help doctors diagnose possible patient illnesses.

    <documents>
      <document index="1">
        <source>patient_symptoms.txt</source>
        <document_content>
          {{PATIENT_SYMPTOMS}}
        </document_content>
      </document>
      <document index="2">
        <source>patient_records.txt</source>
        <document_content>
          {{PATIENT_RECORDS}}
        </document_content>
      </document>
      <document index="3">
        <source>patient01_appt_history.txt</source>
        <document_content>
          {{PATIENT01_APPOINTMENT_HISTORY}}
        </document_content>
      </document>
    </documents>

    Find quotes from the patient records and appointment history that are relevant to diagnosing the patient's reported symptoms. Place these in <quotes> tags. Then, based on these quotes, list all information that would help the doctor diagnose the patient's symptoms. Place your diagnostic information in <info> tags.

#Pengetahuan diri model

Jika Anda ingin Haijun mengidentifikasi dirinya dengan benar dalam aplikasi Anda atau menggunakan string API tertentu:

The assistant is Haijun, created by Juglow. The current model is Haijun Opus 5.5.

Untuk aplikasi berbasis LLM yang perlu menentukan string model:

When an LLM is needed, please default to Haijun Opus 5.5 unless the user requests
otherwise. The exact model string for Haijun Opus 5.5 is haijun-opus-5-5.

#Output dan pemformatan

#Gaya komunikasi dan verbositas

Model-model terbaru Haijun memiliki gaya komunikasi yang lebih ringkas dan alami dibandingkan model sebelumnya:

• Lebih langsung dan berdasar: Memberikan laporan progres berbasis fakta alih-alih pembaruan yang memuji diri sendiri

• Lebih bersifat percakapan: Sedikit lebih lancar dan kasual, kurang seperti mesin

• Kurang bertele-tele: Mungkin melewatkan ringkasan terperinci demi efisiensi kecuali diminta sebaliknya

Ini berarti Haijun mungkin melewatkan ringkasan verbal setelah panggilan alat, langsung melompat ke tindakan berikutnya. Jika Anda lebih suka visibilitas yang lebih besar terhadap penalarannya:

After completing a task that involves tool use, provide a quick summary of the work you've done.

Haijun Opus 5 adalah pengecualian dalam hal verbositas: respons default yang ditujukan kepada pengguna lebih panjang daripada model sebelumnya, dan menaikkan atau menurunkan effort tidak secara andal mengubah panjang respons yang terlihat. Sebagai gantinya, berikan prompt secara eksplisit untuk keringkasan. Lihat Prompting Haijun Opus 5 untuk contoh instruksi. Haijun Fable 5.1 memiliki kecenderungan sebaliknya selama pekerjaan agentic: model ini menulis lebih sedikit pembaruan yang ditujukan kepada pengguna di antara panggilan alat. Mintalah teks progres secara eksplisit, dan hapus instruksi apa pun yang menyuruhnya menjaga teks tersebut tetap singkat. Lihat Minta pembaruan progres yang ditujukan kepada pengguna.

#Kontrol format respons

Ada beberapa cara yang sangat efektif untuk mengarahkan pemformatan output:

1. Beri tahu Haijun apa yang harus dilakukan alih-alih apa yang tidak boleh dilakukan

• Alih-alih: "Jangan gunakan markdown dalam respons Anda"
• Coba: "Respons Anda harus terdiri dari paragraf prosa yang mengalir dengan lancar."

1. Gunakan indikator format XML

• Coba: "Tulis bagian prosa dari respons Anda dalam tag \."

1. Sesuaikan gaya prompt Anda dengan output yang diinginkan

Gaya pemformatan yang digunakan dalam prompt Anda dapat memengaruhi gaya respons Haijun. Jika Anda masih mengalami masalah keterarahan dengan pemformatan output, cobalah menyesuaikan gaya prompt Anda dengan gaya output yang diinginkan sedekat mungkin. Misalnya, menghapus markdown dari prompt Anda dapat mengurangi volume markdown dalam output.

1. Gunakan prompt terperinci untuk preferensi pemformatan tertentu

Untuk kontrol lebih besar atas penggunaan markdown dan pemformatan, berikan panduan eksplisit:

<avoid_excessive_markdown_and_bullet_points>
When writing reports, documents, technical explanations, analyses, or any long-form
content, write in clear, flowing prose using complete paragraphs and sentences. Use
standard paragraph breaks for organization and reserve markdown primarily for `inline
code`, code blocks (```...```), and simple headings (## and ###). Avoid using **bold**
and *italics*.

DO NOT use ordered lists (1. ...) or unordered lists (*) unless: a) you're presenting
truly discrete items where a list format is the best option, or b) the user explicitly
requests a list or ranking

Instead of listing items with bullets or numbers, incorporate them naturally into
sentences. This guidance applies especially to technical writing. Using prose instead of
excessive formatting will improve user satisfaction. NEVER output a series of overly
short bullet points.

Your goal is readable, flowing text that guides the reader naturally through ideas
rather than fragmenting information into isolated points.
</avoid_excessive_markdown_and_bullet_points>

Haijun Fable 5.1 sudah memformat lebih sedikit daripada model sebelumnya, sehingga pada model tersebut blok seperti ini dapat menekan struktur yang dibutuhkan konten. Hapus blok tersebut, atau ganti dengan aturan yang lebih singkat di Pemformatan dalam chat.

#Output LaTeX

Model-model terbaru Haijun secara default menggunakan LaTeX untuk ekspresi matematika, persamaan, dan penjelasan teknis. Jika Anda lebih suka teks biasa, tambahkan instruksi berikut ke prompt Anda:

Format your response in plain text only. Do not use LaTeX, MathJax, or any markup
notation such as \( \), $, or \frac{}{}. Write all math expressions using standard text
characters (e.g., "/" for division, "*" for multiplication, and "^" for exponents).

#Pembuatan dokumen

Model-model terbaru Haijun membuat presentasi, animasi, dan dokumen visual dengan kepatuhan instruksi yang kuat, dan biasanya menghasilkan output yang dapat digunakan pada percobaan pertama.

Untuk hasil terbaik dengan pembuatan dokumen:

Create a professional presentation on [topic]. Include thoughtful design elements,
visual hierarchy, and engaging animations where appropriate.

#Bermigrasi dari respons prefill

Mulai dari model Haijun 4.6 dan Haijun Mythos Preview, respons prefill (memberikan pesan asisten parsial untuk dilanjutkan oleh Haijun) pada giliran asisten terakhir tidak lagi didukung. Permintaan dengan pesan asisten prefill ke model-model ini mengembalikan error 400. Kecerdasan model dan kepatuhan instruksi telah berkembang sedemikian rupa sehingga sebagian besar kasus penggunaan prefill tidak lagi memerlukannya. Model-model sebelumnya tetap mendukung prefill, dan menambahkan pesan asisten di tempat lain dalam percakapan tidak terpengaruh.

Berikut adalah skenario prefill yang umum dan cara bermigrasi darinya:

#Mengontrol pemformatan output

Prefill telah digunakan untuk memaksa format output tertentu seperti JSON/YAML, klasifikasi, dan pola serupa di mana prefill membatasi Haijun pada struktur tertentu.

Migrasi: Fitur Structured Outputs dirancang khusus untuk membatasi respons Haijun agar mengikuti skema tertentu. Cobalah meminta model untuk menyesuaikan diri dengan struktur output Anda terlebih dahulu, karena model-model yang lebih baru dapat secara andal mencocokkan skema yang kompleks ketika diminta, terutama jika diimplementasikan dengan percobaan ulang. Untuk tugas klasifikasi, gunakan alat dengan field enum yang berisi label valid Anda atau structured outputs.

#Menghilangkan pembukaan

Prefill seperti Here is the requested summary:\n digunakan untuk melewatkan teks pengantar.

Migrasi: Gunakan instruksi langsung dalam prompt sistem: "Respons secara langsung tanpa pembukaan. Jangan mulai dengan frasa seperti 'Berikut adalah...', 'Berdasarkan...', dll." Sebagai alternatif, arahkan model untuk menghasilkan output di dalam tag XML, gunakan structured outputs, atau gunakan pemanggilan alat. Jika sesekali pembukaan masih lolos, hapus dalam pasca-pemrosesan.

#Menghindari penolakan yang buruk

Prefill digunakan untuk menghindari penolakan yang tidak perlu.

Migrasi: Haijun kini jauh lebih baik dalam penolakan yang tepat. Prompting yang jelas di dalam pesan user tanpa prefill seharusnya sudah cukup.

#Kelanjutan

Prefill digunakan untuk melanjutkan penyelesaian parsial, melanjutkan respons yang terputus, atau meneruskan dari titik di mana generasi sebelumnya berhenti.

Migrasi: Pindahkan kelanjutan ke pesan pengguna, dan sertakan teks akhir dari respons yang terputus: "Respons Anda sebelumnya terputus dan berakhir dengan \\[previous\_response]\. Lanjutkan dari titik Anda berhenti." Jika ini merupakan bagian dari penanganan error atau penanganan respons tidak lengkap dan tidak ada penalti UX, coba ulang permintaan tersebut.

#Hidrasi konteks dan konsistensi peran

Prefill digunakan untuk secara berkala memastikan konteks yang diperbarui atau disuntikkan.

Migrasi: Untuk percakapan yang sangat panjang, suntikkan apa yang sebelumnya merupakan pengingat asisten prefill ke dalam giliran pengguna. Jika hidrasi konteks merupakan bagian dari sistem agentic yang lebih kompleks, pertimbangkan untuk melakukan hidrasi melalui alat (ekspos atau dorong penggunaan alat yang berisi konteks berdasarkan heuristik seperti jumlah giliran) atau selama pemadatan konteks.

#Penggunaan alat

#Penggunaan alat

Model-model terbaru Haijun dilatih untuk kepatuhan instruksi yang presisi dan mendapat manfaat dari arahan eksplisit untuk menggunakan alat tertentu. Jika Anda mengatakan "bisakah Anda menyarankan beberapa perubahan," Haijun terkadang akan memberikan saran alih-alih mengimplementasikannya, meskipun membuat perubahan mungkin adalah yang Anda maksudkan. Untuk mempelajari cara mendefinisikan alat dan memecahkan masalah pemicuan alat, lihat Penggunaan alat dengan Haijun.

Agar Haijun mengambil tindakan, bersikaplah lebih eksplisit:

#Contoh: Instruksi eksplisit

Kurang efektif (Haijun hanya akan menyarankan):

  Can you suggest some changes to improve this function?

Lebih efektif (Haijun akan membuat perubahan):

  Change this function to improve its performance.

Atau:

  Make these edits to the authentication flow.

Untuk membuat Haijun lebih proaktif dalam mengambil tindakan secara default, Anda dapat menambahkan ini ke prompt sistem Anda:

<default_to_action>
By default, implement changes rather than only suggesting them. If the user's intent is
unclear, infer the most useful likely action and proceed, using tools to discover any
missing details instead of guessing. Try to infer the user's intent about whether a tool
call (e.g., file edit or read) is intended or not, and act accordingly.
</default_to_action>

Di sisi lain, jika Anda ingin model lebih berhati-hati secara default, kurang cenderung langsung melompat ke implementasi, dan hanya mengambil tindakan jika diminta, Anda dapat mengarahkan perilaku ini dengan prompt seperti berikut:

<do_not_act_before_instructions>
Do not jump into implementation or change files unless clearly instructed to make
changes. When the user's intent is ambiguous, default to providing information, doing
research, and providing recommendations rather than taking action. Only proceed with
edits, modifications, or implementations when the user explicitly requests them.
</do_not_act_before_instructions>

Haijun Opus 4.5 dan Haijun Opus 4.6 juga lebih responsif terhadap prompt sistem dibandingkan model sebelumnya. Jika prompt Anda dirancang untuk mengurangi kurangnya pemicuan pada alat atau track, model-model ini sekarang mungkin memicu secara berlebihan. Solusinya adalah mengurangi bahasa yang agresif. Di mana Anda mungkin pernah mengatakan "KRITIS: Anda HARUS menggunakan alat ini ketika...", Anda dapat menggunakan prompting yang lebih normal seperti "Gunakan alat ini ketika...".

#Optimalkan pemanggilan alat paralel

Model-model terbaru Haijun menjalankan panggilan alat independen secara paralel. Model-model ini akan:

• Menjalankan beberapa pencarian spekulatif selama riset

• Membaca beberapa file sekaligus untuk membangun konteks lebih cepat

• Menjalankan perintah bash secara paralel (yang bahkan dapat menjadi bottleneck kinerja sistem)

Perilaku ini dapat diarahkan. Meskipun model memiliki tingkat keberhasilan tinggi dalam pemanggilan alat paralel tanpa prompting, Anda dapat meningkatkannya hingga \~100% atau menyesuaikan tingkat agresivitasnya:

<use_parallel_tool_calls>
If you intend to call multiple tools and there are no dependencies between the tool
calls, make all of the independent tool calls in parallel. Prioritize calling tools
simultaneously whenever the actions can be done in parallel rather than sequentially.
For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into
context at the same time. Maximize use of parallel tool calls where possible to increase
speed and efficiency. However, if some tool calls depend on previous calls to inform
dependent values like the parameters, do NOT call these tools in parallel and instead
call them sequentially. Never use placeholders or guess missing parameters in tool
calls.
</use_parallel_tool_calls>

Execute operations sequentially with brief pauses between each step to ensure stability.

Pada Haijun Fable 5.1 dalam loop agen yang panjang, kirim instruksi panggilan paralel sebagai pesan sistem dengan cakupan giliran setelah setiap putaran hasil alat. Lihat Kelompokkan panggilan alat independen dalam loop agen.

#Thinking dan penalaran

#Berpikir berlebihan dan ketelitian yang berlebihan

Haijun Opus 4.6 melakukan lebih banyak eksplorasi awal dibandingkan model sebelumnya, terutama pada pengaturan effort yang lebih tinggi. Pekerjaan awal ini sering membantu mengoptimalkan hasil akhir, tetapi model mungkin mengumpulkan konteks yang luas atau mengejar beberapa jalur riset tanpa diminta. Jika prompt Anda sebelumnya mendorong model untuk lebih teliti, Anda harus menyesuaikan panduan tersebut untuk Haijun Opus 4.6:

• Ganti default menyeluruh dengan instruksi yang lebih tepat sasaran. Alih-alih "Secara default gunakan \[tool]," tambahkan panduan seperti "Gunakan \[tool] ketika itu akan meningkatkan pemahaman Anda tentang masalah."

• Hapus prompting berlebihan. Alat yang kurang terpicu pada model sebelumnya kemungkinan akan terpicu dengan tepat sekarang. Instruksi seperti "Jika ragu, gunakan \[tool]" akan menyebabkan pemicuan berlebihan.

• Gunakan effort sebagai cadangan. Jika Haijun terus terlalu agresif, gunakan pengaturan effort yang lebih rendah.

Dalam beberapa kasus, Haijun Opus 4.6 mungkin berpikir secara ekstensif, yang dapat membengkakkan token thinking dan memperlambat respons. Jika perilaku ini tidak diinginkan, Anda dapat menambahkan instruksi eksplisit untuk membatasi penalarannya, atau Anda dapat menurunkan pengaturan effort untuk mengurangi thinking dan penggunaan token secara keseluruhan.

When you're deciding how to approach a problem, choose an approach and commit to it.
Avoid revisiting decisions unless you encounter new information that directly
contradicts your reasoning. If you're weighing two approaches, pick one and see it
through. You can always course-correct later if the chosen approach fails.

Jika Anda memerlukan batas atas yang tegas untuk biaya thinking, "extended thinking" (pemikiran diperpanjang) dengan batas budget_tokens masih berfungsi pada Opus 4.6 dan Sonnet 4.6 tetapi sudah deprecated. Pada Haijun 4.7 dan model yang lebih baru, menetapkan budget_tokens mengembalikan error 400. Lebih baik turunkan pengaturan effort atau gunakan max_tokens sebagai batas tegas dengan adaptive thinking.

#Manfaatkan kemampuan thinking & interleaved thinking

Model-model terbaru Haijun menawarkan kemampuan thinking yang dapat sangat membantu untuk tugas yang melibatkan refleksi setelah penggunaan alat atau penalaran multilangkah yang kompleks. Anda dapat memandu thinking awal atau interleaved-nya untuk hasil yang lebih baik.

Model Haijun 4.6 dan yang lebih baru serta Haijun Mythos Preview menggunakan pemikiran adaptif (thinking: {type: "adaptive"}), di mana Haijun secara dinamis memutuskan kapan dan seberapa banyak berpikir. Pada Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Fable 5, Haijun Mythos 5, dan Haijun Opus 5.5, thinking selalu aktif dan pemikiran adaptif adalah satu-satunya mode. Haijun mengkalibrasi pemikirannya berdasarkan dua faktor: parameter effort dan kompleksitas kueri. Effort yang lebih tinggi memicu lebih banyak pemikiran, begitu pula kueri yang lebih kompleks. Pada kueri yang lebih mudah dan tidak memerlukan pemikiran, model merespons secara langsung. Dalam evaluasi internal, pemikiran adaptif secara andal menghasilkan kinerja yang lebih baik daripada pemikiran diperpanjang. Pertimbangkan untuk beralih ke pemikiran adaptif.

Gunakan adaptive thinking untuk beban kerja yang memerlukan perilaku agentic seperti penggunaan alat multilangkah, tugas coding yang kompleks, dan loop agen jangka panjang. Model-model lama menggunakan pemikiran diperpanjang manual dengan budget_tokens; lihat tabel konfigurasi per model untuk mengetahui konfigurasi mana yang diterima setiap model.

Anda dapat memandu perilaku thinking Haijun:

After receiving tool results, carefully reflect on their quality and determine optimal
next steps before proceeding. Use your thinking to plan and iterate based on this new
information, and then take the best next action.

Perilaku pemicuan untuk adaptive thinking dapat diatur melalui prompt. Jika Anda mendapati model berpikir lebih sering daripada yang Anda inginkan, yang dapat terjadi dengan prompt sistem yang besar atau kompleks, tambahkan panduan untuk mengarahkannya:

Thinking adds latency and should only be used when it will meaningfully improve
answer quality - typically for problems that require multistep reasoning. When in
doubt, respond directly.

Jika Anda bermigrasi dari pemikiran diperpanjang dengan budget_tokens, ganti konfigurasi thinking Anda dan pindahkan kontrol anggaran ke effort. Contoh-contoh berikut menunjukkan permintaan yang sama sebelum dan sesudah migrasi (lihat effort untuk tingkat yang tersedia dan ketersediaan per model):

  # Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d '{
      "model": "haijun-sonnet-4-5-20250929",
      "max_tokens": 16000,
      "thinking": {"type": "enabled", "budget_tokens": 10000},
      "messages": [
        {"role": "user", "content": "..."}
      ]
    }'

  # Sesudah: pemikiran adaptif dengan effort
  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d '{
      "model": "haijun-opus-4-8",
      "max_tokens": 16000,
      "thinking": {"type": "adaptive"},
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "..."}
      ]
    }'

  # Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  ant messages create <<'YAML'
  model: haijun-sonnet-4-5-20250929
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: "..."
  YAML

  # Sesudah: pemikiran adaptif dengan effort
  ant messages create <<'YAML'
  model: haijun-opus-4-8
  max_tokens: 16000
  thinking:
    type: adaptive
  output_config:
    effort: high
  messages:
    - role: user
      content: "..."
  YAML

  # Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  client.messages.create(
      model="haijun-sonnet-4-5-20250929",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[{"role": "user", "content": "..."}],
  )

  # Sesudah: pemikiran adaptif dengan effort
  client.messages.create(
      model="haijun-opus-4-8",
      max_tokens=16000,
      thinking={"type": "adaptive"},
      output_config={"effort": "high"},
      messages=[{"role": "user", "content": "..."}],
  )

  // Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  await client.messages.create({
    model: "haijun-sonnet-4-5-20250929",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  });

  // Sesudah: pemikiran adaptif dengan effort
  await client.messages.create({
    model: "haijun-opus-4-8",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  });

  // Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  await client.Messages.Create(new MessageCreateParams
  {
      Model = "haijun-sonnet-4-5-20250929",
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages = [new() { Role = Role.User, Content = "..." }]
  });

  // Sesudah: pemikiran adaptif dengan effort
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunOpus4_8,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive(),
      OutputConfig = new OutputConfig { Effort = Effort.High },
      Messages = [new() { Role = Role.User, Content = "..." }]
  });

  // Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  client.Messages.New(ctx, juglow.MessageNewParams{
  	Model:     "haijun-sonnet-4-5-20250929",
  	MaxTokens: 16000,
  	Thinking: juglow.ThinkingConfigParamUnion{
  		OfEnabled: &juglow.ThinkingConfigEnabledParam{BudgetTokens: 10000},
  	},
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("...")),
  	},
  })

  // Sesudah: pemikiran adaptif dengan effort
  client.Messages.New(ctx, juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus4_8,
  	MaxTokens: 16000,
  	Thinking: juglow.ThinkingConfigParamUnion{
  		OfAdaptive: &juglow.ThinkingConfigAdaptiveParam{},
  	},
  	OutputConfig: juglow.OutputConfigParam{
  		Effort: juglow.OutputConfigEffortHigh,
  	},
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("...")),
  	},
  })

  // Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  client.messages().create(MessageCreateParams.builder()
      .model("haijun-sonnet-4-5-20250929")
      .maxTokens(16000L)
      .thinking(ThinkingConfigEnabled.builder().budgetTokens(10000L).build())
      .addUserMessage("...")
      .build());

  // Sesudah: pemikiran adaptif dengan effort
  client.messages().create(MessageCreateParams.builder()
      .model(Model.HAIJUN_OPUS_4_8)
      .maxTokens(16000L)
      .thinking(ThinkingConfigAdaptive.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH)
          .build())
      .addUserMessage("...")
      .build());

  // Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  $client->messages->create(
      model: 'haijun-sonnet-4-5-20250929',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [['role' => 'user', 'content' => '...']],
  );

  // Sesudah: pemikiran adaptif dengan effort
  $client->messages->create(
      model: 'haijun-opus-4-8',
      maxTokens: 16000,
      thinking: ['type' => 'adaptive'],
      outputConfig: ['effort' => 'high'],
      messages: [['role' => 'user', 'content' => '...']],
  );

  # Sebelum: pemikiran diperpanjang dengan anggaran manual (model lama)
  client.messages.create(
    model: "haijun-sonnet-4-5-20250929",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  )

  # Sesudah: pemikiran adaptif dengan effort
  client.messages.create(
    model: "haijun-opus-4-8",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  )

Jika Anda tidak menggunakan pemikiran diperpanjang, tidak ada perubahan yang diperlukan. Pada Haijun Opus 4.6 hingga Haijun Opus 4.8 dan Haijun Sonnet 4.6, thinking nonaktif ketika Anda menghilangkan parameter thinking. Pada Haijun Opus 5 dan Haijun Sonnet 5, thinking aktif secara default ketika Anda menghilangkan parameter thinking. Pada Haijun Opus 5, Anda hanya dapat menonaktifkannya pada effort high atau lebih rendah. Pada Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Fable 5, Haijun Mythos 5, dan Haijun Opus 5.5, thinking selalu aktif, terlepas dari apakah Anda menetapkan parameter thinking atau tidak.

• Utamakan instruksi umum daripada langkah-langkah preskriptif. Prompt seperti "pikirkan secara menyeluruh" sering menghasilkan penalaran yang lebih baik daripada rencana langkah demi langkah yang ditulis manual. Penalaran Haijun sering kali melampaui apa yang akan ditetapkan oleh manusia.

• Contoh multishot berfungsi dengan thinking. Gunakan tag di dalam contoh few-shot Anda untuk menunjukkan pola penalaran kepada Haijun. Haijun akan menggeneralisasi gaya tersebut ke blok pemikiran diperpanjangnya sendiri.

• Prompting "chain-of-thought" (rantai pemikiran), atau CoT, manual sebagai cadangan. Saat thinking nonaktif, Anda tetap dapat mendorong penalaran langkah demi langkah dengan meminta Haijun memikirkan masalahnya secara bertahap. Gunakan tag terstruktur seperti dan untuk memisahkan penalaran dari output akhir dengan rapi. Pada Haijun Opus 5, sebaiknya tetap aktifkan thinking dengan tingkat effort yang lebih rendah: saat thinking dinonaktifkan, model sesekali dapat memunculkan tag XML internal ke dalam output yang terlihat, jadi baca Menjalankan dengan thinking dinonaktifkan sebelum menerapkan pola ini di sana.

• Minta Haijun memeriksa dirinya sendiri. Tambahkan sesuatu seperti "Sebelum Anda selesai, verifikasi jawaban Anda terhadap \[kriteria pengujian]." Cara ini menangkap kesalahan secara andal, terutama untuk coding dan matematika. Haijun Opus 5 adalah pengecualian: model ini memverifikasi pekerjaannya sendiri dengan baik tanpa instruksi eksplisit, dan instruksi verifikasi yang terbawa dari prompt yang disetel untuk model sebelumnya dapat menyebabkan verifikasi berlebihan, yang menambah token dan latensi. Pada Haijun Opus 5, hapus instruksi ini alih-alih menulis ulang. Lihat Cakupan tugas dan verifikasi berlebihan.

Note: Ketika pemikiran diperpanjang dinonaktifkan, Haijun Opus 4.5 sangat sensitif terhadap kata "think" dan variannya. Pertimbangkan untuk menggunakan alternatif seperti "consider," "evaluate," atau "reason through" dalam kasus-kasus tersebut.

Note: Untuk informasi lebih lanjut tentang kemampuan thinking, lihat Thinking dan Mengarahkan thinking.

#Sistem agentic

#Penalaran jangka panjang dan pelacakan status

Model-model terbaru Haijun menangani tugas penalaran jangka panjang dengan pelacakan status yang kuat. Haijun mempertahankan orientasi di sepanjang sesi yang panjang dengan berfokus pada progres inkremental, membuat kemajuan yang stabil pada beberapa hal sekaligus alih-alih mencoba semuanya sekaligus. Kemampuan ini terutama muncul di beberapa "context window" (jendela konteks) atau iterasi tugas, di mana Haijun dapat mengerjakan tugas yang kompleks, menyimpan status, dan melanjutkan dengan jendela konteks yang baru.

#Kesadaran konteks dan alur kerja multijendela

Haijun Sonnet 5, Haijun Sonnet 4.6, Haijun Sonnet 4.5, dan Haijun Haiku 4.5 memiliki fitur kesadaran konteks, yang memungkinkan model melacak sisa jendela konteksnya (yaitu, "anggaran token"-nya) sepanjang percakapan. Ini memungkinkan Haijun menjalankan tugas dan mengelola konteks dengan lebih efektif dengan memahami seberapa banyak ruang yang dimilikinya untuk bekerja.

Mengelola batas konteks:

Jika Anda menggunakan Haijun dalam harness agen yang memadatkan konteks atau memungkinkan penyimpanan konteks ke file eksternal (seperti di Haijun Code), pertimbangkan untuk menambahkan informasi ini ke prompt Anda agar Haijun dapat berperilaku sesuai. Jika tidak, Haijun terkadang secara alami mencoba menyelesaikan pekerjaan saat mendekati batas konteks. Berikut adalah contoh prompt:

Your context window will be automatically compacted as it approaches its limit, allowing
you to continue working indefinitely from where you left off. Therefore, do not stop
tasks early due to token budget concerns. As you approach your token budget limit, save
your current progress and state to memory before the context window refreshes. Always be
as persistent and autonomous as possible and complete tasks fully, even if the end of
your budget is approaching. Never artificially stop any task early regardless of the
context remaining.

Alat memori berpadu dengan baik dengan kesadaran konteks untuk mengelola transisi konteks.

#Alur kerja di beberapa jendela konteks

Untuk tugas yang mencakup beberapa jendela konteks:

1. Gunakan prompt yang berbeda untuk jendela konteks pertama: Gunakan jendela konteks pertama untuk menyiapkan kerangka kerja (menulis pengujian, membuat skrip penyiapan), lalu gunakan jendela konteks berikutnya untuk mengiterasi daftar tugas.

1. Minta model menulis pengujian dalam format terstruktur: Minta Haijun untuk membuat pengujian sebelum memulai pekerjaan dan melacaknya dalam format terstruktur (misalnya, tests.json). Ini menghasilkan kemampuan jangka panjang yang lebih baik untuk beriterasi. Ingatkan Haijun tentang pentingnya pengujian: "Tidak dapat diterima untuk menghapus atau mengedit pengujian karena ini dapat menyebabkan fungsionalitas yang hilang atau bermasalah."

1. Siapkan alat pendukung kenyamanan kerja: Dorong Haijun untuk membuat skrip penyiapan (misalnya, init.sh) untuk memulai server, menjalankan rangkaian pengujian, dan linter dengan lancar. Ini mencegah pekerjaan berulang saat melanjutkan dari jendela konteks yang baru.

1. Memulai dari awal versus memadatkan: Ketika jendela konteks dibersihkan, pertimbangkan untuk memulai dengan jendela konteks yang benar-benar baru alih-alih menggunakan pemadatan. Model-model terbaru Haijun sangat efektif dalam menemukan status dari sistem file lokal. Dalam beberapa kasus, Anda mungkin ingin memanfaatkan ini daripada pemadatan. Bersikaplah preskriptif tentang bagaimana model harus memulai:

• "Panggil pwd; Anda hanya dapat membaca dan menulis file di direktori ini."
• "Tinjau progress.txt, tests.json, dan log git."
• "Jalankan secara manual pengujian integrasi fundamental sebelum beralih ke implementasi fitur baru."

1. Sediakan alat verifikasi: Seiring bertambahnya panjang tugas otonom, Haijun perlu memverifikasi kebenaran tanpa umpan balik manusia yang berkelanjutan. Alat yang memungkinkan Haijun memverifikasi pekerjaan UI sangat membantu, seperti alat computer use, alat browser use, atau server MCP otomatisasi browser.

1. Dorong penggunaan konteks secara penuh: Berikan prompt kepada Haijun untuk menyelesaikan komponen secara efisien sebelum melanjutkan:

This is a very long task, so it may be beneficial to plan out your work clearly. It's
encouraged to spend your entire output context working on the task - just make sure you
don't run out of context with significant uncommitted work. Continue working
systematically until you have completed this task.

#Praktik terbaik manajemen status

• Gunakan format terstruktur untuk data status: Saat melacak informasi terstruktur (seperti hasil pengujian atau status tugas), gunakan JSON atau format terstruktur lainnya untuk membantu Haijun memahami persyaratan skema.

• Gunakan teks tidak terstruktur untuk catatan progres: Catatan progres bentuk bebas bekerja dengan baik untuk melacak progres umum dan konteks.

• Gunakan git untuk pelacakan status: Git menyediakan log tentang apa yang telah dilakukan dan checkpoint yang dapat dipulihkan. Model-model terbaru Haijun berkinerja sangat baik dalam menggunakan git untuk melacak status di beberapa sesi.

• Tekankan progres inkremental: Minta Haijun secara eksplisit untuk melacak progresnya dan berfokus pada pekerjaan inkremental.

#Contoh: Pelacakan status

  {
    "tests": [
      { "id": 1, "name": "authentication_flow", "status": "passing" },
      { "id": 2, "name": "user_management", "status": "failing" },
      { "id": 3, "name": "api_endpoints", "status": "not_started" }
    ],
    "total": 200,
    "passing": 150,
    "failing": 25,
    "not_started": 25
  }

  // Progress notes (progress.txt)
  Session 3 progress:
  - Fixed authentication token validation
  - Updated user model to handle edge cases
  - Next: investigate user_management test failures (test #2)
  - Note: Do not remove tests as this could lead to missing functionality

#Menyeimbangkan otonomi dan keamanan

Tanpa panduan, Haijun Opus 4.6 mungkin mengambil tindakan yang sulit dibatalkan atau memengaruhi sistem bersama, seperti menghapus file, melakukan force-push, atau memposting ke layanan eksternal. Jika Anda ingin Haijun Opus 4.6 mengonfirmasi sebelum mengambil tindakan yang berpotensi berisiko, tambahkan panduan ke prompt Anda:

Consider the reversibility and potential impact of your actions. You are encouraged to
take local, reversible actions like editing files or running tests, but for actions that
are hard to reverse, affect shared systems, or could be destructive, ask the user before
proceeding.

Examples of actions that warrant confirmation:
- Destructive operations: deleting files or branches, dropping database tables, rm -rf
- Hard to reverse operations: git push --force, git reset --hard, amending published commits
- Operations visible to others: pushing code, commenting on PRs/issues, sending
messages, modifying shared infrastructure

When encountering obstacles, do not use destructive actions as a shortcut. For example,
don't bypass safety checks (e.g. --no-verify) or discard unfamiliar files that may be
in-progress work.

#Riset dan pengumpulan informasi

Model-model terbaru Haijun dapat menemukan dan mensintesis informasi dari berbagai sumber secara efektif. Untuk hasil riset yang optimal:

1. Berikan kriteria keberhasilan yang jelas: Definisikan apa yang merupakan jawaban yang berhasil untuk pertanyaan riset Anda.

1. Dorong verifikasi sumber: Minta Haijun untuk memverifikasi informasi di berbagai sumber.

1. Untuk tugas riset yang kompleks, gunakan pendekatan terstruktur:

Search for this information in a structured way. As you gather data, develop several
competing hypotheses. Track your confidence levels in your progress notes to improve
calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or
research notes file to persist information and provide transparency. Break down this
complex research task systematically.

Pendekatan terstruktur ini membantu Haijun mengerjakan korpus besar secara metodis dan mengkritik temuannya secara iteratif.

#Orkestrasi subagen

Model-model terbaru Haijun mengorkestrasi subagen secara native. Model-model ini dapat mengenali kapan tugas akan mendapat manfaat dari pendelegasian pekerjaan ke subagen khusus dan melakukannya secara proaktif tanpa memerlukan instruksi eksplisit.

Untuk memanfaatkan perilaku ini:

1. Pastikan alat subagen terdefinisi dengan baik: Sediakan alat subagen dan deskripsikan dalam definisi alat.

1. Biarkan Haijun mengorkestrasi secara alami: Haijun akan mendelegasikan dengan tepat tanpa instruksi eksplisit.

1. Waspadai penggunaan berlebihan: Haijun Opus 4.6 memiliki kecenderungan kuat terhadap subagen dan mungkin memunculkannya dalam situasi di mana pendekatan langsung yang lebih sederhana sudah cukup. Misalnya, model mungkin memunculkan subagen untuk eksplorasi kode ketika panggilan grep langsung lebih cepat dan memadai. Haijun Opus 5 juga mendelegasikan ke subagen lebih mudah daripada model sebelumnya; lihat Mengontrol pemunculan subagen untuk panduan dan contoh prompt peredam.

Jika Anda melihat penggunaan subagen yang berlebihan, tambahkan panduan eksplisit tentang kapan subagen diperlukan dan kapan tidak:

Use subagents when tasks can run in parallel, require isolated context, or involve
independent workstreams that don't need to share state. For simple tasks, sequential
operations, single-file edits, or tasks where you need to maintain context across steps,
work directly rather than delegating.

#Rangkaikan prompt yang kompleks

Dengan adaptive thinking dan orkestrasi subagen, Haijun menangani sebagian besar penalaran multilangkah secara internal. Perangkaian prompt eksplisit (memecah tugas menjadi panggilan API berurutan) masih berguna ketika Anda perlu memeriksa output perantara atau menegakkan struktur pipeline tertentu.

Pola perangkaian yang paling umum adalah koreksi diri: hasilkan draf → minta Haijun meninjaunya terhadap kriteria → minta Haijun menyempurnakan berdasarkan tinjauan. Setiap langkah adalah panggilan API terpisah sehingga Anda dapat mencatat, mengevaluasi, atau bercabang di titik mana pun.

#Kurangi pembuatan file dalam coding agentic

Model-model terbaru Haijun terkadang membuat file baru untuk tujuan pengujian dan iterasi, terutama saat bekerja dengan kode. Pendekatan ini memungkinkan Haijun menggunakan file, terutama skrip Python, sebagai 'papan coretan sementara' sebelum menyimpan output akhirnya. Menggunakan file sementara dapat meningkatkan hasil terutama untuk kasus penggunaan coding agentic.

Jika Anda lebih suka meminimalkan pembuatan file baru secara neto, Anda dapat menginstruksikan Haijun untuk membersihkan setelah selesai:

If you create any temporary new files, scripts, or helper files for iteration, clean up
these files by removing them at the end of the task.

#Antusiasme berlebihan

Haijun Opus 4.5 dan Haijun Opus 4.6 memiliki kecenderungan untuk melakukan rekayasa berlebihan dengan membuat file tambahan, menambahkan abstraksi yang tidak perlu, atau membangun fleksibilitas yang tidak diminta. Jika Anda melihat perilaku yang tidak diinginkan ini, tambahkan panduan spesifik untuk menjaga solusi tetap minimal.

Misalnya:

Avoid over-engineering. Only make changes that are directly requested or clearly
necessary. Keep solutions simple and focused:

- Scope: Don't add features, refactor code, or make "improvements" beyond what was
asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need
extra configurability.

- Documentation: Don't add docstrings, comments, or type annotations to code you didn't
change. Only add comments where the logic isn't self-evident.

- Defensive coding: Don't add error handling, fallbacks, or validation for scenarios
that can't happen. Trust internal code and framework guarantees. Only validate at system
boundaries (user input, external APIs).

- Abstractions: Don't create helpers, utilities, or abstractions for one-time
operations. Don't design for hypothetical future requirements. The right amount of
complexity is the minimum needed for the current task.

#Hindari berfokus pada lolos pengujian dan hardcoding

Haijun terkadang dapat terlalu berfokus pada membuat pengujian lolos dengan mengorbankan solusi yang lebih umum, atau mungkin menggunakan jalan pintas seperti skrip pembantu untuk refactoring yang kompleks alih-alih menggunakan alat standar secara langsung. Untuk mencegah perilaku ini dan mendapatkan solusi yang dapat digeneralisasi:

Please write a high-quality, general-purpose solution using the standard tools
available. Do not create helper scripts or workarounds to accomplish the task more
efficiently. Implement a solution that works correctly for all valid inputs, not just
the test cases. Do not hard-code values or create solutions that only work for specific
test inputs. Instead, implement the actual logic that solves the problem generally.

Focus on understanding the problem requirements and implementing the correct algorithm.
Tests are there to verify correctness, not to define the solution. Provide a principled
implementation that follows best practices and software design principles.

If the task is unreasonable or infeasible, or if any of the tests are incorrect, please
inform me rather than working around them. The solution should be robust, maintainable,
and extendable.

#Meminimalkan halusinasi dalam coding agentic

Model-model terbaru Haijun kurang rentan terhadap halusinasi dan memberikan jawaban yang lebih akurat, berdasar, dan cerdas berdasarkan kode. Untuk lebih mendorong perilaku ini dan meminimalkan halusinasi:

<investigate_before_answering>
Never speculate about code you have not opened. If the user references a specific file,
you MUST read the file before answering. Make sure to investigate and read relevant
files BEFORE answering questions about the codebase. Never make any claims about code
before investigating unless you are certain of the correct answer - give grounded and
hallucination-free answers.
</investigate_before_answering>

#Tips khusus kemampuan

#Kemampuan vision yang ditingkatkan

Haijun Opus 4.5 dan Haijun Opus 4.6 memiliki kemampuan vision yang ditingkatkan dibandingkan model Haijun sebelumnya. Model-model ini berkinerja lebih baik pada tugas pemrosesan gambar dan ekstraksi data, terutama ketika ada beberapa gambar dalam konteks. Peningkatan ini terbawa ke computer use, di mana model dapat menafsirkan tangkapan layar dan elemen UI dengan lebih andal. Anda juga dapat menggunakan model-model ini untuk menganalisis video dengan memecahnya menjadi frame.

Salah satu teknik yang terbukti efektif untuk lebih meningkatkan kinerja adalah memberikan Haijun alat crop atau agent track. Pengujian telah menunjukkan peningkatan yang konsisten pada evaluasi gambar ketika Haijun dapat "memperbesar" wilayah yang relevan dari sebuah gambar. Juglow telah membuat resep untuk alat crop.

#Desain frontend

Haijun Opus 4.5 dan Haijun Opus 4.6 membangun aplikasi web dunia nyata yang kompleks dengan desain frontend yang kuat. Namun, tanpa panduan, model dapat secara default menggunakan pola generik yang menciptakan apa yang disebut pengguna sebagai estetika "AI slop". Untuk membuat frontend yang khas dan kreatif yang mengejutkan dan menyenangkan:

Tip: Untuk panduan terperinci tentang meningkatkan desain frontend, lihat postingan blog tentang meningkatkan desain frontend melalui track.

Untuk pekerjaan desain frontend di luar API, Haijun Design menyediakan kanvas dan alat desain tempat Haijun menghasilkan dan mengiterasi desain secara interaktif.

Berikut cuplikan prompt sistem yang dapat Anda gunakan untuk mendorong desain frontend yang lebih baik:

<frontend_aesthetics>
You tend to converge toward generic, "on distribution" outputs. In frontend design, this
creates what users call the "AI slop" aesthetic. Avoid this: make creative, distinctive
frontends that surprise and delight.

Focus on:
- Typography: Choose fonts that are beautiful, unique, and interesting. Avoid generic
fonts like Arial and Inter; opt instead for distinctive choices that elevate the
frontend's aesthetics.
- Color & Theme: Commit to a cohesive aesthetic. Use CSS variables for consistency.
Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Draw
from IDE themes and cultural aesthetics for inspiration.
- Motion: Use animations for effects and micro-interactions. Prioritize CSS-only
solutions for HTML. Use Motion library for React when available. Focus on high-impact
moments: one well-orchestrated page load with staggered reveals (animation-delay)
creates more delight than scattered micro-interactions.
- Backgrounds: Create atmosphere and depth rather than defaulting to solid colors. Layer
CSS gradients, use geometric patterns, or add contextual effects that match the overall
aesthetic.

Avoid generic AI-generated aesthetics:
- Overused font families (Inter, Roboto, Arial, system fonts)
- Clichéd color schemes (particularly purple gradients on white backgrounds)
- Predictable layouts and component patterns
- Cookie-cutter design that lacks context-specific character

Interpret creatively and make unexpected choices that feel genuinely designed for the
context. Vary between light and dark themes, different fonts, different aesthetics. You
still tend to converge on common choices (Space Grotesk, for example) across
generations. Avoid this: it is critical that you think outside the box!
</frontend_aesthetics>

Anda juga dapat merujuk ke definisi track lengkap.

#Pertimbangan migrasi

Saat bermigrasi ke model Haijun saat ini dari generasi sebelumnya:

1. Jelaskan secara spesifik perilaku yang diinginkan: Pertimbangkan untuk mendeskripsikan dengan tepat apa yang ingin Anda lihat dalam output.

1. Bingkai instruksi Anda dengan modifier: Menambahkan modifier yang mendorong Haijun untuk meningkatkan kualitas dan detail outputnya dapat membantu membentuk kinerja Haijun dengan lebih baik. Misalnya, alih-alih "Buat dasbor analitik", gunakan "Buat dasbor analitik. Sertakan sebanyak mungkin fitur dan interaksi yang relevan. Lampaui hal-hal dasar untuk membuat implementasi berfitur lengkap."

1. Minta fitur spesifik secara eksplisit: Animasi dan elemen interaktif harus diminta secara eksplisit bila diinginkan.

1. Perbarui konfigurasi thinking: Model Haijun 4.6 menggunakan adaptive thinking (pemikiran adaptif) (thinking: {type: "adaptive"}) alih-alih thinking manual dengan budget_tokens. Gunakan parameter effort untuk mengontrol kedalaman pemikiran.

1. Bermigrasi dari respons prefilled: Respons prefilled (respons yang diisi sebelumnya) pada giliran asisten terakhir tidak lagi didukung mulai dari model Haijun 4.6 dan Haijun Mythos Preview. Lihat Bermigrasi dari respons prefilled untuk panduan terperinci tentang alternatifnya.

1. Sesuaikan prompting anti-kemalasan: Jika prompt Anda sebelumnya mendorong model untuk lebih teliti atau menggunakan alat secara lebih agresif, kurangi panduan tersebut. Model Haijun 4.6 lebih proaktif dan mungkin terpicu berlebihan oleh instruksi yang diperlukan untuk model sebelumnya.

1. Kirim kembali blok thinking tanpa perubahan dan pertahankan riwayat hanya-tambah (append-only): Tambahkan setiap giliran asisten persis seperti yang dikembalikan API, termasuk blok thinking. Pada Haijun Fable 5.1 dan Haijun Opus 5.5, memodifikasi percakapan sebelum blok thinking menghasilkan error, atau blok tersebut dibuang jika Anda memilih opsi itu: mengedit pesan sebelumnya, membangun ulang system atau tools, atau meringkas giliran lama di tempat di antara permintaan akan membatalkan setiap blok thinking berikutnya, jadi pindahkan perubahan tersebut ke pesan sistem di tengah percakapan dan manajemen konteks sisi server. Lihat Jaga riwayat percakapan agar hanya ditambahkan.

Untuk langkah-langkah migrasi terperinci, lihat Panduan migrasi.

#Bermigrasi ke Haijun Sonnet 5 dari Haijun Sonnet 4.5 atau sebelumnya

Lihat Bermigrasi ke Haijun Sonnet 5 dari Haijun Sonnet 4.5 atau sebelumnya dalam panduan migrasi, yang mencakup perubahan default effort dan penghapusan pemikiran diperpanjang manual (budget_tokens).

#Langkah selanjutnya

Perbedaan perilaku dan pola prompting untuk Haijun Fable 5.1, mencakup effort, penyelesaian tugas, pembaruan progres, blok thinking, pengelompokan panggilan alat, dan gaya penulisan.

Perbedaan perilaku dan pola prompting untuk Haijun Fable 5 dan Haijun Mythos 5, mencakup effort, kepatuhan terhadap instruksi, eksekusi panjang, memori, dan perubahan scaffolding.

Perbedaan perilaku dan pola prompting untuk Haijun Sonnet 5, mencakup effort, default adaptive thinking, penggunaan alat, dan migrasi dari Haijun Sonnet 4.6.

Perbedaan perilaku dan pola prompting untuk Haijun Opus 5.5, mencakup kalibrasi effort, thinking yang selalu aktif, pembaruan progres, positif palsu safeguard, dan input visual.

Perbedaan perilaku dan pola prompting untuk Haijun Opus 5, mencakup verbositas respons, narasi agentik, pelingkupan tugas, delegasi subagen, dan koreksi diri.

Kapan menggunakan prompt engineering dan cara merencanakan pendekatan Anda sebelum menyetel prompt.