▶SUBTHAIแปลไทย · ซับ · พากย์⚙
บทความแปลภาษาไทย · YouTube

Jev for Claude is INSANE (Every Jev Concept Explained)

0:000:00
เล่นเสียงต้นฉบับของวิดีโอ พร้อมแสดงซับไทยซิงก์ตามเวลา
กำลังโหลดวิดีโอ…
01

สรุปย่อ

ประเด็นสำคัญจากวิดีโอ

- **ช่อง:** Simon Scrapes · **ความยาว:** ~37 นาที · **แหล่ง:** https://www.youtube.com/watch?v=D-Z5HnLW_ho

# สรุป: Jev for Claude is INSANE (Every Jev Concept Explained)

- **ช่อง:** Simon Scrapes · **ความยาว:** ~37 นาที · **แหล่ง:** https://www.youtube.com/watch?v=D-Z5HnLW_ho

## ประเด็นหลัก

- **Jev** คือ "judgment model" จาก Typesafe — ไม่เขียนข้อความ ไม่แชท ไม้อธิบายตัวเอง แต่ตอบคำถามเป็นตัวเลขความน่าจะเป็นที่ผ่านการ calibration (พูด 0.8 = ถูก ~8 ครั้งจาก 10)
- ผู้ก่อตั้งคือ Doooo อดีตทีมพัฒนาวิธีการเบื้องหลัง ChatGPT ที่ OpenAI
- ถูกกว่า LLM **40–1,000 เท่า** เร็วกว่า **20–400 เท่า** (~4 เซนต์/ล้าน token input, output แทบฟรี)
- คำถาม 3 แบบ: **null** (ใช่/ไม่ใช่ → ใช้เมื่อต้อง act/not act), **choice** (เลือกหมวด → ใช้เมื่อต้อง route), **score** (คะแนนบนมาตรวัด → ใช้เมื่อต้องเรียงอันดับ) — ใส่รวมกันใน request เดียวได้
- **confidence** คือตัวเลขที่สอง (จาก choice/score) คำนวณจากความกระจายของความน่าจะเป็น — เป็น "กลไกนิรภัย" ก่อนไว้ใจคำตอบ
- ไม่แทนที่ Claude แต่ทำงานเคียงข้าง: "Claude คือบทสนทนา Jev คือท่อใต้พื้นบ้าน" — Jev รับงานตัดสินใจเร็วจำนวนมาก (system one), Claude เก็บงานคิด/เขียน/สนทนา (system two)
- ใช้กับ Claude ได้ 2 แบบ: (1) เป็น guard คัดกรอง input/output รอบ Claude (2) ทำงานกองโตแทน Claude (คัดอีเมล ให้คะแนน lead)
- Typesafe skill ใน Claude Code = rule book (ไม่ใช่เครื่องมือรัน) — Claude อ่านแล้วเขียนสคริปต์+เกณฑ์ให้เอง
- Demo จริง: อีเมลสนับสนุนลูกค้า 50 ฉบับ คัดเข้า 4 กอง + เรียงตามความโกรธ **4.2 วินาที 0.026 เซนต์** (~$1/ปี)
- Checklist หาคำถามที่ใช่: เริ่มจาก action → เขียน trigger เป็นประโยค → กำหนด state → เพิ่ม edge case → ตั้ง confidence ตามต้นทุนความผิดพลาด
- Pattern ทั้ง 4 จาก docs: **speculative fan-out** (ถามทุกอย่างพร้อมกัน จ่ายค่าอ่าน text รอบเดียว), **confidence-gated routing** (threshold ต่อ action — เช็คยอดผ่านที่ 0.6 แต่อนุมัติโอนเงินต้อง 0.85), **weighted scoring** (แตกมิติแยก score แล้วถ่วงน้ำหนักเอง เช่น คัด CV), **intent routing** (จำแนกแล้วส่งให้ตัวจัดการที่ดีที่สุด — database/Claude/คน)

## ความเห็นสรุป

คลิปนี้ครบเครื่องที่สุดเรื่อง Jev ตอนนี้ — ไล่ตั้งแต่แนวคิด ติดตั้ง จนถึง pattern การใช้งานจริง พร้อมตัวเลขต้นทุนจริงให้เห็น สาระสำคัญคือ Jev เปลี่ยน "ความรู้สึก" ที่ซอฟต์แวร์เข้าใจไม่ได้ ให้กลายเป็นตัวเลขที่ if statement ใช้ได้ ในราคาถูกจนเอามาไล่ทั้ง inbox ทุกเช้าได้ในหนึ่งดอลลาร์ต่อปี สำหรับคนทำระบบอัตโนมัติที่มีงานคัดกรอง/จัดหมวด/จัดลำดับเยอะ ๆ นี่คือเครื่องมือใหม่ที่คุ้มค่ามาก
02

คำแปลเต็ม

แปลตามบทสนทนาต้นฉบับ ปรับเป็นภาษาไทยธรรมชาติ

โมเดล AI ที่คนพูดถึงมากที่สุดเดือนนี้ เขียนประโยคแม้แต่ประโยคเดียวไม่ได้ คุยกับมันไม่ได้ และมันอธิบายตัวเองไม่ได้ด้วย และนี่คือสิ่งที่คนสร้างขึ้นมาด้วยมันภายในสัปดาห์แรกที่มันถูกปล่อยออกมา เรามีเบราว์เซอร์ที่กรอกข้อมูล Google Flights เสร็จในประมาณ 7 วินาที และถ้าคุณเคยลองใช้ Claude กับเบราว์เซอร์มาก่อน คุณจะรู้ว่ามันช้ามาก ๆ เรามีข้อมูล session ของเว็บไซต์ 3 ล้าน session ที่จับพวกลูกค้าที่หลุดมือไป ตะกร้าที่ถูกทิ้งไว้ และอื่น ๆ เรียงให้เสร็จใน 40 วินาที ด้วยราคาประมาณ 2 ดอลลาร์ แล้วยังมีอีกคนขับ Chrome ด้วยเสียง โดยที่มันลงมือทำก่อนที่เขาจะพูดประโยคเต็มจบด้วยซ้ำ

มันชื่อ Jev และผมได้อ่านเอกสารทางการทั้งหมดมาแล้ว เพื่อที่คุณจะได้ไม่ต้องอ่านเอง และเมื่อจบคลิปนี้ คุณจะรู้ว่ามันคืออะไร ทำไมมันถึงสำคัญถ้าคุณใช้ Claude อยู่แล้ว วิธีรันจาก Claude Code และถามคำถามที่ถูกต้อง รวมถึงวิธีเอามันไปใช้ให้คุ้มที่สุด

เริ่มจากคุยกันว่าอะไรที่ต่างจริง ๆ ใน Jev เพราะบางส่วนของมันไม่ใช่เรื่องใหม่ ซอฟต์แวร์ทุกชิ้นที่คุณใช้อยู่แล้วเต็มไปด้วย if statement ทั้งนั้น ตัวอย่างเช่น ถ้าออเดอร์มีมูลค่าเกิน 10,000 ดอลลาร์ เราจะตั้งธงให้ตรวจสอบ แต่ข้อจำกัดคือ if statement ตรวจสอบได้เฉพาะสิ่งที่คอมพิวเตอร์วัดได้ เราเปรียบเทียบกับตัวเลข วันที่ เช็คบ็อกซ์ เกณฑ์ที่ชัดเจน แต่มันตรวจไม่ได้ว่าอีเมลนี้ฟังดูโกรธหรือเปล่า หรือออเดอร์นี้ดูน่าสงสัยหรือเปล่า เพราะพวกนั้นไม่ใช่ตัวเลข ไม่ใช่สิ่งที่เช็คได้ มันไม่ deterministic

Jev ทำสิ่งนี้แหละ มันเปลี่ยน input ที่ยุ่งเหยิงจากลูกค้าให้กลายเป็นตัวเลข if statement ก็จะกลายเป็น "ถ้าออเดอร์นี้ดูน่าสงสัย โอเค เรามั่นใจ 95% ตั้งธงให้ตรวจสอบ" ตอนนี้คอมพิวเตอร์อ่านได้และตัดสินใจแทนเราได้ และเราจะคุยกันว่าจะกำหนดยังไงว่าอะไรนับเป็น "น่าสงสัย" เพราะเราจะใช้ Claude กับคุณในการเขียนคำถาม และคุณเป็นคนกำหนดเกณฑ์ของคำตอบ "ใช่" เช่นระดับความมั่นใจ 95%

เราจะส่งชุดคำถามไปให้ Jev แล้ว Jev จะตอบทีละข้อพร้อมบอกว่ามันมั่นใจแค่ไหน และโค้ดของคุณจะตั้งธงออเดอร์ก็ต่อเมื่อทุกคำตอบกลับมาเกินเกณฑ์ที่คุณเลือกไว้ เช่น 95% นั่นแหละ และอาจรู้สึกต่างจาก LLM แบบเดิม ๆ อย่างโมเดลแชทของ Anthropic นี่คือเหตุผลที่ Typesafe บริษัทผู้สร้าง Jev เรียกมันว่า judgment model

ผู้ก่อตั้งคือ Doooo ผู้ช่วยพัฒนาวิธีการเบื้องหลัง ChatGPT ที่ OpenAI นี่คือการประกาศครั้งใหญ่มาก และถ้าเทียบกับ Claude บนพื้นผิว คุณถาม Claude ได้แน่นอนว่า "อีเมลออเดอร์นี้ดูน่าสงสัยไหม" แล้วคุณจะได้ข้อความตอบจาก Claude แบบ "คุณพูดถูกเลย อันนี้ดูน่าสงสัยจริง ๆ นะ ต้องการให้ผมร่างอีเมลตอบลูกค้าไหม" ซึ่งใช้เวลาประมาณ 10-15 วินาทีกว่าจะได้คำตอบนั้น เทียบกับ Jev ที่ได้รับชุดคำถามให้มองหาล่วงหน้า คำตอบของคำถามเหล่านั้นจะเป็นตัวกำหนดว่ามันน่าสงสัยแค่ไหน เช่น "ที่อยู่ใบแจ้งหนี้กับที่อยู่จัดส่งตรงกันไหม" แล้วมันจะได้รับข้อมูลที่กำลังประมวลผลจริง ๆ ซึ่งเรียกว่า state ในกรณีนี้ก็คืออีเมลออเดอร์ฉบับเดียวที่เรากำลังประเมิน

และคำตอบจาก Jev จะไม่ใช่ข้อความตอบ มันให้แค่ตัวเลขจากตัวเลือกที่เรากำหนดไว้เท่านั้น ตัวเลขนั้นบอกความน่าจะเป็นที่มันน่าสงสัยเทียบกับเกณฑ์ที่เราตั้งไว้ มันไม่มีวันเขียน output เหมือน Claude และสิ่งนี้มีข้อดีหลายอย่างที่เดี๋ยวจะเล่าให้ฟัง นี่ต่างจากอินเทอร์เฟซแชทที่เราคุ้นเคยใน LLM (large language model) โดยสิ้นเชิง มันใกล้เคียงกับโมเดล deterministic machine learning ซึ่งเป็นสไตล์ AI อีกแบบหนึ่ง Typesafe เรียกสิ่งนี้ว่า system one model ตามหนังสือ Thinking Fast and Slow โดย system one คือการตัดสินใจด้วยสัญชาณญาณอย่างรวดเร็ว ส่วน system two คือนั่งลงคิดและใช้เหตุผล โมเดลแชทอย่าง Claude และโมเดล reasoning อื่น ๆ อยู่ใน system two แต่ Jev อยู่ใน system one

แล้วทำไมมันถึงพิเศษเมื่อเทียบกับ LLM แชทแบบที่เราเห็นกันทุกวันนี้ มีอยู่ไม่กี่เหตุผลที่การไม่เขียน output เป็นข้อได้เปรียบในบาง use case ข้อแรก มันถูกและเร็วสุดขั้น บอกกันว่าถูกกว่า LLM ดั้งเดิม 40 ถึง 1,000 เท่า และเร็วกว่า 20 ถึง 400 เท่า ราคาประมาณ 4 เซนต์ต่อล้าน token ฝั่ง input และ output แทบจะฟรี

ข้อสอง มันปลอมแปลงคำตอบไม่ได้ ถ้าคุณให้ 3 ตัวเลือก มันตอบกลับมาด้วยหนึ่งใน 3 ตัวเลือกนั้นทุกครั้ง นี่เป็นทั้งข้อดีและข้อเสีย ซึ่งเดี๋ยวจะคุยกันตอนพูดถึงกฎเฉพาะที่ต้องให้กับ Jev ตอนใช้งาน ข้อสาม มันให้คำตอบเดิมหรือเกือบเดิมเมื่อถามซ้ำสองรอบ มัน consistent กว่า LLM มากในการตอบคำถามเดิมบนชุดข้อมูลเดิม ในการทดสอบเดียวกัน พวกเขาถามคำถามเดิมซ้ำ ๆ และคำตอบจาก Jev ขยับน้อยกว่าโมเดลแชททุกตัวที่ลอง แม้จะตั้งค่า prompt ให้ repeatable ที่สุดแล้วก็ตาม

และประเด็นหลักทั้งหมดของเรื่องนี้คือ ตัวเลขที่ Jev ให้เป็น output ทำให้สิ่งที่ปกติไม่แน่นอน อย่างอีเมลลูกค้าที่ยุ่งเหยิง เต็มไปด้วยข้อความ กลายเป็นสิ่งที่ซอฟต์แวร์นำไปใช้ได้จริง Typesafe เทรนโมเดลนี้ให้ความน่าจะเป็นมี calibration พูดง่าย ๆ คือมันทำงานเหมือนพยากรณ์อากาศ เมื่อ Jev ตอบ 0.8 มันควรจะถูกประมาณ 8 ครั้งจาก 10 และจากความมั่นใจ 8 ใน 10 นั้นแหละ ที่ทำให้ซอฟต์แวร์ตัดสินใจได้ว่าจะลงมือทำตามหรือไม่ จะส่ง query นั้นไปที่อื่นหรือเปล่า การกระทำถัดไปถูกตัดสินจากตัวเลขนั้น

Jev ให้ความน่าจะเป็นของคำถามนั้น ๆ ว่าจริงหรือเท็จ แล้วเดี๋ยวเราจะเห็นตัวเลือกประเภทต่าง ๆ ที่ให้ Jev ได้ เทียบกับโมเดลแชท LLM ที่ถูกเทรนให้ฟังดูถูกต้องสำหรับคนฟังโดยเฉพาะ นั่นคือเหตุผลที่เรามีอคติแบบเห็นด้วยกับทุกอย่างที่เราพูด Jev ไม่ได้ถูกสร้างแบบนั้น

สำคัญมาก ถ้าคุณใช้ Claude หรือ GPT อยู่แล้ว Jev ไม่ได้มาแทนที่มัน แต่จะทำงานเคียงข้างและเพิ่มข้อได้เปรียบให้บาง workflow Jev แทนที่หนึ่งหมวดของงานที่ Claude ทำอยู่ในปัจจุบันทั้งหมด และเมื่อผมพูดว่า Claude คุณแทนด้วยผู้ให้บริการ LLM ตัวไหนก็ได้ตามต้องการ หมวดงานนั้นคือการตัดสินใจเร็ว ๆ ที่ต้องทำจำนวนมากภายในซอฟต์แวร์

ดังนั้นโค้ดที่คุณจะส่งให้ Jev จะส่งมอบข้อมูลนั้น เช่น อีเมลลูกค้าของเรา พร้อมชุดคำถามที่นิยามชัดเจนซึ่งเราอยากรู้คำตอบ แล้ว Jev จะส่งกลับมาเป็นความน่าจะเป็น หมวดหมู่ หรือคะแนน จากนั้นโค้ดของคุณก็จะเอาไปใช้ต่อ เพื่อ route มัน เรียงลำดับ ตั้งธงให้มนุษย์ดู หรือดำเนินการต่อ มันอาจลงมือทำอะไรบางอย่างตามนั้นได้ แต่ทุกอย่างที่ต้องสนทนา แชทไปมา ใช้เหตุผล หรือเขียนข้อความ จะยังอยู่ในอินเทอร์เฟซ Claude ของเราเหมือนเดิม Doooo ผู้ก่อตั้งพูดชัด ๆ ในพอดแคสต์ Latent Space ว่า "Claude คือบทสนทนา ส่วน Jev คือระบบท่อใต้พื้นบ้าน" และสำคัญที่ต้องตระหนักคือมันทำทุกอย่างไม่ได้ จริง ๆ แล้วมันทำได้ไม่กี่อย่าง แต่สิ่งที่มันทำได้ มันทำได้ดีมาก ๆ

เราพูดไปแล้วว่าคำถามแต่ละอย่างที่มันตอบแบ่งได้เป็นหนึ่งในสามแบบ มาไล่ดูทีละแบบด้วยตัวอย่างลูกค้าโกรธเหมือนเดิมเพื่อความง่าย

แบบแรกคือคำถามใช่/ไม่ใช่ เรียกว่า null อาจเป็นคำถามว่า "ลูกค้าคนนี้ฟังดูโกรธหรือเปล่า" สมมติ Jev ตอบ 0.9 กลับมา แปลว่ามันคิดว่ามีโอกาส 90% ว่าใช่ ลูกค้าคนนี้โกรธ แล้วโค้ดหรือสคริปต์ของคุณ — สำคัญนะ นี่ไม่ใช่ Jev ไม่ใช่ LLM แต่เป็นสคริปต์ที่เราให้ Claude เขียนได้ — ก็จะทำส่วนที่เหลือด้วย if statement ปกติ ถ้าผลลัพธ์เกินสัก 0.8 เราจะส่งต่อให้ผู้จัดการ เพื่อให้ผู้จัดการตอบลูกค้ารายนั้นโดยตรง หรือถ้าต่ำกว่า 0.2 คือแน่นอนว่าไม่โกรธ หรือ Jev ตัดสินว่าไม่โกรธแน่นอน เราก็จะไม่ส่งต่อ แต่จะลดความสำคัญของมันลง

แต่ต้องเข้าใจให้ชัดว่า Jev ไม่เคยส่งต่ออะไรเลย มันแค่ให้ตัวเลขที่แทนความน่าจะเป็นของคำตอบ "ใช่" ในกรณีนี้ 0.9 คือใช่แบบมั่นใจ ลูกค้าโกรธ ส่วน 0.5 แปลว่ามันไม่รู้เลย เหมือนโยนเหรียญ แล้วโค้ดหรือสคริปต์จะเป็นผู้ตัดสินใจจากตัวเลขที่ได้กลับมา

แบบที่สองเรียกว่า choice ตรงตัวตามชื่อ คุณกำหนดหมวดหมู่ล่วงหน้า ในเคสลูกค้าโกรธ ก็เช่น "ทีมไหนควรรับผิดชอบ query นี้ ทีมบิลลิ่ง เทคนิค หรือฝ่ายขาย" แล้วมันจะตอบกลับมาพร้อมความน่าจะเป็นของทุกตัวเลือก มันไม่ได้ตอบว่า "ใช่ เป็นฝ่ายบิลลิ่ง" แต่มันจะบอกว่าบิลลิ่งมีโอกาส 85% ที่จะถูก เทคนิค 10% ฝ่ายขาย 5% แล้วโค้ดจะ route อีเมลไปยังตัวที่ชนะ ในที่นี้คือบิลลิ่ง ดังนั้นใช้ choice เมื่อคุณจะ route output ไปที่ไหนสักแห่ง ส่วนเมื่อตัวเลือกมีลำดับ เราจะใช้แบบที่สามซึ่งเดี๋ยวคุยกัน

เมื่อมีมากกว่าหนึ่งตัวเลือก — บิลลิ่ง เทคนิค และฝ่ายขาย — คุณจะได้ตัวเลขที่สองจาก Jev เรียกว่า confidence ซึ่งคำนวณจากความกระจายของความน่าจะเป็นเหล่านั้น 85% สำหรับบิลลิ่งถือว่ามั่นใจ แต่สมมติบิลลิ่งได้ 40 เทคนิค 35 ฝ่ายขาย 25 เราก็จะมั่นใจน้อยลง บิลลิ่งยังถูกเลือกอยู่ดี แต่ confidence จะต่ำ และตัวเลขนั้นแหละที่โค้ดต้องเช็คก่อนจะไว้ใจการเลือกนั้น โค้ดจะเช็คตัวเลข confidence ด้วย

นี่คือสิ่งที่ demo เบราว์เซอร์ที่เห็นตอนต้นคลิปทำอยู่ ทุกปุ่มและช่องกรอกบนหน้าจอง booking เที่ยวบินจะได้ตัวเลข แล้ว Jev ตอบ choice สองอย่างพร้อมกัน — จะทำอะไรกับมัน คลิก พิมพ์ หรือเลื่อน ตามการกระทำหรือ input จากเสียง และจะทำกับตัวเลขไหน เราเรียงทุกอย่างบนหน้าเพจให้ได้ตัวเลข แล้วเลือก element ที่ 3 หรือ 4 หรือ 7 ซึ่งไม่มีลำดับอยู่ในตัว เราจึงรู้ว่าแบบนี้ต้องเป็น choice และ confidence ก็เป็นเหมือนกลไกนิรภัย ถ้า Jev มั่นใจ คืออยู่เหนือระดับ confidence ที่ตั้งไว้ คลิกก็จะเกิดขึ้น แต่ถ้าต่ำกว่า agent จะหยุดและถามผู้ใช้ คุณปรับเพดาน confidence ขึ้นลงได้ตามการกระทำเฉพาะ ถ้าเป็นสิ่งที่จะสร้างความเสียหายหรือมีต้นทุนสูง เราก็ต้องการ confidence ที่สูงกว่าจึงจะอนุญาตให้ลงมือ

แบบที่สามคือ score แนวคิดเหมือน choice แต่ตัวเลือกมีลำดับ และคุณอธิบายแต่ละระดับด้วยคำพูด คำถามอาจเป็น "ลูกค้าคนนี้โกรธแค่ไหน" ผลลัพธ์จะเป็นคะแนนบนมาตรวัดระหว่าง ใจเย็น หงุดหงิด และ โกรธจัด นี่คือสามตัวเลือก Jev จะตอบกลับมาเป็นตำแหน่งบนมาตรวัดนั้น และมันตกกลางระดับได้ด้วย เช่น 2.4 จาก 3 แปลว่าส่วนใหญ่หงุดหงิด (ตัวเลือกที่สอง) แต่กำลังจะไปทางโกรธจัด

เมื่อเราเรียง inbox อีเมลฝ่ายบริการลูกค้าทั้งกล่อง เราสามารถจัดเรียงจากร้ายแรงที่สุดมาก่อนได้ นี่คือสิ่งที่โค้ดหรือสคริปต์ของเราทำ 3 เต็มจาก 3 อยู่บนสุด ส่วน 1 จาก 3 อยู่ล่างสุด ใช้ score กับทุกสิ่งที่คุณวางบนมาตรวัดได้ ความต่างสำคัญระหว่าง choice กับ score คือลำดับ เช่น "ticket นี้เร่งด่วนแค่ไหน" "lead นี้เข้ากับสิ่งที่เราขายแค่ไหน" "ผู้สมัครคนนี้อยู่ระดับไหนบนมาตรวัดนี้" "bug นี้แย่แค่ไหน เป็น bug เรื่องหน้าตา bug น่ารำคาญ หรือ bug ที่ขวางการทำงาน" ใช้ score เมื่อต้องการจัดอันดับหรือเรียง ไม่ใช่ route คำตอบเหมือน choice และเพราะมันมีหลายระดับ มันจึงมี confidence แบบเดียวกับ choice แต่ null ไม่มี confidence เพราะมีแค่ใช่หรือไม่ใช่

demo ของ session เว็บไซต์ที่โชว์ไว้ตอนต้นคลิปใช้แบบแรกเป็นหลัก คือใช่/ไม่ใช่ต่อเหตุการณ์ "คนนี้คลิกแบบหงุดหงิดไหม" "คลิกแล้วไม่มีอะไรเกิดขึ้นไหม" "หน้าเพจ error ไหม" แล้วเราค่อยเพิ่ม score เป็นชั้นบนสุด "session ทั้งหมดนี้แย่แค่ไหนสำหรับผู้ใช้คนนี้" เพื่อที่เวลาเรียง session เหล่านั้น เราเรียงจากแย่สุดมาก่อนได้ แล้วคนก็แค่เปิด 10 อันดับแรก ทั้งหมดนี้ทำใน LLM ก็ได้แน่นอน แต่ LLM ไม่ได้ถูก optimize สำหรับการตัดสินใจเชิงความน่าจะเป็นแบบนี้ เราจึงทำได้ปริมาณมหาศาลในเวลาสั้น ๆ ด้วยราคาถูกมาก ๆ

วิธีเลือกระหว่างสามแบบนี้ — null, choice หรือ score — คือดูว่าโค้ดของคุณจะเอาคำตอบไปทำอะไรต่อ ถ้าต้องลงมือหรือไม่ลงมือตามคำตอบ นั่นคือใช่/ไม่ใช่ หรือ null ถ้าต้อง route คำตอบไปที่ไหนสักแห่ง นั่นคือ choice หรือถ้าต้องเรียงหรือจัดอันดับด้วย นั่นคือ score และสำคัญที่สุด ทั้งสามแบบใส่ไปใน request เดียวถึง Jev ได้เลย นี่คือตัวอย่างอีเมลหนึ่งฉบับเข้าไปพร้อมคำถามทั้งสามแบบ และนี่คือสิ่งที่ได้กลับมา เรามี null ก่อน คำถามว่า "ลูกค้าคนนี้ฟังดูโกรธไหม" ได้ 0.9 แปลว่าโค้ดควรส่งต่อให้พนักงาน ต่อมา choice "นี่ทีมไหน" บิลลิ่ง 85 เทคนิค 10 ฝ่ายขาย 5 พร้อม confidence สูง ก็จะ route ไปทีมบิลลิ่ง แล้ว score "ใจเย็น หงุดหงิด โกรธ หรือ โกรธจัด" บนมาตรวัด 4 ระดับ ได้ 2.4 ที่ confidence 80% ก็จะไปอยู่ใกล้ ๆ กองบนสุดของอีเมลที่ทีมบิลลิ่งต้องตอบ และพวกเขาจะเห็นเฉพาะฉบับที่ลูกค้าฟังดูโกรธจริง ๆ เท่านั้น รายการสั้น ๆ เพราะ Jev ประมวลผลกองใหญ่ที่ไม่จำเป็นต้องถึงมือพนักงานไปแล้ว หนึ่งอีเมลเข้า สามคำตอบออก ในเวลาที่สั้นมาก ๆ

ต่อไปมาดูวิธีจับคู่กับ Claude Code จริง ๆ เพื่อให้ได้ประโยชน์เต็ม ๆ จากทั้งสองเครื่องมือ แต่ก่อนอื่น ผมเหลืออีกไม่ถึงพัน sub ก็จะถึงหมื่นสองพันที่วิเศษและป้ายบนผนังบ้านแล้ว ถ้าดูคลิปนี้แล้วเพลิน กด sub ด้านล่างหน่อยนะครับ

มีสองวิธีจับคู่กับ Claude เพื่อให้ได้จุดแข็งของทั้งคู่ และ Typesafe พูดชัดเจนมากใน docs ว่ามันไม่ถนัดอะไร จึงควรใช้ Claude ตรงนั้น นั่นคือการใช้เหตุผล ความรู้เฉพาะทาง และทุกอย่างที่ต้องเขียนข้อความ

วิธีแรกคือใช้มันล้อมรอบความสามารถของ Claude เพื่อตรวจสอบสิ่งต่าง ๆ ก่อนที่ Claude จะอ่านอะไร ให้ Jev ตัดสินก่อนว่า Claude ควรอ่านไหม ควรเปลือง token กับสิ่งนั้นไหม Typesafe ใช้ตัวอย่าง guardrails ซึ่งคัดกรองข้อความทุกฉบับที่เข้าหา Claude เรื่อง jailbreak และคำขอที่เป็นอันตราย ตอนเข้า แล้วคัดกรองคำตอบของ Claude อีกทีตอนออก ก่อนผู้ใช้จะเห็น นี่คือตัวอย่างที่ Claude อยู่ตรงกลาง แต่ใช้ราวกัน้ำของ Jev ครอบหน้า-หลัง

ใช้แนวคิดเดียวกันหลังการประมวลผล LLM ได้ด้วย ในตัวอย่าง citation ของพวกเขา LLM เขียนเอกสารที่มีการอ้างอิง 8 จุด แล้ว Jev ตรวจ quote แต่ละอันกับแหล่งที่มา 4 จุดผ่าน 1 จุดเป็นการอ้างอิงที่ไม่มีอยู่จริง 1 จุดพูดตรงข้ามกับต้นฉบับ และ 2 จุดถูกส่งต่อให้มนุษย์เพราะ Jev ไม่แน่ใจ นี่คือการ post-process เนื้อหาของ Claude ผ่าน Jev เพื่อยืนยันว่าทุกอย่างที่ปล่อยออกไปถูกต้องตามข้อเท็จจริง

วิธีที่สองคือใช้มันแทน Claude สำหรับงานจำนวนมาก งานที่ scale ใหญ่กว่าแต่ deterministic มาก อย่าใช้ Claude เรียง 5,000 แถว แท็ก ticket ทุกใบใน inbox หรือให้คะแนน lead ทุกตัว Claude ควรได้เฉพาะแถวที่ Jev ไม่แน่ใจ หรือแถวที่ต้องเขียนอะไรสักอย่าง ถ้าเป็นการให้คะแนนแบบ deterministic ก็ควรใช้ Jev แทน Claude ในขั้นตอนนั้นของ workflow และนี่คือสิ่งที่คุณคงเห็นกันทั่ว X หรือ Twitter มีคนให้คะแนน sales lead 700 ตัวใน 40 วินาที ราคาประมาณ 9 เซนต์ งานกองโตอย่างนี้ใช้ Claude จะช้ากว่ามากและแพงกว่ามากด้วย และทั้งสองตัวอย่างนี้ เราจะสร้างมันด้วยกันใน 5-10 นาทีต่อจากนี้ด้วยเคสฝ่ายบริการลูกค้า

มาตั้งค่าใน Claude Code กันเลย Typesafe ปล่อย skill สำหรับใช้ใน LLM อย่าง Claude Code หรือ harness ทำนองเดียวกันมาให้ ติดตั้งแค่สองบรรทัด จะทำผ่าน console หลังสมัครที่ typesafe.ai ก็ได้ ก็อปปี agent prompt ไป หรือไปที่ docs.typesafe.ai/agent-skill แล้วรันสองคำสั่งนี้ใน terminal เพื่อติดตั้งเข้า Claude Code เอาคำสั่งจากตรงนั้นตรง ๆ ก็ได้ หรือใช้กับ agent ตัวอื่นก็ได้เหมือนกัน ข้อแนะนำคือต้องเอ่ยชื่อ skill ใน prompt ทุกครั้ง เช่น "use the Typesafe skill" คุณจะเห็นใน prompt ของเราตลอด รันสองคำสั่งนั้น มันจะเพิ่ม marketplace แล้วเรา reload เพื่อยืนยันว่า plugin ติดตั้งแล้ว ขึ้นว่า success พอ reload หรือเปิด session ใหม่ใน Claude Code รัน /plugins ไปที่ installed จะเห็น plugin ของ Typesafe เปิดใช้งานแล้ว จากนั้นไปที่หมวด API key สร้าง key ใหม่ แล้วใส่ในไฟล์ env ชื่อ TYPESAFE_API_KEY แล้วทดสอบว่าใช้ได้ด้วยการสั่ง "use the Typesafe skill" ซึ่งสำคัญมาก "ตรวจว่า key ของผมใช้ได้ไหม ถาม Jev คำถามใช่/ไม่ใช่หนึ่งข้อเกี่ยวกับ" และนี่คือ input ของเราที่สมมติเป็นอีเมลลูกค้า "เราถูกตัดเงินสองครั้ง ช่วยแก้ด่วน" แล้วขอให้ Jev ประเมินตามคำถาม "ลูกค้ากำลังรายงานปัญหาการเรียกเก็บเงิน" และบอกคำตอบดิบที่ได้จาก Jev กลับมา ควรได้แค่ใช่หรือไม่ใช่ในรูปตัวเลขที่บอกว่านี่เป็นปัญหาบิลลิ่งหรือน่าจะเป็น

ก่อนรัน ถ้าคุณไม่ได้ใช้ Claude Code ตรง ๆ แต่อยากใช้ในแอป desktop ผมยังไม่ได้ทดสอบ แต่น่าจะเหมือนกันทุกประการ เพียงไปหา skill.md บน GitHub เปิดหน้านั้นแล้วดาวน์โหลด แล้วอัปโหลด skill ในหมวด customize ภายใน skills ของคุณ แล้วคุณก็ควรจะใช้ Jev ในแอป Claude desktop ได้เช่นกัน

มารัน prompt นี้กัน ใช้ Typesafe skill แล้วดูว่าได้อะไรกลับมา นี่คือ request ที่สร้างจาก Typesafe skill state คือข้อมูลที่เราส่ง "ถูกตัดเงินสองครั้ง แก้ด่วน" คืออีเมล ส่งให้ Jev คำถามคือ "เป็นปัญหาบิลลิ่งไหม" ระบุว่าเป็นใช่/ไม่ใช่ พร้อมคำอธิบายเกณฑ์ "ลูกค้ากำลังรายงานปัญหาการเรียกเก็บเงิน" ตรงตามเกณฑ์ที่เราต้องการประเมินเลย

เกณฑ์ของ "ใช่" คือ ข้อความรายงานปัญหาเกี่ยวกับค่าธรรมเนียม การชำระเงิน ใบแจ้งหนี้ การคืนเงิน หรือการเรียกเก็บค่าสมาชิก ส่วนเกณฑ์ของ "ไม่ใช่" คือ ข้อความไม่ได้รายงานปัญหาบิลลิ่ง เห็นไหมว่านี่คือเกณฑ์ที่อธิบายละเอียด จน Jev ตัดสินได้ว่าข้อความหรือ state นี้น่าจะเป็นใช่หรือไม่ใช่เทียบกับเกณฑ์นั้น Claude สร้างเกณฑ์นี้ขึ้นจาก Typesafe skill

คำตอบที่ได้กลับมาคือตัวเลขเดียว 0.99 โดย 1 หมายถึงเป็นปัญหาบิลลิ่งแน่นอน 0 หมายถึงไม่ใช่เลย นี่คือ response ตรง ๆ จาก Jev input 324 token output 24 token และผมขอให้ Claude ดึงเวลาและต้นทุนมาด้วย ส่วนของ Jev ใช้เวลา 0.3 วินาที ซึ่งน่าจะเป็นตัวเลขที่สูงเกินจริง เพราะ Claude ต้องเชื่อมต่อก่อนหน้านั้นด้วย ส่วน 324 input token มีค่าประมาณ 0.0136 เซนต์ เห็นไหมว่าถ้าทำแบบนี้กับอีเมลหลายพันฉบับก็แทบไม่กระทบเงินไม่กี่เซนต์เลย ต้องเรียกแบบนี้ถึง 73,000 ครั้งถึงจะใช้เงินหนึ่งดอลลาร์ ถูกและเร็วสุดขั้นจริง ๆ ส่วน output 24 token ที่แค่บอกตัวเลขนั้น แทบไม่มีค่าใช้จ่ายเลย

และถ้าย้อนกลับไปดูว่า skill นี้ทำอะไร — Typesafe skill ไม่ได้รันอะไรเองเลย มันคือ rule book ที่ Claude หรือ agent อื่นใช้กับคำถามสามแบบนั้น มันบอกได้ว่าคำถามควรเป็นแบบไหน วิธีเขียนคำถามที่ Jev จะไม่อ่านเข้าใจผิด เรื่องความเฉพาะเจาะจงของคำถาม เมื่อไหร่ควรรวมคำถามเป็นชุด เมื่อไหร่ควรแยก ซึ่งเดี๋ยวค่อยคุยกัน และวิธีวาง threshold และระดับ confidence ดังนั้นถ้าคุณทำงานจาก Claude คุณไม่ได้คุยกับ Jev ตรง ๆ เลย คุณอธิบายงานเป็นภาษาคน Claude อ่าน skill เขียนสคริปต์ประเมิน สคริปต์ส่งแถวข้อมูลไปให้ Jev แล้ว Claude อ่านผลลัพธ์กลับมาให้ฟัง นี่คือวิธีใช้ทั้งคู่ร่วมกัน ทางเลือกอื่นคือใช้ OpenRouter ข้าม Claude Code แล้วเรียกโมเดล Jev จาก OpenRouter ตรง ๆ แต่แปลว่าคุณต้องแต่งคำถาม แต่งคำอธิบาย และจัดโครงสร้าง input ให้ Jev เองทั้งหมด

ตอนนี้คุณเห็นแล้วว่า key ใช้ได้ เร็วมาก และขยาย scale ได้ มาถอดโครงวิธีใช้สิ่งนี้เองด้วยตัวอย่างอีเมลสนับสนุนลูกค้า 50 ฉบับที่เข้ามาข้ามคืน ผมมี CSV หรือ Google Sheet ของอีเมลสนับสนุน 50 ฉบับ เวลาที่ได้รับ ID อีเมล ลูกค้ารายนี้อยู่กับเราตั้งแต่เมื่อไหร่ แพ็กเกจไหน ใบแจ้งหนี้ล่าสุดที่จ่าย หัวเรื่อง เนื้อความ ทุกอย่างที่ต้องส่งให้ Jev เราจะถอดวิธีเปลี่ยนสิ่งนี้เป็น workflow ที่คัดแยกให้ฉบับง่าย ๆ ได้คำตอบอัตโนมัติ ฉบับเสี่ยงส่งต่อพนักงาน และเมื่อเข้าคิวแล้วเรียงตามลำดับความสำคัญ เพื่อให้คนที่มานั่งเปิดอ่านตอนเช้าเห็นเรียงไปทำทีละอัน

อีเมลเหล่านี้อยู่ใน emails.csv ที่เตรียมไว้ หรือถ้าใช้ harness อย่าง Claude Code ก็เสียบ MCP ตรงเข้า inbox อีเมลจริงแล้วประมวลผลแบบเดียวกันได้ มีตัวอย่างเช่น "สวัสดี เพิ่งเห็นว่าถูกตัดเงินสองรายการ 99 ดอลลาร์" "สมัครทดลองใช้แล้ว magic link ไม่มา" มี feature request "เพิ่ม Perplexity ได้ไหม" มีเรื่องร้องเรียน "ตัวเลข metrics ไม่แสดง หรือตัวเลขลดลง" มีคำถามเรื่อง GDPR compliance ทั้งหมดนี้คือข้อมูลที่ให้ Jev ประเมินได้เร็วมากเทียบกับชุดคำถาม

เวลาถอดโครง สิ่งสำคัญที่สุดก่อนเขียนสักคำถามเดียวคือตัดสินใจก่อนว่าโค้ดจะเอาคำตอบแต่ละอันไปทำอะไร คำตอบที่ได้จาก Jev ไม่ว่าจะความน่าจะเป็นหรือตัวเลข ต้องเป็น trigger ของการกระทำ ทุกคำถามที่เราแต่งต้อง trigger การกระทำเฉพาะเจาะจง และเดี๋ยวเราจะคุยกันว่าหาคำถามจากไหนก่อน

พิจารณาการกระทำที่จะเกิดจากผลลัพธ์ในเคสสนับสนุนลูกค้านี้ เรามีสี่การกระทำ คือ ตอบอีเมลด้วย Claude โดยตรงหรือให้ Claude ร่าง ส่งเข้าคิว engineering ในฐานะ bug ที่ต้องแก้ บันทึกเป็น feature request ไว้ก่อน หรือส่งต่อ/ขยายเรื่องให้คนจัดการ นี่คือสิ่งที่ผมต้องบอก Claude — งานที่ต้องทำ สี่การกระทำหรือเส้นทางที่เลือกได้ และคำสั่งเดียวคือ "โชว์แผนก่อนรันอะไรทั้งสิ้น" เพื่อให้เราเห็นโครงสร้างแผนที่จะส่งให้ Jev และไล่อ่านทีละชิ้นก่อนรันกับข้อมูลทั้งกองว่ามีคำถามอะไร รันบนข้อมูลชุดไหน

เรื่อง prompt ผมเจาะจงมาก แต่คุณจะให้ Claude เขียน prompt แบบนี้สำหรับ use case ของคุณเองก็ได้แหละ อย่างที่ผมทำ อีกครั้ง ต้องมี "use the Typesafe skill" สำคัญมาก "ผมมีอีเมลสนับสนุน 50 ฉบับใน emails.csv ในโฟลเดอร์ downloads ทุกเช้า ผมอยากให้มันถูกคัดเข้าสี่กอง" — นี่คือสี่การกระทำของเรา ตอบด้วย Claude คิว engineering ส่งให้คน ฯลฯ "แต่ละกองเรียงลูกค้าที่โกรธที่สุดขึ้นก่อน" จากสิ่งเหล่านี้ บวกกับ Typesafe skill มันจะเข้าใจลำดับความสำคัญและคำถามที่ต้องถาม เข้าใจว่าต้องมีคำถามแบบ score เพื่อให้คะแนนความโกรธ และเพราะผมมีภาพชัดว่าอยากรู้อะไรในแต่ละฉบับ ผมระบุไปเลย แต่ปล่อยให้ Claude กำหนดคำถามและเกณฑ์เองก็ได้

ต่อฉบับ ผมอยากรู้ว่ามันเกี่ยวกับอะไร อาจเป็น choice บิลลิ่ง เทคนิค feature request บัญชี หรือ "ไม่ใช่อันไหนเลย" การใส่ "ไม่ใช่อันไหนเลย" สำคัญมาก เพราะถ้าไม่มีตัวเลือกนี้ Jev จะพยายามเลือกอะไรที่น่าจะใช่ที่สุดอยู่ดี แต่พอมีตัวเลือกนี้ มันมีทางออกให้ตอบว่าไม่เข้าข่าย ผมอยากรู้ว่าเขาขอเงินคืนหรือขอ refund ไหม อยากรู้ว่ามีอะไรพังหรือเปล่า เพราะนั่นคือ trigger ให้ส่งเข้าคิว engineering

ผมอยากรู้ระดับความโกรธบนมาตรวัด ใจเย็น หงุดหงิด โกรธจัด ประมาณ 1 ถึง 3 และอยากรู้ว่าเป็นเรื่องกิจวัตรธรรมดา ต้องใช้วิจารณญาณหน่อย หรือผิดสังเกตพอที่ควรให้คนจัดการ จากนั้นผมเพิ่มกฎว่าโค้ดจะทำอะไร Claude Code จะสร้างโค้ดที่ประมวลผลคำตอบของ Jev — ทุกอย่างที่เกี่ยวกับเงินต้องส่งให้คนเสมอ ห้ามให้ Claude จัดการ และผมต้องการ confidence สูงสำหรับข้อนี้ ถ้า Jev ไม่มั่นใจเรื่องหมวดหมู่ หรือเคสผิดสังเกต ส่งให้คน ถ้าผลิตภัณฑ์พังจนใช้ไม่ได้ ส่ง engineering ส่วน feature request บันทึกไว้ ที่เหลือให้ Claude ร่างคำตอบโดยใช้ reply guide ที่กำหนด ซึ่งเป็นทรัพยากรแบรนด์แยกต่างหาก และเราจะเรียงทุกกองด้วยคะแนนความสำคัญที่อิงความโกรธเป็นหลักและความรุนแรงของปัญหาเป็นรอง ดังนั้นต้อง score จากหลายคำถาม

Claude ทำงานร่วมกับ Typesafe skill จะเข้าใจว่าต้องแตกสิ่งเหล่านี้เป็นคำถามเชิง deterministic แยกอัน ที่ Jev ให้คะแนนความน่าจะเป็นพร้อม confidence และเราระบุเพิ่มเพราะอยากได้การตรวจสอบพิเศษ ก่อนเซฟฉบับร่างของ Claude ทุกฉบับ ให้เช็คกับ Jev อีกหนึ่ง request แยกต่างหาก ด้วยคำถามต่างจากชุดแรก — "มันตอบคำถามของลูกค้าจริงไหม" และ "มันรับปากคืนเงินหรือลดราคาไหม" คือทำ validation ซ้ำหลัง Claude สำหรับฉบับที่ Claude เขียน แล้วเก็บเฉพาะฉบับที่ผ่านทั้งสองด่าน เขียนแผนเป็นสามส่วน — state คือข้อมูล input คำถามพร้อมเกณฑ์ และการ route พร้อม threshold ของทุกกฎ คือระดับ confidence ที่ผ่านกฎนั้น ๆ เก็บในไฟล์เดียว และโชว์แผนก่อนรันอะไรทั้งสิ้น

คุณจะขอดูสคริปต์ที่จะส่งให้ Typesafe หรือ Jev ก็ได้ แต่แบบนี้เราก็อปปีไปวางใน Claude Code ที่ติดตั้ง Typesafe ไว้แล้วรันได้เลย และสิ่งที่มันจะทำคือส่งแผนกลับมา ตอนนี้เรายังไม่สนเรื่องความเร็ว เพราะเป้าหมายตอนนี้คือได้แผนดี ๆ พร้อมชุดคำถามที่ดี เพื่อให้รันกับ Jev ได้เต็มที่ Jev จะทรงพลังกับ workflow แบบกองโตก็ต่อเมื่อเราถามได้ดี และ Claude หรือ LLM สามารถแตกความต้องการของเราเป็นคำถามที่ดีได้

ตอนนี้เราได้แผนของ Claude กลับมาในไฟล์ questions.py แล้ว สิ่งแรกที่เห็นคือ state หรือหน้าตาของแต่ละอีเมลเมื่อถึงมือ Jev มันใช้ skill กำหนดว่า state ควรหน้าตาเป็นแบบไหน เรามี ID เวลาที่รับ แพ็กเกจ หัวเรื่อง เนื้อความ ทุกฟิลด์ สิ่งที่มันบอกคือเราต้องมี object หนึ่งชิ้นต่ออีเมล แทนที่จะเป็นข้อความยาว ๆ เพื่อให้ทุกส่วนมีชื่อที่บอกความหมาย ความสัมพันธ์จึงชัดเจน มันใส่ข้อมูลลูกค้าเช่นแพ็กเกจหรืออายุการเป็นลูกค้า เพราะลูกค้ารายแรกบนแพ็กเกจสูงสุดเป็นเคสคนละเรื่องกับทรายลองอายุหนึ่งวัน Jev จะปฏิบัติทั้งสองแบบต่างกัน

มันแมพคอลัมน์ของ CSV ออกมาให้สคริปต์ แปลงหนึ่งแถว CSV เป็น state หรือ input ของ triage request ทุกแถวจะมีข้อมูลอีเมลที่ส่งเข้า Jev และข้อมูลลูกค้า แยกเป็นหมวดเฉพาะเจาะจง เพราะ skill สั่งให้ทำ เพื่อให้คำถามเรียกฟิลด์ได้ด้วยชื่อ และตัดสิ่งที่ไม่เกี่ยวออก เช่น ประวัติบทสนทนาเก่า ๆ เพราะยิ่งมีข้อความที่ไม่เกี่ยวเข้าสู่การตัดสินใจมากเท่าไหร่ยิ่งแย่ และนี่พาเราไปสู่ข้อจำกัดแบบ hard limit ของ Jev คือ 64,000 token ต่อ request แต่คุณไม่ควรจะเข้าใกล้ตัวเลขนั้นเลย มันไม่ได้ออกแบบมาแบบ LLM ที่ยัด input ล้าน token มันต่างกันมาก request แบบ structured นี้กระชับตรงประเด็น ถามคำถามที่นิยามชัดเจน

เรายังมี state สำหรับรอบสอง ซึ่งอิงจากหัวเรื่องและเนื้อความของอีเมลที่ถูกร่างคำตอบ และ state ตัวที่สองสำหรับรอบสองที่จะทำตอน Claude ร่างคำตอบ มันจะบรรจุข้อมูลอีเมลและฉบับร่างจริง เพื่อดูว่าเราตอบคำถามหรือยัง ซึ่งเป็นรอบที่สองที่เราวางไว้

ส่วนที่สองที่มันแตกออกมาคือคำถาม เรามีห้าคำถามต่ออีเมลใน request เดียว ทุกอีเมลใน CSV จะได้คำถามทั้งห้าข้อตอบใน request เดียว ซึ่งไม่มีปัญหา เพราะทุกคำถามที่เพิ่มเข้าไป จะสิบหรือสิบห้าข้อก็แทบไม่มีค่าใช้จ่าย คำถามเหล่านี้แทบฟรี เราจึงส่งทีเดียวทั้งหมด ให้ประมวลผลทุกเกณฑ์ขนานกันไป และในแต่ละคำตอบเราจะได้คะแนนและ confidence กลับจาก Jev

มันสร้างคำถาม triage หลายข้อ ข้อแรกเป็น choice "อีเมลสนับสนุนนี้เกี่ยวกับอะไรเป็นหลัก" ถ้าเป็นบิลลิ่ง เกณฑ์คือเรื่องค่าธรรมเนียม ใบแจ้งหนี้ การชำระเงิน ค่าสมาชิก แต่ไม่รวมปัญหาล็อกอินหรือการเข้าถึง เราระบุชัดว่าคืออะไรและไม่ใช่อะไร พร้อมตัวอย่าง ต่อมาเทคนิค feature request บัญชี และ "ไม่มี" อย่างที่บอก ทุก request ต้องมีทางออกให้เลือก "ไม่มี" เพื่อไม่ให้มันต้องยัดเยียดเข้าหมวดใดหมวดหนึ่ง

แล้วเราแตกต่อเรื่อง "ขอเงินคืน" เกณฑ์ของ null ถ้าจริง คืออีเมลขอให้คืนเงินหรือ cred เงินคืน ถ้าเท็จ คืออีเมลไม่ได้อ้างสิทธิ์เงินที่จ่ายไปแล้ว และระบุว่าการขอยกเลิกโดยไม่พูดถึงการคืนเงินถือเป็นเท็จ เพราะเขาจะไม่ได้เงินคืนจากการนั้น เราแตกเรื่อง "พังหนักแค่ไหน" เป็น score ให้เกณฑ์แต่ละระดับจาก 1 ถึง 4 — ไม่มีอะไรพัง เสียหายเรื่องหน้าตา น่ารำคาญ และใช้ของไม่ได้เลย สิ่งสำคัญคือเราเจาะจงกับเกณฑ์มาก "น่ารำคาญ" หมายถึงอะไร หมายถึงฟีเจอร์ทำงานเสื่อมหรือล้มเหลวบางครั้ง แต่มีทางแก้ผ่าน

เพราะเราระบุไว้ Jev จึงมั่นใจได้มากขึ้นในการตัดสินว่าน่ารำคาญหรือไม่ และต้องจำไว้ว่าทุกอีเมลผ่านเกณฑ์เดียวกันหมด เช่น อีเมลบิลลิ่งก็ยังโดนถามคำถามความเสียหายเหมือนกัน "ผลิตภัณฑ์พังแค่ไหนสำหรับลูกค้าคนนี้" จากที่อีเมลบรรยายมันก็จะตอบว่าไม่พังเลย และคะแนนนั้นก็ถูกละเลยไป การส่งคำถามทั้งหมดพร้อมกันทำให้เร็วขึ้น ประมวลผลขนานกันหมด เราแค่เข้าใจว่าไม่เกี่ยวกับความเสียหาย คะแนนเป็นศูนย์ และไม่มีการกระทำตามคะแนนนั้นสำหรับอีเมลนั้น

เรื่องความโกรธ "ลูกค้าคนนี้โกรธแค่ไหน" เป็น score จากใจเย็นถึงโกรธจัด และ Claude ยังแตกเรื่อง "ต้องใช้วิจารณญาณมนุษย์แค่ไหน" เป็นเคสมาตรฐาน ต้องใช้วิจารณญาณ หรือผิดสังเกต ซึ่งเป็น choice ให้เลือกหนึ่งในสาม

ในรอบสอง เรามีคำถามยืนยัน — ตอบคำถามหรือยัง รับปากคืนเงินหรือลดราคาไหม — แล้ว Claude จะใช้ Typesafe skill แปลงทั้งหมดเป็น request ตามโครงสร้าง JSON ที่เห็นก่อนหน้า ส่งให้ Jev

ในแผนยังมีกฎการ route — จะส่งให้คน ทีม engineering หรือกองไว้ให้ Claude ร่างคำตอบ พร้อมระดับ confidence ที่ใช้วัด คุณเข้าไปแก้ค่าพวกนี้ได้ ถ้า confidence ของหมวดหมู่ต่ำกว่าเกณฑ์ในกฎข้อสอง ผลลัพธ์จะไม่ถูกไว้ใจ และจะถูก route ไปหาคน แล้วล่างสุดมีสคริปต์ route จริง ๆ ที่ Claude เขียนตาม Typesafe skill อย่างที่บอก ไม่มีการตัดสินด้วย LLM ตรงนี้เลย เป็นสคริปต์ล้วน ๆ ส่งผลลัพธ์จาก Jev ผ่านกฎเหล่านี้เข้ากองที่ถูกต้อง ทั้งหมดเป็น if statement ที่ตรวจสอบได้กับตัวเลขที่ Jev ตอบกลับมา

คุณเห็นแล้ววิธีเขียนสิ่งนี้ด้วย Claude ซึ่งเร็วกว่าเขียนเองมาก แต่ส่วนที่ยากกว่าคือการรู้ว่าควรถามอะไรเกี่ยวกับกระบวนการของคุณตั้งแต่แรก นี่คือส่วนที่ผมหาในเน็ตไม่เจอ ไม่มีใครเขียนไว้ ผมเลยทำ checklist ของตัวเอง ดาวน์โหลดฟรีในคำอธิบายด้านล่าง ใช้ไล่หาคำถามที่ต้องถามกับกระบวนการของคุณ หรือหา requirement ที่จะใส่เป็น prompt แรก สิ่งนี้ไม่มีแม้แต่ใน skill ที่เขาให้มา ซึ่งเป็นเกณฑ์เฉพาะเรื่องโครงสร้าง request ไปหา Jev

นี่คือ checklist ที่ผมใช้กับห้าหัวข้อคำถาม ประกอบจาก docs ที่อ่านและวิดีโอ use case ของ Jev ที่ดูมา หลักการคือคิดจากมุมว่าซอฟต์แวร์จะทำอะไรต่อ ไม่ใช่มุมของข้อมูล ทุกคำถามที่ถาม Jev มีอยู่เพราะต้อง trigger การกระทำ การกระทำขึ้นอยู่กับมัน ดังนั้นเขียนรายการการกระทำก่อนเป็นข้อหนึ่ง ของเราคือ Claude ตอบ ส่งคิว engineering บันทึก feature log หรือส่งให้คน

ข้อสอง สำหรับทุกการกระทำ เขียน trigger เป็นหนึ่งประโยค ประโยคนั้นคือคำถามของคุณ และมันบอกการกระทำซึ่งบอกชนิดคำถาม — ถ้าลงมือหรือไม่ลงมือคือ null ใช่/ไม่ใช่ ถ้าเลือกปลายทางต่างกันคือ choice เป็นปัญหา routing ถ้าเรียงลำดับคือ score ข้อสาม เขียนว่าคนจะดูอะไรก่อนตัดสินใจ คือ input คือ state อะไร ในที่นี้คืออีเมลเดี่ยวหรือรายการอีเมล ข้อสี่ เพิ่ม "อะไรอีกที่อาจเป็นจริงและจะเปลี่ยนการ route" นี่คือ edge case แม้หายากมาก ความรุนแรงของ bug มาจากไหนก็จากตรงนี้ เราจะ route ตามความรุนแรงของ bug จึงต้อง score มัน ข้อห้า ตัดสินว่าคำตอบผิดจะทำให้เสียหายเท่าไหร่ เพื่อตั้งระดับ confidence หรือความยอมรับได้ นั่นคือ threshold ของแต่ละการกระทำ ซึ่งคุณเห็นแล้วว่าเรามี threshold ของ confidence ครบทุกกฎ

ผมรันกับอีเมลทั้ง 50 ฉบับใน CSV แล้ว ใช้เวลา 4.2 วินาทีสำหรับทั้งหมดด้วย worker ขนานแปดตัว ถ้ารันเรียงลำดับจะใช้ 31 วินาที ซึ่งเป็นวิธีที่คุณน่าจะทำกับ LLM แต่มันทำพร้อมกันหมดได้ ต้นทุน 0.026 เซนต์สำหรับทั้ง 50 ประมาณ 19,000 อีเมลต่อหนึ่งดอลลาร์ ถ้ารันทุกเช้า 50 ฉบับ จะเสียค่าใช้จ่ายราวหนึ่งดอลลาร์ต่อปี ถูกเหลือเชื่อ

ผลลัพธ์อยู่ในไฟล์ markdown ให้อ่านง่าย เรียงตามลำดับความสำคัญ โดยถ่วงน้ำหนักความโกรธ 70% ความรุนแรง 30% เห็นว่า 19 ฉบับถูก route ไปหาคน ตามระดับความโกรธและความรุนแรง พร้อมหัวเรื่องและเหตุผลที่จัดหมวดนั้น เช่นคนขอเงินคืนบนมาตรวัด 0 ถึง 3 เขาโกรธมาก และ Jev ถือว่ารุนแรง พนักงานสนับสนุนลูกค้าจึงมีลิสต์เคสเรียงลำดับความสำคัญไว้ทุกเช้า และใช้เวลาไม่ถึงสิบวินาที นอกจากนี้ยังมีกองคิว engineering กอง feature request และ 19 ฉบับที่ Claude ตอบได้เลย ซึ่งไม่ใช่งานของพนักงานอีกต่อไป

ตอนนี้คุณเห็นวิธีจับ Jev คู่กับ Claude แล้ว ต่อไปคือกฎที่ต้องทำตามเพื่อให้ได้ประโยชน์สูงสุด นี่คือ pattern ที่ถอดจาก docs โดยตรง ข้อแรกฟังดูย้อนแย้งแต่เป็น insight สุดยอด — ถามทุกอย่างพร้อมกันเลย เราถามคำถามทั้งห้าใน request เดียวอย่างที่ทำไปแล้ว

ปัญหาที่ pattern นี้แก้ก็คือการรอคอย และนี่คือเหตุผลที่มันเร็วสุดขั้น กับโมเดลแชท คุณถามหนึ่งอย่าง รอ แล้วค่อยตัดสินว่าจะถามอะไรต่อ แต่กับ Jev ทุกคำถามใน request รันขนานกันอย่างที่เห็น และคุณจ่ายค่าอ่านข้อความแค่ครั้งเดียว ถามทุกอย่างล่วงหน้า รวมถึงคำถามที่อาจไม่เกี่ยว เช่น ความรุนแรงของ bug ในสถานการณ์บิลลิ่งเมื่อกี้ แล้วมันก็จะตัดสิ่งที่ไม่ต้องใช้ทิ้ง นี่เรียกว่า speculative fan-out เช่น ถ้ากลับมาเป็น query บิลลิ่ง คำตอบเรื่อง bug จะถูกละเลยในการประมวลผลทันที แต่ถ้ามันเป็น bug คุณก็มีความรุนแรงอยู่แล้ว ไม่ต้องเรียกอีกรอบเพื่อดูความรุนแรง หนึ่ง request คำถามหลายข้อ หลายชนิดปนกันได้ทั้ง null choice และ score

Pattern สองคือการ gate การตัดสินใจตามระดับ confidence ของการกระทำเฉพาะ ช่วยให้คุณสร้างระบบที่ทั้งเสถียรและปลอดภัย รู้ว่าฟังยาวไป ตัวอย่างที่ Typesafe ใช้ใน docs คือ voice banking สมมติ confidence ต่ำกว่า 0.6 คือ 60% ใกล้ ๆ ห้าสิบห้าสิบ จะถูกส่งต่อให้คน "เช็คยอดคงเหลือ" ที่ 0.6 ก็ผ่านได้ เพราะกรณีแย่ที่สุดคือมีคนได้ยินยอดของตัวเองหากมันพลาด แต่การกระทำต่างชนิดกันต้อง gate ต่างกัน "อนุมัติโอนเงิน" ต้องมั่นใจกว่านั้นมาก สัก 0.85 ต่ำกว่านั้นมันจะขอให้คุณยืนยันก่อนว่าใช่การกระทำที่ตั้งใจทำหรือเปล่า คุณเห็นสิ่งนี้ใน demo เบราว์เซอร์เสียงตอนต้นคลิป — เลื่อนหน้าลงเกิดขึ้นทันทีเลย แต่การกระทำที่ทำลายอะไรบางอย่าง เช่น ปิดแท็บ มันจะหยุดถามขอยืนยันก่อนเสมอ เพราะมันต่ำกว่า threshold ที่ตั้งไว้ คุณมีหนึ่ง threshold ต่อหนึ่งการกระทำ กำหนดจากต้นทุนของการตอบผิดในการกระทำนั้น

Pattern สามคือการให้คะแนนรายส่วนโดยแตกเป็นคำถามแยก แล้วถ่วงน้ำหนักหรือรวมกัน กฎนี้มีเพราะคุณถูกส่งเสริมให้แตกการตัดสินของมิติต่าง ๆ ที่เป็นอิสระต่อกันออกเป็นคำถามแยก ให้คะแนนแต่ละด้านแยก แล้วรวมด้วยน้ำหนัก เพื่อที่เราจะคุมการ route ได้ในโค้ด ยกตัวอย่างให้เห็นภาพ คือการตัดสินใหญ่ ๆ ยุ่ง ๆ เราอาจมี CV กองหนึ่ง แล้วถามว่า "คนนี้เป็นผู้สมัครที่ดีไหม" ให้คะแนน 1 ถึง 10 คุณจะได้ตัวเลขเดียวจาก Jev ที่คุณถามต่อไม่ได้ ไม่รู้ว่ามันใช้เกณฑ์อะไรตัดสิน แต่สิ่งที่เราควรทำคือแตกมันออกเป็นสิ่งที่ความ "ดี" หมายถึง สำหรับวิศวกร อาจเป็นความลึกด้าน Python ทักษะนำทีม การออกแบบระบบ หรือความเร็วในการเรียนรู้ของใหม่ สำหรับ senior engineer คุณถ่วง Python กับ design อย่างละ 40% เป็นเกณฑ์ แต่สำหรับตำแหน่งผู้จัดการ อาจเป็น leadership ที่ได้ 40% แทน

Pattern สี่ pattern สุดท้ายคือ route ไปยังตัวจัดการที่ดีที่สุดสำหรับงานนั้น เรียกว่า intent routing เราจะจำแนก request ที่เข้ามาแล้ว route แต่ละอันไปยังตัวจัดการที่เหมาะสมที่สุด ไม่ว่าจะเป็น logic deterministic ในสคริปต์อย่างที่เห็น LLM เฉพาะทางอย่าง Claude หรือมนุษย์ Jev นั่งอยู่หน้าทั้งหมดนี้ในฐานะตัวจำแนกที่เร็วและถูก ตัดสินว่าจะเรียกตัวจัดการไหน จะส่งให้พนักงานบริการลูกค้าหรือไม่ "ออเดอร์ของผมอยู่ไหน" จะไปที่การค้น database ไม่ใช้ AI ไม่ต้องใช้คน แต่คำถามเรื่องผลิตภัณฑ์จะไปที่ Claude ที่เข้าถึงเอกสารผลิตภัณฑ์ แล้วเรื่องร้องเรียนจะโดนถามต่ออีกข้อว่าซับซ้อนแค่ไหน และพวกยุ่งยากจะไปหาคนตั้งแต่แรก ส่วนอะไรที่ confidence ต่ำจะไม่ผ่าน threshold และไปหาคนอยู่ดี

เมื่อรวมสี่ pattern เข้าด้วยกัน คุณจะได้ demo บ้านอัจฉริยะที่ Typesafe มีไว้ใน docs ซึ่งใช้ทุกอย่างพร้อมกัน นี่คือการควบคุมไฟและอุปกรณ์ในบ้านด้วยเสียง การพิมพ์คำสั่ง หรือแอป คุณพิมพ์ว่า "ปิดไฟทั้งบ้าน" request เดียวจะถามว่าเป็นคำขอชนิดไหน ห้องไหน อุปกรณ์อะไร และต้องทำการกระทำอะไร แล้วถ้าคุณพิมพ์สองคำสั่งในหนึ่งประโยค Jev จะเห็นว่าเป็น compound request แล้วส่งให้ LLM แยกมันออก จากนั้นค่อยตัดสินทั้งสองส่วน มันเข้าใจว่าต้องแตก request เป็นหลายคำถาม แล้วถ้าคุณถามเรื่องทั่วไปที่ไม่เกี่ยว มันก็รู้จักส่งต่อให้ LLM ตอบ นั่นคือ pattern สี่นั่นเอง

ประเด็นทั้งหมดคือพวกเขาวาง Jev เคียงข้าง LLM Jev ทำงานเร็วมากบนการกระทำ deterministic ที่มีคำถาม threshold confidence ฯลฯ จนคุณแทบไม่รู้สึกถึงตัวตนมัน มันตัดสินใจได้เร็วมากจนกำหนดขั้นตอนถัดไปที่น่าจะใช่ได้ทันที ตามคะแนนและ confidence เทียบกับเกณฑ์ของคุณ

ถ้ายังไม่เห็น ผมตื่นเต้นกับเรื่องนี้มาก เพราะพอจับมันคู่กับ Claude Code หรือ GPT Astra คุณได้คอมบิเนชันที่โหดจริง ๆ Jev ทำงานจำแนก deterministic จำนวนมากได้เร็วสุดขั้วในราคาต่ำสุดเป็นประวัติการณ์ ขณะที่ Claude ทำแชทไปมา การใช้เหตุผล และการตัดสินใจที่ต้องคิดเพิ่มหรือเกณฑ์ยืดหยุ่นกว่า ถ้าอยากดูวิดีโอการเอาคอมบิเนชันนี้ไปใช้กับโดเมนอย่าง GEO หรือ browser use คอมเมนต์ไว้ด้านล่างได้เลย แล้วพบกันคลิปหน้าครับ

03

หมายเหตุการแปล

ความโปร่งใสเกี่ยวกับความไม่แน่นอนในต้นฉบับ

  • "0.0136"** — คำบรรยายพูดว่า "324 input tokens is effectively 0.0136" หน่วยไม่ชัด (เซนต์/ดอลลาร์) เก็บเป็นตัวเลขเดิมโดยไม่สรุปหน่วยเพิ่ม
  • ไม่มีการใช้สัญลักษณ์ระบุเสียงไม่ชัดเจนใด ๆ (0 จุด) — ทุก segment แปลได้ครบถ้วน
04

อภิธานศัพท์เทคนิค

คำศัพท์และชื่อผลิตภัณฑ์ที่คงรูปภาษาอังกฤษ

ศัพท์คำแปล / คำอธิบาย
Jevjudgment model จาก Typesafe — โมเดล AI ที่ตอบคำถามเป็นความน่าจะเป็น/หมวด/คะแนน ไม่เขียนข้อความ
Judgment modelโมเดลตัดสิน — แปลง input ที่ยุ่งเหยิงให้เป็นตัวเลขที่ซอฟต์แวร์ใช้ตัดสินใจได้
Typesafeบริษัทผู้สร้าง Jev (typesafe.ai)
Calibrated probabilityความน่าจะเป็นที่ผ่านการสอบเทียบ — บอก 0.8 คือถูกจริง ~80% ของครั้ง
Nullคำถามแบบใช่/ไม่ใช่ — ตอบ 0–1 (0.5 = ไม่รู้ เหมือนโยนเหรียญ)
Choiceคำถามเลือกหมวด — ตอบความน่าจะเป็นของทุกตัวเลือก ใช้เมื่อต้อง route
Scoreคำถามคะแนนบนมาตรวัดที่มีลำดับ — ใช้เมื่อต้องเรียงอันดับ
Confidenceตัวเลขที่สองของ choice/score — บอกว่าคำตอบนั้นน่าเชื่อแค่ไหน (จากความกระจายของความน่าจะเป็น)
Thresholdเกณฑ์ตัดผ่าน — ค่า confidence ขั้นต่ำที่ยอมให้การกระทำเกิดขึ้น
Stateข้อมูล input ที่ส่งให้ Jev ประเมิน (เช่น อีเมลหนึ่งฉบับ) — จัดเป็นฟิลด์มีชื่อ
Speculative fan-outpattern ถามทุกคำถามพร้อมกันใน request เดียว — จ่ายค่าอ่าน text รอบเดียว ข้อไม่เกี่ยวถูกละเลย
Confidence-gated routingpattern กำหนด threshold ต่อการกระทำ — งานเสี่ยงสูงต้อง confidence สูงกว่า
Weighted scoringpattern แตกการตัดสินเป็นหลายมิติ ให้คะแนนแยกแล้วถ่วงน้ำหนักรวมเอง
Intent routingpattern จำแนก request แล้วส่งให้ตัวจัดการที่เหมาะสม (script/LLM/คน)
System one / System twoจากหนังสือ Thinking Fast and Slow — system one = ตัดสินเร็วด้วยสัญชาณญาณ (Jev), system two = คิดเชิงเหตุผล (LLM)
Typesafe skillskill สำหรับ Claude Code — rule book สอนวิธีแต่งคำถาม/เกณฑ์/threshold ให้ Jev
Guardrailsการคัดกรอง input/output รอบ LLM (เช่น กัน jailbreak ตอนเข้า ตรวจ citation ตอนออก)
GEOGenerative Engine Optimization — การทำให้แบรนด์ถูกแนะนำโดย AI
Latent Spaceพอดแคสต์เกี่ยวกับ AI ที่ผู้ก่อตั้ง Jev ให้สัมภาษณ์
05

ซับไตเติ้ลภาษาไทย

ดาวน์โหลดหรือดูซับทั้งหมด

1
00:00:00,000 --> 00:00:02,787
โมเดล AI ที่คนพูดถึงมากที่สุดเดือนนี้

2
00:00:02,787 --> 00:00:05,349
เขียนประโยคแม้แต่ประโยคเดียวไม่ได้

3
00:00:05,349 --> 00:00:08,663
คุยกับมันไม่ได้ และมันอธิบายตัวเองไม่ได้ด้วย

4
00:00:08,663 --> 00:00:13,937
และนี่คือสิ่งที่คนสร้างขึ้นมาด้วยมันภายในสัปดาห์แรกที่มันถูกปล่อยออกมา
thai-subtitles.srt
SubRip — ใช้กับเครื่องเล่นวิดีโอส่วนใหญ่
↓ ดาวน์โหลด
thai-subtitles.vtt
WebVTT — ใช้กับเว็บ / YouTube
↓ ดาวน์โหลด
เปิดดูซับไตเติ้ลทั้งหมด (780 segments)
1
00:00:00,000 --> 00:00:02,787
โมเดล AI ที่คนพูดถึงมากที่สุดเดือนนี้

2
00:00:02,787 --> 00:00:05,349
เขียนประโยคแม้แต่ประโยคเดียวไม่ได้

3
00:00:05,349 --> 00:00:08,663
คุยกับมันไม่ได้ และมันอธิบายตัวเองไม่ได้ด้วย

4
00:00:08,663 --> 00:00:13,937
และนี่คือสิ่งที่คนสร้างขึ้นมาด้วยมันภายในสัปดาห์แรกที่มันถูกปล่อยออกมา

5
00:00:13,937 --> 00:00:17,251
เรามีเบราว์เซอร์ที่กรอกข้อมูล Google Flights

6
00:00:17,251 --> 00:00:20,340
เสร็จในประมาณ 7 วินาที และถ้าคุณเคยลองใช้

7
00:00:20,340 --> 00:00:22,374
Claude กับเบราว์เซอร์มาก่อน

8
00:00:22,374 --> 00:00:25,538
คุณจะรู้ว่ามันช้ามาก ๆ เรามีข้อมูล session

9
00:00:25,538 --> 00:00:27,496
ของเว็บไซต์ 3 ล้าน session

10
00:00:27,496 --> 00:00:29,530
ที่จับพวกลูกค้าที่หลุดมือไป

11
00:00:29,530 --> 00:00:32,920
ตะกร้าที่ถูกทิ้งไว้ และอื่น ๆ เรียงให้เสร็จใน

12
00:00:32,920 --> 00:00:35,482
40 วินาที ด้วยราคาประมาณ 2 ดอลลาร์

13
00:00:35,482 --> 00:00:38,043
แล้วยังมีอีกคนขับ Chrome ด้วยเสียง

14
00:00:38,043 --> 00:00:41,810
โดยที่มันลงมือทำก่อนที่เขาจะพูดประโยคเต็มจบด้วยซ้ำ

15
00:00:41,810 --> 00:00:42,905
มันชื่อ Jev

16
00:00:42,905 --> 00:00:45,692
และผมได้อ่านเอกสารทางการทั้งหมดมาแล้ว

17
00:00:45,692 --> 00:00:47,952
เพื่อที่คุณจะได้ไม่ต้องอ่านเอง

18
00:00:47,952 --> 00:00:50,890
และเมื่อจบคลิปนี้ คุณจะรู้ว่ามันคืออะไร

19
00:00:50,890 --> 00:00:53,904
ทำไมมันถึงสำคัญถ้าคุณใช้ Claude อยู่แล้ว

20
00:00:53,904 --> 00:00:57,218
วิธีรันจาก Claude Code และถามคำถามที่ถูกต้อง

21
00:00:57,218 --> 00:00:59,780
รวมถึงวิธีเอามันไปใช้ให้คุ้มที่สุด

22
00:00:59,780 --> 00:01:02,868
เริ่มจากคุยกันว่าอะไรที่ต่างจริง ๆ ใน Jev

23
00:01:02,868 --> 00:01:05,430
เพราะบางส่วนของมันไม่ใช่เรื่องใหม่

24
00:01:05,430 --> 00:01:08,895
ซอฟต์แวร์ทุกชิ้นที่คุณใช้อยู่แล้วเต็มไปด้วย if

25
00:01:08,895 --> 00:01:11,230
statement ทั้งนั้น ตัวอย่างเช่น

26
00:01:11,230 --> 00:01:14,018
ถ้าออเดอร์มีมูลค่าเกิน 10,000 ดอลลาร์

27
00:01:14,018 --> 00:01:16,956
เราจะตั้งธงให้ตรวจสอบ แต่ข้อจำกัดคือ if

28
00:01:16,956 --> 00:01:18,051
statement

29
00:01:18,051 --> 00:01:20,989
ตรวจสอบได้เฉพาะสิ่งที่คอมพิวเตอร์วัดได้

30
00:01:20,989 --> 00:01:24,078
เราเปรียบเทียบกับตัวเลข วันที่ เช็คบ็อกซ์

31
00:01:24,078 --> 00:01:25,173
เกณฑ์ที่ชัดเจน

32
00:01:25,173 --> 00:01:28,563
แต่มันตรวจไม่ได้ว่าอีเมลนี้ฟังดูโกรธหรือเปล่า

33
00:01:28,563 --> 00:01:31,049
หรือออเดอร์นี้ดูน่าสงสัยหรือเปล่า

34
00:01:31,049 --> 00:01:34,439
เพราะพวกนั้นไม่ใช่ตัวเลข ไม่ใช่สิ่งที่เช็คได้

35
00:01:34,439 --> 00:01:37,302
มันไม่ deterministic Jev ทำสิ่งนี้แหละ

36
00:01:37,302 --> 00:01:38,507
มันเปลี่ยน input

37
00:01:38,507 --> 00:01:41,596
ที่ยุ่งเหยิงจากลูกค้าให้กลายเป็นตัวเลข if

38
00:01:41,596 --> 00:01:43,253
statement ก็จะกลายเป็น

39
00:01:43,253 --> 00:01:46,492
"ถ้าออเดอร์นี้ดูน่าสงสัย โอเค เรามั่นใจ 95%

40
00:01:46,492 --> 00:01:47,773
ตั้งธงให้ตรวจสอบ"

41
00:01:47,773 --> 00:01:51,088
ตอนนี้คอมพิวเตอร์อ่านได้และตัดสินใจแทนเราได้

42
00:01:51,088 --> 00:01:54,327
และเราจะคุยกันว่าจะกำหนดยังไงว่าอะไรนับเป็น

43
00:01:54,327 --> 00:01:56,662
"น่าสงสัย" เพราะเราจะใช้ Claude

44
00:01:56,662 --> 00:01:58,244
กับคุณในการเขียนคำถาม

45
00:01:58,244 --> 00:02:00,956
และคุณเป็นคนกำหนดเกณฑ์ของคำตอบ "ใช่"

46
00:02:00,956 --> 00:02:04,346
เช่นระดับความมั่นใจ 95% เราจะส่งชุดคำถามไปให้

47
00:02:04,346 --> 00:02:05,442
Jev แล้ว Jev

48
00:02:05,442 --> 00:02:08,304
จะตอบทีละข้อพร้อมบอกว่ามันมั่นใจแค่ไหน

49
00:02:08,304 --> 00:02:13,954
และโค้ดของคุณจะตั้งธงออเดอร์ก็ต่อเมื่อทุกคำตอบกลับมาเกินเกณฑ์ที่คุณเลือกไว้

50
00:02:13,954 --> 00:02:17,043
เช่น 95% นั่นแหละ และอาจรู้สึกต่างจาก LLM

51
00:02:17,043 --> 00:02:19,755
แบบเดิม ๆ อย่างโมเดลแชทของ Anthropic

52
00:02:19,755 --> 00:02:22,994
นี่คือเหตุผลที่ Typesafe บริษัทผู้สร้าง Jev

53
00:02:22,994 --> 00:02:26,459
เรียกมันว่า judgment model ผู้ก่อตั้งคือ Doooo

54
00:02:26,459 --> 00:02:29,548
ผู้ช่วยพัฒนาวิธีการเบื้องหลัง ChatGPT ที่

55
00:02:29,548 --> 00:02:32,109
OpenAI นี่คือการประกาศครั้งใหญ่มาก

56
00:02:32,109 --> 00:02:35,499
และถ้าเทียบกับ Claude บนพื้นผิว คุณถาม Claude

57
00:02:35,499 --> 00:02:38,739
ได้แน่นอนว่า "อีเมลออเดอร์นี้ดูน่าสงสัยไหม"

58
00:02:38,739 --> 00:02:41,451
แล้วคุณจะได้ข้อความตอบจาก Claude แบบ

59
00:02:41,451 --> 00:02:44,389
"คุณพูดถูกเลย อันนี้ดูน่าสงสัยจริง ๆ นะ

60
00:02:44,389 --> 00:02:46,950
ต้องการให้ผมร่างอีเมลตอบลูกค้าไหม"

61
00:02:46,950 --> 00:02:48,683
ซึ่งใช้เวลาประมาณ 10-15

62
00:02:48,683 --> 00:02:51,470
วินาทีกว่าจะได้คำตอบนั้น เทียบกับ Jev

63
00:02:51,470 --> 00:02:53,956
ที่ได้รับชุดคำถามให้มองหาล่วงหน้า

64
00:02:53,956 --> 00:02:58,175
คำตอบของคำถามเหล่านั้นจะเป็นตัวกำหนดว่ามันน่าสงสัยแค่ไหน

65
00:02:58,175 --> 00:02:59,270
เช่น

66
00:02:59,270 --> 00:03:02,585
"ที่อยู่ใบแจ้งหนี้กับที่อยู่จัดส่งตรงกันไหม"

67
00:03:02,585 --> 00:03:05,824
แล้วมันจะได้รับข้อมูลที่กำลังประมวลผลจริง ๆ

68
00:03:05,824 --> 00:03:07,180
ซึ่งเรียกว่า state

69
00:03:07,180 --> 00:03:11,173
ในกรณีนี้ก็คืออีเมลออเดอร์ฉบับเดียวที่เรากำลังประเมิน

70
00:03:11,173 --> 00:03:13,734
และคำตอบจาก Jev จะไม่ใช่ข้อความตอบ

71
00:03:13,734 --> 00:03:17,350
มันให้แค่ตัวเลขจากตัวเลือกที่เรากำหนดไว้เท่านั้น

72
00:03:17,350 --> 00:03:22,322
ตัวเลขนั้นบอกความน่าจะเป็นที่มันน่าสงสัยเทียบกับเกณฑ์ที่เราตั้งไว้

73
00:03:22,322 --> 00:03:25,109
มันไม่มีวันเขียน output เหมือน Claude

74
00:03:25,109 --> 00:03:28,650
และสิ่งนี้มีข้อดีหลายอย่างที่เดี๋ยวจะเล่าให้ฟัง

75
00:03:28,650 --> 00:03:31,889
นี่ต่างจากอินเทอร์เฟซแชทที่เราคุ้นเคยใน LLM

76
00:03:31,889 --> 00:03:34,450
(large language model) โดยสิ้นเชิง

77
00:03:34,450 --> 00:03:37,614
มันใกล้เคียงกับโมเดล deterministic machine

78
00:03:37,614 --> 00:03:41,080
learning ซึ่งเป็นสไตล์ AI อีกแบบหนึ่ง Typesafe

79
00:03:41,080 --> 00:03:44,319
เรียกสิ่งนี้ว่า system one model ตามหนังสือ

80
00:03:44,319 --> 00:03:47,106
Thinking Fast and Slow โดย system one

81
00:03:47,106 --> 00:03:50,421
คือการตัดสินใจด้วยสัญชาณญาณอย่างรวดเร็ว ส่วน

82
00:03:50,421 --> 00:03:53,058
system two คือนั่งลงคิดและใช้เหตุผล

83
00:03:53,058 --> 00:03:56,523
โมเดลแชทอย่าง Claude และโมเดล reasoning อื่น ๆ

84
00:03:56,523 --> 00:03:59,762
อยู่ใน system two แต่ Jev อยู่ใน system one

85
00:03:59,762 --> 00:04:02,474
แล้วทำไมมันถึงพิเศษเมื่อเทียบกับ LLM

86
00:04:02,474 --> 00:04:04,584
แชทแบบที่เราเห็นกันทุกวันนี้

87
00:04:04,584 --> 00:04:07,522
มีอยู่ไม่กี่เหตุผลที่การไม่เขียน output

88
00:04:07,522 --> 00:04:10,309
เป็นข้อได้เปรียบในบาง use case ข้อแรก

89
00:04:10,309 --> 00:04:13,398
มันถูกและเร็วสุดขั้น บอกกันว่าถูกกว่า LLM

90
00:04:13,398 --> 00:04:16,788
ดั้งเดิม 40 ถึง 1,000 เท่า และเร็วกว่า 20 ถึง

91
00:04:16,788 --> 00:04:20,177
400 เท่า ราคาประมาณ 4 เซนต์ต่อล้าน token ฝั่ง

92
00:04:20,177 --> 00:04:22,588
input และ output แทบจะฟรี ข้อสอง

93
00:04:22,588 --> 00:04:25,827
มันปลอมแปลงคำตอบไม่ได้ ถ้าคุณให้ 3 ตัวเลือก

94
00:04:25,827 --> 00:04:29,293
มันตอบกลับมาด้วยหนึ่งใน 3 ตัวเลือกนั้นทุกครั้ง

95
00:04:29,293 --> 00:04:31,251
นี่เป็นทั้งข้อดีและข้อเสีย

96
00:04:31,251 --> 00:04:34,792
ซึ่งเดี๋ยวจะคุยกันตอนพูดถึงกฎเฉพาะที่ต้องให้กับ

97
00:04:34,792 --> 00:04:36,299
Jev ตอนใช้งาน ข้อสาม

98
00:04:36,299 --> 00:04:39,689
มันให้คำตอบเดิมหรือเกือบเดิมเมื่อถามซ้ำสองรอบ

99
00:04:39,689 --> 00:04:41,421
มัน consistent กว่า LLM

100
00:04:41,421 --> 00:04:44,058
มากในการตอบคำถามเดิมบนชุดข้อมูลเดิม

101
00:04:44,058 --> 00:04:47,222
ในการทดสอบเดียวกัน พวกเขาถามคำถามเดิมซ้ำ ๆ

102
00:04:47,222 --> 00:04:48,352
และคำตอบจาก Jev

103
00:04:48,352 --> 00:04:51,742
ขยับน้อยกว่าโมเดลแชททุกตัวที่ลอง แม้จะตั้งค่า

104
00:04:51,742 --> 00:04:54,529
prompt ให้ repeatable ที่สุดแล้วก็ตาม

105
00:04:54,529 --> 00:04:57,995
และประเด็นหลักทั้งหมดของเรื่องนี้คือ ตัวเลขที่

106
00:04:57,995 --> 00:05:01,309
Jev ให้เป็น output ทำให้สิ่งที่ปกติไม่แน่นอน

107
00:05:01,309 --> 00:05:04,775
อย่างอีเมลลูกค้าที่ยุ่งเหยิง เต็มไปด้วยข้อความ

108
00:05:04,775 --> 00:05:07,637
กลายเป็นสิ่งที่ซอฟต์แวร์นำไปใช้ได้จริง

109
00:05:07,637 --> 00:05:10,575
Typesafe เทรนโมเดลนี้ให้ความน่าจะเป็นมี

110
00:05:10,575 --> 00:05:12,157
calibration พูดง่าย ๆ

111
00:05:12,157 --> 00:05:15,396
คือมันทำงานเหมือนพยากรณ์อากาศ เมื่อ Jev ตอบ

112
00:05:15,396 --> 00:05:18,033
0.8 มันควรจะถูกประมาณ 8 ครั้งจาก 10

113
00:05:18,033 --> 00:05:20,519
และจากความมั่นใจ 8 ใน 10 นั้นแหละ

114
00:05:20,519 --> 00:05:24,286
ที่ทำให้ซอฟต์แวร์ตัดสินใจได้ว่าจะลงมือทำตามหรือไม่

115
00:05:24,286 --> 00:05:26,847
จะส่ง query นั้นไปที่อื่นหรือเปล่า

116
00:05:26,847 --> 00:05:29,785
การกระทำถัดไปถูกตัดสินจากตัวเลขนั้น Jev

117
00:05:29,785 --> 00:05:32,045
ให้ความน่าจะเป็นของคำถามนั้น ๆ

118
00:05:32,045 --> 00:05:36,188
ว่าจริงหรือเท็จ แล้วเดี๋ยวเราจะเห็นตัวเลือกประเภทต่าง ๆ

119
00:05:36,188 --> 00:05:38,825
ที่ให้ Jev ได้ เทียบกับโมเดลแชท LLM

120
00:05:38,825 --> 00:05:42,140
ที่ถูกเทรนให้ฟังดูถูกต้องสำหรับคนฟังโดยเฉพาะ

121
00:05:42,140 --> 00:05:46,358
นั่นคือเหตุผลที่เรามีอคติแบบเห็นด้วยกับทุกอย่างที่เราพูด

122
00:05:46,358 --> 00:05:49,673
Jev ไม่ได้ถูกสร้างแบบนั้น สำคัญมาก ถ้าคุณใช้

123
00:05:49,673 --> 00:05:53,138
Claude หรือ GPT อยู่แล้ว Jev ไม่ได้มาแทนที่มัน

124
00:05:53,138 --> 00:05:56,528
แต่จะทำงานเคียงข้างและเพิ่มข้อได้เปรียบให้บาง

125
00:05:56,528 --> 00:05:59,843
workflow Jev แทนที่หนึ่งหมวดของงานที่ Claude

126
00:05:59,843 --> 00:06:02,856
ทำอยู่ในปัจจุบันทั้งหมด และเมื่อผมพูดว่า

127
00:06:02,856 --> 00:06:05,342
Claude คุณแทนด้วยผู้ให้บริการ LLM

128
00:06:05,342 --> 00:06:06,924
ตัวไหนก็ได้ตามต้องการ

129
00:06:06,924 --> 00:06:09,259
หมวดงานนั้นคือการตัดสินใจเร็ว ๆ

130
00:06:09,259 --> 00:06:11,595
ที่ต้องทำจำนวนมากภายในซอฟต์แวร์

131
00:06:11,595 --> 00:06:13,779
ดังนั้นโค้ดที่คุณจะส่งให้ Jev

132
00:06:13,779 --> 00:06:16,868
จะส่งมอบข้อมูลนั้น เช่น อีเมลลูกค้าของเรา

133
00:06:16,868 --> 00:06:20,333
พร้อมชุดคำถามที่นิยามชัดเจนซึ่งเราอยากรู้คำตอบ

134
00:06:20,333 --> 00:06:23,799
แล้ว Jev จะส่งกลับมาเป็นความน่าจะเป็น หมวดหมู่

135
00:06:23,799 --> 00:06:26,963
หรือคะแนน จากนั้นโค้ดของคุณก็จะเอาไปใช้ต่อ

136
00:06:26,963 --> 00:06:30,277
เพื่อ route มัน เรียงลำดับ ตั้งธงให้มนุษย์ดู

137
00:06:30,277 --> 00:06:31,483
หรือดำเนินการต่อ

138
00:06:31,483 --> 00:06:34,119
มันอาจลงมือทำอะไรบางอย่างตามนั้นได้

139
00:06:34,119 --> 00:06:37,208
แต่ทุกอย่างที่ต้องสนทนา แชทไปมา ใช้เหตุผล

140
00:06:37,208 --> 00:06:40,673
หรือเขียนข้อความ จะยังอยู่ในอินเทอร์เฟซ Claude

141
00:06:40,673 --> 00:06:43,762
ของเราเหมือนเดิม Doooo ผู้ก่อตั้งพูดชัด ๆ

142
00:06:43,762 --> 00:06:47,227
ในพอดแคสต์ Latent Space ว่า "Claude คือบทสนทนา

143
00:06:47,227 --> 00:06:49,563
ส่วน Jev คือระบบท่อใต้พื้นบ้าน"

144
00:06:49,563 --> 00:06:52,877
และสำคัญที่ต้องตระหนักคือมันทำทุกอย่างไม่ได้

145
00:06:52,877 --> 00:06:53,973
จริง ๆ

146
00:06:53,973 --> 00:06:58,342
แล้วมันทำได้ไม่กี่อย่าง แต่สิ่งที่มันทำได้ มันทำได้ดีมาก ๆ

147
00:06:58,342 --> 00:07:03,088
เราพูดไปแล้วว่าคำถามแต่ละอย่างที่มันตอบแบ่งได้เป็นหนึ่งในสามแบบ

148
00:07:03,088 --> 00:07:07,533
มาไล่ดูทีละแบบด้วยตัวอย่างลูกค้าโกรธเหมือนเดิมเพื่อความง่าย

149
00:07:07,533 --> 00:07:10,395
แบบแรกคือคำถามใช่/ไม่ใช่ เรียกว่า null

150
00:07:10,395 --> 00:07:11,525
อาจเป็นคำถามว่า

151
00:07:11,525 --> 00:07:14,915
"ลูกค้าคนนี้ฟังดูโกรธหรือเปล่า" สมมติ Jev ตอบ

152
00:07:14,915 --> 00:07:18,230
0.9 กลับมา แปลว่ามันคิดว่ามีโอกาส 90% ว่าใช่

153
00:07:18,230 --> 00:07:21,469
ลูกค้าคนนี้โกรธ แล้วโค้ดหรือสคริปต์ของคุณ —

154
00:07:21,469 --> 00:07:23,880
สำคัญนะ นี่ไม่ใช่ Jev ไม่ใช่ LLM

155
00:07:23,880 --> 00:07:26,968
แต่เป็นสคริปต์ที่เราให้ Claude เขียนได้ —

156
00:07:26,968 --> 00:07:29,982
ก็จะทำส่วนที่เหลือด้วย if statement ปกติ

157
00:07:29,982 --> 00:07:33,372
ถ้าผลลัพธ์เกินสัก 0.8 เราจะส่งต่อให้ผู้จัดการ

158
00:07:33,372 --> 00:07:36,310
เพื่อให้ผู้จัดการตอบลูกค้ารายนั้นโดยตรง

159
00:07:36,310 --> 00:07:39,549
หรือถ้าต่ำกว่า 0.2 คือแน่นอนว่าไม่โกรธ หรือ

160
00:07:39,549 --> 00:07:42,788
Jev ตัดสินว่าไม่โกรธแน่นอน เราก็จะไม่ส่งต่อ

161
00:07:42,788 --> 00:07:44,596
แต่จะลดความสำคัญของมันลง

162
00:07:44,596 --> 00:07:48,062
แต่ต้องเข้าใจให้ชัดว่า Jev ไม่เคยส่งต่ออะไรเลย

163
00:07:48,062 --> 00:07:51,226
มันแค่ให้ตัวเลขที่แทนความน่าจะเป็นของคำตอบ

164
00:07:51,226 --> 00:07:54,691
"ใช่" ในกรณีนี้ 0.9 คือใช่แบบมั่นใจ ลูกค้าโกรธ

165
00:07:54,691 --> 00:07:57,930
ส่วน 0.5 แปลว่ามันไม่รู้เลย เหมือนโยนเหรียญ

166
00:07:57,930 --> 00:08:02,224
แล้วโค้ดหรือสคริปต์จะเป็นผู้ตัดสินใจจากตัวเลขที่ได้กลับมา

167
00:08:02,224 --> 00:08:05,087
แบบที่สองเรียกว่า choice ตรงตัวตามชื่อ

168
00:08:05,087 --> 00:08:08,100
คุณกำหนดหมวดหมู่ล่วงหน้า ในเคสลูกค้าโกรธ

169
00:08:08,100 --> 00:08:10,812
ก็เช่น "ทีมไหนควรรับผิดชอบ query นี้

170
00:08:10,812 --> 00:08:13,072
ทีมบิลลิ่ง เทคนิค หรือฝ่ายขาย"

171
00:08:13,072 --> 00:08:16,839
แล้วมันจะตอบกลับมาพร้อมความน่าจะเป็นของทุกตัวเลือก

172
00:08:16,839 --> 00:08:19,626
มันไม่ได้ตอบว่า "ใช่ เป็นฝ่ายบิลลิ่ง"

173
00:08:19,626 --> 00:08:22,715
แต่มันจะบอกว่าบิลลิ่งมีโอกาส 85% ที่จะถูก

174
00:08:22,715 --> 00:08:25,577
เทคนิค 10% ฝ่ายขาย 5% แล้วโค้ดจะ route

175
00:08:25,577 --> 00:08:28,440
อีเมลไปยังตัวที่ชนะ ในที่นี้คือบิลลิ่ง

176
00:08:28,440 --> 00:08:31,529
ดังนั้นใช้ choice เมื่อคุณจะ route output

177
00:08:31,529 --> 00:08:34,542
ไปที่ไหนสักแห่ง ส่วนเมื่อตัวเลือกมีลำดับ

178
00:08:34,542 --> 00:08:37,028
เราจะใช้แบบที่สามซึ่งเดี๋ยวคุยกัน

179
00:08:37,028 --> 00:08:40,343
เมื่อมีมากกว่าหนึ่งตัวเลือก — บิลลิ่ง เทคนิค

180
00:08:40,343 --> 00:08:43,356
และฝ่ายขาย — คุณจะได้ตัวเลขที่สองจาก Jev

181
00:08:43,356 --> 00:08:44,787
เรียกว่า confidence

182
00:08:44,787 --> 00:08:48,328
ซึ่งคำนวณจากความกระจายของความน่าจะเป็นเหล่านั้น

183
00:08:48,328 --> 00:08:50,513
85% สำหรับบิลลิ่งถือว่ามั่นใจ

184
00:08:50,513 --> 00:08:53,677
แต่สมมติบิลลิ่งได้ 40 เทคนิค 35 ฝ่ายขาย 25

185
00:08:53,677 --> 00:08:56,991
เราก็จะมั่นใจน้อยลง บิลลิ่งยังถูกเลือกอยู่ดี

186
00:08:56,991 --> 00:08:58,498
แต่ confidence จะต่ำ

187
00:08:58,498 --> 00:09:02,641
และตัวเลขนั้นแหละที่โค้ดต้องเช็คก่อนจะไว้ใจการเลือกนั้น

188
00:09:02,641 --> 00:09:06,106
โค้ดจะเช็คตัวเลข confidence ด้วย นี่คือสิ่งที่

189
00:09:06,106 --> 00:09:09,044
demo เบราว์เซอร์ที่เห็นตอนต้นคลิปทำอยู่

190
00:09:09,044 --> 00:09:11,681
ทุกปุ่มและช่องกรอกบนหน้าจอง booking

191
00:09:11,681 --> 00:09:14,694
เที่ยวบินจะได้ตัวเลข แล้ว Jev ตอบ choice

192
00:09:14,694 --> 00:09:18,009
สองอย่างพร้อมกัน — จะทำอะไรกับมัน คลิก พิมพ์

193
00:09:18,009 --> 00:09:21,098
หรือเลื่อน ตามการกระทำหรือ input จากเสียง

194
00:09:21,098 --> 00:09:22,529
และจะทำกับตัวเลขไหน

195
00:09:22,529 --> 00:09:25,316
เราเรียงทุกอย่างบนหน้าเพจให้ได้ตัวเลข

196
00:09:25,316 --> 00:09:28,104
แล้วเลือก element ที่ 3 หรือ 4 หรือ 7

197
00:09:28,104 --> 00:09:29,836
ซึ่งไม่มีลำดับอยู่ในตัว

198
00:09:29,836 --> 00:09:32,624
เราจึงรู้ว่าแบบนี้ต้องเป็น choice และ

199
00:09:32,624 --> 00:09:35,712
confidence ก็เป็นเหมือนกลไกนิรภัย ถ้า Jev

200
00:09:35,712 --> 00:09:39,178
มั่นใจ คืออยู่เหนือระดับ confidence ที่ตั้งไว้

201
00:09:39,178 --> 00:09:41,890
คลิกก็จะเกิดขึ้น แต่ถ้าต่ำกว่า agent

202
00:09:41,890 --> 00:09:45,054
จะหยุดและถามผู้ใช้ คุณปรับเพดาน confidence

203
00:09:45,054 --> 00:09:46,937
ขึ้นลงได้ตามการกระทำเฉพาะ

204
00:09:46,937 --> 00:09:50,478
ถ้าเป็นสิ่งที่จะสร้างความเสียหายหรือมีต้นทุนสูง

205
00:09:50,478 --> 00:09:52,210
เราก็ต้องการ confidence

206
00:09:52,210 --> 00:09:55,374
ที่สูงกว่าจึงจะอนุญาตให้ลงมือ แบบที่สามคือ

207
00:09:55,374 --> 00:09:58,689
score แนวคิดเหมือน choice แต่ตัวเลือกมีลำดับ

208
00:09:58,689 --> 00:10:02,003
และคุณอธิบายแต่ละระดับด้วยคำพูด คำถามอาจเป็น

209
00:10:02,003 --> 00:10:03,736
"ลูกค้าคนนี้โกรธแค่ไหน"

210
00:10:03,736 --> 00:10:06,825
ผลลัพธ์จะเป็นคะแนนบนมาตรวัดระหว่าง ใจเย็น

211
00:10:06,825 --> 00:10:09,989
หงุดหงิด และ โกรธจัด นี่คือสามตัวเลือก Jev

212
00:10:09,989 --> 00:10:12,625
จะตอบกลับมาเป็นตำแหน่งบนมาตรวัดนั้น

213
00:10:12,625 --> 00:10:15,563
และมันตกกลางระดับได้ด้วย เช่น 2.4 จาก 3

214
00:10:15,563 --> 00:10:18,501
แปลว่าส่วนใหญ่หงุดหงิด (ตัวเลือกที่สอง)

215
00:10:18,501 --> 00:10:21,665
แต่กำลังจะไปทางโกรธจัด เมื่อเราเรียง inbox

216
00:10:21,665 --> 00:10:23,925
อีเมลฝ่ายบริการลูกค้าทั้งกล่อง

217
00:10:23,925 --> 00:10:27,089
เราสามารถจัดเรียงจากร้ายแรงที่สุดมาก่อนได้

218
00:10:27,089 --> 00:10:30,555
นี่คือสิ่งที่โค้ดหรือสคริปต์ของเราทำ 3 เต็มจาก

219
00:10:30,555 --> 00:10:34,020
3 อยู่บนสุด ส่วน 1 จาก 3 อยู่ล่างสุด ใช้ score

220
00:10:34,020 --> 00:10:36,355
กับทุกสิ่งที่คุณวางบนมาตรวัดได้

221
00:10:36,355 --> 00:10:39,821
ความต่างสำคัญระหว่าง choice กับ score คือลำดับ

222
00:10:39,821 --> 00:10:42,608
เช่น "ticket นี้เร่งด่วนแค่ไหน" "lead

223
00:10:42,608 --> 00:10:44,868
นี้เข้ากับสิ่งที่เราขายแค่ไหน"

224
00:10:44,868 --> 00:10:48,183
"ผู้สมัครคนนี้อยู่ระดับไหนบนมาตรวัดนี้" "bug

225
00:10:48,183 --> 00:10:51,045
นี้แย่แค่ไหน เป็น bug เรื่องหน้าตา bug

226
00:10:51,045 --> 00:10:54,360
น่ารำคาญ หรือ bug ที่ขวางการทำงาน" ใช้ score

227
00:10:54,360 --> 00:10:57,599
เมื่อต้องการจัดอันดับหรือเรียง ไม่ใช่ route

228
00:10:57,599 --> 00:11:00,688
คำตอบเหมือน choice และเพราะมันมีหลายระดับ

229
00:11:00,688 --> 00:11:03,852
มันจึงมี confidence แบบเดียวกับ choice แต่

230
00:11:03,852 --> 00:11:07,242
null ไม่มี confidence เพราะมีแค่ใช่หรือไม่ใช่

231
00:11:07,242 --> 00:11:08,447
demo ของ session

232
00:11:08,447 --> 00:11:11,837
เว็บไซต์ที่โชว์ไว้ตอนต้นคลิปใช้แบบแรกเป็นหลัก

233
00:11:11,837 --> 00:11:13,720
คือใช่/ไม่ใช่ต่อเหตุการณ์

234
00:11:13,720 --> 00:11:15,604
"คนนี้คลิกแบบหงุดหงิดไหม"

235
00:11:15,604 --> 00:11:18,994
"คลิกแล้วไม่มีอะไรเกิดขึ้นไหม" "หน้าเพจ error

236
00:11:18,994 --> 00:11:22,082
ไหม" แล้วเราค่อยเพิ่ม score เป็นชั้นบนสุด

237
00:11:22,082 --> 00:11:25,548
"session ทั้งหมดนี้แย่แค่ไหนสำหรับผู้ใช้คนนี้"

238
00:11:25,548 --> 00:11:28,184
เพื่อที่เวลาเรียง session เหล่านั้น

239
00:11:28,184 --> 00:11:31,574
เราเรียงจากแย่สุดมาก่อนได้ แล้วคนก็แค่เปิด 10

240
00:11:31,574 --> 00:11:34,889
อันดับแรก ทั้งหมดนี้ทำใน LLM ก็ได้แน่นอน แต่

241
00:11:34,889 --> 00:11:36,546
LLM ไม่ได้ถูก optimize

242
00:11:36,546 --> 00:11:39,560
สำหรับการตัดสินใจเชิงความน่าจะเป็นแบบนี้

243
00:11:39,560 --> 00:11:42,196
เราจึงทำได้ปริมาณมหาศาลในเวลาสั้น ๆ

244
00:11:42,196 --> 00:11:43,402
ด้วยราคาถูกมาก ๆ

245
00:11:43,402 --> 00:11:46,792
วิธีเลือกระหว่างสามแบบนี้ — null, choice หรือ

246
00:11:46,792 --> 00:11:47,887
score —

247
00:11:47,887 --> 00:11:50,825
คือดูว่าโค้ดของคุณจะเอาคำตอบไปทำอะไรต่อ

248
00:11:50,825 --> 00:11:53,236
ถ้าต้องลงมือหรือไม่ลงมือตามคำตอบ

249
00:11:53,236 --> 00:11:56,324
นั่นคือใช่/ไม่ใช่ หรือ null ถ้าต้อง route

250
00:11:56,324 --> 00:11:58,961
คำตอบไปที่ไหนสักแห่ง นั่นคือ choice

251
00:11:58,961 --> 00:12:02,049
หรือถ้าต้องเรียงหรือจัดอันดับด้วย นั่นคือ

252
00:12:02,049 --> 00:12:05,515
score และสำคัญที่สุด ทั้งสามแบบใส่ไปใน request

253
00:12:05,515 --> 00:12:06,946
เดียวถึง Jev ได้เลย

254
00:12:06,946 --> 00:12:11,014
นี่คือตัวอย่างอีเมลหนึ่งฉบับเข้าไปพร้อมคำถามทั้งสามแบบ

255
00:12:11,014 --> 00:12:14,103
และนี่คือสิ่งที่ได้กลับมา เรามี null ก่อน

256
00:12:14,103 --> 00:12:17,267
คำถามว่า "ลูกค้าคนนี้ฟังดูโกรธไหม" ได้ 0.9

257
00:12:17,267 --> 00:12:20,431
แปลว่าโค้ดควรส่งต่อให้พนักงาน ต่อมา choice

258
00:12:20,431 --> 00:12:23,595
"นี่ทีมไหน" บิลลิ่ง 85 เทคนิค 10 ฝ่ายขาย 5

259
00:12:23,595 --> 00:12:26,909
พร้อม confidence สูง ก็จะ route ไปทีมบิลลิ่ง

260
00:12:26,909 --> 00:12:30,375
แล้ว score "ใจเย็น หงุดหงิด โกรธ หรือ โกรธจัด"

261
00:12:30,375 --> 00:12:33,689
บนมาตรวัด 4 ระดับ ได้ 2.4 ที่ confidence 80%

262
00:12:33,689 --> 00:12:34,895
ก็จะไปอยู่ใกล้ ๆ

263
00:12:34,895 --> 00:12:41,298
กองบนสุดของอีเมลที่ทีมบิลลิ่งต้องตอบ และพวกเขาจะเห็นเฉพาะฉบับที่ลูกค้าฟังดูโกรธจริง ๆ

264
00:12:41,298 --> 00:12:43,633
เท่านั้น รายการสั้น ๆ เพราะ Jev

265
00:12:43,633 --> 00:12:47,400
ประมวลผลกองใหญ่ที่ไม่จำเป็นต้องถึงมือพนักงานไปแล้ว

266
00:12:47,400 --> 00:12:50,790
หนึ่งอีเมลเข้า สามคำตอบออก ในเวลาที่สั้นมาก ๆ

267
00:12:50,790 --> 00:12:53,879
ต่อไปมาดูวิธีจับคู่กับ Claude Code จริง ๆ

268
00:12:53,879 --> 00:12:57,344
เพื่อให้ได้ประโยชน์เต็ม ๆ จากทั้งสองเครื่องมือ

269
00:12:57,344 --> 00:12:59,980
แต่ก่อนอื่น ผมเหลืออีกไม่ถึงพัน sub

270
00:12:59,980 --> 00:13:03,521
ก็จะถึงหมื่นสองพันที่วิเศษและป้ายบนผนังบ้านแล้ว

271
00:13:03,521 --> 00:13:05,630
ถ้าดูคลิปนี้แล้วเพลิน กด sub

272
00:13:05,630 --> 00:13:09,020
ด้านล่างหน่อยนะครับ มีสองวิธีจับคู่กับ Claude

273
00:13:09,020 --> 00:13:12,109
เพื่อให้ได้จุดแข็งของทั้งคู่ และ Typesafe

274
00:13:12,109 --> 00:13:14,896
พูดชัดเจนมากใน docs ว่ามันไม่ถนัดอะไร

275
00:13:14,896 --> 00:13:18,211
จึงควรใช้ Claude ตรงนั้น นั่นคือการใช้เหตุผล

276
00:13:18,211 --> 00:13:21,676
ความรู้เฉพาะทาง และทุกอย่างที่ต้องเขียนข้อความ

277
00:13:21,676 --> 00:13:24,916
วิธีแรกคือใช้มันล้อมรอบความสามารถของ Claude

278
00:13:24,916 --> 00:13:27,703
เพื่อตรวจสอบสิ่งต่าง ๆ ก่อนที่ Claude

279
00:13:27,703 --> 00:13:30,641
จะอ่านอะไร ให้ Jev ตัดสินก่อนว่า Claude

280
00:13:30,641 --> 00:13:33,730
ควรอ่านไหม ควรเปลือง token กับสิ่งนั้นไหม

281
00:13:33,730 --> 00:13:36,065
Typesafe ใช้ตัวอย่าง guardrails

282
00:13:36,065 --> 00:13:39,154
ซึ่งคัดกรองข้อความทุกฉบับที่เข้าหา Claude

283
00:13:39,154 --> 00:13:42,619
เรื่อง jailbreak และคำขอที่เป็นอันตราย ตอนเข้า

284
00:13:42,619 --> 00:13:45,482
แล้วคัดกรองคำตอบของ Claude อีกทีตอนออก

285
00:13:45,482 --> 00:13:48,570
ก่อนผู้ใช้จะเห็น นี่คือตัวอย่างที่ Claude

286
00:13:48,570 --> 00:13:51,056
อยู่ตรงกลาง แต่ใช้ราวกัน้ำของ Jev

287
00:13:51,056 --> 00:13:54,521
ครอบหน้า-หลัง ใช้แนวคิดเดียวกันหลังการประมวลผล

288
00:13:54,521 --> 00:13:57,911
LLM ได้ด้วย ในตัวอย่าง citation ของพวกเขา LLM

289
00:13:57,911 --> 00:14:01,377
เขียนเอกสารที่มีการอ้างอิง 8 จุด แล้ว Jev ตรวจ

290
00:14:01,377 --> 00:14:04,315
quote แต่ละอันกับแหล่งที่มา 4 จุดผ่าน 1

291
00:14:04,315 --> 00:14:06,951
จุดเป็นการอ้างอิงที่ไม่มีอยู่จริง 1

292
00:14:06,951 --> 00:14:09,136
จุดพูดตรงข้ามกับต้นฉบับ และ 2

293
00:14:09,136 --> 00:14:12,074
จุดถูกส่งต่อให้มนุษย์เพราะ Jev ไม่แน่ใจ

294
00:14:12,074 --> 00:14:15,464
นี่คือการ post-process เนื้อหาของ Claude ผ่าน

295
00:14:15,464 --> 00:14:16,559
Jev

296
00:14:16,559 --> 00:14:20,778
เพื่อยืนยันว่าทุกอย่างที่ปล่อยออกไปถูกต้องตามข้อเท็จจริง

297
00:14:20,778 --> 00:14:22,963
วิธีที่สองคือใช้มันแทน Claude

298
00:14:22,963 --> 00:14:26,127
สำหรับงานจำนวนมาก งานที่ scale ใหญ่กว่าแต่

299
00:14:26,127 --> 00:14:29,441
deterministic มาก อย่าใช้ Claude เรียง 5,000

300
00:14:29,441 --> 00:14:32,605
แถว แท็ก ticket ทุกใบใน inbox หรือให้คะแนน

301
00:14:32,605 --> 00:14:35,619
lead ทุกตัว Claude ควรได้เฉพาะแถวที่ Jev

302
00:14:35,619 --> 00:14:38,632
ไม่แน่ใจ หรือแถวที่ต้องเขียนอะไรสักอย่าง

303
00:14:38,632 --> 00:14:41,947
ถ้าเป็นการให้คะแนนแบบ deterministic ก็ควรใช้

304
00:14:41,947 --> 00:14:44,960
Jev แทน Claude ในขั้นตอนนั้นของ workflow

305
00:14:44,960 --> 00:14:47,898
และนี่คือสิ่งที่คุณคงเห็นกันทั่ว X หรือ

306
00:14:47,898 --> 00:14:51,213
Twitter มีคนให้คะแนน sales lead 700 ตัวใน 40

307
00:14:51,213 --> 00:14:54,603
วินาที ราคาประมาณ 9 เซนต์ งานกองโตอย่างนี้ใช้

308
00:14:54,603 --> 00:14:57,315
Claude จะช้ากว่ามากและแพงกว่ามากด้วย

309
00:14:57,315 --> 00:15:00,629
และทั้งสองตัวอย่างนี้ เราจะสร้างมันด้วยกันใน

310
00:15:00,629 --> 00:15:03,718
5-10 นาทีต่อจากนี้ด้วยเคสฝ่ายบริการลูกค้า

311
00:15:03,718 --> 00:15:07,108
มาตั้งค่าใน Claude Code กันเลย Typesafe ปล่อย

312
00:15:07,108 --> 00:15:10,422
skill สำหรับใช้ใน LLM อย่าง Claude Code หรือ

313
00:15:10,422 --> 00:15:13,888
harness ทำนองเดียวกันมาให้ ติดตั้งแค่สองบรรทัด

314
00:15:13,888 --> 00:15:16,976
จะทำผ่าน console หลังสมัครที่ typesafe.ai

315
00:15:16,976 --> 00:15:19,839
ก็ได้ ก็อปปี agent prompt ไป หรือไปที่

316
00:15:19,839 --> 00:15:21,948
docs.typesafe.ai/agent-skill

317
00:15:21,948 --> 00:15:24,208
แล้วรันสองคำสั่งนี้ใน terminal

318
00:15:24,208 --> 00:15:26,318
เพื่อติดตั้งเข้า Claude Code

319
00:15:26,318 --> 00:15:29,406
เอาคำสั่งจากตรงนั้นตรง ๆ ก็ได้ หรือใช้กับ

320
00:15:29,406 --> 00:15:31,440
agent ตัวอื่นก็ได้เหมือนกัน

321
00:15:31,440 --> 00:15:34,378
ข้อแนะนำคือต้องเอ่ยชื่อ skill ใน prompt

322
00:15:34,378 --> 00:15:37,241
ทุกครั้ง เช่น "use the Typesafe skill"

323
00:15:37,241 --> 00:15:40,706
คุณจะเห็นใน prompt ของเราตลอด รันสองคำสั่งนั้น

324
00:15:40,706 --> 00:15:43,494
มันจะเพิ่ม marketplace แล้วเรา reload

325
00:15:43,494 --> 00:15:46,582
เพื่อยืนยันว่า plugin ติดตั้งแล้ว ขึ้นว่า

326
00:15:46,582 --> 00:15:49,671
success พอ reload หรือเปิด session ใหม่ใน

327
00:15:49,671 --> 00:15:52,684
Claude Code รัน /plugins ไปที่ installed

328
00:15:52,684 --> 00:15:55,773
จะเห็น plugin ของ Typesafe เปิดใช้งานแล้ว

329
00:15:55,773 --> 00:15:58,711
จากนั้นไปที่หมวด API key สร้าง key ใหม่

330
00:15:58,711 --> 00:16:01,649
แล้วใส่ในไฟล์ env ชื่อ TYPESAFE_API_KEY

331
00:16:01,649 --> 00:16:04,511
แล้วทดสอบว่าใช้ได้ด้วยการสั่ง "use the

332
00:16:04,511 --> 00:16:07,600
Typesafe skill" ซึ่งสำคัญมาก "ตรวจว่า key

333
00:16:07,600 --> 00:16:09,257
ของผมใช้ได้ไหม ถาม Jev

334
00:16:09,257 --> 00:16:12,497
คำถามใช่/ไม่ใช่หนึ่งข้อเกี่ยวกับ" และนี่คือ

335
00:16:12,497 --> 00:16:15,133
input ของเราที่สมมติเป็นอีเมลลูกค้า

336
00:16:15,133 --> 00:16:18,523
"เราถูกตัดเงินสองครั้ง ช่วยแก้ด่วน" แล้วขอให้

337
00:16:18,523 --> 00:16:19,955
Jev ประเมินตามคำถาม

338
00:16:19,955 --> 00:16:22,968
"ลูกค้ากำลังรายงานปัญหาการเรียกเก็บเงิน"

339
00:16:22,968 --> 00:16:25,529
และบอกคำตอบดิบที่ได้จาก Jev กลับมา

340
00:16:25,529 --> 00:16:31,104
ควรได้แค่ใช่หรือไม่ใช่ในรูปตัวเลขที่บอกว่านี่เป็นปัญหาบิลลิ่งหรือน่าจะเป็น

341
00:16:31,104 --> 00:16:34,193
ก่อนรัน ถ้าคุณไม่ได้ใช้ Claude Code ตรง ๆ

342
00:16:34,193 --> 00:16:37,206
แต่อยากใช้ในแอป desktop ผมยังไม่ได้ทดสอบ

343
00:16:37,206 --> 00:16:40,596
แต่น่าจะเหมือนกันทุกประการ เพียงไปหา skill.md

344
00:16:40,596 --> 00:16:43,233
บน GitHub เปิดหน้านั้นแล้วดาวน์โหลด

345
00:16:43,233 --> 00:16:46,246
แล้วอัปโหลด skill ในหมวด customize ภายใน

346
00:16:46,246 --> 00:16:49,334
skills ของคุณ แล้วคุณก็ควรจะใช้ Jev ในแอป

347
00:16:49,334 --> 00:16:52,724
Claude desktop ได้เช่นกัน มารัน prompt นี้กัน

348
00:16:52,724 --> 00:16:55,813
ใช้ Typesafe skill แล้วดูว่าได้อะไรกลับมา

349
00:16:55,813 --> 00:16:58,902
นี่คือ request ที่สร้างจาก Typesafe skill

350
00:16:58,902 --> 00:17:02,216
state คือข้อมูลที่เราส่ง "ถูกตัดเงินสองครั้ง

351
00:17:02,216 --> 00:17:05,004
แก้ด่วน" คืออีเมล ส่งให้ Jev คำถามคือ

352
00:17:05,004 --> 00:17:08,243
"เป็นปัญหาบิลลิ่งไหม" ระบุว่าเป็นใช่/ไม่ใช่

353
00:17:08,243 --> 00:17:09,599
พร้อมคำอธิบายเกณฑ์

354
00:17:09,599 --> 00:17:12,612
"ลูกค้ากำลังรายงานปัญหาการเรียกเก็บเงิน"

355
00:17:12,612 --> 00:17:15,852
ตรงตามเกณฑ์ที่เราต้องการประเมินเลย เกณฑ์ของ

356
00:17:15,852 --> 00:17:16,947
"ใช่" คือ

357
00:17:16,947 --> 00:17:19,885
ข้อความรายงานปัญหาเกี่ยวกับค่าธรรมเนียม

358
00:17:19,885 --> 00:17:22,371
การชำระเงิน ใบแจ้งหนี้ การคืนเงิน

359
00:17:22,371 --> 00:17:25,234
หรือการเรียกเก็บค่าสมาชิก ส่วนเกณฑ์ของ

360
00:17:25,234 --> 00:17:28,548
"ไม่ใช่" คือ ข้อความไม่ได้รายงานปัญหาบิลลิ่ง

361
00:17:28,548 --> 00:17:31,863
เห็นไหมว่านี่คือเกณฑ์ที่อธิบายละเอียด จน Jev

362
00:17:31,863 --> 00:17:34,048
ตัดสินได้ว่าข้อความหรือ state

363
00:17:34,048 --> 00:17:37,212
นี้น่าจะเป็นใช่หรือไม่ใช่เทียบกับเกณฑ์นั้น

364
00:17:37,212 --> 00:17:40,376
Claude สร้างเกณฑ์นี้ขึ้นจาก Typesafe skill

365
00:17:40,376 --> 00:17:43,540
คำตอบที่ได้กลับมาคือตัวเลขเดียว 0.99 โดย 1

366
00:17:43,540 --> 00:17:45,875
หมายถึงเป็นปัญหาบิลลิ่งแน่นอน 0

367
00:17:45,875 --> 00:17:49,340
หมายถึงไม่ใช่เลย นี่คือ response ตรง ๆ จาก Jev

368
00:17:49,340 --> 00:17:52,504
input 324 token output 24 token และผมขอให้

369
00:17:52,504 --> 00:17:55,593
Claude ดึงเวลาและต้นทุนมาด้วย ส่วนของ Jev

370
00:17:55,593 --> 00:17:56,949
ใช้เวลา 0.3 วินาที

371
00:17:56,949 --> 00:18:00,414
ซึ่งน่าจะเป็นตัวเลขที่สูงเกินจริง เพราะ Claude

372
00:18:00,414 --> 00:18:03,729
ต้องเชื่อมต่อก่อนหน้านั้นด้วย ส่วน 324 input

373
00:18:03,729 --> 00:18:05,989
token มีค่าประมาณ 0.0136 เซนต์

374
00:18:05,989 --> 00:18:11,337
เห็นไหมว่าถ้าทำแบบนี้กับอีเมลหลายพันฉบับก็แทบไม่กระทบเงินไม่กี่เซนต์เลย

375
00:18:11,337 --> 00:18:13,221
ต้องเรียกแบบนี้ถึง 73,000

376
00:18:13,221 --> 00:18:15,405
ครั้งถึงจะใช้เงินหนึ่งดอลลาร์

377
00:18:15,405 --> 00:18:18,720
ถูกและเร็วสุดขั้นจริง ๆ ส่วน output 24 token

378
00:18:18,720 --> 00:18:21,809
ที่แค่บอกตัวเลขนั้น แทบไม่มีค่าใช้จ่ายเลย

379
00:18:21,809 --> 00:18:24,747
และถ้าย้อนกลับไปดูว่า skill นี้ทำอะไร —

380
00:18:24,747 --> 00:18:28,212
Typesafe skill ไม่ได้รันอะไรเองเลย มันคือ rule

381
00:18:28,212 --> 00:18:30,171
book ที่ Claude หรือ agent

382
00:18:30,171 --> 00:18:32,054
อื่นใช้กับคำถามสามแบบนั้น

383
00:18:32,054 --> 00:18:34,314
มันบอกได้ว่าคำถามควรเป็นแบบไหน

384
00:18:34,314 --> 00:18:37,327
วิธีเขียนคำถามที่ Jev จะไม่อ่านเข้าใจผิด

385
00:18:37,327 --> 00:18:39,512
เรื่องความเฉพาะเจาะจงของคำถาม

386
00:18:39,512 --> 00:18:42,751
เมื่อไหร่ควรรวมคำถามเป็นชุด เมื่อไหร่ควรแยก

387
00:18:42,751 --> 00:18:45,840
ซึ่งเดี๋ยวค่อยคุยกัน และวิธีวาง threshold

388
00:18:45,840 --> 00:18:48,929
และระดับ confidence ดังนั้นถ้าคุณทำงานจาก

389
00:18:48,929 --> 00:18:51,640
Claude คุณไม่ได้คุยกับ Jev ตรง ๆ เลย

390
00:18:51,640 --> 00:18:54,654
คุณอธิบายงานเป็นภาษาคน Claude อ่าน skill

391
00:18:54,654 --> 00:18:57,968
เขียนสคริปต์ประเมิน สคริปต์ส่งแถวข้อมูลไปให้

392
00:18:57,968 --> 00:19:00,906
Jev แล้ว Claude อ่านผลลัพธ์กลับมาให้ฟัง

393
00:19:00,906 --> 00:19:04,372
นี่คือวิธีใช้ทั้งคู่ร่วมกัน ทางเลือกอื่นคือใช้

394
00:19:04,372 --> 00:19:07,837
OpenRouter ข้าม Claude Code แล้วเรียกโมเดล Jev

395
00:19:07,837 --> 00:19:11,302
จาก OpenRouter ตรง ๆ แต่แปลว่าคุณต้องแต่งคำถาม

396
00:19:11,302 --> 00:19:14,466
แต่งคำอธิบาย และจัดโครงสร้าง input ให้ Jev

397
00:19:14,466 --> 00:19:17,630
เองทั้งหมด ตอนนี้คุณเห็นแล้วว่า key ใช้ได้

398
00:19:17,630 --> 00:19:19,514
เร็วมาก และขยาย scale ได้

399
00:19:19,514 --> 00:19:23,808
มาถอดโครงวิธีใช้สิ่งนี้เองด้วยตัวอย่างอีเมลสนับสนุนลูกค้า

400
00:19:23,808 --> 00:19:27,122
50 ฉบับที่เข้ามาข้ามคืน ผมมี CSV หรือ Google

401
00:19:27,122 --> 00:19:30,437
Sheet ของอีเมลสนับสนุน 50 ฉบับ เวลาที่ได้รับ

402
00:19:30,437 --> 00:19:31,532
ID อีเมล

403
00:19:31,532 --> 00:19:34,395
ลูกค้ารายนี้อยู่กับเราตั้งแต่เมื่อไหร่

404
00:19:34,395 --> 00:19:37,710
แพ็กเกจไหน ใบแจ้งหนี้ล่าสุดที่จ่าย หัวเรื่อง

405
00:19:37,710 --> 00:19:40,346
เนื้อความ ทุกอย่างที่ต้องส่งให้ Jev

406
00:19:40,346 --> 00:19:43,284
เราจะถอดวิธีเปลี่ยนสิ่งนี้เป็น workflow

407
00:19:43,284 --> 00:19:46,298
ที่คัดแยกให้ฉบับง่าย ๆ ได้คำตอบอัตโนมัติ

408
00:19:46,298 --> 00:19:48,030
ฉบับเสี่ยงส่งต่อพนักงาน

409
00:19:48,030 --> 00:19:51,119
และเมื่อเข้าคิวแล้วเรียงตามลำดับความสำคัญ

410
00:19:51,119 --> 00:19:55,187
เพื่อให้คนที่มานั่งเปิดอ่านตอนเช้าเห็นเรียงไปทำทีละอัน

411
00:19:55,187 --> 00:19:58,426
อีเมลเหล่านี้อยู่ใน emails.csv ที่เตรียมไว้

412
00:19:58,426 --> 00:20:01,741
หรือถ้าใช้ harness อย่าง Claude Code ก็เสียบ

413
00:20:01,741 --> 00:20:03,021
MCP ตรงเข้า inbox

414
00:20:03,021 --> 00:20:05,658
อีเมลจริงแล้วประมวลผลแบบเดียวกันได้

415
00:20:05,658 --> 00:20:07,315
มีตัวอย่างเช่น "สวัสดี

416
00:20:07,315 --> 00:20:10,555
เพิ่งเห็นว่าถูกตัดเงินสองรายการ 99 ดอลลาร์"

417
00:20:10,555 --> 00:20:13,493
"สมัครทดลองใช้แล้ว magic link ไม่มา" มี

418
00:20:13,493 --> 00:20:16,581
feature request "เพิ่ม Perplexity ได้ไหม"

419
00:20:16,581 --> 00:20:19,670
มีเรื่องร้องเรียน "ตัวเลข metrics ไม่แสดง

420
00:20:19,670 --> 00:20:23,060
หรือตัวเลขลดลง" มีคำถามเรื่อง GDPR compliance

421
00:20:23,060 --> 00:20:25,245
ทั้งหมดนี้คือข้อมูลที่ให้ Jev

422
00:20:25,245 --> 00:20:28,635
ประเมินได้เร็วมากเทียบกับชุดคำถาม เวลาถอดโครง

423
00:20:28,635 --> 00:20:35,038
สิ่งสำคัญที่สุดก่อนเขียนสักคำถามเดียวคือตัดสินใจก่อนว่าโค้ดจะเอาคำตอบแต่ละอันไปทำอะไร

424
00:20:35,038 --> 00:20:36,394
คำตอบที่ได้จาก Jev

425
00:20:36,394 --> 00:20:39,407
ไม่ว่าจะความน่าจะเป็นหรือตัวเลข ต้องเป็น

426
00:20:39,407 --> 00:20:42,571
trigger ของการกระทำ ทุกคำถามที่เราแต่งต้อง

427
00:20:42,571 --> 00:20:44,605
trigger การกระทำเฉพาะเจาะจง

428
00:20:44,605 --> 00:20:47,619
และเดี๋ยวเราจะคุยกันว่าหาคำถามจากไหนก่อน

429
00:20:47,619 --> 00:20:51,837
พิจารณาการกระทำที่จะเกิดจากผลลัพธ์ในเคสสนับสนุนลูกค้านี้

430
00:20:51,837 --> 00:20:54,850
เรามีสี่การกระทำ คือ ตอบอีเมลด้วย Claude

431
00:20:54,850 --> 00:20:57,562
โดยตรงหรือให้ Claude ร่าง ส่งเข้าคิว

432
00:20:57,562 --> 00:21:00,877
engineering ในฐานะ bug ที่ต้องแก้ บันทึกเป็น

433
00:21:00,877 --> 00:21:02,610
feature request ไว้ก่อน

434
00:21:02,610 --> 00:21:05,020
หรือส่งต่อ/ขยายเรื่องให้คนจัดการ

435
00:21:05,020 --> 00:21:08,335
นี่คือสิ่งที่ผมต้องบอก Claude — งานที่ต้องทำ

436
00:21:08,335 --> 00:21:10,821
สี่การกระทำหรือเส้นทางที่เลือกได้

437
00:21:10,821 --> 00:21:14,286
และคำสั่งเดียวคือ "โชว์แผนก่อนรันอะไรทั้งสิ้น"

438
00:21:14,286 --> 00:21:17,450
เพื่อให้เราเห็นโครงสร้างแผนที่จะส่งให้ Jev

439
00:21:17,450 --> 00:21:21,594
และไล่อ่านทีละชิ้นก่อนรันกับข้อมูลทั้งกองว่ามีคำถามอะไร

440
00:21:21,594 --> 00:21:24,833
รันบนข้อมูลชุดไหน เรื่อง prompt ผมเจาะจงมาก

441
00:21:24,833 --> 00:21:28,148
แต่คุณจะให้ Claude เขียน prompt แบบนี้สำหรับ

442
00:21:28,148 --> 00:21:31,161
use case ของคุณเองก็ได้แหละ อย่างที่ผมทำ

443
00:21:31,161 --> 00:21:34,174
อีกครั้ง ต้องมี "use the Typesafe skill"

444
00:21:34,174 --> 00:21:36,962
สำคัญมาก "ผมมีอีเมลสนับสนุน 50 ฉบับใน

445
00:21:36,962 --> 00:21:39,900
emails.csv ในโฟลเดอร์ downloads ทุกเช้า

446
00:21:39,900 --> 00:21:42,235
ผมอยากให้มันถูกคัดเข้าสี่กอง" —

447
00:21:42,235 --> 00:21:45,399
นี่คือสี่การกระทำของเรา ตอบด้วย Claude คิว

448
00:21:45,399 --> 00:21:47,207
engineering ส่งให้คน ฯลฯ

449
00:21:47,207 --> 00:21:50,371
"แต่ละกองเรียงลูกค้าที่โกรธที่สุดขึ้นก่อน"

450
00:21:50,371 --> 00:21:53,158
จากสิ่งเหล่านี้ บวกกับ Typesafe skill

451
00:21:53,158 --> 00:21:56,397
มันจะเข้าใจลำดับความสำคัญและคำถามที่ต้องถาม

452
00:21:56,397 --> 00:21:58,582
เข้าใจว่าต้องมีคำถามแบบ score

453
00:21:58,582 --> 00:22:00,164
เพื่อให้คะแนนความโกรธ

454
00:22:00,164 --> 00:22:03,403
และเพราะผมมีภาพชัดว่าอยากรู้อะไรในแต่ละฉบับ

455
00:22:03,403 --> 00:22:05,663
ผมระบุไปเลย แต่ปล่อยให้ Claude

456
00:22:05,663 --> 00:22:08,225
กำหนดคำถามและเกณฑ์เองก็ได้ ต่อฉบับ

457
00:22:08,225 --> 00:22:11,464
ผมอยากรู้ว่ามันเกี่ยวกับอะไร อาจเป็น choice

458
00:22:11,464 --> 00:22:14,553
บิลลิ่ง เทคนิค feature request บัญชี หรือ

459
00:22:14,553 --> 00:22:17,717
"ไม่ใช่อันไหนเลย" การใส่ "ไม่ใช่อันไหนเลย"

460
00:22:17,717 --> 00:22:20,504
สำคัญมาก เพราะถ้าไม่มีตัวเลือกนี้ Jev

461
00:22:20,504 --> 00:22:23,517
จะพยายามเลือกอะไรที่น่าจะใช่ที่สุดอยู่ดี

462
00:22:23,517 --> 00:22:24,873
แต่พอมีตัวเลือกนี้

463
00:22:24,873 --> 00:22:27,209
มันมีทางออกให้ตอบว่าไม่เข้าข่าย

464
00:22:27,209 --> 00:22:30,297
ผมอยากรู้ว่าเขาขอเงินคืนหรือขอ refund ไหม

465
00:22:30,297 --> 00:22:33,386
อยากรู้ว่ามีอะไรพังหรือเปล่า เพราะนั่นคือ

466
00:22:33,386 --> 00:22:35,872
trigger ให้ส่งเข้าคิว engineering

467
00:22:35,872 --> 00:22:38,735
ผมอยากรู้ระดับความโกรธบนมาตรวัด ใจเย็น

468
00:22:38,735 --> 00:22:41,070
หงุดหงิด โกรธจัด ประมาณ 1 ถึง 3

469
00:22:41,070 --> 00:22:43,782
และอยากรู้ว่าเป็นเรื่องกิจวัตรธรรมดา

470
00:22:43,782 --> 00:22:45,364
ต้องใช้วิจารณญาณหน่อย

471
00:22:45,364 --> 00:22:47,774
หรือผิดสังเกตพอที่ควรให้คนจัดการ

472
00:22:47,774 --> 00:22:51,014
จากนั้นผมเพิ่มกฎว่าโค้ดจะทำอะไร Claude Code

473
00:22:51,014 --> 00:22:53,726
จะสร้างโค้ดที่ประมวลผลคำตอบของ Jev —

474
00:22:53,726 --> 00:22:56,739
ทุกอย่างที่เกี่ยวกับเงินต้องส่งให้คนเสมอ

475
00:22:56,739 --> 00:23:00,129
ห้ามให้ Claude จัดการ และผมต้องการ confidence

476
00:23:00,129 --> 00:23:01,862
สูงสำหรับข้อนี้ ถ้า Jev

477
00:23:01,862 --> 00:23:04,875
ไม่มั่นใจเรื่องหมวดหมู่ หรือเคสผิดสังเกต

478
00:23:04,875 --> 00:23:07,813
ส่งให้คน ถ้าผลิตภัณฑ์พังจนใช้ไม่ได้ ส่ง

479
00:23:07,813 --> 00:23:10,977
engineering ส่วน feature request บันทึกไว้

480
00:23:10,977 --> 00:23:14,442
ที่เหลือให้ Claude ร่างคำตอบโดยใช้ reply guide

481
00:23:14,442 --> 00:23:17,531
ที่กำหนด ซึ่งเป็นทรัพยากรแบรนด์แยกต่างหาก

482
00:23:17,531 --> 00:23:24,085
และเราจะเรียงทุกกองด้วยคะแนนความสำคัญที่อิงความโกรธเป็นหลักและความรุนแรงของปัญหาเป็นรอง

483
00:23:24,085 --> 00:23:26,872
ดังนั้นต้อง score จากหลายคำถาม Claude

484
00:23:26,872 --> 00:23:28,906
ทำงานร่วมกับ Typesafe skill

485
00:23:28,906 --> 00:23:32,146
จะเข้าใจว่าต้องแตกสิ่งเหล่านี้เป็นคำถามเชิง

486
00:23:32,146 --> 00:23:34,255
deterministic แยกอัน ที่ Jev

487
00:23:34,255 --> 00:23:37,042
ให้คะแนนความน่าจะเป็นพร้อม confidence

488
00:23:37,042 --> 00:23:40,206
และเราระบุเพิ่มเพราะอยากได้การตรวจสอบพิเศษ

489
00:23:40,206 --> 00:23:43,521
ก่อนเซฟฉบับร่างของ Claude ทุกฉบับ ให้เช็คกับ

490
00:23:43,521 --> 00:23:45,856
Jev อีกหนึ่ง request แยกต่างหาก

491
00:23:45,856 --> 00:23:47,664
ด้วยคำถามต่างจากชุดแรก —

492
00:23:47,664 --> 00:23:50,150
"มันตอบคำถามของลูกค้าจริงไหม" และ

493
00:23:50,150 --> 00:23:52,937
"มันรับปากคืนเงินหรือลดราคาไหม" คือทำ

494
00:23:52,937 --> 00:23:56,403
validation ซ้ำหลัง Claude สำหรับฉบับที่ Claude

495
00:23:56,403 --> 00:23:59,491
เขียน แล้วเก็บเฉพาะฉบับที่ผ่านทั้งสองด่าน

496
00:23:59,491 --> 00:24:02,731
เขียนแผนเป็นสามส่วน — state คือข้อมูล input

497
00:24:02,731 --> 00:24:06,045
คำถามพร้อมเกณฑ์ และการ route พร้อม threshold

498
00:24:06,045 --> 00:24:09,360
ของทุกกฎ คือระดับ confidence ที่ผ่านกฎนั้น ๆ

499
00:24:09,360 --> 00:24:12,750
เก็บในไฟล์เดียว และโชว์แผนก่อนรันอะไรทั้งสิ้น

500
00:24:12,750 --> 00:24:16,140
คุณจะขอดูสคริปต์ที่จะส่งให้ Typesafe หรือ Jev

501
00:24:16,140 --> 00:24:19,379
ก็ได้ แต่แบบนี้เราก็อปปีไปวางใน Claude Code

502
00:24:19,379 --> 00:24:22,091
ที่ติดตั้ง Typesafe ไว้แล้วรันได้เลย

503
00:24:22,091 --> 00:24:24,502
และสิ่งที่มันจะทำคือส่งแผนกลับมา

504
00:24:24,502 --> 00:24:26,837
ตอนนี้เรายังไม่สนเรื่องความเร็ว

505
00:24:26,837 --> 00:24:29,248
เพราะเป้าหมายตอนนี้คือได้แผนดี ๆ

506
00:24:29,248 --> 00:24:32,035
พร้อมชุดคำถามที่ดี เพื่อให้รันกับ Jev

507
00:24:32,035 --> 00:24:34,747
ได้เต็มที่ Jev จะทรงพลังกับ workflow

508
00:24:34,747 --> 00:24:38,137
แบบกองโตก็ต่อเมื่อเราถามได้ดี และ Claude หรือ

509
00:24:38,137 --> 00:24:39,233
LLM

510
00:24:39,233 --> 00:24:42,472
สามารถแตกความต้องการของเราเป็นคำถามที่ดีได้

511
00:24:42,472 --> 00:24:45,334
ตอนนี้เราได้แผนของ Claude กลับมาในไฟล์

512
00:24:45,334 --> 00:24:48,423
questions.py แล้ว สิ่งแรกที่เห็นคือ state

513
00:24:48,423 --> 00:24:51,813
หรือหน้าตาของแต่ละอีเมลเมื่อถึงมือ Jev มันใช้

514
00:24:51,813 --> 00:24:55,278
skill กำหนดว่า state ควรหน้าตาเป็นแบบไหน เรามี

515
00:24:55,278 --> 00:24:58,367
ID เวลาที่รับ แพ็กเกจ หัวเรื่อง เนื้อความ

516
00:24:58,367 --> 00:25:01,456
ทุกฟิลด์ สิ่งที่มันบอกคือเราต้องมี object

517
00:25:01,456 --> 00:25:04,620
หนึ่งชิ้นต่ออีเมล แทนที่จะเป็นข้อความยาว ๆ

518
00:25:04,620 --> 00:25:07,256
เพื่อให้ทุกส่วนมีชื่อที่บอกความหมาย

519
00:25:07,256 --> 00:25:08,838
ความสัมพันธ์จึงชัดเจน

520
00:25:08,838 --> 00:25:12,605
มันใส่ข้อมูลลูกค้าเช่นแพ็กเกจหรืออายุการเป็นลูกค้า

521
00:25:12,605 --> 00:25:17,954
เพราะลูกค้ารายแรกบนแพ็กเกจสูงสุดเป็นเคสคนละเรื่องกับทรายลองอายุหนึ่งวัน

522
00:25:17,954 --> 00:25:20,214
Jev จะปฏิบัติทั้งสองแบบต่างกัน

523
00:25:20,214 --> 00:25:22,926
มันแมพคอลัมน์ของ CSV ออกมาให้สคริปต์

524
00:25:22,926 --> 00:25:26,090
แปลงหนึ่งแถว CSV เป็น state หรือ input ของ

525
00:25:26,090 --> 00:25:29,555
triage request ทุกแถวจะมีข้อมูลอีเมลที่ส่งเข้า

526
00:25:29,555 --> 00:25:32,719
Jev และข้อมูลลูกค้า แยกเป็นหมวดเฉพาะเจาะจง

527
00:25:32,719 --> 00:25:34,301
เพราะ skill สั่งให้ทำ

528
00:25:34,301 --> 00:25:36,862
เพื่อให้คำถามเรียกฟิลด์ได้ด้วยชื่อ

529
00:25:36,862 --> 00:25:39,122
และตัดสิ่งที่ไม่เกี่ยวออก เช่น

530
00:25:39,122 --> 00:25:40,629
ประวัติบทสนทนาเก่า ๆ

531
00:25:40,629 --> 00:25:45,601
เพราะยิ่งมีข้อความที่ไม่เกี่ยวเข้าสู่การตัดสินใจมากเท่าไหร่ยิ่งแย่

532
00:25:45,601 --> 00:25:49,066
และนี่พาเราไปสู่ข้อจำกัดแบบ hard limit ของ Jev

533
00:25:49,066 --> 00:25:51,175
คือ 64,000 token ต่อ request

534
00:25:51,175 --> 00:25:53,812
แต่คุณไม่ควรจะเข้าใกล้ตัวเลขนั้นเลย

535
00:25:53,812 --> 00:25:56,976
มันไม่ได้ออกแบบมาแบบ LLM ที่ยัด input ล้าน

536
00:25:56,976 --> 00:26:00,140
token มันต่างกันมาก request แบบ structured

537
00:26:00,140 --> 00:26:03,304
นี้กระชับตรงประเด็น ถามคำถามที่นิยามชัดเจน

538
00:26:03,304 --> 00:26:05,338
เรายังมี state สำหรับรอบสอง

539
00:26:05,338 --> 00:26:09,406
ซึ่งอิงจากหัวเรื่องและเนื้อความของอีเมลที่ถูกร่างคำตอบ

540
00:26:09,406 --> 00:26:12,495
และ state ตัวที่สองสำหรับรอบสองที่จะทำตอน

541
00:26:12,495 --> 00:26:13,700
Claude ร่างคำตอบ

542
00:26:13,700 --> 00:26:16,412
มันจะบรรจุข้อมูลอีเมลและฉบับร่างจริง

543
00:26:16,412 --> 00:26:18,521
เพื่อดูว่าเราตอบคำถามหรือยัง

544
00:26:18,521 --> 00:26:20,706
ซึ่งเป็นรอบที่สองที่เราวางไว้

545
00:26:20,706 --> 00:26:23,117
ส่วนที่สองที่มันแตกออกมาคือคำถาม

546
00:26:23,117 --> 00:26:25,904
เรามีห้าคำถามต่ออีเมลใน request เดียว

547
00:26:25,904 --> 00:26:28,917
ทุกอีเมลใน CSV จะได้คำถามทั้งห้าข้อตอบใน

548
00:26:28,917 --> 00:26:31,027
request เดียว ซึ่งไม่มีปัญหา

549
00:26:31,027 --> 00:26:33,060
เพราะทุกคำถามที่เพิ่มเข้าไป

550
00:26:33,060 --> 00:26:35,923
จะสิบหรือสิบห้าข้อก็แทบไม่มีค่าใช้จ่าย

551
00:26:35,923 --> 00:26:39,162
คำถามเหล่านี้แทบฟรี เราจึงส่งทีเดียวทั้งหมด

552
00:26:39,162 --> 00:26:41,272
ให้ประมวลผลทุกเกณฑ์ขนานกันไป

553
00:26:41,272 --> 00:26:44,436
และในแต่ละคำตอบเราจะได้คะแนนและ confidence

554
00:26:44,436 --> 00:26:47,449
กลับจาก Jev มันสร้างคำถาม triage หลายข้อ

555
00:26:47,449 --> 00:26:48,730
ข้อแรกเป็น choice

556
00:26:48,730 --> 00:26:51,668
"อีเมลสนับสนุนนี้เกี่ยวกับอะไรเป็นหลัก"

557
00:26:51,668 --> 00:26:54,756
ถ้าเป็นบิลลิ่ง เกณฑ์คือเรื่องค่าธรรมเนียม

558
00:26:54,756 --> 00:26:57,167
ใบแจ้งหนี้ การชำระเงิน ค่าสมาชิก

559
00:26:57,167 --> 00:26:59,804
แต่ไม่รวมปัญหาล็อกอินหรือการเข้าถึง

560
00:26:59,804 --> 00:27:02,290
เราระบุชัดว่าคืออะไรและไม่ใช่อะไร

561
00:27:02,290 --> 00:27:05,378
พร้อมตัวอย่าง ต่อมาเทคนิค feature request

562
00:27:05,378 --> 00:27:08,467
บัญชี และ "ไม่มี" อย่างที่บอก ทุก request

563
00:27:08,467 --> 00:27:10,576
ต้องมีทางออกให้เลือก "ไม่มี"

564
00:27:10,576 --> 00:27:13,966
เพื่อไม่ให้มันต้องยัดเยียดเข้าหมวดใดหมวดหนึ่ง

565
00:27:13,966 --> 00:27:17,356
แล้วเราแตกต่อเรื่อง "ขอเงินคืน" เกณฑ์ของ null

566
00:27:17,356 --> 00:27:20,746
ถ้าจริง คืออีเมลขอให้คืนเงินหรือ cred เงินคืน

567
00:27:20,746 --> 00:27:21,842
ถ้าเท็จ

568
00:27:21,842 --> 00:27:24,930
คืออีเมลไม่ได้อ้างสิทธิ์เงินที่จ่ายไปแล้ว

569
00:27:24,930 --> 00:27:28,998
และระบุว่าการขอยกเลิกโดยไม่พูดถึงการคืนเงินถือเป็นเท็จ

570
00:27:28,998 --> 00:27:32,464
เพราะเขาจะไม่ได้เงินคืนจากการนั้น เราแตกเรื่อง

571
00:27:32,464 --> 00:27:34,422
"พังหนักแค่ไหน" เป็น score

572
00:27:34,422 --> 00:27:37,737
ให้เกณฑ์แต่ละระดับจาก 1 ถึง 4 — ไม่มีอะไรพัง

573
00:27:37,737 --> 00:27:39,846
เสียหายเรื่องหน้าตา น่ารำคาญ

574
00:27:39,846 --> 00:27:41,202
และใช้ของไม่ได้เลย

575
00:27:41,202 --> 00:27:44,441
สิ่งสำคัญคือเราเจาะจงกับเกณฑ์มาก "น่ารำคาญ"

576
00:27:44,441 --> 00:27:45,537
หมายถึงอะไร

577
00:27:45,537 --> 00:27:48,852
หมายถึงฟีเจอร์ทำงานเสื่อมหรือล้มเหลวบางครั้ง

578
00:27:48,852 --> 00:27:51,488
แต่มีทางแก้ผ่าน เพราะเราระบุไว้ Jev

579
00:27:51,488 --> 00:27:55,104
จึงมั่นใจได้มากขึ้นในการตัดสินว่าน่ารำคาญหรือไม่

580
00:27:55,104 --> 00:27:58,343
และต้องจำไว้ว่าทุกอีเมลผ่านเกณฑ์เดียวกันหมด

581
00:27:58,343 --> 00:27:59,439
เช่น

582
00:27:59,439 --> 00:28:03,055
อีเมลบิลลิ่งก็ยังโดนถามคำถามความเสียหายเหมือนกัน

583
00:28:03,055 --> 00:28:05,842
"ผลิตภัณฑ์พังแค่ไหนสำหรับลูกค้าคนนี้"

584
00:28:05,842 --> 00:28:08,780
จากที่อีเมลบรรยายมันก็จะตอบว่าไม่พังเลย

585
00:28:08,780 --> 00:28:10,588
และคะแนนนั้นก็ถูกละเลยไป

586
00:28:10,588 --> 00:28:13,526
การส่งคำถามทั้งหมดพร้อมกันทำให้เร็วขึ้น

587
00:28:13,526 --> 00:28:14,882
ประมวลผลขนานกันหมด

588
00:28:14,882 --> 00:28:17,745
เราแค่เข้าใจว่าไม่เกี่ยวกับความเสียหาย

589
00:28:17,745 --> 00:28:18,840
คะแนนเป็นศูนย์

590
00:28:18,840 --> 00:28:22,079
และไม่มีการกระทำตามคะแนนนั้นสำหรับอีเมลนั้น

591
00:28:22,079 --> 00:28:25,319
เรื่องความโกรธ "ลูกค้าคนนี้โกรธแค่ไหน" เป็น

592
00:28:25,319 --> 00:28:28,031
score จากใจเย็นถึงโกรธจัด และ Claude

593
00:28:28,031 --> 00:28:31,270
ยังแตกเรื่อง "ต้องใช้วิจารณญาณมนุษย์แค่ไหน"

594
00:28:31,270 --> 00:28:34,660
เป็นเคสมาตรฐาน ต้องใช้วิจารณญาณ หรือผิดสังเกต

595
00:28:34,660 --> 00:28:37,899
ซึ่งเป็น choice ให้เลือกหนึ่งในสาม ในรอบสอง

596
00:28:37,899 --> 00:28:40,461
เรามีคำถามยืนยัน — ตอบคำถามหรือยัง

597
00:28:40,461 --> 00:28:43,926
รับปากคืนเงินหรือลดราคาไหม — แล้ว Claude จะใช้

598
00:28:43,926 --> 00:28:46,789
Typesafe skill แปลงทั้งหมดเป็น request

599
00:28:46,789 --> 00:28:50,103
ตามโครงสร้าง JSON ที่เห็นก่อนหน้า ส่งให้ Jev

600
00:28:50,103 --> 00:28:52,966
ในแผนยังมีกฎการ route — จะส่งให้คน ทีม

601
00:28:52,966 --> 00:28:56,130
engineering หรือกองไว้ให้ Claude ร่างคำตอบ

602
00:28:56,130 --> 00:28:58,465
พร้อมระดับ confidence ที่ใช้วัด

603
00:28:58,465 --> 00:29:01,403
คุณเข้าไปแก้ค่าพวกนี้ได้ ถ้า confidence

604
00:29:01,403 --> 00:29:03,889
ของหมวดหมู่ต่ำกว่าเกณฑ์ในกฎข้อสอง

605
00:29:03,889 --> 00:29:07,053
ผลลัพธ์จะไม่ถูกไว้ใจ และจะถูก route ไปหาคน

606
00:29:07,053 --> 00:29:10,368
แล้วล่างสุดมีสคริปต์ route จริง ๆ ที่ Claude

607
00:29:10,368 --> 00:29:13,005
เขียนตาม Typesafe skill อย่างที่บอก

608
00:29:13,005 --> 00:29:15,415
ไม่มีการตัดสินด้วย LLM ตรงนี้เลย

609
00:29:15,415 --> 00:29:18,052
เป็นสคริปต์ล้วน ๆ ส่งผลลัพธ์จาก Jev

610
00:29:18,052 --> 00:29:21,517
ผ่านกฎเหล่านี้เข้ากองที่ถูกต้อง ทั้งหมดเป็น if

611
00:29:21,517 --> 00:29:24,455
statement ที่ตรวจสอบได้กับตัวเลขที่ Jev

612
00:29:24,455 --> 00:29:27,544
ตอบกลับมา คุณเห็นแล้ววิธีเขียนสิ่งนี้ด้วย

613
00:29:27,544 --> 00:29:29,804
Claude ซึ่งเร็วกว่าเขียนเองมาก

614
00:29:29,804 --> 00:29:35,303
แต่ส่วนที่ยากกว่าคือการรู้ว่าควรถามอะไรเกี่ยวกับกระบวนการของคุณตั้งแต่แรก

615
00:29:35,303 --> 00:29:38,768
นี่คือส่วนที่ผมหาในเน็ตไม่เจอ ไม่มีใครเขียนไว้

616
00:29:38,768 --> 00:29:40,802
ผมเลยทำ checklist ของตัวเอง

617
00:29:40,802 --> 00:29:43,062
ดาวน์โหลดฟรีในคำอธิบายด้านล่าง

618
00:29:43,062 --> 00:29:46,151
ใช้ไล่หาคำถามที่ต้องถามกับกระบวนการของคุณ

619
00:29:46,151 --> 00:29:49,315
หรือหา requirement ที่จะใส่เป็น prompt แรก

620
00:29:49,315 --> 00:29:52,178
สิ่งนี้ไม่มีแม้แต่ใน skill ที่เขาให้มา

621
00:29:52,178 --> 00:29:55,643
ซึ่งเป็นเกณฑ์เฉพาะเรื่องโครงสร้าง request ไปหา

622
00:29:55,643 --> 00:29:59,108
Jev นี่คือ checklist ที่ผมใช้กับห้าหัวข้อคำถาม

623
00:29:59,108 --> 00:30:02,423
ประกอบจาก docs ที่อ่านและวิดีโอ use case ของ

624
00:30:02,423 --> 00:30:03,518
Jev ที่ดูมา

625
00:30:03,518 --> 00:30:06,682
หลักการคือคิดจากมุมว่าซอฟต์แวร์จะทำอะไรต่อ

626
00:30:06,682 --> 00:30:09,470
ไม่ใช่มุมของข้อมูล ทุกคำถามที่ถาม Jev

627
00:30:09,470 --> 00:30:11,880
มีอยู่เพราะต้อง trigger การกระทำ

628
00:30:11,880 --> 00:30:13,538
การกระทำขึ้นอยู่กับมัน

629
00:30:13,538 --> 00:30:16,702
ดังนั้นเขียนรายการการกระทำก่อนเป็นข้อหนึ่ง

630
00:30:16,702 --> 00:30:20,167
ของเราคือ Claude ตอบ ส่งคิว engineering บันทึก

631
00:30:20,167 --> 00:30:22,502
feature log หรือส่งให้คน ข้อสอง

632
00:30:22,502 --> 00:30:24,837
สำหรับทุกการกระทำ เขียน trigger

633
00:30:24,837 --> 00:30:27,851
เป็นหนึ่งประโยค ประโยคนั้นคือคำถามของคุณ

634
00:30:27,851 --> 00:30:30,487
และมันบอกการกระทำซึ่งบอกชนิดคำถาม —

635
00:30:30,487 --> 00:30:33,425
ถ้าลงมือหรือไม่ลงมือคือ null ใช่/ไม่ใช่

636
00:30:33,425 --> 00:30:36,589
ถ้าเลือกปลายทางต่างกันคือ choice เป็นปัญหา

637
00:30:36,589 --> 00:30:39,377
routing ถ้าเรียงลำดับคือ score ข้อสาม

638
00:30:39,377 --> 00:30:42,691
เขียนว่าคนจะดูอะไรก่อนตัดสินใจ คือ input คือ

639
00:30:42,691 --> 00:30:43,787
state อะไร

640
00:30:43,787 --> 00:30:47,101
ในที่นี้คืออีเมลเดี่ยวหรือรายการอีเมล ข้อสี่

641
00:30:47,101 --> 00:30:50,341
เพิ่ม "อะไรอีกที่อาจเป็นจริงและจะเปลี่ยนการ

642
00:30:50,341 --> 00:30:52,977
route" นี่คือ edge case แม้หายากมาก

643
00:30:52,977 --> 00:30:56,217
ความรุนแรงของ bug มาจากไหนก็จากตรงนี้ เราจะ

644
00:30:56,217 --> 00:30:59,531
route ตามความรุนแรงของ bug จึงต้อง score มัน

645
00:30:59,531 --> 00:31:02,997
ข้อห้า ตัดสินว่าคำตอบผิดจะทำให้เสียหายเท่าไหร่

646
00:31:02,997 --> 00:31:06,236
เพื่อตั้งระดับ confidence หรือความยอมรับได้

647
00:31:06,236 --> 00:31:08,797
นั่นคือ threshold ของแต่ละการกระทำ

648
00:31:08,797 --> 00:31:11,585
ซึ่งคุณเห็นแล้วว่าเรามี threshold ของ

649
00:31:11,585 --> 00:31:14,598
confidence ครบทุกกฎ ผมรันกับอีเมลทั้ง 50

650
00:31:14,598 --> 00:31:16,632
ฉบับใน CSV แล้ว ใช้เวลา 4.2

651
00:31:16,632 --> 00:31:19,721
วินาทีสำหรับทั้งหมดด้วย worker ขนานแปดตัว

652
00:31:19,721 --> 00:31:22,056
ถ้ารันเรียงลำดับจะใช้ 31 วินาที

653
00:31:22,056 --> 00:31:24,467
ซึ่งเป็นวิธีที่คุณน่าจะทำกับ LLM

654
00:31:24,467 --> 00:31:27,103
แต่มันทำพร้อมกันหมดได้ ต้นทุน 0.026

655
00:31:27,103 --> 00:31:29,514
เซนต์สำหรับทั้ง 50 ประมาณ 19,000

656
00:31:29,514 --> 00:31:32,678
อีเมลต่อหนึ่งดอลลาร์ ถ้ารันทุกเช้า 50 ฉบับ

657
00:31:32,678 --> 00:31:35,390
จะเสียค่าใช้จ่ายราวหนึ่งดอลลาร์ต่อปี

658
00:31:35,390 --> 00:31:38,403
ถูกเหลือเชื่อ ผลลัพธ์อยู่ในไฟล์ markdown

659
00:31:38,403 --> 00:31:40,964
ให้อ่านง่าย เรียงตามลำดับความสำคัญ

660
00:31:40,964 --> 00:31:44,053
โดยถ่วงน้ำหนักความโกรธ 70% ความรุนแรง 30%

661
00:31:44,053 --> 00:31:46,388
เห็นว่า 19 ฉบับถูก route ไปหาคน

662
00:31:46,388 --> 00:31:48,573
ตามระดับความโกรธและความรุนแรง

663
00:31:48,573 --> 00:31:51,360
พร้อมหัวเรื่องและเหตุผลที่จัดหมวดนั้น

664
00:31:51,360 --> 00:31:54,600
เช่นคนขอเงินคืนบนมาตรวัด 0 ถึง 3 เขาโกรธมาก

665
00:31:54,600 --> 00:31:56,106
และ Jev ถือว่ารุนแรง

666
00:31:56,106 --> 00:32:00,852
พนักงานสนับสนุนลูกค้าจึงมีลิสต์เคสเรียงลำดับความสำคัญไว้ทุกเช้า

667
00:32:00,852 --> 00:32:04,318
และใช้เวลาไม่ถึงสิบวินาที นอกจากนี้ยังมีกองคิว

668
00:32:04,318 --> 00:32:07,783
engineering กอง feature request และ 19 ฉบับที่

669
00:32:07,783 --> 00:32:08,988
Claude ตอบได้เลย

670
00:32:08,988 --> 00:32:11,324
ซึ่งไม่ใช่งานของพนักงานอีกต่อไป

671
00:32:11,324 --> 00:32:14,563
ตอนนี้คุณเห็นวิธีจับ Jev คู่กับ Claude แล้ว

672
00:32:14,563 --> 00:32:18,104
ต่อไปคือกฎที่ต้องทำตามเพื่อให้ได้ประโยชน์สูงสุด

673
00:32:18,104 --> 00:32:20,816
นี่คือ pattern ที่ถอดจาก docs โดยตรง

674
00:32:20,816 --> 00:32:24,055
ข้อแรกฟังดูย้อนแย้งแต่เป็น insight สุดยอด —

675
00:32:24,055 --> 00:32:27,294
ถามทุกอย่างพร้อมกันเลย เราถามคำถามทั้งห้าใน

676
00:32:27,294 --> 00:32:30,759
request เดียวอย่างที่ทำไปแล้ว ปัญหาที่ pattern

677
00:32:30,759 --> 00:32:32,191
นี้แก้ก็คือการรอคอย

678
00:32:32,191 --> 00:32:35,505
และนี่คือเหตุผลที่มันเร็วสุดขั้น กับโมเดลแชท

679
00:32:35,505 --> 00:32:36,937
คุณถามหนึ่งอย่าง รอ

680
00:32:36,937 --> 00:32:39,950
แล้วค่อยตัดสินว่าจะถามอะไรต่อ แต่กับ Jev

681
00:32:39,950 --> 00:32:43,039
ทุกคำถามใน request รันขนานกันอย่างที่เห็น

682
00:32:43,039 --> 00:32:45,826
และคุณจ่ายค่าอ่านข้อความแค่ครั้งเดียว

683
00:32:45,826 --> 00:32:49,291
ถามทุกอย่างล่วงหน้า รวมถึงคำถามที่อาจไม่เกี่ยว

684
00:32:49,291 --> 00:32:50,949
เช่น ความรุนแรงของ bug

685
00:32:50,949 --> 00:32:52,907
ในสถานการณ์บิลลิ่งเมื่อกี้

686
00:32:52,907 --> 00:32:55,544
แล้วมันก็จะตัดสิ่งที่ไม่ต้องใช้ทิ้ง

687
00:32:55,544 --> 00:32:58,256
นี่เรียกว่า speculative fan-out เช่น

688
00:32:58,256 --> 00:33:01,495
ถ้ากลับมาเป็น query บิลลิ่ง คำตอบเรื่อง bug

689
00:33:01,495 --> 00:33:04,961
จะถูกละเลยในการประมวลผลทันที แต่ถ้ามันเป็น bug

690
00:33:04,961 --> 00:33:06,844
คุณก็มีความรุนแรงอยู่แล้ว

691
00:33:06,844 --> 00:33:09,933
ไม่ต้องเรียกอีกรอบเพื่อดูความรุนแรง หนึ่ง

692
00:33:09,933 --> 00:33:13,398
request คำถามหลายข้อ หลายชนิดปนกันได้ทั้ง null

693
00:33:13,398 --> 00:33:16,336
choice และ score Pattern สองคือการ gate

694
00:33:16,336 --> 00:33:18,596
การตัดสินใจตามระดับ confidence

695
00:33:18,596 --> 00:33:19,801
ของการกระทำเฉพาะ

696
00:33:19,801 --> 00:33:22,965
ช่วยให้คุณสร้างระบบที่ทั้งเสถียรและปลอดภัย

697
00:33:22,965 --> 00:33:26,430
รู้ว่าฟังยาวไป ตัวอย่างที่ Typesafe ใช้ใน docs

698
00:33:26,430 --> 00:33:29,896
คือ voice banking สมมติ confidence ต่ำกว่า 0.6

699
00:33:29,896 --> 00:33:33,210
คือ 60% ใกล้ ๆ ห้าสิบห้าสิบ จะถูกส่งต่อให้คน

700
00:33:33,210 --> 00:33:35,772
"เช็คยอดคงเหลือ" ที่ 0.6 ก็ผ่านได้

701
00:33:35,772 --> 00:33:39,764
เพราะกรณีแย่ที่สุดคือมีคนได้ยินยอดของตัวเองหากมันพลาด

702
00:33:39,764 --> 00:33:42,702
แต่การกระทำต่างชนิดกันต้อง gate ต่างกัน

703
00:33:42,702 --> 00:33:45,866
"อนุมัติโอนเงิน" ต้องมั่นใจกว่านั้นมาก สัก

704
00:33:45,866 --> 00:33:46,962
0.85

705
00:33:46,962 --> 00:33:52,084
ต่ำกว่านั้นมันจะขอให้คุณยืนยันก่อนว่าใช่การกระทำที่ตั้งใจทำหรือเปล่า

706
00:33:52,084 --> 00:33:53,666
คุณเห็นสิ่งนี้ใน demo

707
00:33:53,666 --> 00:33:55,776
เบราว์เซอร์เสียงตอนต้นคลิป —

708
00:33:55,776 --> 00:33:57,885
เลื่อนหน้าลงเกิดขึ้นทันทีเลย

709
00:33:57,885 --> 00:34:01,200
แต่การกระทำที่ทำลายอะไรบางอย่าง เช่น ปิดแท็บ

710
00:34:01,200 --> 00:34:04,514
มันจะหยุดถามขอยืนยันก่อนเสมอ เพราะมันต่ำกว่า

711
00:34:04,514 --> 00:34:07,603
threshold ที่ตั้งไว้ คุณมีหนึ่ง threshold

712
00:34:07,603 --> 00:34:08,808
ต่อหนึ่งการกระทำ

713
00:34:08,808 --> 00:34:11,822
กำหนดจากต้นทุนของการตอบผิดในการกระทำนั้น

714
00:34:11,822 --> 00:34:12,917
Pattern

715
00:34:12,917 --> 00:34:16,081
สามคือการให้คะแนนรายส่วนโดยแตกเป็นคำถามแยก

716
00:34:16,081 --> 00:34:17,964
แล้วถ่วงน้ำหนักหรือรวมกัน

717
00:34:17,964 --> 00:34:21,882
กฎนี้มีเพราะคุณถูกส่งเสริมให้แตกการตัดสินของมิติต่าง

718
00:34:21,882 --> 00:34:24,518
ๆ ที่เป็นอิสระต่อกันออกเป็นคำถามแยก

719
00:34:24,518 --> 00:34:27,456
ให้คะแนนแต่ละด้านแยก แล้วรวมด้วยน้ำหนัก

720
00:34:27,456 --> 00:34:30,093
เพื่อที่เราจะคุมการ route ได้ในโค้ด

721
00:34:30,093 --> 00:34:33,558
ยกตัวอย่างให้เห็นภาพ คือการตัดสินใหญ่ ๆ ยุ่ง ๆ

722
00:34:33,558 --> 00:34:35,894
เราอาจมี CV กองหนึ่ง แล้วถามว่า

723
00:34:35,894 --> 00:34:39,284
"คนนี้เป็นผู้สมัครที่ดีไหม" ให้คะแนน 1 ถึง 10

724
00:34:39,284 --> 00:34:42,673
คุณจะได้ตัวเลขเดียวจาก Jev ที่คุณถามต่อไม่ได้

725
00:34:42,673 --> 00:34:44,933
ไม่รู้ว่ามันใช้เกณฑ์อะไรตัดสิน

726
00:34:44,933 --> 00:34:48,323
แต่สิ่งที่เราควรทำคือแตกมันออกเป็นสิ่งที่ความ

727
00:34:48,323 --> 00:34:51,638
"ดี" หมายถึง สำหรับวิศวกร อาจเป็นความลึกด้าน

728
00:34:51,638 --> 00:34:53,973
Python ทักษะนำทีม การออกแบบระบบ

729
00:34:53,973 --> 00:34:57,439
หรือความเร็วในการเรียนรู้ของใหม่ สำหรับ senior

730
00:34:57,439 --> 00:35:00,904
engineer คุณถ่วง Python กับ design อย่างละ 40%

731
00:35:00,904 --> 00:35:04,143
เป็นเกณฑ์ แต่สำหรับตำแหน่งผู้จัดการ อาจเป็น

732
00:35:04,143 --> 00:35:07,533
leadership ที่ได้ 40% แทน Pattern สี่ pattern

733
00:35:07,533 --> 00:35:08,739
สุดท้ายคือ route

734
00:35:08,739 --> 00:35:11,601
ไปยังตัวจัดการที่ดีที่สุดสำหรับงานนั้น

735
00:35:11,601 --> 00:35:14,765
เรียกว่า intent routing เราจะจำแนก request

736
00:35:14,765 --> 00:35:16,197
ที่เข้ามาแล้ว route

737
00:35:16,197 --> 00:35:19,059
แต่ละอันไปยังตัวจัดการที่เหมาะสมที่สุด

738
00:35:19,059 --> 00:35:21,470
ไม่ว่าจะเป็น logic deterministic

739
00:35:21,470 --> 00:35:24,935
ในสคริปต์อย่างที่เห็น LLM เฉพาะทางอย่าง Claude

740
00:35:24,935 --> 00:35:26,031
หรือมนุษย์ Jev

741
00:35:26,031 --> 00:35:29,722
นั่งอยู่หน้าทั้งหมดนี้ในฐานะตัวจำแนกที่เร็วและถูก

742
00:35:29,722 --> 00:35:31,831
ตัดสินว่าจะเรียกตัวจัดการไหน

743
00:35:31,831 --> 00:35:34,393
จะส่งให้พนักงานบริการลูกค้าหรือไม่

744
00:35:34,393 --> 00:35:37,707
"ออเดอร์ของผมอยู่ไหน" จะไปที่การค้น database

745
00:35:37,707 --> 00:35:39,365
ไม่ใช้ AI ไม่ต้องใช้คน

746
00:35:39,365 --> 00:35:42,152
แต่คำถามเรื่องผลิตภัณฑ์จะไปที่ Claude

747
00:35:42,152 --> 00:35:44,035
ที่เข้าถึงเอกสารผลิตภัณฑ์

748
00:35:44,035 --> 00:35:47,953
แล้วเรื่องร้องเรียนจะโดนถามต่ออีกข้อว่าซับซ้อนแค่ไหน

749
00:35:47,953 --> 00:35:51,192
และพวกยุ่งยากจะไปหาคนตั้งแต่แรก ส่วนอะไรที่

750
00:35:51,192 --> 00:35:53,678
confidence ต่ำจะไม่ผ่าน threshold

751
00:35:53,678 --> 00:35:56,314
และไปหาคนอยู่ดี เมื่อรวมสี่ pattern

752
00:35:56,314 --> 00:35:59,403
เข้าด้วยกัน คุณจะได้ demo บ้านอัจฉริยะที่

753
00:35:59,403 --> 00:36:02,793
Typesafe มีไว้ใน docs ซึ่งใช้ทุกอย่างพร้อมกัน

754
00:36:02,793 --> 00:36:05,957
นี่คือการควบคุมไฟและอุปกรณ์ในบ้านด้วยเสียง

755
00:36:05,957 --> 00:36:08,518
การพิมพ์คำสั่ง หรือแอป คุณพิมพ์ว่า

756
00:36:08,518 --> 00:36:10,251
"ปิดไฟทั้งบ้าน" request

757
00:36:10,251 --> 00:36:12,963
เดียวจะถามว่าเป็นคำขอชนิดไหน ห้องไหน

758
00:36:12,963 --> 00:36:15,449
อุปกรณ์อะไร และต้องทำการกระทำอะไร

759
00:36:15,449 --> 00:36:18,538
แล้วถ้าคุณพิมพ์สองคำสั่งในหนึ่งประโยค Jev

760
00:36:18,538 --> 00:36:21,928
จะเห็นว่าเป็น compound request แล้วส่งให้ LLM

761
00:36:21,928 --> 00:36:24,790
แยกมันออก จากนั้นค่อยตัดสินทั้งสองส่วน

762
00:36:24,790 --> 00:36:27,879
มันเข้าใจว่าต้องแตก request เป็นหลายคำถาม

763
00:36:27,879 --> 00:36:30,666
แล้วถ้าคุณถามเรื่องทั่วไปที่ไม่เกี่ยว

764
00:36:30,666 --> 00:36:33,981
มันก็รู้จักส่งต่อให้ LLM ตอบ นั่นคือ pattern

765
00:36:33,981 --> 00:36:37,070
สี่นั่นเอง ประเด็นทั้งหมดคือพวกเขาวาง Jev

766
00:36:37,070 --> 00:36:40,083
เคียงข้าง LLM Jev ทำงานเร็วมากบนการกระทำ

767
00:36:40,083 --> 00:36:43,473
deterministic ที่มีคำถาม threshold confidence

768
00:36:43,473 --> 00:36:45,883
ฯลฯ จนคุณแทบไม่รู้สึกถึงตัวตนมัน

769
00:36:45,883 --> 00:36:50,328
มันตัดสินใจได้เร็วมากจนกำหนดขั้นตอนถัดไปที่น่าจะใช่ได้ทันที

770
00:36:50,328 --> 00:36:53,492
ตามคะแนนและ confidence เทียบกับเกณฑ์ของคุณ

771
00:36:53,492 --> 00:36:56,430
ถ้ายังไม่เห็น ผมตื่นเต้นกับเรื่องนี้มาก

772
00:36:56,430 --> 00:36:59,895
เพราะพอจับมันคู่กับ Claude Code หรือ GPT Astra

773
00:36:59,895 --> 00:37:03,135
คุณได้คอมบิเนชันที่โหดจริง ๆ Jev ทำงานจำแนก

774
00:37:03,135 --> 00:37:04,230
deterministic

775
00:37:04,230 --> 00:37:07,997
จำนวนมากได้เร็วสุดขั้วในราคาต่ำสุดเป็นประวัติการณ์

776
00:37:07,997 --> 00:37:10,709
ขณะที่ Claude ทำแชทไปมา การใช้เหตุผล

777
00:37:10,709 --> 00:37:14,475
และการตัดสินใจที่ต้องคิดเพิ่มหรือเกณฑ์ยืดหยุ่นกว่า

778
00:37:14,475 --> 00:37:18,393
ถ้าอยากดูวิดีโอการเอาคอมบิเนชันนี้ไปใช้กับโดเมนอย่าง

779
00:37:18,393 --> 00:37:21,858
GEO หรือ browser use คอมเมนต์ไว้ด้านล่างได้เลย

780
00:37:21,858 --> 00:37:23,440
แล้วพบกันคลิปหน้าครับ