Golang The Series EP.146: Prompt Engineering for Gophers สั่ง AI ให้ Go ทำงานง่าย

ยินดีต้อนรับเข้าสู่ EP.146 ครับ หลังจากที่เราลองรันโมเดลทั้งบน Cloud และ Local LLM กันไปแล้ว หลายคนน่าจะเจอปัญหาชวนปวดหัวเหมือนกันคือ "ทำไม AI ตอบไม่ตรงบรีฟ?" หรือ "จะเอา Output ไป Parse ลงโค้ด Go ทำไมมันยากจัง?"

วันนี้เราจะมาคุยเรื่อง Prompt Engineering กันครับ แต่เราจะไม่คุยในมุมของ User ที่พิมพ์แชทเล่นไปวันๆ เราจะคุยกันในฐานะ Gopher ที่ต้องเขียน Prompt ฝังลงใน Source Code เพื่อควบคุม AI ให้ทำงานร่วมกับระบบ Backend ของเราได้อย่างแม่นยำและไร้รอยต่อครับ

Structure is Everything: การใช้ Constant และ Template

การเขียน Prompt ยาวๆ ลงในฟังก์ชันโดยตรง (Hardcoding) นอกจากจะทำให้โค้ดดูรกแล้ว ยังทำให้การแก้ไขหรือทำ A/B Testing กับ Prompt ทำได้ยากมากครับ เทคนิคที่ Gopher มือโปรใช้กันคือการจัดการ Prompt ให้เป็นสัดส่วน

A. ใช้ Constants (สำหรับ Static Prompt)

หาก Prompt ของคุณตายตัว ไม่มีการเปลี่ยนตาม Variable แนะนำให้ใช้ Raw String Literals (backticks) เก็บไว้ใน Constant นอกฟังก์ชันครับ

Go

const SystemRolePrompt = `คุณคือผู้ช่วยอธิบายโค้ดภาษา Go 
จงตอบคำถามให้กระชับและเน้นตัวอย่างโค้ดที่เป็นไปตาม Go Best Practices`

B. ใช้ text/template (สำหรับ Dynamic Prompt)

ในกรณีที่ต้องมีการฉีดข้อมูล (Data Injection) เช่น ใส่ชื่อผู้ใช้ หรือเนื้อหาบทความลงไปใน Prompt การใช้ fmt.Sprintf อาจจะดูยุ่งเหยิงเมื่อ Prompt มีขนาดใหญ่ การใช้ Package text/template จะช่วยให้โค้ดดูสะอาดและจัดการโครงสร้างได้ดีกว่ามากครับ

Go

const SummaryTemplate = `จงสรุปเนื้อหาบทความเรื่อง "{{.Title}}" 
โดยเน้นประเด็นสำคัญไม่เกิน 3 ข้อ ดังนี้: {{.Content}}`

💡 Tips จากประสบการณ์:

• แยกไฟล์: หากโปรเจกต์เริ่มใหญ่ แนะนำให้แยกไฟล์ prompts.go ออกมาโดยเฉพาะ เพื่อให้ง่ายต่อการที่ทีม (หรือแม้แต่คนทำ Prompt Engineer) จะมาช่วยเกลาข้อความโดยไม่ต้องไล่หาใน Logic ของโปรแกรมครับ

• Version Control: การแยก Constant ช่วยให้เราเห็นความเปลี่ยนแปลงของ Prompt ผ่าน Git Diff ได้ชัดเจนขึ้นมาก

Output Formatting: บังคับ AI ให้ตอบเป็น JSON

ปัญหาที่น่าปวดหัวที่สุดของ Developer คือ AI มักจะ "ใจดีเกินไป" แถมนบทนำและบทสรุปมาให้ด้วย (เช่น "ได้ค่ะ นี่คือ JSON ที่คุณต้องการ...") ซึ่งประโยคเหล่านี้จะทำให้ฟังก์ชัน json.Unmarshal ของ Go พ่น Error ออกมาทันที

เทคนิคการคุม Output ให้แม่นยำ:

• กำชับด้วย Negative Prompt: นอกจากบอกว่าให้ตอบเป็น JSON ต้องกำชับด้วยว่า "No prose, no explanations, just raw JSON" เพื่อตัดส่วนเกินออก

• ส่ง JSON Schema เป็นตัวอย่าง: AI จะทำงานได้ดีขึ้นมากถ้าเห็นโครงสร้าง (Structure) ที่เราต้องการ

• เปิดใช้ JSON Mode: หากคุณใช้ OpenAI หรือ Ollama รุ่นใหม่ๆ ให้ตั้งค่าใน API Request เป็น response_format: { "type": "json_object" } ซึ่งจะเป็นการบังคับที่ระดับ Engine ให้ตอบกลับมาเป็น JSON ที่ถูกต้องทางไวยากรณ์ (Valid JSON) เท่านั้น

ตัวอย่างการวางโครงสร้างใน Go:

Go

const JSONPrompt = `จงสรุปเนื้อหาบทความนี้ให้อยู่ในรูปแบบ JSON เท่านั้น
กฎ: ห้ามมีคำนำหรือคำบรรยายอื่นใดนอกจาก JSON
Schema: {
  "title": "string",
  "summary": "string", 
  "tags": ["string", "string"]
}`

⚠️ ข้อควรระวัง (Pro Tip for Gophers):

แม้เราจะสั่ง "ตอบเฉพาะ JSON" แต่บางครั้ง AI ก็ยังแถม Markdown Backticks (เช่น json ... ) มาให้ในคำตอบ

วิธีแก้: ในโค้ด Go ของคุณ ควรมีฟังก์ชันเล็กๆ สำหรับการ Trim หรือลบ ```json และ ``` ออกจาก String ก่อนจะนำไป Unmarshal เพื่อให้ระบบของคุณ Robust หรือ "อึด" ต่อความผิดพลาดของ AI มากที่สุดครับ

Few-Shot Prompting: สอน AI ด้วยตัวอย่าง (Examples)

บางครั้งการอธิบายด้วยคำพูด (Instruction) อย่างเดียวอาจจะไม่เห็นภาพเท่ากับการ "ทำให้ดู" ครับ Few-Shot Prompting คือการส่งตัวอย่างชุดข้อมูล (Input/Output) ให้ AI เห็นเป็นแนวทางก่อนที่จะให้มันตอบคำถามจริง

ทำไมต้องทำแบบนี้?

• คุมสไตล์การตอบ: เช่น อยากให้ตอบสั้นๆ หรือตอบแบบกวนๆ

• คุม Format ที่ซับซ้อน: ช่วยให้ AI เข้าใจโครงสร้างข้อมูลที่อธิบายยากๆ ได้ดีขึ้น

• ลด Error: เมื่อ AI เห็นตัวอย่างที่ถูกต้อง มันจะเลียนแบบตามแนวทางนั้นทันที

ตัวอย่างการวางโครงสร้างใน Go:

เราจะใช้การเรียง Messages ใน Slice โดยจำลองสถานการณ์การคุยกันที่ผ่านมา (Chat History) ครับ

Go

messages := []openai.ChatCompletionMessage{
    // ตัวอย่างที่ 1
    {Role: "user", Content: "Go คืออะไร?"},
    {Role: "assistant", Content: "Go คือภาษาโปรแกรมที่เน้นความเรียบง่ายและประสิทธิภาพ"},
    
    // ตัวอย่างที่ 2
    {Role: "user", Content: "แล้ว Docker คืออะไร?"},
    {Role: "assistant", Content: "Docker คือแพลตฟอร์มที่ใช้จัดการ Container เพื่อให้รันแอปได้ทุกที่"},
    
    // คำถามจริง
    {Role: "user", Content: "Kubernetes คืออะไร?"}, 
    // AI จะตอบกลับมาด้วยสไตล์ "นิยามสั้นๆ" เหมือนตัวอย่างด้านบนเป๊ะ!
}

💡 Tips สำหรับ Gopher:

ในงานจริง คุณสามารถเก็บชุดตัวอย่างเหล่านี้ไว้ในไฟล์ JSON หรือ Database แล้วโหลดขึ้นมาฉีดใส่ []openai.ChatCompletionMessage ก่อนส่งไปที่ API วิธีนี้จะช่วยให้เราสามารถปรับเปลี่ยนพฤติกรรม AI ได้โดยไม่ต้อง Compile โค้ดใหม่ทุกครั้งครับ

Chain of Thought: สั่งให้ AI คิดก่อนตอบ

เคยไหมครับ? สั่งให้ AI เขียนอัลกอริทึมยากๆ แล้วมันดันเขียนโค้ดที่รันไม่ได้ หรือ Logic ผิดแบบงงๆ นั่นเป็นเพราะ AI พยายามเดาคำตอบถัดไป (Next Token Prediction) โดยที่ยังไม่ได้วางแผนแก้ปัญหาในหัวครับ

Chain of Thought (CoT) คือเทคนิคการสั่งให้ AI "แจกแจงตรรกะ" ออกมาก่อนจะสรุปคำตอบ ซึ่งจะช่วยเพิ่มความแม่นยำได้มหาศาล

เทคนิคการเขียนใน Prompt:

• เพิ่มประโยคทองคำอย่าง "Let’s think step by step" หรือ "จงคิดทีละขั้นตอนอย่างเป็นเหตุเป็นผล"

• หากต้องการผลลัพธ์ที่เป็น JSON แต่ยังอยากให้มันคิดก่อน คุณสามารถสั่งให้ AI แบ่งโครงสร้างคำตอบเป็น 2 ส่วน คือ thoughts (สำหรับแสดงวิธีคิด) และ result (สำหรับคำตอบจริง)

ตัวอย่างการใช้ในงาน Go:

Go

const ComplexLogicPrompt = `จงเขียนฟังก์ชันสำหรับคำนวณภาษีแบบขั้นบันไดในภาษา Go 
โดยให้คุณ "คิดทีละขั้นตอน" ดังนี้:
1. วิเคราะห์เงื่อนไขภาษีแต่ละขั้น
2. วางโครงสร้างตัวแปรที่จำเป็น
3. เขียน Logic การคำนวณ
4. ตรวจสอบความถูกต้อง (Edge Cases)
5. สรุปเป็นโค้ด Go ที่ใช้งานได้จริง`

💡 ทำไม Gopher ถึงควรใช้ CoT?

ในงาน Backend บางครั้งเราต้องการให้ AI ช่วย Review โค้ดหรือหาจุด Bug การสั่งให้มัน "แจกแจงสาเหตุ" ก่อนบอกวิธีแก้ จะทำให้เราตรวจสอบได้ง่ายขึ้นว่า AI เข้าใจ Logic ของเราถูกต้องจริงๆ หรือไม่ ไม่ใช่แค่แก้สุ่มๆ ให้รันผ่านครับ

🎯 ท้าให้ลอง (Daily Mission)

เพื่อให้ทุกคนเห็นพลังของ Prompt Engineering ผมอยากให้ลองสร้างฟังก์ชันใน Go ที่รับ "บทความดิบ" เข้าไป แล้วเขียน Prompt บังคับให้ AI สรุปบทความออกมาเป็น JSON Struct ที่ประกอบด้วย:

• title (ชื่อเรื่อง)

• abstract (บทคัดย่อสั้นๆ)

• category (หมวดหมู่)

โจทย์การบ้าน

ลองปรับแก้ Prompt ของคุณจนกว่า AI จะตอบกลับมาเป็น JSON ที่สะอาดพอจะใช้ json.Unmarshal ลงใน Struct ของ Go ได้ 100% โดยไม่มี Error แม้แต่ครั้งเดียว!

บทสรุป: จากแค่การสั่งเป็นการควบคุม

การทำ Prompt Engineering สำหรับ Gopher ไม่ใช่งานสายศิลปะที่ต้องใช้คำสวยหรูครับ แต่มันคือการออกแบบ Interface ของข้อมูล เพื่อให้ AI คุยกับโปรแกรมของเราได้รู้เรื่องที่สุด

จำไว้ว่า Prompt ที่ดีใน Source Code ต้อง อ่านง่าย (Structure), แม่นยำ (JSON), มีตัวอย่าง (Few-Shot) และ มีเหตุผล (CoT) เมื่อคุณคุมปัจจัยเหล่านี้ได้ AI จะไม่ได้เป็นแค่แชทบอทอีกต่อไป แต่จะเป็นโมดูลอัจฉริยะโมดูลหนึ่งในระบบ Backend ของคุณอย่างแท้จริงครับ

ตอนต่อไป | EP.147: Structured Output — บังคับ AI ตอบกลับเป็น JSON ให้ Go Parse ได้แม่นยำ 100%

ในตอนนี้เราเรียนรู้เทคนิคการเขียน Prompt ไปแล้ว แต่ในโลกความเป็นจริง AI ก็ยังมีโอกาสนอกลู่นอกทางหรือคืนค่า JSON ที่มี Format แปลกๆ มาทำให้โค้ด Go ของเรา Panic ได้!

ถ้าคุณอยากสร้างระบบที่ไม่มีวันพังเพราะ AI ตอบเพี้ยน ห้ามพลาด EP.147 ครับ!

ฝากกดติดตามพวกเราได้ที่ Superdev Academy ในทุกช่องทางนะครับ!

• 🔵 Facebook: Superdev Academy Thailand (อัปเดตข่าวสารและบทความใหม่)

• 🎬 YouTube: Superdev Academy Channel (ติวเข้มแบบวิดีโอ)

• 📸 Instagram: @superdevacademy (เกร็ดความรู้สั้นๆ และเบื้องหลังการทำงาน)

• 🎬 TikTok: @superdevacademy (Tips & Tricks ฉบับย่อยง่าย)

• 🌐 Website: superdevacademy.com (คลังบทความและคอร์สเรียนฉบับเต็ม)