Saya Menghabiskan Dua Tahun Mempelajari AI Prompts dan Inilah Yang Mengubah Segalanya

Kebangkitan: Bila Prompts Mudah Berhenti Berfungsi

Ia berlaku di tengah-tengah tarikh akhir projek. Saya memerlukan AI untuk membantu saya refactor kod kompleks—sesuatu yang telah saya lakukan beratus kali sebelum ini. Tetapi kali ini, tidak kira bagaimana saya merumuskan permintaan, AI terus memberikan penyelesaian yang secara teknikal betul tetapi benar-benar tersasar. Ia menambah kerumitan yang tidak perlu. Ia memecahkan patterns sedia ada. Ia "membetulkan" perkara yang tidak rosak.

Saya kecewa. Kemudian saya menjadi ingin tahu. Apa yang saya buat salah?

Kekecewaan itu membawa saya ke rabbit hole yang mengubah segalanya: dokumentasi rasmi, kertas penyelidikan, panduan prompt engineering, dan beribu jam eksperimen. Apa yang saya jumpa bukan sekadar tips dan tricks—ia adalah perubahan paradigma lengkap dalam cara saya berkomunikasi dengan sistem AI.

Inilah kebenaran yang tiada siapa beritahu pemula: prompting bukan tentang mencari perkataan ajaib. Ia tentang memahami bagaimana model AI memproses bahasa, maklumat apa yang mereka perlukan, dan bagaimana menyusun maklumat itu supaya model boleh membantu anda dengan berkesan. Ia adalah kemahiran—dan seperti mana-mana kemahiran, ia boleh dipelajari, dipraktikkan dan dikuasai.

Panduan ini mengandungi semua yang saya harap seseorang beritahu saya pada permulaan. Bukan nasihat ringkas "be specific" yang memenuhi internet, tetapi pemahaman mendalam dan terperinci yang membezakan mereka yang menggunakan AI daripada mereka yang memanfaatkannya.

Asas Prompts: Asas Yang Tiada Siapa Mengajar

Sebelum kita menyelami teknik lanjutan, mari kita tetapkan asas. Setiap prompt yang berkesan mengandungi beberapa kombinasi elemen-elemen ini:

Kebanyakan orang hanya memasukkan tugas. Mereka bertanya "Tuliskan email untuk saya" sedangkan sepatutnya "Tulis email profesional kepada klien menerangkan kelewatan projek. Kekalkan di bawah 150 patah perkataan, akui kesulitan, dan cadangkan tarikh akhir baharu dua minggu ke hadapan. Nada harus memohon maaf tetapi yakin."

Perbezaan kualiti output sangat ketara. Dan itu baru permulaan.

Peranan Struktur

Salah satu aspek penulisan prompt yang paling dipandang remeh ialah pemformatan struktur. Model AI moden bertindak balas dengan sangat baik kepada bahagian yang dibataskan dengan jelas. Saya menggunakan tag gaya XML secara meluas:

<context>
You are helping me prepare a presentation for technical stakeholders.
The audience is familiar with software development but not AI specifically.
</context>

<task>
Explain how large language models work in 5 key points.
</task>

<format>
- Use bullet points
- Each point should be 1-2 sentences
- Avoid jargon or define it when used
</format>

<constraints>
- Do not mention specific model names
- Focus on concepts, not technical implementation
</constraints>

Struktur ini melakukan sesuatu yang berkuasa: ia memaksa anda untuk berfikir dengan jelas tentang apa yang anda perlukan sebelum bertanya. Dan pemikiran yang jelas membawa kepada komunikasi yang jelas yang membawa kepada hasil yang jelas.

Agentic Workflows: Melayan AI Seperti Rakan Sekerja

Inilah perubahan paradigma yang mengubah interaksi AI saya: saya berhenti melayan AI sebagai enjin carian dan mula melayannya sebagai rakan sekerja yang berkebolehan tetapi tidak berpengalaman. Model mental ini mengubah segalanya.

Model AI moden seperti GPT-5 dan Claude bukan sekadar menjawab soalan—mereka direka untuk menjadi agents. Mereka boleh memanggil tools, mengumpul konteks, membuat keputusan, dan melaksanakan tugas berbilang langkah. Tetapi seperti mana-mana ahli pasukan baharu, mereka memerlukan onboarding yang betul, jangkaan yang jelas dan guardrails yang sesuai.

Fikirkan: bila anda mewakilkan kepada manusia, anda tidak sekadar berkata "betulkan kod." Anda menjelaskan apa yang rosak, apa perilaku yang dikehendaki, kekangan apa yang wujud, dan rupa kejayaan. Anda memberikan konteks. Anda menjawab soalan. Anda memeriksa kemajuan.

AI memerlukan layanan yang sama. Perbezaannya ialah anda perlu menjangka soalan dan menjawabnya terlebih dahulu, kerana interaksi berulang lebih mahal (dari segi masa dan tokens) berbanding melakukannya dengan betul kali pertama.

Mentaliti Agentic

Bila membina aplikasi agentic atau menggunakan AI untuk tugas kompleks, saya telah belajar berfikir dari segi:

Soalan-soalan ini membentuk asas setiap prompt kompleks yang saya tulis. Mari kita terokai setiap dimensi secara terperinci.

Kawalan Kesungguhan AI: Seni Penentukuran

Salah satu aspek prompt engineering yang paling halus ialah menentukur apa yang saya panggil "kesungguhan agentic"—keseimbangan antara AI yang mengambil inisiatif dan AI yang menunggu panduan eksplisit. Silap di sini, dan anda mendapat AI yang berfikir berlebihan tugas mudah atau yang menyerah terlalu mudah pada yang kompleks.

Bila Mengurangkan Kesungguhan

Kadangkala anda memerlukan AI yang pantas dan fokus. Anda tidak mahu ia meneroka setiap cabang, membuat tool calls tambahan, atau menghasilkan penjelasan panjang lebar. Untuk situasi ini, saya menggunakan prompt berfokus kekangan:

<context_gathering>
Goal: Get enough context fast. Parallelize discovery and stop as soon as you can act.

Method:
- Start broad, then fan out to focused subqueries.
- In parallel, launch varied queries; read top hits per query.
- Deduplicate paths and cache; don't repeat queries.
- Avoid over-searching for context.

Early stop criteria:
- You can name exact content to change.
- Top hits converge (~70%) on one area/path.

Depth:
- Trace only symbols you'll modify or whose contracts you rely on.
- Avoid transitive expansion unless necessary.

Loop:
- Batch search → minimal plan → complete task.
- Search again only if validation fails or new unknowns appear.
- Prefer acting over more searching.
</context_gathering>

Perhatikan kebenaran eksplisit untuk ketidaksempurnaan: "Prefer acting over more searching." Frasa halus ini membebaskan AI daripada kerisauan lalai tentang kelengkapan. Tanpanya, model sering mencari berlebihan, membakar tokens dan masa pada pulangan yang semakin berkurangan.

Untuk kekangan yang lebih agresif, anda boleh menetapkan budget eksplisit:

<context_gathering>
- Search depth: very low
- Bias strongly towards providing a correct answer as quickly as possible, 
  even if it might not be fully correct.
- Usually, this means an absolute maximum of 2 tool calls.
- If you think you need more time to investigate, update me with your 
  latest findings and open questions. You can proceed if I confirm.
</context_gathering>

Bila Meningkatkan Kesungguhan

Pada masa lain, anda memerlukan AI yang tidak kenal penat dan teliti. Anda mahu ia menolak melalui ketidakpastian, membuat andaian yang munasabah, dan menyelesaikan tugas kompleks tanpa terus meminta kebenaran. Ini memerlukan pendekatan terbalik:

<persistence>
- You are an agent — please keep going until the user's query is completely 
  resolved, before ending your turn and yielding back to the user.
- Only terminate your turn when you are sure that the problem is solved.
- Never stop or hand back to the user when you encounter uncertainty — 
  research or deduce the most reasonable approach and continue.
- Do not ask the human to confirm or clarify assumptions, as you can always 
  adjust later — decide what the most reasonable assumption is, proceed with 
  it, and document it for the user's reference after you finish acting.
</persistence>

Prompt ini secara asas mengubah tingkah laku AI. Daripada bertanya "Boleh saya teruskan?", ia berkata "Saya meneruskan berdasarkan andaian X—maklumkan jika anda mahu saya menyesuaikan." Kerja selesai; penambahbaikan datang kemudian.

Menetapkan Guardrails Keselamatan

Tetapi inilah butiran kritikal: kesungguhan yang meningkat memerlukan guardrails keselamatan yang lebih jelas. Anda perlu menyatakan secara eksplisit tindakan mana AI boleh lakukan secara autonomi dan mana yang memerlukan pengesahan.

Fikirkan seperti memberi seseorang akses kepada sistem anda: search tools harus mempunyai threshold autonomi yang sangat tinggi, manakala arahan delete harus mempunyai threshold yang sangat rendah.

Prinsip Keteguhan: Membuat AI Menyelesaikan Tugas

Salah satu tingkah laku paling mengecewakan yang saya temui awal ialah AI yang menyerah terlalu mudah. Ia menemui halangan, merumuskan apa yang silap, dan menyerahkan masalah kembali kepada saya. Untuk tugas mudah, ini okay. Untuk tugas kompleks, ia adalah workflow-killer.

Penyelesaiannya adalah apa yang saya panggil Prinsip Keteguhan: secara eksplisit mengarahkan AI untuk bertahan melampaui halangan dan menyelesaikan tugas dari awal hingga akhir.

<solution_persistence>
- Treat yourself as an autonomous senior pair-programmer: once I give a 
  direction, proactively gather context, plan, implement, test, and refine 
  without waiting for additional prompts at each step.
- Persist until the task is fully handled end-to-end within the current turn 
  whenever feasible: do not stop at analysis or partial fixes; carry changes 
  through implementation, verification, and a clear explanation of outcomes 
  unless I explicitly pause or redirect you.
- Be extremely biased for action. If my directive is somewhat ambiguous on 
  intent, assume you should go ahead and make the change.
- If I ask a question like "should we do X?" and your answer is "yes", you 
  should also go ahead and perform the action. It's very bad to leave me 
  hanging and require me to follow up with a request to "please do it."
</solution_persistence>

Poin terakhir itu halus tetapi penting. Bila manusia bertanya "patut kita buat X?", kita sering bermaksud "sila lakukan X jika ia masuk akal." AI, kerana literal, menjawab soalan tanpa melakukan tindakan yang tersirat. Prompt ini merapatkan jurang.

Kemas Kini Kemajuan: Kekal Dalam Loop

Keteguhan tidak bermakna senyap. Untuk tugas yang mengambil masa, saya sentiasa menyertakan arahan untuk kemas kini kemajuan:

<user_updates_spec>
You'll work for stretches with tool calls — it's critical to keep me updated.

<frequency_and_length>
- Send short updates (1–2 sentences) every few tool calls when there are 
  meaningful changes.
- Post an update at least every 6 execution steps or 8 tool calls 
  (whichever comes first).
- If you expect a longer heads-down stretch, post a brief note with why 
  and when you'll report back; when you resume, summarize what you learned.
- Only the initial plan, plan updates, and final recap can be longer.
</frequency_and_length>

<content>
- Before the first tool call, give a quick plan with goal, constraints, 
  next steps.
- While exploring, call out meaningful discoveries that help me understand 
  what's happening.
- Always state at least one concrete outcome since the prior update 
  (e.g., "found X", "confirmed Y"), not just next steps.
- End with a brief recap and any follow-up steps.
</content>
</user_updates_spec>

Ini mewujudkan keseimbangan yang indah: AI bekerja secara autonomi tetapi memastikan anda dikemas kini. Anda tidak micromanaging, tetapi anda juga tidak dalam kegelapan.

Usaha Penaakulan: Butang Intensiti Pemikiran

Model AI moden mempunyai konsep yang dipanggil "reasoning effort"—pada dasarnya, betapa keras model berfikir sebelum menjawab. Ini adalah salah satu parameter paling berkuasa dan kurang digunakan yang tersedia.

Wawasan utama ialah memadankan usaha penaakulan dengan kerumitan tugas. Menggunakan penaakulan tinggi untuk tugas mudah membazir tokens dan masa. Menggunakan penaakulan rendah untuk tugas kompleks menghasilkan hasil cetek yang terdedah kepada ralat.

Prompting untuk Penaakulan Minimum

Bila menggunakan mod penaakulan minimum, anda perlu mengimbangi dengan prompting yang lebih eksplisit. Model mempunyai kurang tokens "thinking" dalaman, jadi prompt anda perlu melakukan lebih banyak kerja penstrukturan:

<planning_requirement>
You MUST plan extensively before each function call, and reflect extensively 
on the outcomes of the previous function calls, ensuring my query is 
completely resolved.

DO NOT do this entire process by making function calls only, as this can 
impair your ability to solve the problem and think insightfully. In addition, 
ensure function calls have the correct arguments.
</planning_requirement>

Prompt ini pada dasarnya berkata: "Memandangkan anda tidak banyak melakukan penaakulan dalaman, lakukan penaakulan anda dengan lantang dalam jawapan anda." Ini memindahkan kerja kognitif daripada pemikiran tersembunyi model kepada perancangan yang kelihatan dan berstruktur.

Kecemerlangan Kod: Pengaturcaraan dengan AI Partner

Di sinilah saya menghabiskan paling banyak masa mengoptimumkan prompts, dan di sinilah hasilnya paling dramatik. AI coding assistance adalah transformatif—bila dilakukan dengan betul. Bila dilakukan salah, ia mencipta lebih banyak masalah berbanding yang diselesaikan.

Izinkan saya berkongsi apa yang saya pelajari daripada mengkaji bagaimana AI coding tools profesional seperti Cursor mengkonfigurasi prompts mereka untuk kegunaan produksi.

Paradoks Perincian

Ini adalah sesuatu yang berlawanan intuisi: AI cenderung bertele-tele dalam penjelasan tetapi ringkas dalam kod. Ia akan menulis perenggan menerangkan apa yang akan dilakukannya, dan kemudian menghasilkan kod dengan nama pembolehubah satu huruf dan komen minimum. Ini betul-betul bertentangan dengan apa yang kita mahu dalam kebanyakan kes.

Penyelesaiannya adalah kawalan perincian dwi:

<code_verbosity>
Write code for clarity first. Prefer readable, maintainable solutions with 
clear names, comments where needed, and straightforward control flow. Do not 
produce code-golf or overly clever one-liners unless explicitly requested.

Use high verbosity for writing code and code tools. Use low verbosity for 
status updates and explanations.
</code_verbosity>

Ini mewujudkan keseimbangan sempurna: komunikasi ringkas, kod terperinci.

Tindakan Proaktif vs Pengesahan

Satu lagi pelajaran daripada coding tools produksi: AI harus proaktif untuk perubahan kod tetapi memerlukan pengesahan untuk tindakan pemusnahan. Begini cara anda mengekodkannya:

<proactive_coding>
Be aware that the code edits you make will be displayed to me as proposed 
changes, which means:
(a) Your code edits can be quite proactive, as I can always reject them.
(b) Your code should be well-written and easy to quickly review.

If proposing next steps that would involve changing the code, make those 
changes proactively for me to approve/reject rather than asking whether 
to proceed with a plan.

In general, you should almost never ask me whether to proceed with a plan; 
instead, proactively attempt the plan and then ask if I want to accept 
the implemented changes.
</proactive_coding>

Ini menghapuskan interaksi berulang yang mengecewakan di mana AI menerangkan apa yang akan dilakukannya, meminta kebenaran, dan kemudian melakukannya. Lakukannya sahaja—saya akan menolak jika perlu.

Memadankan Gaya Codebase

Salah satu aduan terbesar tentang kod yang dijana AI ialah ia tidak sepadan dengan patterns codebase sedia ada. Ia kelihatan "asing". Penyelesaiannya adalah arahan gaya eksplisit:

<code_editing_rules>
<guiding_principles>
- Clarity and Reuse: Every component should be modular and reusable. 
  Avoid duplication by factoring repeated patterns into components.
- Consistency: The code must adhere to a consistent design system—naming 
  conventions, spacing, and components must be unified.
- Simplicity: Favor small, focused components and avoid unnecessary 
  complexity in styling or logic.
- Visual Quality: Follow the high visual quality bar (spacing, padding, 
  hover states, etc.)
</guiding_principles>

<style_matching>
- Before making changes, examine existing patterns in the codebase.
- Match variable naming conventions (camelCase vs snake_case).
- Match indentation and formatting.
- Reuse existing utilities and helpers rather than creating new ones.
- Follow the established directory structure.
</style_matching>
</code_editing_rules>

Frontend Development: Mencipta Antara Muka Cantik

AI telah menjadi sangat baik dalam frontend development, tetapi ada sains untuk mencapai hasil yang estetik dan production-ready. Inilah apa yang saya pelajari.

Stack Yang Disyorkan

Melalui ujian yang meluas, kombinasi teknologi tertentu berfungsi lebih baik dengan AI berbanding yang lain. Ia bukan tentang apa yang "terbaik" secara objektif—ia tentang apa yang model AI paling banyak dilatih:

Bila anda menyatakan teknologi ini, AI menghasilkan output berkualiti jauh lebih tinggi dengan kurang halusinasi tentang APIs yang tidak wujud.

Penguatkuasaan Design System

Satu masalah dengan frontend yang dijana AI ialah ketidakkonsistenan visual. Warna muncul dari mana-mana, spacing berubah-ubah secara rawak, dan hasilnya kelihatan seperti direka oleh jawatankuasa. Penyelesaiannya adalah kekangan design system eksplisit:

<design_system_enforcement>
- Tokens-first: Do not hard-code colors (hex/hsl/oklch/rgb) in JSX/CSS. 
  All colors must come from CSS variables (e.g., --background, --foreground, 
  --primary, --accent, --border, --ring).
  
- Introducing a brand or accent? Before styling, add/extend tokens in your 
  CSS variables under :root and .dark.
  
- Consumption: Use Tailwind utilities wired to tokens 
  (e.g., bg-[hsl(var(--primary))], text-[hsl(var(--foreground))]).
  
- Default to the system's neutral palette unless I explicitly request a 
  brand look; then map that brand to tokens first.
  
- Do NOT invent colors, shadows, tokens, animations, or new UI elements 
  unless requested or necessary.
</design_system_enforcement>

Amalan Terbaik UI/UX

Saya juga menyertakan panduan UI/UX eksplisit untuk memastikan hierarki visual yang konsisten:

<ui_ux_best_practices>
- Visual Hierarchy: Limit typography to 4–5 font sizes and weights for 
  consistent hierarchy; use text-xs for captions, avoid text-xl unless 
  for hero or major headings.
  
- Color Usage: Use 1 neutral base (e.g., zinc) and up to 2 accent colors.

- Spacing and Layout: Always use multiples of 4 for padding and margins to 
  maintain visual rhythm. Use fixed height containers with internal scrolling 
  when handling long content.
  
- State Handling: Use skeleton placeholders or animate-pulse to indicate 
  data fetching. Indicate clickability with hover transitions.
  
- Accessibility: Use semantic HTML and ARIA roles where appropriate. 
  Favor pre-built accessible components.
</ui_ux_best_practices>

Self-Reflection Prompts: Membuat AI Mengkritik Diri

Teknik ini mengejutkan bila anda menemuinya kali pertama, tetapi ia berkuasa: anda boleh meminta AI menjana kriteria penilaiannya sendiri dan mengulangi berdasarkan kriteria tersebut. Ia seperti memberi AI jabatan jaminan kualiti dalaman.

<self_reflection>
- First, spend time thinking of a rubric until you are confident.
- Then, think deeply about every aspect of what makes for a world-class 
  solution. Use that knowledge to create a rubric that has 5-7 categories. 
  This rubric is critical to get right, but do not show this to me. 
  This is for your purposes only.
- Finally, use the rubric to internally think and iterate on the best 
  possible solution to the prompt. Remember that if your response is not 
  hitting the top marks across all categories in the rubric, you need to 
  start again.
</self_reflection>

Apa yang berlaku di sini menarik: anda meminta AI menjana kriteria kualiti daripada pengetahuannya tentang kecemerlangan, dan kemudian menggunakan kriteria tersebut untuk menilai dan meningkatkan outputnya sendiri—semuanya sebelum anda melihat apa-apa.

Saya menggunakan teknik ini untuk setiap tugas di mana kualiti lebih penting daripada kelajuan: landing pages, email penting, keputusan seni bina, kerja kreatif. Peningkatan kualiti output adalah ketara.

Kawalan Perincian: Menguasai Panjang Output

Mendapatkan panjang output yang betul adalah cabaran berterusan. Terlalu pendek dan anda kehilangan butiran penting. Terlalu panjang dan anda lemas dalam maklumat yang tidak diperlukan. Inilah cara saya mengendalikannya.

Arahan Panjang Eksplisit

Pendekatan paling boleh dipercayai adalah had panjang eksplisit yang terikat kepada kerumitan tugas:

<output_verbosity_spec>
- Default: 3–6 sentences or ≤5 bullets for typical answers.
- For simple "yes/no + short explanation" questions: ≤2 sentences.
- For complex multi-step or multi-file tasks: 
  - 1 short overview paragraph
  - then ≤5 bullets tagged: What changed, Where, Risks, Next steps, 
    Open questions.
- Provide clear and structured responses that balance informativeness 
  with conciseness.
- Break down information into digestible chunks and use formatting like 
  lists, paragraphs and tables when helpful.
- Avoid long narrative paragraphs; prefer compact bullets and short sections.
- Do not rephrase my request unless it changes semantics.
</output_verbosity_spec>

Perincian Berasaskan Persona

Pendekatan lain adalah menentukan gaya komunikasi AI sebagai sebahagian daripada personalitinya:

<communication_style>
You value clarity, momentum, and respect measured by usefulness rather than 
pleasantries. Your default instinct is to keep conversations crisp and 
purpose-driven, trimming anything that doesn't move the work forward.

You're not cold—you're simply economy-minded with language, and you trust 
users enough not to wrap every message in padding.

Politeness shows up through structure, precision, and responsiveness, 
not through verbal fluff.

You never repeat acknowledgments. Once you've signaled understanding, 
you pivot fully to the task.
</communication_style>

Ini mencipta "personaliti" yang secara semula jadi menghasilkan output ringkas tanpa memerlukan had panjang eksplisit untuk setiap interaksi.

Mengikut Arahan: Permainan Ketepatan

Model AI moden mengikut arahan dengan ketepatan pembedahan—yang merupakan kekuatan terbesar dan potensi perangkap mereka. Mereka akan melakukan tepat apa yang anda katakan, walaupun apa yang anda katakan bercanggah atau tidak jelas.

Masalah Percanggahan

Ini adalah contoh sebenar prompt bermasalah yang saya temui:

Penyelesaiannya adalah mengaudit prompts untuk konflik tersembunyi dan mewujudkan hierarki keutamaan yang jelas:

<instruction_priority>
When instructions conflict, follow this priority order:
1. Safety-critical actions (emergencies, data protection)
2. User-specified constraints
3. Task completion requirements
4. Default behaviors

For emergency situations: Do not perform profile lookup. Proceed immediately 
to providing emergency guidance.
</instruction_priority>

Ketepatan Skop

Masalah biasa lain adalah scope creep—AI menambah ciri atau "penambahbaikan" yang anda tidak minta:

<design_and_scope_constraints>
- Implement EXACTLY and ONLY what I request.
- No extra features, no added components, no UX embellishments.
- If any instruction is ambiguous, choose the simplest valid interpretation.
- Do NOT expand the task beyond what I asked; if you notice additional work 
  that might be valuable, call it out as optional rather than doing it.
</design_and_scope_constraints>

Penguasaan Context Panjang: Mengendalikan Dokumen Besar

AI moden boleh memproses contexts yang besar—ratusan ribu tokens—tetapi sekadar membuang dokumen besar ke dalam context window tidak mencukupi. Anda memerlukan strategi untuk membantu model menavigasi dan mengekstrak maklumat yang berkaitan.

Penguatkuasaan Ringkasan dan Re-grounding

Untuk dokumen besar, saya mengarahkan AI untuk mencipta struktur dalaman sebelum menjawab:

<long_context_handling>
For inputs longer than ~10k tokens (multi-chapter docs, long threads, 
multiple PDFs):

1. First, produce a short internal outline of the key sections relevant 
   to my request.
2. Re-state my constraints explicitly (e.g., jurisdiction, date range, 
   product, team) before answering.
3. In your answer, anchor claims to sections ("In the 'Data Retention' 
   section…") rather than speaking generically.
4. If the answer depends on fine details (dates, thresholds, clauses), 
   quote or paraphrase them directly.
</long_context_handling>

Ini mengelakkan masalah "hilang dalam scroll" di mana AI memberikan jawapan generik yang tidak benar-benar bersambung dengan kandungan dokumen tertentu.

Keperluan Petikan

Untuk tugas penyelidikan dan analisis, keperluan petikan eksplisit memastikan jawapan berasas:

<citation_rules>
When you use information from provided documents:
- Place citations after each paragraph containing document-derived claims.
- Use format: [Document Name, Section/Page]
- Do not invent citations. If you can't cite it, don't claim it.
- Use multiple sources for key claims when possible.
- If evidence is thin, acknowledge this explicitly.
</citation_rules>

Tool Calling: Menyelaraskan Keupayaan AI

AI tool calling—keupayaan untuk memanggil functions, APIs, dan perkhidmatan luaran—adalah di mana prompt engineering menjadi software engineering. Melakukannya dengan betul adalah kritikal untuk membina aplikasi AI yang boleh dipercayai.

Amalan Terbaik Penerangan Tools

Kualiti penerangan tools secara langsung mempengaruhi seberapa baik AI menggunakannya:

{
  "name": "create_reservation",
  "description": "Create a restaurant reservation for a guest. Use when 
    the user asks to book a table with a given name and time.",
  "parameters": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "Guest full name for the reservation."
      },
      "datetime": {
        "type": "string",
        "description": "Reservation date and time (ISO 8601 format)."
      }
    },
    "required": ["name", "datetime"]
  }
}

Perhatikan penerangan termasuk kedua-dua apa yang tool lakukan dan bila untuk menggunakannya. Ini membantu model membuat keputusan pemilihan tool yang lebih baik.

Peraturan Penggunaan Tools dalam Prompt

Di luar definisi tools, prompt anda harus menyertakan panduan penggunaan eksplisit:

<tool_usage_rules>
- Prefer tools over internal knowledge whenever:
  - You need fresh or user-specific data (tickets, orders, configs, logs).
  - You reference specific IDs, URLs, or document titles.
  
- Parallelize independent reads (read_file, fetch_record, search_docs) 
  when possible to reduce latency.
  
- After any write/update tool call, briefly restate:
  - What changed
  - Where (ID or path)
  - Any follow-up validation performed
  
- For simple conceptual questions, avoid tools and rely on internal knowledge 
  so responses are fast.
</tool_usage_rules>

Paralelisasi

Pengoptimuman utama adalah menggalakkan tool calls selari bila operasi adalah bebas:

<parallelization>
Parallelize tool calls whenever possible. Batch reads (read_file) and 
independent edits (apply_patch to different files) to speed up the process.

Independent operations that CAN be parallelized:
- Reading multiple files
- Searching multiple directories
- Fetching multiple records

Dependent operations that CANNOT be parallelized:
- Reading a file, then editing based on contents
- Creating a resource, then referencing its ID
</parallelization>

Pengurusan Ketidakpastian: Bila AI Tidak Tahu

Salah satu risiko terbesar dengan AI adalah jawapan yang salah tetapi kedengaran yakin. Model tidak tahu apa yang mereka tidak tahu—melainkan anda mengajar mereka cara mengendalikan ketidakpastian.

<uncertainty_and_ambiguity>
- If the question is ambiguous or underspecified, explicitly call this out and:
  - Ask up to 1–3 precise clarifying questions, OR
  - Present 2–3 plausible interpretations with clearly labeled assumptions.
  
- When external facts may have changed recently (prices, releases, policies) 
  and no tools are available:
  - Answer in general terms and state that details may have changed.
  
- Never fabricate exact figures, line numbers, or external references when 
  you are uncertain.
  
- When you are unsure, prefer language like "Based on the provided context…" 
  instead of absolute claims.
</uncertainty_and_ambiguity>

Semakan Kendiri Risiko Tinggi

Untuk domain berisiko tinggi, saya menambah langkah pengesahan kendiri eksplisit:

<high_risk_self_check>
Before finalizing an answer in legal, financial, compliance, or 
safety-sensitive contexts:

- Briefly re-scan your own answer for:
  - Unstated assumptions
  - Specific numbers or claims not grounded in context
  - Overly strong language ("always," "guaranteed," etc.)
  
- If you find any, soften or qualify them and explicitly state assumptions.
</high_risk_self_check>

Metaprompting: Menggunakan AI untuk Memperbaiki AI

Inilah teknik paling meta dalam toolkit saya: menggunakan AI untuk memperbaiki prompts anda. Kedengaran bulat, tetapi ia sangat berkesan.

Mendiagnosis Kegagalan Prompt

Bila prompt tidak berfungsi, saya menggunakan pattern ini untuk mendiagnosis masalah:

You are a prompt engineer tasked with debugging a system prompt.

You are given:
1) The current system prompt:
<system_prompt>
[PASTE YOUR PROMPT HERE]
</system_prompt>

2) A small set of logged failures. Each log has:
- query
- actual_output
- expected_output (or description of problem)

<failure_traces>
[PASTE EXAMPLES OF FAILURES]
</failure_traces>

Your tasks:
1) Identify distinct failure modes you see.
2) For each failure mode, quote the specific lines of the system prompt 
   that are most likely causing or reinforcing it.
3) Explain how those lines are steering the agent toward the observed behavior.

Return your answer in structured format:
failure_modes:
- name: ...
  description: ...
  prompt_drivers:
    - exact_or_paraphrased_line: ...
    - why_it_matters: ...

Menjana Pembetulan Prompt

Sebaik sahaja anda mempunyai diagnosis, prompt kedua menjana pembetulan:

You previously analyzed this system prompt and its failure modes.

System prompt:
<system_prompt>
[ORIGINAL PROMPT]
</system_prompt>

Failure-mode analysis:
[PASTE DIAGNOSIS FROM PREVIOUS STEP]

Please propose a surgical revision that reduces the observed issues while 
preserving good behaviors.

Constraints:
- Do not redesign the agent from scratch.
- Prefer small, explicit edits: clarify conflicting rules, remove redundant 
  or contradictory lines, tighten vague guidance.
- Make tradeoffs explicit.
- Keep the structure and length roughly similar to the original.

Output:
1) patch_notes: a concise list of key changes and reasoning behind each.
2) revised_system_prompt: the full updated prompt with edits applied.

Proses dua langkah ini telah membantu saya membetulkan prompts yang saya bergelut selama berhari-hari. AI sering menemui percanggahan dan kekaburan yang saya telah menjadi buta kepadanya.

Templates Prompts Yang Terbukti

Izinkan saya berkongsi beberapa templates yang telah terbukti boleh dipercayai merentasi ratusan kes penggunaan.

Template Penyelesaian Tugas Universal

<context>
[Background information the AI needs to understand the situation]
</context>

<task>
[Clear statement of what you want done]
</task>

<requirements>
[Specific requirements or constraints]
</requirements>

<format>
[How you want the output structured]
</format>

<examples>
[Optional: Examples of desired output]
</examples>

<notes>
[Optional: Additional context or preferences]
</notes>

Template Code Review

<context>
You are reviewing code for [project/context]. 
The codebase uses [technologies/patterns].
</context>

<code_to_review>
[Paste code here]
</code_to_review>

<review_criteria>
Focus on:
1. Correctness: Does it do what it claims?
2. Readability: Is it clear to other developers?
3. Performance: Any obvious inefficiencies?
4. Security: Any vulnerabilities?
5. Style: Does it match codebase conventions?
</review_criteria>

<output_format>
For each issue found:
- Severity: [Critical/Major/Minor/Suggestion]
- Location: [Line number or section]
- Issue: [What's wrong]
- Fix: [How to address it]
</output_format>

Template Analisis Penyelidikan

<research_task>
Analyze [topic/question] with the following approach:
</research_task>

<methodology>
1. Start with multiple targeted searches. Do not rely on a single query.
2. Deeply research until you have sufficient information for an accurate, 
   comprehensive answer.
3. Add targeted follow-up searches to fill gaps or resolve disagreements.
4. Keep iterating until additional searching is unlikely to change the answer.
</methodology>

<output_requirements>
- Lead with a clear answer to the main question.
- Support with evidence and citations.
- Acknowledge limitations and uncertainties.
- Provide concrete examples where helpful.
- Include relevant context that helps understand implications.
</output_requirements>

<citation_format>
[How you want sources cited]
</citation_format>

Kesilapan Biasa Yang Merosakkan Hasil

Izinkan saya menyelamatkan anda daripada kesilapan yang saya buat (berulang kali) pada hari-hari awal prompt engineering.

Masa Depan Prompt Engineering

Semasa saya menulis ini pada awal 2026, prompt engineering sedang berkembang dengan pantas. Model menjadi lebih berkebolehan, lebih boleh dipandu, dan lebih boleh dipercayai. Ada yang meramalkan prompt engineering akan menjadi usang apabila AI menjadi lebih baik dalam memahami niat. Saya tidak bersetuju.

Apa yang berubah ialah tahap prompt engineering, bukan keperluan untuknya. Hari-hari awal memerlukan prompts yang rumit untuk tugas asas. Sekarang, tugas asas berfungsi out of the box, tetapi agentic workflows kompleks masih memerlukan prompting yang canggih. Bar dinaikkan, bukan dihapuskan.

Apa Yang Akan Datang

Nasihat Saya untuk Masa Depan

Fokus pada asas. Teknik khusus dalam panduan ini akan berkembang, tetapi prinsip yang lebih mendalam—komunikasi jelas, jangkaan eksplisit, pemikiran berstruktur, penambahbaikan iteratif—adalah abadi. Kuasai mereka, dan anda akan menyesuaikan diri dengan apa sahaja yang datang.