<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Technology &#8211; Few Steps &#8211; ก้าวสั้นๆ แต่ไปเรื่อยๆ</title>
	<atom:link href="https://myifew.com/technology/feed/" rel="self" type="application/rss+xml" />
	<link>https://myifew.com</link>
	<description></description>
	<lastBuildDate>Sun, 27 Sep 2026 03:27:06 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.3</generator>

<image>
	<url>https://myifew.com/wp-content/uploads/2018/07/cropped-logo6-ts-32x32.png</url>
	<title>Technology &#8211; Few Steps &#8211; ก้าวสั้นๆ แต่ไปเรื่อยๆ</title>
	<link>https://myifew.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>ลองจับ Jev มาช่วยคัด Lead ปลอม ทำได้จริงไหม</title>
		<link>https://myifew.com/8543/jev-ai-fake-lead/</link>
					<comments>https://myifew.com/8543/jev-ai-fake-lead/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Sun, 27 Sep 2026 02:47:32 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI]]></category>
		<category><![CDATA[Jev]]></category>
		<category><![CDATA[Lead Spam]]></category>
		<category><![CDATA[TypeSafe AI]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=8543</guid>

					<description><![CDATA[ช่วงนี้มีเทรนด์ AI ใหม่ตัวหนึ่ง ที่ไม่ได้ใช้คุยกับมนุษย์ปกติทั่วไป แต่มีไว้ให้ซอฟต์แวร์ถามแล้วได้คำตอบที่โค้ดเอาไปใช้ต่อได้ ตัวที่ผมลองชื่อว่า Jev เป็นโมเดลของ TypeSafe AI ที่รับข้อมูลเข้าไป แล้วตอบกลับมาเป็นค่าที่มีชนิดชัดเจน เช่น เลือกหนึ่งตัวเลือก (Choice) ให้คะแนน (Score) หรือคืนความน่าจะเป็นของคำตอบใช่หรือไม่ใช่&#8230;]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ช่วงนี้มีเทรนด์ AI ใหม่ตัวหนึ่ง ที่ไม่ได้ใช้คุยกับมนุษย์ปกติทั่วไป แต่มีไว้ให้ซอฟต์แวร์ถามแล้วได้คำตอบที่โค้ดเอาไปใช้ต่อได้</p>



<p class="wp-block-paragraph">ตัวที่ผมลองชื่อว่า <strong>Jev</strong> เป็นโมเดลของ TypeSafe AI ที่รับข้อมูลเข้าไป แล้วตอบกลับมาเป็นค่าที่มีชนิดชัดเจน เช่น เลือกหนึ่งตัวเลือก (Choice) ให้คะแนน (Score) หรือคืนความน่าจะเป็นของคำตอบใช่หรือไม่ใช่ (Noul) ผมเลยเอามันทดลองกับโจทย์ใกล้ตัวมากๆ คือการคัด Lead ปลอมที่ได้มาจากการลงทะเบียน  โดยใช้ข้อมูลจริง 788 ราย ที่ทีมผมเคยพิจารณาตรวจคำตอบไว้ก่อนหน้านั้นแล้ว</p>



<p class="wp-block-paragraph">ผลออกมาค่อนข้างน่าสนใจพอสมควร เลยแชร์ไว้เผื่อเป็นประโยชน์ครับ</p>



<span id="more-8543"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: เอเจ้นชมพูช่วยถอดความและเรียบเรียงบทความนี้จากบันทึก โค้ด และผลการทดลองจริงของฟิวส์</em></p>



<p class="wp-block-paragraph"><em><strong>หมายเหตุเรื่องข้อมูล:</strong> ตัวอย่างชื่อทั้งหมดในบทความเป็นชื่อสมมติที่สร้างให้มีคุณสมบัติทางภาษาเหมือนข้อมูลจริง ไม่ได้นำชื่อจากไฟล์ลูกค้ามาเผยแพร่ เพราะแม้แถวที่ถูกตัดสินว่าเป็น spam ก็ยังอาจเป็นชื่อของคนจริง</em></p>



<h2 class="wp-block-heading">สรุปไฮไลต์สั้นๆ</h2>



<ul class="wp-block-list">
<li><strong>Jev คืนค่าแบบ typed output</strong> โค้ดใช้ผลลัพธ์ต่อได้โดยไม่ต้องแกะข้อความหรือหวังว่า JSON จะไม่พัง</li>



<li><strong>ทดสอบกับลีดจริง 788 ราย</strong> ครอบคลุมข้อมูล 38 สัปดาห์ และผมมีเฉยๆ ของมนุษย์ครบทุกแถว เพื่อไว้ Cross Check แล้ว</li>



<li><strong>ระบบตัดสินเองได้ 66.4%</strong> บนชุดทดสอบชุดแรก (312 ราย) โดยกลุ่มที่ระบบตัดเป็น spam เองไม่มีลีดจริงปะปน 0 จาก 28 ราย</li>



<li><strong>Probability calibration ทำได้ดีขึ้น</strong> ค่าที่ใช้วัดความแม่นยำของความน่าจะเป็น (ECE) อยู่ที่ 0.065 จึงอยู่ในระดับที่ใช้ตั้ง threshold กับข้อมูลชุดนี้ได้</li>



<li><strong>ไม่แนะนำให้</strong> <strong>AI ทำแทน deterministic logic</strong> เรื่องรูปแบบอีเมล ตัวเลขในชื่อ หรือประวัติในฐานข้อมูล เราเขียนโค้ดและเช็คฐานข้อมูลเองได้ ถูกกว่า</li>
</ul>



<h2 class="wp-block-heading">Jev คืออะไร และต่างจาก LLM ที่เราใช้กันอย่างไร</h2>



<p class="wp-block-paragraph"><strong>Jev</strong> คือโมเดลตัวแรกที่ TypeSafe AI พัฒนาขึ้นมา เรียกว่า <strong>System One model</strong> ชื่อนี้ยืมแนวคิด System 1 และ System 2 ที่ <strong>Daniel Kahneman</strong> ทำให้คนรู้จักผ่านหนังสือ <em>Thinking, Fast and Slow</em></p>



<p class="wp-block-paragraph">System 1 คือการตัดสินใจเร็วๆ แบบที่สมองทำอัตโนมัติ</p>



<p class="wp-block-paragraph">ส่วน System 2 คือการคิดใคร่ครวญทีละขั้น </p>



<p class="wp-block-paragraph">Jev ถูกออกแบบมาสำหรับการตัดสินใจแบบแรก คือถามเรื่องแคบๆ ให้ชัด แล้วคืนคำตอบที่ software ใช้ต่อได้ทันที</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ซอฟต์แวร์ไม่ได้อยากได้ข้อความยาวๆ ซอฟต์แวร์อยากได้คำตอบที่เอาไป branch, sort, threshold หรือ route ต่อได้เลย</p>
</blockquote>



<p class="wp-block-paragraph">ถ้าเราถาม LLM ว่า lead รายนี้เป็นของปลอมไหม แล้วได้คำตอบว่า จากข้อมูลที่ให้มามีความเป็นไปได้ค่อนข้างสูง เราต้องเขียนโค้ดแกะข้อความอีกชั้น และมีโอกาสพังวันที่โมเดลเปลี่ยนสำนวนการตอบ</p>



<p class="wp-block-paragraph">Jev ไม่เขียนคำอธิบายแบบนั้นครับ มันรับ state แล้วคืน typed answers กับ probability distribution ตามชนิดคำถามที่เรากำหนดไว้ เอกสารของ TypeSafe แบ่ง primitive ออกเป็น 3 แบบ</p>



<figure class="wp-block-table"><table><thead><tr><th>แบบคำถาม</th><th>ใช้ถามอะไร</th><th>ค่าที่ได้กลับมา</th></tr></thead><tbody><tr><td><strong>Choice</strong></td><td>เลือก 1 จากตัวเลือกที่กำหนด</td><td>ตัวเลือกที่เลือก ความน่าจะเป็นทุกตัวเลือก และ confidence</td></tr><tr><td><strong>Score</strong></td><td>ให้คะแนนตามระดับที่เรียงไว้</td><td>คะแนน legend ความน่าจะเป็นแต่ละระดับ และ confidence</td></tr><tr><td><strong>Noul</strong></td><td>คำถามใช่หรือไม่ใช่</td><td>ตัวเลข 0 ถึง 1 ซึ่งเป็นความน่าจะเป็นที่คำตอบคือใช่</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">ตัวอย่างจาก Python SDK จะประมาณนี้</p>



<pre class="wp-block-code"><code>from typesafe_sdk import Choice, Noul, TypeSafeClient

with TypeSafeClient() as client:
    result = client.system_one(
        state={"message": "ผมโดนเรียกเก็บเงินซ้ำสองรอบ ช่วยแก้ด่วนเลยครับ"},
        questions={
            "department": Choice(
                instructions="ทีมไหนควรรับเรื่องนี้",
                criteria={
                    "billing": "เรื่องการเงิน",
                    "technical": "เรื่องระบบ",
                },
            ),
            "is_urgent": Noul(
                instructions="ข้อความนี้แสดงความเร่งด่วน"
            ),
        },
    )

print(result.choices&#91;"department"].choice)
print(result.choices&#91;"department"].confidence)
print(result.nouls&#91;"is_urgent"].noul)</code></pre>



<p class="wp-block-paragraph">จุดที่ผมชอบคือไม่ต้อง regex ข้อความ ไม่ต้องลุ้นว่าโมเดลจะครอบ JSON ด้วย markdown หรือใส่คำอธิบายเกินมา โค้ดรู้ตั้งแต่ต้นว่าจะได้ข้อมูลรูปแบบไหนกลับมา</p>



<h3 class="wp-block-heading">Probability กับ confidence ไม่ใช่ค่าเดียวกัน</h3>



<p class="wp-block-paragraph">ตามเอกสารของ TypeSafe ค่า probability บอกการกระจายของคำตอบ ส่วน confidence เป็นสถิติที่สรุปว่าการกระจายนั้นมีคำตอบที่ควรจะใช่ ชัดแค่ไหน และมีเฉพาะ Choice กับ Score ส่วน Noul คืน probability โดยตรง ไม่มี confidence แยกอีกตัว</p>



<p class="wp-block-paragraph">แนวคิดนี้เอาไปสร้างระบบแบบ confidence-gated routing ได้ เช่น confidence สูงให้ทำอัตโนมัติ confidence กลางส่งให้คนตรวจ และ confidence ต่ำไม่ให้ระบบเดา แต่ค่าตัดตรงไหนต้องวัดจากข้อมูลของงานเราเอง ไม่ควรหยิบเลขจากตัวอย่างใน docs มาใช้ตรงๆ</p>



<h2 class="wp-block-heading">โจทย์ที่เอามาทดลองคือ Fake Lead </h2>



<p class="wp-block-paragraph">เว็บไซต์ที่ผมหยิบมาทดสอบ มีฟอร์มให้คนสนใจกรอกข้อมูล แล้วส่งลีดต่อให้ทีมขายโทรติดตาม ปัญหาคือมีทั้งลูกค้าจริงที่กรอกข้อมูลแปลกๆ คนก่อกวน และบอท</p>



<p class="wp-block-paragraph">ระบบเดิมมี rule คอยดักไว้ชั้นหนึ่ง เช่น ชื่อมีตัวเลข ชื่อยาวเกิน xx ตัวอักษร อีเมลผิดรูปแบบ หรือเบอร์เคยอยู่ในฐาน spam จากนั้นถ้าเจอว่าก้ำกึ่งๆ ให้คนนั่งตรวจทีละราย</p>



<p class="wp-block-paragraph">ข้อมูลที่ผมใช้ทดลองมาจากผลการตรวจจริง 38 สัปดาห์ รวม 788 ราย ทุกแถวมีคำตัดสินของคนกำกับไว้ทุกรายการก่อนแล้ว (แต่ผมไม่ส่งเฉลยให้ Jev นะ)</p>



<p class="wp-block-paragraph">ตัวเลขแรกก็สะดุดแล้วครับ จาก 788 รายที่ระบบกฎดักไว้ คนตัดสินว่าไม่ใช่ spam ถึง 542 ราย หรือ 68.8% แปลว่างานตรวจส่วนใหญ่คือการยืนยันว่ากฎดักผิด</p>



<p class="wp-block-paragraph">เหตุผลที่เจอบ่อยที่สุดคือ <code>Numbers found in name</code> จำนวน 305 ราย และเกือบทั้งหมดเป็นลีดจริง ตัวอย่างรูปแบบสมมติจะเป็นแบบนี้</p>



<pre class="wp-block-code"><code>38-605 สมหญิง ใจดี
สุภาพร 05
10 สมชาย รักดี</code></pre>



<p class="wp-block-paragraph">คนเหล่านี้อาจลืมาสลับแป้น เผลอกรอกผิด หรือเอาเลขที่บ้าน เลขลำดับ หรือข้อมูลบางอย่างไปใส่รวมกับชื่อ แต่ก็ยังเป็นคนจริงที่ติดต่อได้ ระบบกฎเห็นแค่รูปแบบผิด ส่วนคนตรวจมองเจตนาและบริบทออก</p>



<p class="wp-block-paragraph"><strong>แกนที่กฎแยกไม่ออก คือคนจริงที่กรอกมั่ว กับคนที่ตั้งใจปลอมตัวตน</strong></p>



<h2 class="wp-block-heading">แยกสิ่งที่คำนวณได้ ออกจากสิ่งที่ต้องใช้ judgment</h2>



<p class="wp-block-paragraph">เงื่อนไขที่ทีมให้มามี 12 ข้อ แต่พอดูจริงๆ แล้วส่วนใหญ่ไม่ใช่คำถามสำหรับ AI เลยครับ อีเมลผิดรูปแบบไหม ชื่อมีตัวเลขไหม เบอร์ยาวเกิน xx หลักไหม โค้ดธรรมดาตอบได้แม่นกว่า เร็วกว่า และฟรี</p>



<pre class="wp-block-preformatted">ข้อมูลลีด
  └─ โค้ดคำนวณข้อเท็จจริง 23 ตัว
       └─ ส่ง facts ให้ Jev ตัดสินส่วนที่ต้องใช้ judgment
            └─ โค้ดใช้ threshold และ confidence ตัดสินว่าจะทำเองหรือส่งให้คน</pre>



<p class="wp-block-paragraph">ผมให้ Jev ตอบ Choice 3 ทาง</p>



<ul class="wp-block-list">
<li><code>spam</code> ตั้งใจปลอม</li>



<li><code>low_quality_but_real</code> เป็นคนจริง แต่กรอกข้อมูลเลอะ</li>



<li><code>legitimate</code> ลีดปกติ</li>
</ul>



<p class="wp-block-paragraph">ที่ไม่ใช้แค่ spam กับ not spam เพราะสองตัวเลือกนั้นบีบให้โมเดลทิ้งข้อมูลสำคัญพอดี กลุ่มที่ระบบเดิมมีปัญหาคือคนจริงที่กรอกมั่ว ถ้าไม่มี class ตรงกลาง โมเดลก็ต้องยัดคนเหล่านี้ไปฝั่งใดฝั่งหนึ่ง</p>



<h3 class="wp-block-heading">ทำไมไม่เขียนกฎเพิ่มไปเรื่อยๆ</h3>



<p class="wp-block-paragraph">ผมลองแล้วครับ และมันสอนบทเรียนค่อนข้างแพงทางเวลา ฮาาา</p>



<p class="wp-block-paragraph">การทดลองแรกคือเอาถังคำหยาบภาษาไทยและอังกฤษ 173 คำไปค้นในชื่อทั้ง 788 ราย พบ 11 ราย แต่ 10 รายในนั้น คนยืนยันว่าไม่ใช่ spam</p>



<figure class="wp-block-table"><table><thead><tr><th>รูปแบบชื่อ ตัวอย่างสมมติ</th><th>ไปตรงกับคำว่า</th><th>สาเหตุที่ไม่ควรตัดสินทันที</th></tr></thead><tbody><tr><td>Somsak Theechai</td><td>hee</td><td>นามสกุลไทยที่ถอดเสียงมีพยางค์ <code>-hee-</code></td></tr><tr><td>Marco Grassano</td><td>ass</td><td>นามสกุลอิตาลีลงท้าย <code>-assano</code></td></tr><tr><td>Rapee7 สุขใจ</td><td>rape</td><td>ชื่อ ระพี ถอดเสียงเป็น <code>Rapee</code></td></tr><tr><td>สมหญิง ทรงกูล</td><td>กู</td><td>นามสกุลลงท้ายด้วย กูล</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">ถังคำหยาบมีคำอย่าง อี กู ขี้ หน้า แม่ ซึ่งเป็นพยางค์ปกติในชื่อคนไทยได้ การ match substring ตรงๆ จึงเหมือนเอาตะแกรงช่องใหญ่ไปกรองทราย เม็ดที่ไม่เกี่ยวติดมาด้วยเต็มไปหมด</p>



<p class="wp-block-paragraph">การทดลองที่สองคือเขียน detector หกรูปแบบ เช่น อักษรซ้ำ ชื่อเหมือนนามสกุล และ keyboard smash มันจับตัวอย่าง spam ที่ทีมให้มาได้ 16 จาก 17 ราย ฟังดูดีมาก</p>



<p class="wp-block-paragraph">แต่พอใช้กับข้อมูลจริง มันไปโดนคนที่ไม่ใช่ spam 91 จาก 542 ราย หรือ 16.8% ตัวอย่างสมมติคือนามสกุลแบบ <code>Chaichanachai</code> ที่โดนเพราะพยางค์ <code>cha</code> ซ้ำสี่ครั้ง</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">Signal เป็นหลักฐาน ไม่ใช่คำตัดสิน หน้าที่ของมันคือบอกว่าเราเห็นอะไร แล้วให้ระบบชั่งน้ำหนักร่วมกับบริบทอื่น</p>
</blockquote>



<h2 class="wp-block-heading">ผลทดลองบนข้อมูลที่ไม่เคยใช้เลือก threshold</h2>



<p class="wp-block-paragraph">ผมแบ่งข้อมูลตามเวลา โดยใช้สัปดาห์ 1 ถึง 26 จำนวน 476 รายสำหรับเลือก threshold, แล้ววัดผลจริงบนสัปดาห์ 27 ถึง 38 อีก 312 รายที่ไม่เคยถูกใช้เลือกอะไรเลย</p>



<p class="wp-block-paragraph">การแบ่งตามเวลาสำคัญมาก เพราะระบบจริงไม่ได้สุ่มอดีตและอนาคตมาปนกัน เราตั้งเกณฑ์จากอดีตแล้วเอาไปใช้กับข้อมูลที่เข้ามาทีหลัง</p>



<figure class="wp-block-table"><table><thead><tr><th>ตัวชี้วัดบนชุดทดสอบ 312 ราย</th><th>ผล และช่วงเชื่อมั่น 95%</th></tr></thead><tbody><tr><td>ตัดสินเองได้โดยไม่ต้องให้คนดู</td><td><strong>66.4%</strong> (60.9 ถึง 71.4%)</td></tr><tr><td>ผิดพลาด ที่ไปตัดลีดจริงทิ้ง</td><td><strong>0%</strong> หรือ 0 จาก 28 ราย</td></tr><tr><td>จับ spam ได้ครบแค่ไหน</td><td>47.8% (37.8 ถึง 58.0%)</td></tr><tr><td>ผิดพลาด ที่ปล่อย spam ผ่านเข้าระบบ</td><td>14.0% (9.6 ถึง 19.8%)</td></tr><tr><td>ค่าความคลาดของความน่าจะเป็น ECE</td><td>0.065</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">เลขที่สำคัญที่สุดสำหรับผมคือ 0 จาก 28 ราย เพราะต้นทุนของความผิดสองแบบไม่เท่ากัน การตัดลูกค้าจริงทิ้งคือเสียโอกาสขายไปเลย ส่วนการปล่อย spam ผ่านคือทีมขายเสียเวลาโทร</p>



<p class="wp-block-paragraph">แต่ต้องอ่านให้ครบครับ 0 จาก 28 ไม่ได้แปลว่าอัตราผิดจริงคือศูนย์ เพราะขอบบนของช่วงเชื่อมั่นยังอยู่ที่ 12.1% จากฐานข้อมูลแค่ 28 ราย อาจจะยังเล็กเกินกว่าจะสรุปว่า Jev มี error rate ต่ำกว่า 1% ซึ่งคงต้องหาข้อมูลมาเพิ่มเติมทดสอบใหม่</p>



<h3 class="wp-block-heading">Probability calibration รอบนี้ดีขึ้นจนใช้ตั้งเกณฑ์ได้</h3>



<p class="wp-block-paragraph">ค่า <strong>Expected Calibration Error (ECE)</strong> ซึ่งใช้วัดว่าความน่าจะเป็นที่โมเดลรายงานตรงกับอัตราที่เกิดจริงแค่ไหน ออกมาที่ 0.065 ถือว่าดีสำหรับข้อมูลชุดนี้</p>



<p class="wp-block-paragraph">พูดแบบง่ายๆ เวลาโมเดลตอบ 0.8 อัตราที่เกิดจริงอยู่ตั้งแต่ 0.74 ถึง 0.87 ตัวเลขจึงเชื่อถือได้ในระดับที่เอาไปตั้ง threshold สำหรับข้อมูลชุดนี้ได้</p>



<p class="wp-block-paragraph">ถึงตัวเลขรอบนี้จะดีขึ้น หลักเดิมยังเหมือนเดิมครับ ต่อให้ผู้ผลิตบอกว่าโมเดลถูกฝึกเรื่อง calibration มา เราก็ต้องวัดกับ domain, ภาษา และข้อมูลของตัวเองก่อนตั้งเกณฑ์ใช้งานจริง</p>



<h2 class="wp-block-heading">Jev ทำอะไรได้ และอะไรควรปล่อยให้ฐานข้อมูลทำ</h2>



<p class="wp-block-paragraph">พอผมให้รันเหมือนระบบจริงทั้ง 788 ราย โดยจะมีเงื่อนไขตรวจสอบตามกฎ และส่งผลลัพธ์การตรวจพร้อมชื่อ เบอร์โทร อีเมล วันที่กรอกฟอร์ม ให้ Jev พิจารณาต่อแทนคน ผลลัพธ์ที่ได้น่าสนใจมาก คือ</p>



<figure class="wp-block-table"><table><thead><tr><th>เหตุผลที่คนเขียน</th><th>จำนวน</th><th>Jev ระบุเหตุผลตรงกันกับคน</th></tr></thead><tbody><tr><td>ติดต่อได้ เป็นคนจริง</td><td>421</td><td><strong>98.3%</strong> (Jev ไม่ได้ติดต่อคนจริงๆ นะ ดูจากข้อมูลเท่านั้น)</td></tr><tr><td>เป็นข้อมูลทดสอบ</td><td>16</td><td><strong>100%</strong> (มีอยู่ผลลัพธ์คัดกรองหลายๆ ข้อ ที่ส่งให้ Jev)</td></tr><tr><td>ลงทะเบียนซ้ำหลายครั้ง</td><td>92</td><td>3.3% (โค้ดประมวลผลจากวันที่กรอกฟอร์ม และส่งให้ Jev)</td></tr><tr><td>เคยอยู่ในฐาน spam</td><td>212</td><td><strong>0%</strong> (โค้ดและ Jev ตรวจสอบไม่ได้ เพราะผมไม่ได้จำลองข้อมูลไว้ให้)</td></tr></tbody></table></figure>



<p class="wp-block-paragraph"><code>known_spam_record</code> ร่วงเป็น 0% และนี่ไม่ใช่ความผิดของโมเดล เราไม่สามารถรู้ว่าเบอร์หนึ่งเคยเป็น spam ด้วยการมองตัวเลข ต้อง query ฐานข้อมูล คนตรวจมีฐานนั้น แต่ Jev ไม่มี</p>



<p class="wp-block-paragraph">การเช็คประวัติจึงเป็นงานของ database กับ deterministic rule เพราะเร็ว แม่น และ audit ได้ ส่วนการตัดสินว่าข้อมูลชุดนี้ดูเป็นคนจริงที่ติดต่อได้หรือเป็นการปลอมตัวตน เป็นงานที่ Jev ช่วยได้ดีกว่า</p>



<p class="wp-block-paragraph">นี่อธิบายด้วยว่าทำไม recall ฝั่ง spam อยู่เพียงราว 48% เพราะ 85% ของสิ่งที่คนเรียกว่า spam ในข้อมูลชุดนี้เป็นเคสที่อาศัยประวัติจากฐานข้อมูลล้วนๆ</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">จุดที่ผมคิดว่าคุ้มที่สุดคือใช้ Jev ช่วยจัดการ 305 รายที่ rule ดักเพราะชื่อมีตัวเลข ซึ่งปัจจุบันคนต้องคอยตรวจและยืนยันทีละราย </p>
</blockquote>



<h2 class="wp-block-heading">ค่าใช้จ่ายถูกจนไม่ใช่ปัจจัยตัดสินใจ</h2>



<figure class="wp-block-table"><table><tbody><tr><th>ประมวลผล 788 ราย</th><td><strong>$0.042</strong> หรือประมาณ 1.5 บาท</td></tr><tr><th>ค่าใช้จ่ายต่อราย</th><td>$0.0000525</td></tr><tr><th>ปริมาณจริงประมาณ 21 รายต่อสัปดาห์</th><td>ประมาณ $0.06 ต่อปี</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">ต้นทุนทั้งปีถูกกว่ากาแฟหนึ่งแก้วอีกครับ ทำให้ผมปรับคำถาม ปรับ threshold แล้วรันข้อมูลทั้งชุดใหม่ได้หลายรอบโดยไม่ต้องกังวลเรื่องค่า API</p>



<p class="wp-block-paragraph">แต่ราคาถูกไม่ได้แปลว่าควรใช้ทุกที่ ถ้าโค้ดหรือ SQL ตอบได้ตรงๆ ต่อให้ AI ฟรีก็ยังเป็นทางเลือกที่ซับซ้อนกว่า</p>



<h2 class="wp-block-heading">ถ้าจะเอา Jev ไปใช้จริง ผมจะเริ่มแบบนี้</h2>



<ol class="wp-block-list">
<li><strong>เลือก judgment ที่แคบและชัด</strong> เช่น intent, routing, risk tier หรือข้อมูลดูเป็นคนจริงหรือไม่ ไม่โยนโจทย์กว้างให้วิเคราะห์ทุกอย่าง</li>



<li><strong>แยก deterministic facts ออกมาก่อน</strong> ใช้ code, regex, database และ validation สำหรับเรื่องที่ตอบแน่นอนได้</li>



<li><strong>มนุษย์ควรมายืนยันความน่า</strong><strong>เชื่อถือ</strong> และเก็บเหตุผลไว้ด้วย เพราะ accuracy อย่างเดียวบอกไม่พอว่าโมเดลใช้เหตุผลถูกหรือไม่</li>



<li><strong>แบ่ง train และ evaluation ตามเวลา</strong> เลือก threshold จากอดีตแล้ววัดกับอนาคตให้เหมือน production</li>



<li><strong>ตรวจ lineage ของทุก feature</strong> กัน label leakage ที่อ้อมผ่าน lookup, cache หรือ aggregate</li>



<li><strong>เขียนกติกาภายในทีมออกมาให้ชัด</strong> สิ่งที่คนทำงานรู้กันเองอาจไม่มีอยู่ในนิยามที่ส่งให้โมเดล</li>



<li><strong>วัด calibration และ distribution</strong> อย่าเชื่อ probability หรือ metric รวมโดยไม่เปิดดูพฤติกรรมรายกลุ่ม</li>



<li><strong>ออกแบบ human review เป็นส่วนหนึ่งของระบบ</strong> เคส confidence ต่ำหรือผลกระทบสูงควรส่งให้คนตัดสิน</li>
</ol>



<h2 class="wp-block-heading">บทสรุป</h2>



<p class="wp-block-paragraph">หลังลองกับข้อมูลจริง ผมมองว่า Jev น่าสนใจตรงที่มันอยู่กึ่งกลางระหว่าง rule engine กับ LLM แบบสร้างข้อความ มันรับภาษาธรรมชาติและใช้ judgment ได้ แต่ผลลัพธ์ยังอยู่ในรูปที่โค้ดควบคุมต่อได้</p>



<p class="wp-block-paragraph">สิ่งที่ผมชอบที่สุดไม่ใช่ accuracy สูงสุด แต่คือความสามารถในการออกแบบระบบที่ยอมรับว่าไม่มั่นใจ แล้วส่งเคสยากกลับให้คนตรวจ ตรงนี้เหมาะกับงานที่ความผิดแต่ละฝั่งมีต้นทุนไม่เท่ากันมากๆ</p>



<p class="wp-block-paragraph">ส่วนที่ต้องระวังคือ AI ไม่ได้เติมข้อมูลที่ไม่มีให้เรา ถ้าคำตอบอยู่ในฐาน spam ก็ต้องเปิดฐานข้อมูล ถ้ากฎธรรมดาตรวจอีเมลได้ก็ใช้กฎธรรมดา ส่วน probability calibration แม้รอบนี้จะทำได้ดี ก็ยังต้องวัดใหม่เมื่อ domain, ภาษา หรือข้อมูลเปลี่ยน</p>



<p class="wp-block-paragraph">ผลการทดลองรอบนี้ยังไม่ทำให้ผมเปิดระบบตัด lead อัตโนมัติเต็มรูปแบบทันที ฐานตัวอย่างฝั่งที่ตัดเป็น spam เองยังน้อย และ recall ยังมีข้อจำกัด แต่ผมเห็นจุดที่เอาไปลดงาน manual review ได้ชัด คือกลุ่มคนจริงที่กรอกข้อมูลเลอะเทอะ โดยเฉพาะชื่อที่มีตัวเลข (แต่ถ้าว่ากันตามจริง ช่วยได้น้อยมากๆ ผมอาจจะแค่ปรับ rule เช็คให้ดีขึ้น)</p>



<p class="wp-block-paragraph">สำหรับผม คำตอบว่า ยังไม่ควรใช้ Jev เต็มระบบ ไม่ใช่ว่ามันไม่ดีนะครับ มันคือผลลัพธ์ที่มีค่าที่สุดของการทดลอง เพราะอย่างน้อยเรารู้ว่าควรใช้ตรงไหน ไม่ควรใช้ตรงไหน และต้องเก็บหลักฐานเพิ่มอีกเท่าไร</p>



<p class="wp-block-paragraph">การทดลองทั้งหมดเขียนด้วย Python มี test 137 ตัว และตัวเลขในบทความมาจากการรันกับข้อมูลลีดจริง 788 รายจาก 38 สัปดาห์ ชื่อบุคคลทุกชื่อที่ใช้เป็นตัวอย่างเป็นข้อมูลสมมติ</p>



<h2 class="wp-block-heading">ผู้อ่านได้อะไรจากบทความนี้</h2>



<ul class="wp-block-list">
<li><strong>รู้จัก Jev และ System One model</strong> ว่าเหมาะกับ typed decisions มากกว่างานสร้างข้อความ</li>



<li><strong>เห็นตัวอย่าง evaluation บนข้อมูลจริง</strong> ตั้งแต่ temporal split, confidence interval, precision, recall ไปจนถึง calibration</li>



<li><strong>แยกบทบาท AI กับ deterministic system ได้ชัดขึ้น</strong> เพื่อไม่เอาโมเดลไปทำงานที่ code หรือ database ทำได้ดีกว่า</li>



<li><strong>รู้จัก data leakage แบบอ้อมๆ</strong> ซึ่งซ่อนอยู่ใน feature, lookup และ cache ได้</li>



<li><strong>อ่าน metric อย่างระวัง</strong> โดยดู distribution, class behavior และต้นทุนของความผิดแต่ละแบบร่วมกัน</li>



<li><strong>ออกแบบ human review ได้เป็นระบบ</strong> แทนการบังคับให้ AI ตอบทุกเคส</li>
</ul>



<h2 class="wp-block-heading">แหล่งข้อมูล</h2>



<ul class="wp-block-list">
<li><a href="https://docs.typesafe.ai" target="_blank" rel="noreferrer noopener">TypeSafe AI Documentation</a></li>



<li><a href="https://docs.typesafe.ai/concepts/system-one" target="_blank" rel="noreferrer noopener">System One model</a></li>



<li><a href="https://docs.typesafe.ai/primitives" target="_blank" rel="noreferrer noopener">Choice, Score และ Noul primitives</a></li>



<li><a href="https://docs.typesafe.ai/confidence" target="_blank" rel="noreferrer noopener">Probability และ confidence</a></li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/8543/jev-ai-fake-lead/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>AI-Native SDLC มนุษย์อยู่ตรงจุดไหน และใช้ส่งต่องานกันอย่างไร</title>
		<link>https://myifew.com/8495/ai-native-sdlc-software-delivery-playbook/</link>
					<comments>https://myifew.com/8495/ai-native-sdlc-software-delivery-playbook/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Sun, 13 Sep 2026 16:50:36 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI]]></category>
		<category><![CDATA[AI-SDLC]]></category>
		<category><![CDATA[Context Engineering]]></category>
		<category><![CDATA[Vibe Code]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=8495</guid>

					<description><![CDATA[AI-Native SDLC เปลี่ยน Plan, Build, Test และ Deploy อย่างไร เมื่อ AI เขียนโค้ดเร็วขึ้น พร้อมเทียบแนวทาง Anthropic, AWS, McKinsey และ Snyk]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ไม่กี่วันก่อนผมเขียนเรื่อง <a href="https://myifew.com/8478/ai-coding-bottleneck-requirement-workflow/">AI เขียนโค้ดเร็วแล้ว แต่ทำไมงานยังช้าอยู่</a> จากสิ่งที่เห็นรอบตัวว่า coding agent ทำให้คนสร้าง software ได้เร็วขึ้นมาก แต่หลายโครงการก็ยังติดอยู่ที่ requirement การตัดสินใจ และการส่งต่องานเหมือนเดิม</p>



<p class="wp-block-paragraph">พอดีผมไปอ่านบทความของ Anthropic เรื่อง <a href="https://claude.com/blog/the-ai-native-sdlc-playbook" target="_blank" rel="noreferrer noopener">The AI-Native SDLC playbook</a> ของ <strong>Louis Claxton</strong> ผู้เขียนจาก Anthropic แล้วรู้สึกว่า นี่คือภาคต่อของคำถามนั้นพอดีครับ นอกจากเขาคิดว่า code ไม่ใช่คอขวดแล้ว แต่เขาแบทั้งวงจรว่า ถ้าการสร้างซอร์ฟแวร์ได้เร็วขึ้นจากสัปดาห์-เดือน เหลือเพียงไม่กี่ชั่วโมง การทำ Plan, Design, Test, Deploy และ Maintain จะต้องเปลี่ยนตามอย่างไร</p>



<p class="wp-block-paragraph">คำตอบของ <strong>Louis Claxton</strong> คือ AI-Native SDLC ที่เอา AI เข้าไปอยู่ทุกช่วง ใช้เอกสารที่ทั้งคนและ agent อ่านได้ ส่งงานต่อกันได้ วาง automation ในจุดที่ตรวจแบบตรงไปตรงมาได้ แล้วเหลือมนุษย์ไว้ตรงจุดที่ต้องใช้ judgment และรับผิดชอบต่อความเสี่ยง อ่านแล้วตรงกับที่ผมสงสัยในวิธีการที่ผมทำอยู่พอดิบพอดี ซึ่งผมชอบนะ แต่ก็มีหลายจุดที่ในบทความบอกว่าถ้าเอาไปใช้แบบยกชุดโดยไม่ดูบริบท ทีมอาจได้ระบบเอกสารใหม่ที่หนักพอๆ กับของเดิมก็ได้ 5555</p>



<span id="more-8495"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้เอเจ้นชมพูช่วยแปลและเรียบเรียงจากบทความ <a href="https://claude.com/blog/the-ai-native-sdlc-playbook" target="_blank" rel="noreferrer noopener">The AI-Native SDLC playbook</a> ของ Louis Claxton และใช้<em>มุมมองกับประสบการณ์ของฟิวส์ </em></em><em>และค้นข้อมูลเสริมจาก Second Brain ของฟิวส์ เพื่อปรับเรื่องให้ผู้อ่านเห็นภาพชัดเจนยิ่งขึ้น</em></p>



<h2 class="wp-block-heading">สรุปสั้นๆ สำหรับคนขี้เกียจอ่าน</h2>



<ul class="wp-block-list">
<li><strong>Code ไม่ใช่คอขวดหลักแล้ว</strong> แต่คิวงานย้ายไปกองที่ planning, review, security และ deployment</li>



<li><strong>Artifact chain กลายเป็นทางส่งงาน</strong> ผ่าน <code>intent.md</code>, <code>spec.md</code>, <code>plan.md</code>, tests, PR และ incident record</li>



<li><strong>Guideline กับ control ต้องแยกกัน</strong> skills ใช้บอกแนวทาง ส่วน hooks, tests, sandbox และ branch protection ใช้บังคับสิ่งที่ห้ามพลาด</li>



<li><strong>คนต้อง reskill และรับผิดชอบกว้างขึ้น</strong> จากการทำงานเฉพาะช่วง ไปสู่การเข้าใจ architecture, spec, plan, task, implementation และ test ตลอดสาย</li>



<li><strong>แต่ละสำนักมองคนละมุม</strong> Anthropic เน้น control architecture, AWS เน้น AI-first collaboration, McKinsey เน้น operating model, Snyk เน้น security และ Addy Osmani เน้น loop, ส่วนฟิวส์ อะไรที่เขาว่าดี ฟิวส์ก็ว่าดี ฮ่าๆ</li>
</ul>



<h2 class="wp-block-heading">วันที่ Build เร็วขึ้น แต่คิวงานรอบข้างยาวกว่าเดิม</h2>


<div class="wp-block-image">
<figure class="aligncenter size-large"><img alt="" fetchpriority="high" decoding="async" width="1200" height="461" src="https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-1200x461.png" alt="" class="wp-image-8502" srcset="https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-1200x461.png 1200w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-768x295.png 768w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-1024x394.png 1024w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-541x208.png 541w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-1083x416.png 1083w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-791x304.png 791w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18-1228x472.png 1228w, https://myifew.com/wp-content/uploads/2026/09/6a8739a1b934ffe55bfc9715_44592f18.png 1400w" sizes="(max-width: 1200px) 100vw, 1200px" /></figure>
</div>


<p class="wp-block-paragraph">SDLC แบบเดิมถูกออกแบบในยุคที่การเขียน code ใช้เวลานาน และมีขั้นตอนสูง เลยจำเป็นต้องมีคนที่ชำนาญเพื่อทำในแต่ละหน้าที่ และส่งต่องานกัน ตั้งแต่ Product Manager/BA เขียน requirement, Architect/SA ออกแบบระบบ, Developer ลงมือสร้าง, QA/Tester ตรวจสอบ, Release team ปล่อยของ และ Operations/Support ทำการเฝ้าดูระบบ ซึ่งแต่ละช่วงเราต้องมีเอกสาร มีการส่งมอบ และมีคนอนุมัติ อาจกินเวลาหลายเดือน เพื่อให้ได้หนึ่งระบบ</p>



<p class="wp-block-paragraph">พอ coding agent สร้าง implementation ได้เร็วขึ้น โครงสร้างรอบข้างกลับไม่ได้เร็วตาม Security team ยังมีคนเท่าเดิม, Reviewer ยังอ่าน PR ด้วยตาคู่เดิม, Change Advisory Board ก็ยังประชุมตามรอบเดิม ผลคือเราไม่ได้กำจัดคอขวดครับ เราแค่ย้ายมันจากโต๊ะ Developer ไปกองไว้หน้าโต๊ะคนอื่น</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">AI ทำให้กำลังการผลิต code เพิ่มขึ้น แต่ถ้าระบบตรวจและตัดสินใจยังเท่าเดิม มันแค่ย้ายจาก Developer ไปที่คนอื่นแทน และไม่ได้เพิ่มความเร็วในการส่งมอบ</p>
</blockquote>



<p class="wp-block-paragraph">เรื่องนี้ต่อกับสิ่งที่ผมเขียนไว้ก่อนหน้า แต่บทความของ Anthropic ตั้งคำถามไปไกลกว่า requirement โดยมองครบทั้งหกช่วง ตั้งแต่การ Plan ไปจนถึง Maintain และถามใหม่ว่า control เดิมต้องรักษาอะไรไว้ แล้วควรเปลี่ยนวิธีบังคับอย่างไร มาถึงจุดนี้ เริ่มน่าสนใจแล้วไหมครับ เช่นนั้นตามมาดูกันต่อ</p>



<h2 class="wp-block-heading">AI-Native SDLC ไม่ได้ตัดขั้นตอน แต่เปลี่ยนวิธีส่งงาน</h2>



<p class="wp-block-paragraph">สิ่งที่ผมคิดว่าน่าสนใจที่สุดคือ committed artifact โดยทุกช่วงการทำงานจะต้องทิ้งของบางอย่างไว้ให้ช่วงถัดไปอ่านได้ ไม่ใช่จบอยู่ในห้องประชุมหรือใน chat ที่หายไปพร้อม context</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><img alt="" decoding="async" width="1200" height="759" src="https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1200x759.png" alt="" class="wp-image-8501" srcset="https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1200x759.png 1200w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-768x486.png 768w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1024x648.png 1024w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1536x972.png 1536w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-540x342.png 540w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1082x685.png 1082w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-792x501.png 792w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df-1229x778.png 1229w, https://myifew.com/wp-content/uploads/2026/09/6a8858c2eccce183e7553cf2_53b010df.png 2048w" sizes="(max-width: 1200px) 100vw, 1200px" /></figure>
</div>


<figure class="wp-block-table"><table><thead><tr><th>Stage</th><th>Artifact หรือหลักฐาน</th><th>คนยังต้องตัดสินใจอะไร</th></tr></thead><tbody><tr><td>Plan</td><td><code>intent.md</code></td><td>โจทย์นี้ควรทำไหม และเข้าใจปัญหาถูกหรือยัง</td></tr><tr><td>Design</td><td><code>spec.md</code></td><td>ข้อกำหนด ข้อขัดแย้ง และความเสี่ยงยอมรับได้ไหม</td></tr><tr><td>Build</td><td><code>plan.md</code>, code และ tests</td><td>แผนสมเหตุผลไหม จุดเสี่ยงอยู่ตรงไหน</td></tr><tr><td>Test</td><td>ผล test, build, screenshot และ eval</td><td>หลักฐานเพียงพอจะเชื่อว่างานใช้ได้หรือยัง</td></tr><tr><td>Deploy</td><td>PR, review findings และ approval record</td><td>ควรอนุญาตให้ขึ้น production หรือไม่</td></tr><tr><td>Maintain</td><td>incident record หรือ <code>intent.md</code> รอบใหม่</td><td>แก้ทันที จัดลำดับไว้ก่อน หรือยอมรับความเสี่ยง</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">ผมมองว่ามันเหมือนการส่งไม้ผลัดครับ ถ้าคนวิ่งแต่ละคนส่งกันด้วยคำพูดว่า เอาประมาณที่คุยเมื่อกี้นะ ต่อให้ทุกคนวิ่งเร็ว ไม้ก็หล่นอยู่ดี แต่ถ้า artifact เก็บทั้ง intent, constraint, decision และ proof ไว้ งานช่วงถัดไปก็เริ่มจากสิ่งที่ตรวจย้อนกลับได้</p>



<p class="wp-block-paragraph">ตรงนี้เชื่อมกับ <a href="https://myifew.com/7704/spec-driven-development-ai-thai/">Spec-Driven Development</a> ที่ผมเคยเขียนไว้ค่อนข้างตรง ต่างกันตรงที่ Spec-Driven Development สนใจ spec ในฐานะ living contract ขณะที่ Anthropic พยายามต่อ contract ให้ครบทั้งสาย ตั้งแต่ความต้องการไปถึง production feedback</p>



<p class="wp-block-paragraph">ตรงนี้ผมมองว่าเป็นวิวัฒนาการหนึ่งในการใช้ AI เขียนโค้ดนะครับ ตั้งแต่เราทำ Vibe Coding สั่งด้วย Prompt มาจนถึง Context Engineering เขียนเอกสารในฉบับเดียว และมาตอนนี้ที่เราเริ่มเซ็ตเอกสารได้ตามช่วงการทำงาน และใช้ส่งต่องานกันระหว่าง AI เอง และผมคิดว่าผมเป็นคนหนึ่งที่ตามลองอยู่เรื่อยๆ จะเห็นได้ว่าวิวัฒนาการนี้มันไปไวมากนะครับ ภายในระยะเวลาไม่กี่เดือน อะไรที่เคยคิดว่าเหมาะสมแล้ว ก็จะมีที่เหมาะสมกว่า (ผมไม่ได้บอกว่าของเดิมไม่ดีนะ แต่อาจจะเหมาะกับงานบางลักษณะ เช่น การสั่งทีละ prompt ผมก็ยังใช้กับงานโค้ดเล็กๆ อยู่นะ)  </p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">เอกสารใน AI-Native SDLC ไม่ควรเป็นรายงานที่เขียนไว้ให้ครบพิธี แต่มันต้องเป็น state ที่ทั้งคนและ agent ใช้ทำงานรอบถัดไปได้จริง</p>
</blockquote>



<h2 class="wp-block-heading">Skills บอกเส้นทางไป ส่วน hooks ทำหน้าที่เป็นรั้วกั้น (Guardrails)</h2>



<p class="wp-block-paragraph">ในบทความเขาแยกบทบาทของเครื่องมือรอบๆ agent ได้ชัดดีครับ</p>



<p class="wp-block-paragraph"><strong>CLAUDE.md</strong> คือไฟล์ความรู้ประจำ repository เช่นคำสั่ง build, test, conventions, architecture และสิ่งที่ Claude มักทำพลาด </p>



<p class="wp-block-paragraph">ส่วน <strong>Skills</strong> คือความรู้หรือ policy ที่จะถูกเรียกใช้ซ้ำๆ ในงานแต่ละอย่าง เพื่อให้ได้ของที่มีแนวทางเดิมเสมอ </p>



<p class="wp-block-paragraph">แต่ <strong>Skills </strong>เป็นคำแนะนำครับ มันช่วยให้ agent มีแนวโน้มทำถูก ไม่ได้แปลว่าจะบังคับได้ทุกครั้ง (ผมเลยใช้คำว่าเป็น &#8220;แนวทางเดิม&#8221;) ถ้าเป็นกฎที่ห้ามผิด เช่นห้ามอ่าน secret, ห้ามแก้ generated code, ต้อง run test หรือห้าม deploy production โดยไม่มี approval บทความเสนอให้มี <strong>Hooks</strong> ซึ่งเป็น script ที่ allow, ask หรือ block การกระทำ ร่วมกับการตั้งค่าใน <strong>Tools </strong>ต่างๆ เช่น permissions, sandbox และ branch protection</p>



<p class="wp-block-paragraph">ภาพง่ายๆ บทความจะสื่อคือ <strong>Skills </strong>เหมือนป้ายบอกทางว่าโค้งข้างหน้าควรลดความเร็ว ส่วน <strong>Hooks </strong>คือราวกั้นที่ไม่ยอมให้รถวิ่งตกเหว ถ้าเรื่องไหนผิดแล้วเสียหายจริง เราไม่ควรฝากความหวังไว้กับป้ายอย่างเดียว</p>



<p class="wp-block-paragraph">เรื่องของ Hooks ต้องยอมรับว่า ผมเองไม่ค่อยคิดถึงในการหยิบมาทำ Guardrails เท่าไร ส่วนมากผมชอบไประบุใน <strong>CLAUDE.md</strong> แทน เป็นจุดหนึ่งที่ผมจะต้องลองปรับการ implement ของตนเองดู แล้วไว้มาแชร์ให้อ่านอีกที</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">Policy ที่ควรทำ เขียนเป็น skill ได้ แต่ policy ที่ต้องไม่พลาด ควรมี Hooks เป็น deterministic control รองรับ</p>
</blockquote>



<h2 class="wp-block-heading">Test code อย่างเดียวไม่พอ ต้อง test ตัว harness ด้วย</h2>



<p class="wp-block-paragraph">ส่วนที่ผมชอบอีกอย่างคือการพูดถึง continuous evaluations (ในบทความจะเขียนสั้นๆว่า continuous evals) ถ้าเราเปลี่ยน model, prompt, <code>CLAUDE.md</code>, skill หรือ hook แล้วพฤติกรรมของ agent อาจเปลี่ยนทั้งที่ application code ไม่ได้เปลี่ยนเลย ดังนั้น configuration รอบ agent ก็ควรมี regression test ของมันเองด้วย</p>



<p class="wp-block-paragraph">เรื่องนี้ต้องทดสอบจริงๆครับ จากประสบการณ์ผมเจอเองตั้งแต่ตอนย้ายจาก OpenClaw มา Hermes Agent และที่ทีมผมก็เพิ่งเจอเมื่อเร็วๆ นี้ คือตอนที่ทำ MCP เรียกใช้ข้อมูลในองค์กร โดย harness ที่ต่อ มีทั้งบน Claude, Hermes Agent ที่ผมตั้ง, Agent ที่ทีมผมใช้ Google ADK ทำขึ้น ปรากฎว่าผลลัพธ์มันต่างกันพอสมควร แม้บน LLM Models เดียวกัน ได้คำตอบและ Artifacts ต่างกันแบบเห็นได้ชัด </p>



<p class="wp-block-paragraph">Anthropic แนะนำให้รวบรวมงานจริงประมาณ 20 ถึง 50 เคส พร้อมผลลัพธ์ที่ยอมรับได้ แล้วรัน suite นี้เมื่อ agent configuration เปลี่ยน สำหรับ bug fix ให้เขียน failing test ก่อน ล็อกไม่ให้ agent แก้ test เพื่อเอาตัวรอด แล้วให้แก้ implementation จน test ผ่าน วิธีนี้ไม่ได้ทำให้ AI ไม่มีวันโกงนะครับ แต่มันทำให้หลักฐานว่าทำงานเสร็จแยกออกจากคำบอกของ agent ชัดขึ้น</p>



<p class="wp-block-paragraph">แนวคิดนี้สอดคล้องกับ <strong>Addy Osmani</strong> วิศวกรและผู้เขียนด้าน web performance ที่เสนอเรื่อง <a href="https://addyosmani.com/blog/loop-engineering/" target="_blank" rel="noreferrer noopener">Loop Engineering</a> ว่า leverage เริ่มย้ายจากการเขียน prompt ทีละรอบ ไปอยู่ที่ loop ซึ่งค้นงาน มอบหมาย ตรวจผล และเก็บ state ได้เอง ยิ่ง loop ทำงานโดยไม่มีคนเฝ้ามากเท่าไร verifier และ stop condition ก็ยิ่งสำคัญขึ้นเท่านั้น</p>



<p class="wp-block-paragraph">ผมเคยสรุปอีกมุมของเรื่องนี้ไว้ใน <a href="https://myifew.com/7748/loop-engineering-3-product-development-loops/">Loop Engineering: 3 ลูปที่ทำร่วมกับ AI Agent เพื่อสร้าง Product ได้จริง</a> ใครสนใจเรื่อง feedback loop ระหว่าง agent, developer และผู้ใช้ ลองอ่านต่อได้ครับ</p>



<h2 class="wp-block-heading">เมื่อเทียบกับแนวทางของสำนักต่างๆ แต่ละคนกำลังแก้คนละชั้น</h2>



<p class="wp-block-paragraph">ใน Second Brain ของผมมีบทความกลุ่ม AI SDLC ที่เก็บไว้หลายชิ้น พอผมให้วิเคราะห์แล้วเอามาเทียบกันแล้ว พบว่าไม่ได้มีใครเสนอคำตอบเดียวกันทั้งหมด แต่ละสำนักกำลังซ่อมคนละชั้นของระบบ</p>



<figure class="wp-block-table"><table><thead><tr><th>บริษัทหรือผู้เขียน</th><th>แนวทาง</th><th>จุดที่เน้น</th></tr></thead><tbody><tr><td><strong>Anthropic</strong> บริษัทผู้พัฒนา Claude</td><td><a href="https://claude.com/blog/the-ai-native-sdlc-playbook" target="_blank" rel="noreferrer noopener">AI-Native SDLC</a></td><td>artifact chain, evals, review, governance และ human approval</td></tr><tr><td><strong>AWS</strong> ผู้ให้บริการ cloud และเครื่องมือพัฒนา</td><td><a href="https://aws.amazon.com/blogs/devops/ai-driven-development-life-cycle/" target="_blank" rel="noreferrer noopener">AI-Driven Development Life Cycle</a></td><td>AI เป็น collaborator ที่ช่วย plan, clarify, validate และ execute ภายใต้ human oversight</td></tr><tr><td><strong>McKinsey &amp; Company</strong> บริษัทที่ปรึกษาด้านองค์กร</td><td><a href="https://www.mckinsey.com/capabilities/mckinsey-technology/our-insights/rewiring-software-delivery-for-the-agentic-era" target="_blank" rel="noreferrer noopener">Rewiring software delivery for the agentic era</a></td><td>operating model, machine-readable handoff, knowledge layer และการจัดโครงสร้างทีมใหม่</td></tr><tr><td><strong>Snyk</strong> บริษัทด้าน developer security</td><td><a href="https://snyk.io/articles/complete-guide-ai-powered-software-development/" target="_blank" rel="noreferrer noopener">Secure AI-powered software development</a></td><td>security, secret leakage, traceability, compliance และการเริ่มจาก pilot</td></tr><tr><td><strong>Addy Osmani</strong> ผู้เขียนด้าน software engineering</td><td><a href="https://addyosmani.com/blog/loop-engineering/" target="_blank" rel="noreferrer noopener">Loop Engineering</a></td><td>automation, worktrees, skills, connectors, subagents และ persistent memory</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">AWS ใช้ภาพว่า AI เริ่มต้นงาน คนตรวจสอบ แล้ว AI จึงลงมือทำต่อ, McKinsey ขยายไปถึง operating model ที่มนุษย์ใช้เวลากับ judgment และ agent ทำงานที่มีโครงสร้างต่อเนื่อง รวมถึงเสนอ machine-readable handoff กับ knowledge layer เพื่อไม่ให้บริบทกระจัดกระจาย</p>



<p class="wp-block-paragraph">Snyk เติมคำเตือนที่ควรมีอยู่ในทุก playbook คือ ถ้า AI เร่งทุก phase ได้ มันก็เร่งการสร้าง security debt ได้เช่นกัน จึงต้องมี access control, logging, audit trail และการค่อยๆ เพิ่ม autonomy จาก pilot แทนการเปิดทั้งองค์กรในครั้งเดียว</p>



<p class="wp-block-paragraph">ส่วน Microsoft ก็มีแนวทาง <a href="https://techcommunity.microsoft.com/blog/appsonazureblog/an-ai-led-sdlc-building-an-end-to-end-agentic-software-development-lifecycle-wit/4491896" target="_blank" rel="noreferrer noopener">AI-led SDLC บน Azure และ GitHub</a> ที่พยายามเชื่อม agentic development เข้ากับ delivery pipeline จริง ตั้งแต่ development environment ไปถึงการ promote งานตามลำดับ ผมมองว่ามุมนี้ช่วยเตือนว่า framework จะมีค่าก็ต่อเมื่อมันเชื่อมกับ toolchain ที่ทีมใช้อยู่ ไม่ใช่จบเป็นรูปวงกลมสวยๆ ใน slide</p>



<h2 class="wp-block-heading">ยืนยันสิ่งที่ตนเองทำร่วมกับทีมทำงาน </h2>



<p class="wp-block-paragraph">ก่อนอ่าน playbook ชิ้นนี้ ผมทำ template และ workflow มาตรฐานกลางให้ทีมในบริษัทใช้อยู่แล้ว ชื่อภายในคือ <strong>AI Project Boilerplate</strong> เป็นโครงตั้งต้นที่รวม skills, agents, rules, CI และเอกสารมาตรฐานไว้ด้วยกัน เพื่อให้โปรเจกต์ใหม่เริ่มจากวิธีทำงานชุดเดียวกัน แทนที่แต่ละคนจะเปิด coding agent แล้วสั่งกันตามความถนัดของตัวเอง</p>



<p class="wp-block-paragraph">กระบวนการเริ่มจากมนุษย์เขียน requirement ซึ่งเป็น source of truth จากนั้น AI ช่วย คิด/brainstorming ถามกลับเรื่องขอบเขต เสนอทางเลือก และเขียน design ให้คนอนุมัติ ก่อนแตกออกมาเป็น plan, ADR, Git issue และ feature branch โดยการ implement ผมบังคับให้ใช้ TDD เสมอ และแยก subagent ทำหน้าที่ในการ implementer, tester กับ reviewer แล้วจึงให้คนเข้าทดสอบแบบผู้ใช้จริง ก่อนที่ท้ายสุดเลยคือกระบวนการ Continuous Integration (CI) ในช่วง merge เข้า dev branch จะทำการตรวจ lint, test และ DevSecOps และแจ้งให้ Team Lead review เพื่ออนุมัติการ merge main branch ขึ้น production environment</p>



<figure class="wp-block-table"><table><thead><tr><th>AI Project Boilerplate ที่ผมใช้กับทีม</th><th>สิ่งที่ Anthropic เสนอ</th><th>ความสัมพันธ์</th></tr></thead><tbody><tr><td>Requirement จากคน ทำเป็น source of truth และ AI ต้องถามกลับก่อนลงมือ</td><td>Plan stage สร้าง <code>intent.md</code> แล้วให้มนุษย์ตรวจ intent</td><td>เริ่มจากความต้องการของคน ไม่ให้ agent เดาโจทย์เอง</td></tr><tr><td>Brainstorming สร้าง design, writing plan สร้าง task และ ADR</td><td>Design กับ Build ส่งต่อผ่าน <code>spec.md</code> และ <code>plan.md</code></td><td>ใช้ artifact เป็นข้อตกลงระหว่างคนกับ AI</td></tr><tr><td>TDD พร้อม implementer, tester และ reviewer ที่แยกบทบาทกัน</td><td>ใช้ tests, evals และ independent review เป็นหลักฐาน</td><td>คนสร้างงานไม่ควรเป็นผู้ตัดสินผลงานของตัวเองฝ่ายเดียว</td></tr><tr><td>CI ตรวจ test, Semgrep, Gitleaks และ Trivy</td><td>Hooks, sandbox, permissions และ branch protection</td><td>กฎที่ผิดไม่ได้ต้องบังคับด้วยระบบ ไม่ใช่เขียนเตือนไว้อย่างเดียว</td></tr><tr><td>Team Lead review และ approve ก่อน merge เข้า <code>main</code></td><td>Agent ทำงานได้ถึง production gate แต่อนุมัติตัวเองไม่ได้</td><td>มนุษย์ยังถือสิทธิ์รับความเสี่ยงขั้นสุดท้าย</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">พอใช้งานจริง ผมพบว่าแนวทางนี้ทำงานได้ดีครับ ทีมไม่ต้องจำว่าจะเรียก skill ไหนต่อ เพราะ workflow พาไปจาก brainstorming, spec, plan, issue, branch, TDD และ review ตามลำดับ Artifact ที่เกิดขึ้นก็ทำให้ย้อนดูได้ว่า งานเริ่มจากโจทย์อะไร ตัดสินใจอะไรไป และผลทดสอบอยู่ตรงไหน</p>



<p class="wp-block-paragraph">สิ่งที่ตรงกับ Anthropic มากคือ เราไม่ได้พยายามทำให้ AI เก่งด้วย prompt ยาวๆ อย่างเดียว แต่จัด environment รอบมันให้ชัด ทั้งไฟล์กฎ skills ที่เลือกใช้ตามงาน การแยก agent ตามบทบาท และ CI ที่ไม่ยอมให้ของไม่ผ่านเงื่อนไขไหลต่อไปเอง พอระบบรอบข้างดีขึ้น model เดิมก็ทำงานสม่ำเสมอขึ้นอย่างเห็นได้ชัด</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ประสบการณ์ของผมคือ AI ทำงานร่วมกับทีมได้ดี เมื่อเราเลิกคาดหวังความเก่งของ model อย่างเดียว แล้วออกแบบ workflow, role และ artifacts ให้ครบ ตามบริบทการทำงานของเรา ซึ่งถ้าใครทำคล้ายๆกันนี้แล้ว บทความของ Anthopic เองเป็นตัวยืนยันว่าคุณมาถูกทาง</p>
</blockquote>



<h2 class="wp-block-heading">ปัญหาที่ยากกว่า tool คือ คนต้องล้างวิธีคิดเดิม</h2>



<p class="wp-block-paragraph">ส่วนที่ผมคิดว่ายากที่สุดกลับไม่ใช่การทำ template หรือเลือก coding agent ครับ แต่คือการ reskill และ upskill คน รวมถึงการล้างวิธีคิดเดิมว่าแต่ละคนรับผิดชอบเฉพาะชิ้นของตัวเองก็พอ</p>



<p class="wp-block-paragraph">ในกระบวนการเดิม architect อาจส่งแบบให้ developer ต่อมา developer เขียน code แล้วส่งให้ tester จากนั้นแต่ละคนก็รอ feedback จากคนถัดไป แต่เมื่อ AI ทำ implementation ได้เร็วมาก คนทำงานไม่ควรมองเฉพาะ task ตรงหน้าได้เหมือนเดิม เพราะความผิดพลาดจาก spec หรือ architecture จะถูก AI ขยายให้กลายเป็น code และ test จำนวนมากในเวลาไม่นาน</p>



<p class="wp-block-paragraph">Developer ยุคนี้จึงต้องมองงานตั้งแต่ต้นน้ำถึงปลายน้ำ architecture, spec, plan, task, implementation ไปจนถึง test เองให้ได้ ไม่ได้หมายความว่าทุกคนต้องเก่งที่สุดทุกด้าน หรือองค์กรไม่ต้องมี specialist แล้วนะครับ แต่คนที่ใช้ AI ต้องเข้าใจว่าสิ่งที่อยู่ก่อนและหลัง code เชื่อมกันอย่างไร ต้องกล้าถาม requirement ต้องเห็นผลกระทบเชิงสถาปัตยกรรม ต้องตรวจว่า plan ขาดอะไร และต้องอ่าน test ว่าพิสูจน์ behavior จริงหรือเพียงทำให้ตัวเลข coverage ดูดี</p>



<p class="wp-block-paragraph">หน้าที่ของคนคุมทีมก็เปลี่ยนเหมือนกัน จากเดิมที่แบ่งงานและเช็กสถานะ อาจต้องออกแบบ guardrail, นิยามจุดอนุมัติ, สอนให้ทีมอ่าน artifact ข้ามบทบาท และสร้างพื้นที่ให้คนทดลองโดยผิดพลาดได้ในวงที่ควบคุมไว้ ถ้าหัวหน้าทีมที่ไหนยังวัดผลงานจากจำนวน ticket หรือบรรทัด code อย่างเดียว คนก็จะใช้ AI เพื่อผลิตของให้เยอะขึ้น แทนที่จะใช้มันช่วยคิดและตรวจงานให้ดีขึ้น ซึ่งผมเองไม่เคยใช้ตัวชี้วัดนี้กับทีมมาแต่แรก ดังนั้นเลยข้ามพฤติกรรมแบบนี้ของคนไปได้เลย</p>



<figure class="wp-block-table"><table><thead><tr><th>บทบาทเดิม</th><th>ความรับผิดชอบที่ต้องเพิ่ม</th></tr></thead><tbody><tr><td>Developer รอรับ task แล้ว implement</td><td>ตรวจ requirement, challenge spec, วาง plan, ประเมิน architecture และพิสูจน์ผลด้วย test</td></tr><tr><td>Architect ออกแบบแล้วส่งต่อ</td><td>ทำ decision และ constraint ให้เป็น artifact ที่ agent นำไปใช้และตรวจย้อนกลับได้</td></tr><tr><td>Tester รอตรวจหลังพัฒนาเสร็จ</td><td>เข้ามาช่วยกำหนด acceptance criteria, test strategy และ evidence ตั้งแต่ก่อน implement</td></tr><tr><td>Team Lead แบ่งงานและติดตามสถานะ</td><td>ออกแบบ workflow, guardrail, review gate, feedback loop และแผนพัฒนาทักษะของทีม</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">คำว่าล้างสมองในที่นี้ ผมไม่ได้หมายถึงให้ทิ้งหลักวิศวกรรมเดิม ตรงกันข้ามเลยครับ เรายังต้องใช้ architecture, specification, testing, security และ review เหมือนเดิม เพียงแต่ต้องเลิกคิดว่าสิ่งเหล่านี้เป็นสถานีที่มีเจ้าหน้าที่คนละคนเฝ้าอยู่ และคนอื่นไม่จำเป็นต้องเข้าใจ</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">AI ลดภาระการพิมพ์ code แต่เพิ่มความจำเป็นที่คนทำงานต้องเข้าใจ software ทั้งสาย ตั้งแต่โจทย์จนถึงหลักฐานว่ามันใช้งานได้จริง</p>
</blockquote>



<p class="wp-block-paragraph">ถ้าคนยังทำงานแบบโยนบอลข้ามกำแพง ต่อให้เปลี่ยนกำแพงนั้นเป็น Markdown และมี agent วิ่งรับส่งเอกสารให้ เราก็ยังมี process เดิมที่เคลื่อนที่เร็วขึ้นเท่านั้น ปัญหาของผู้จัดการจึงไม่ใช่แค่ซื้อเครื่องมือหรือเขียน policy แต่ต้องช่วยให้ทีมมองเห็นความรับผิดชอบแบบ end-to-end และให้เวลาเขาในการพัฒนาทักษะที่จำเป็นจริงๆ</p>



<h2 class="wp-block-heading">ถ้าจะเริ่มกับทีมจริง ผมแนะนำว่าอย่าเริ่มจากระบบอัตโนมัติทั้งวงจร</h2>



<p class="wp-block-paragraph">Playbook ของ Anthropic ยาวและครอบคลุมมาก ถ้าอ่านแล้วเกิดไฟลุก ไปพยายามทำทุกอย่างพร้อมกัน เราอาจใช้เวลาสร้าง process จนไม่ได้ส่งของจริงๆ ผมแนะนำให้เริ่มจากส่วนที่ลดงานซ้ำและตรวจผลได้ก่อน</p>



<ol class="wp-block-list">
<li>ทำคำสั่ง build, test และ lint ให้ agent เรียกใช้ได้ง่าย และคืนผลสำเร็จหรือล้มเหลวชัดเจน</li>



<li>เขียน <code>CLAUDE.md</code> หรือ <code>AGENTS.md</code> ให้สั้นพอที่จะอ่านจริง เก็บ conventions กับ recurring mistakes ที่กระทบงาน</li>



<li>กำหนดว่างานระดับไหนต้องมี <code>intent.md</code>, <code>spec.md</code> และ <code>plan.md</code> งานเล็กไม่จำเป็นต้องแบกเอกสารเท่างานเสี่ยงสูง</li>



<li>เลือก policy ที่ห้ามผิดเลย สักหนึ่งหรือสองเรื่อง แล้วทำ hook หรือ CI check ให้บังคับได้จริง</li>



<li>เก็บงานจริงเป็น eval ทีละเคส โดยเฉพาะ bug หรือ review comment ที่เกิดซ้ำ</li>



<li>เมื่อ feedback loop และ rollback ใช้งานได้แล้ว ค่อยเพิ่ม autonomy ใน development ก่อนขยับไป staging และ production</li>
</ol>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">อย่าเริ่ม AI-Native SDLC ด้วยการให้อำนาจ agent มากขึ้น เริ่มด้วยการทำให้มันพิสูจน์งานของตัวมันเองได้ก่อน</p>
</blockquote>



<p class="wp-block-paragraph">อีกเรื่องที่ต้องตกลงให้ชัดคือ source of truth ถ้าองค์กรใช้ Jira/ServiceNow เป็นระบบหลักอยู่แล้ว ไม่จำเป็นต้องย้ายทุกอย่างเข้า Markdown แต่ artifact ใน repository กับ record ในระบบเดิมต้องเชื่อมกลับหากันได้ ไม่อย่างนั้นเราจะได้ข้อมูลสองชุดที่ดูน่าเชื่อถือพอๆ กัน แล้วไม่มีใครรู้ว่าชุดไหนล่าสุด อันนี้น่ากลัวกว่าไม่มีเอกสารอีกครับ 555</p>



<p class="wp-block-paragraph">ส่วนตัวผม ไม่ได้ใช้พวก Project Management อย่าง Jira/ServiceNow อยู่แล้ว ข้อนี้ผมเลยทำ spec/plan/task หลักไว้ที่ Markdown แต่ผมให้แตก task ไว้บน GitLab Issues และให้ AI จัดการปิดงานตาม Checklist ด้วย เพื่อคอย monitor สถานะงานและใข้รวบรวมเปิด PR Merge แทนคน</p>



<h2 class="wp-block-heading">บทสรุป</h2>



<p class="wp-block-paragraph">หลังอ่าน The AI-Native SDLC playbook แล้วเทียบกับสิ่งที่ผมกำลังทำกับทีม ผมรู้สึกว่าประโยค code is no longer the bottleneck เป็นเพียงตัวเปิดเรื่อง สิ่งที่กำลังเปลี่ยนจริงคือทั้งหน่วยของการทำงานและขอบเขตความรับผิดชอบ จากเดิมที่แบ่งกันตามตำแหน่ง กลายเป็นการส่งต่อ intent, constraint, implementation และ proof ผ่าน artifact ที่ตรวจย้อนหลังได้ โดยคนทำงานต้องเข้าใจความเชื่อมโยงของมันตลอดสาย</p>



<p class="wp-block-paragraph">ผมยังไม่คิดว่าทุกทีมควรเปลี่ยนไปใช้ไฟล์ <code>intent.md</code> หรือ <code>spec.md</code> เหมือนกันหมด ชื่อไฟล์ไม่ใช่สาระเท่ากับคำถามว่า คนกับ agent กำลังอ่านความจริงชุดเดียวกันหรือเปล่า งานที่บอกว่าเสร็จมีหลักฐานอะไร และใครเป็นคนมีสิทธิ์รับความเสี่ยงเมื่อจะขึ้น production</p>



<p class="wp-block-paragraph">ถ้าเราตอบสามข้อนี้ไม่ได้ การเพิ่ม agent อีกสิบตัวอาจทำให้ทีมผลิตของที่ต้องตามแก้ได้เร็วขึ้นเท่านั้น แต่ถ้าตอบได้ AI-Native SDLC ก็ไม่ใช่ buzzword ใหม่ครับ มันคือการค่อยๆ เปลี่ยน process ให้ความเร็วของ AI ไม่วิ่งหนีความสามารถในการควบคุมของทีม</p>



<p class="wp-block-paragraph">สำหรับผม จุดเริ่มที่เหมาะที่สุดยังเป็นของพื้นฐานมากๆ คือโจทย์ชัด, แผนอ่านรู้เรื่อง, test รันได้, และคนที่อนุมัติรู้ว่าตัวเองกำลังอนุมัติอะไร ฟังดูไม่ล้ำเลยเนอะ แต่ของพื้นฐานพวกนี้แหละครับที่ทำให้ automation ไปต่อได้โดยไม่ต้องคอยลุ้นทุกครั้ง</p>



<h2 class="wp-block-heading">ผู้อ่านได้อะไรจากบทความนี้</h2>



<ul class="wp-block-list">
<li><strong>มองเห็นคอขวดใหม่</strong> หลัง AI ทำให้การเขียน code เร็วขึ้น</li>



<li><strong>เข้าใจ artifact chain</strong> ตั้งแต่ intent, spec และ plan ไปจนถึง production feedback</li>



<li><strong>แยกคำแนะนำออกจากการบังคับ</strong> ว่าเรื่องใดใช้ skill และเรื่องใดควรมี hook หรือ CI gate</li>



<li><strong>เห็นความต่างของแต่ละแนวทาง</strong> จาก Anthropic, AWS, McKinsey, Snyk, Microsoft และ Addy Osmani</li>



<li><strong>มีลำดับเริ่มต้นที่เล็กพอ</strong> สำหรับทดลองกับทีม โดยเริ่มจาก verification ก่อน autonomy</li>



<li><strong>วางแผน reskill ทีม</strong> ให้คนเข้าใจ architecture, spec, plan, implementation และ test แบบ end-to-end พร้อมปรับบทบาทของหัวหน้าทีมจากผู้ติดตามงานเป็นผู้ออกแบบระบบการทำงาน</li>
</ul>



<h2 class="wp-block-heading">แหล่งอ้างอิง</h2>



<ul class="wp-block-list">
<li><a href="https://claude.com/blog/the-ai-native-sdlc-playbook" target="_blank" rel="noreferrer noopener">The AI-Native SDLC playbook</a> โดย Louis Claxton, Anthropic</li>



<li><a href="https://aws.amazon.com/blogs/devops/ai-driven-development-life-cycle/" target="_blank" rel="noreferrer noopener">AI-Driven Development Life Cycle</a> จาก AWS</li>



<li><a href="https://www.mckinsey.com/capabilities/mckinsey-technology/our-insights/rewiring-software-delivery-for-the-agentic-era" target="_blank" rel="noreferrer noopener">Rewiring software delivery for the agentic era</a> จาก McKinsey &amp; Company</li>



<li><a href="https://snyk.io/articles/complete-guide-ai-powered-software-development/" target="_blank" rel="noreferrer noopener">Complete guide to AI-powered software development</a> จาก Snyk</li>



<li><a href="https://addyosmani.com/blog/loop-engineering/" target="_blank" rel="noreferrer noopener">Loop Engineering</a> โดย Addy Osmani</li>



<li><a href="https://techcommunity.microsoft.com/blog/appsonazureblog/an-ai-led-sdlc-building-an-end-to-end-agentic-software-development-lifecycle-wit/4491896" target="_blank" rel="noreferrer noopener">An AI-led SDLC with Azure and GitHub</a> จาก Microsoft</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/8495/ai-native-sdlc-software-delivery-playbook/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>AI เขียนโค้ดเร็วแล้ว แต่ทำไมงานยังช้าอยู่</title>
		<link>https://myifew.com/8478/ai-coding-bottleneck-requirement-workflow/</link>
					<comments>https://myifew.com/8478/ai-coding-bottleneck-requirement-workflow/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Mon, 07 Sep 2026 17:49:25 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI]]></category>
		<category><![CDATA[Context Engineering]]></category>
		<category><![CDATA[Vibe Coding]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=8478</guid>

					<description><![CDATA[AI ทำให้เขียนโค้ดเร็วขึ้น แต่เหตุใดงาน software ยังช้าอยู่ มุมมองจากประสบการณ์ที่เห็น user และ programmer ใช้ AI ทำงานร่วมกัน]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">วันนี้ผมตกผลึกเรื่องหนึ่งขึ้นมาครับ หลังจากใช้ AI และอยู่ท่ามกลางคนที่ใช้ AI ทั้งฝั่ง user และ developer มาประมาณ 1-2 ปี ผมเห็นคนรอบตัวเปลี่ยนวิธีสร้าง software เร็วมาก โดยเฉพาะตั้งแต่ต้นปี 2026 ที่เครื่องมือกลุ่ม coding agent และ AI สำหรับช่วยทำงานเริ่มเข้าถึงคนที่ไม่ได้เป็น programmer มากขึ้น</p>



<p class="wp-block-paragraph">ตอนแรกผมใช้ AI เขียนโปรแกรมด้วยตัวเองเป็นหลัก เพราะผมเป็น programmer อยู่แล้ว จึงรู้ว่าต้องสั่งอะไร ต้องดู code ตรงไหน และควรสงสัยผลลัพธ์เมื่อไร แต่ระยะหลัง เจ้านาย น้องในทีม และเพื่อนร่วมงานที่ไม่ได้ทำหน้าที่ programmer โดยตรง เริ่มทำ prototype ออกมาเอง บางคนไปไกลถึงขั้นสร้างโปรแกรมที่ใช้งานได้ แล้วค่อยเรียก programmer เข้าไปช่วยเฉพาะจุด</p>



<p class="wp-block-paragraph">ภาพนี้ทำให้ผมกลับมาถามว่า ถ้า AI เขียน code ได้เร็วมากแล้ว ทำไมหลายโครงการยังช้าเหมือนเดิม คำตอบที่ผมได้ คือ เราเร่งช่วงผลิต code ได้ แต่ช่วงที่คนหนึ่งพยายามอธิบายสิ่งที่ตัวเองต้องการให้อีกคนเข้าใจ ยังเป็นคอขวดก้อนเดิมครับ</p>



<span id="more-8478"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: เอเจ้นชมพูช่วยถอดความและเรียบเรียงจากประสบการณ์กับมุมมองที่ฟิวส์เล่าอย่างละเอียด</em></p>



<h2 class="wp-block-heading">สรุปไฮไลต์สั้นๆ</h2>



<ul class="wp-block-list">
<li><strong>AI เร่งการเขียน code</strong> แต่ไม่ได้ทำให้การค้นหาและถ่ายทอดความต้องการเร็วขึ้นโดยอัตโนมัติ</li>



<li><strong>คนทำ software เริ่มแยกได้ 5 กลุ่ม</strong> ตามระยะห่างระหว่างคนที่มีความต้องการกับคนที่ลงมือสร้าง</li>



<li><strong>Prototype ที่ใช้งานได้จริง</strong> สื่อสารได้ชัดกว่า requirement หรือ wireframe ที่ยังต้องตีความอีกหลายทอด</li>



<li><strong>Programmer จะขยับเข้าใกล้บทบาท consultant</strong> มากขึ้น โดยช่วยเรื่อง architecture, integration, security และ production readiness</li>



<li><strong>อนาคตอาจเหลือ workflow เด่นเพียง 2 แบบ</strong> คือ user สร้างเองโดยมี programmer ช่วยไกด์ กับ user ทำของที่ชัดแล้วส่งให้ programmer ทำต่อ</li>
</ul>



<h2 class="wp-block-heading">ผมเห็นคนสร้าง software อยู่ประมาณ 5 กลุ่ม</h2>



<p class="wp-block-paragraph">ถ้าแบ่งแบบหยาบๆ จากคนที่ผมเจอ ผมคิดว่าตอนนี้มีอยู่ประมาณ 5 กลุ่มครับ เส้นแบ่งของแต่ละกลุ่มไม่ได้อยู่ที่ว่าใครใช้ AI รุ่นไหน แต่อยู่ที่ว่าใครเป็นคนถือความต้องการ และใครเป็นคนแปลงมันให้กลายเป็นของที่ใช้ได้จริง</p>



<figure class="wp-block-table"><table><thead><tr><th>กลุ่ม</th><th>รูปแบบการทำงาน</th><th>ความเร็วที่ผมสังเกต</th><th>จุดที่มักติด</th></tr></thead><tbody><tr><td>1</td><td>Programmer คิดและเขียนเอง</td><td>เร็ว</td><td>ขอบเขตความรู้และการตัดสินใจอยู่ที่คนเดียว</td></tr><tr><td>2</td><td>Programmer รับคำสั่งหรือ requirement มาทำ</td><td>ช้า</td><td>ต้องถามกลับและแปลความต้องการหลายรอบ</td></tr><tr><td>3</td><td>User ทำ prototype แล้วส่งให้ programmer</td><td>ปานกลาง</td><td>เห็นหน้าตา แต่ behavior และเงื่อนไขอาจยังไม่ครบ</td></tr><tr><td>4</td><td>User สร้าง prototype หรือระบบเอง แล้วให้ programmer เป็น consultant</td><td>เร็ว</td><td>ต้องมีคนช่วยดู architecture และข้อจำกัดที่ user อาจไม่เห็น</td></tr><tr><td>5</td><td>User สั่ง AI และสร้างโปรแกรมเองได้</td><td>เร็วที่สุดในบางงาน</td><td>ต้องมีพื้นฐานพอจะตรวจสิ่งที่ AI ทำ</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">กลุ่มแรกเข้าใจง่ายครับ Programmer รู้ความต้องการเองและลงมือเอง เมื่อมี AI ก็เหมือนได้เครื่องมือเพิ่มกำลัง เขารู้ว่าจะออกคำสั่งอย่างไร อ่านผลลัพธ์เป็น และพอเดาได้ว่าตรงไหนน่าจะมีปัญหา</p>



<p class="wp-block-paragraph">กลุ่มที่สองกลับยากกว่าที่หลายคนคิด แม้ programmer จะใช้ AI เขียน code ได้เร็ว แต่กว่าจะรู้ว่าคนขออยากได้อะไรจริงๆ ยังต้องประชุม ถามกลับ เขียน requirement แตกเป็น function แล้วแปลงต่อเป็น technical spec กว่าจะเริ่มเขียนได้ เครื่องมือเร็วขึ้น แต่รถยังติดอยู่หน้าด่านเดิมครับ</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">AI ทำให้มือของ programmer เร็วขึ้น แต่ยังไม่ได้ทำให้คนสองคนเข้าใจกันเร็วขึ้นเสมอไป</p>
</blockquote>



<h2 class="wp-block-heading">Prototype เปลี่ยนการคุยจากคำอธิบายเป็นของที่มองเห็น</h2>



<p class="wp-block-paragraph">กลุ่มที่สามคือ user ทำ prototype แล้วส่งให้ programmer ทำต่อ แบบนี้เร็วขึ้นกว่าส่ง requirement หรือ wireframe อย่างเดียวเยอะครับ เพราะ programmer เห็นหน้าจอ เห็น flow และเห็นว่าคนขอพยายามแก้ปัญหาอะไรอยู่</p>



<p class="wp-block-paragraph">แต่ prototype ก็ยังมีช่องว่างของมัน หน้าจอที่กดได้อาจบอกว่า user ต้องการอะไรเมื่อทุกอย่างปกติ แต่ไม่ได้บอกเสมอว่าถ้าข้อมูลผิดจะทำอย่างไร ใครมีสิทธิ์เห็นอะไร ระบบเดิมต้องเชื่อมแบบไหน หรือข้อมูลต้องถูกเก็บนานแค่ไหน หน้าตาชัดไม่ได้แปลว่า behavior ข้างในชัดครบครับ</p>



<p class="wp-block-paragraph">ถึงอย่างนั้น ผมยังมองว่ามันดีกว่าการส่งประโยคว่า อยากได้ระบบประมาณนี้ แล้วปล่อยให้คนถัดไปจินตนาการเอง เหมือนคนหนึ่งเอาภาพห้องครัวที่ลองจัดมาแล้วไปให้ช่างดู ต่อให้ยังขาดแบบไฟกับท่อน้ำ อย่างน้อยก็ไม่ต้องเริ่มคุยกันจากคำว่า อยากได้ครัวสวยๆ 555</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">Prototype ที่ดีไม่ได้กำจัด requirement แต่มันลดพื้นที่ที่แต่ละคนต้องจินตนาการไม่เหมือนกัน</p>
</blockquote>



<h2 class="wp-block-heading">เมื่อ user ลงมือสร้างเอง Programmer จึงกลายเป็นที่ปรึกษา</h2>



<p class="wp-block-paragraph">กลุ่มที่สี่น่าสนใจมากครับ User มี prototype หรือระบบที่ทำงานได้ประมาณหนึ่งแล้ว จากนั้นให้ programmer เข้าไปเป็น consultant ช่วยดูว่าส่วนไหนควรแก้ ควรต่อกับระบบเดิมอย่างไร หรือมีความเสี่ยงอะไรที่ยังมองไม่เห็น</p>



<p class="wp-block-paragraph">ผมเห็นเพื่อนร่วมงานชาวต่างชาติคนหนึ่งทำแบบนี้ เขาไม่ได้เริ่มจากพื้นฐาน programmer เต็มตัว แต่เป็นคนเรียนรู้เร็ว ชอบศึกษา และมีความสามารถในการตั้งคำถาม เขาสร้างของออกมาได้ระดับหนึ่งแล้วมาปรึกษา programmer เพิ่มอีกไม่มาก จากนั้นก็กลับไปต่อยอดสิ่งที่ตัวเองต้องการได้</p>



<p class="wp-block-paragraph">ลักษณะนี้ใกล้กับการมี programmer ยืนอยู่ข้างๆ มากกว่านั่งรอรับเอกสารปลายทาง บทบาทของ programmer จึงไม่ใช่คนพิมพ์ code ตามแบบ แต่เป็นคนช่วยชี้ blind spot ตั้งคำถามเรื่อง architecture, data, security และช่วยตรวจว่าของที่วิ่งได้บนเครื่อง จะไปต่อใน production ได้หรือไม่</p>



<p class="wp-block-paragraph">มันมีส่วนคล้ายแนวทางของ <strong>Forward Deployed Engineer (FDE)</strong> ซึ่งเป็น engineer ที่เข้าไปทำงานใกล้กับผู้ใช้หรือทีมลูกค้า ช่วยค้นหาความต้องการ สร้าง prototype ปรับระบบ และนำไปใช้ในสภาพแวดล้อมจริง แทนที่จะรับ spec แล้วหายกลับไปเขียนอยู่คนเดียว <a href="https://www.datacamp.com/blog/what-is-forward-deployed-engineer" target="_blank" rel="noreferrer noopener">คำอธิบายบทบาท FDE จาก DataCamp</a></p>



<h2 class="wp-block-heading">User เขียนโปรแกรมเองได้ ทำไมถึงเร็วที่สุด</h2>



<p class="wp-block-paragraph">กลุ่มที่ห้าคือ user สร้างโปรแกรมเอง เขารู้ปัญหา รู้ว่าต้องการอะไร และสั่ง coding agent ให้ช่วยสร้างสิ่งนั้นได้โดยตรง ระยะทางจากความคิดไปถึงของที่กดได้จึงสั้นมาก ไม่ต้องผ่านคนกลางหลายทอด</p>



<p class="wp-block-paragraph">เจ้านายผมเป็นอดีต programmer พอได้รื้อฟื้นพื้นฐานเดิมร่วมกับ AI เขาก็ไปต่อได้เร็ว เพราะยังมี foundation พอจะเข้าใจว่า code, database, API และ flow ของระบบเกี่ยวกันอย่างไร เขาอาจจำ syntax ไม่ครบ แต่ syntax กลายเป็นเรื่องที่ AI ช่วยได้แล้ว</p>



<p class="wp-block-paragraph">ตรงนี้มีเงื่อนไขสำคัญครับ User ที่สร้างเองได้เร็ว ไม่ได้แปลว่าไม่ต้องรู้อะไรเลย อย่างน้อยต้องมีพื้นฐานทาง programming หรือมีความสามารถพอจะตรวจสอบ ตั้งคำถาม และรู้ว่าเมื่อไรควรเรียกคนที่มีประสบการณ์เข้ามาช่วย ไม่อย่างนั้นความเร็วอาจพาไปถึงของที่ดูเหมือนใช้ได้ แต่มีปัญหาอยู่ข้างในแบบที่เจ้าตัวไม่รู้</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">วันหนึ่ง คนที่ทำโปรแกรมได้ดีที่สุดอาจจะไม่ใช่มาจากโปรแกรมเมอร์ที่เก่งที่สุด แต่จะเป็น User ที่ใช้เอไอเขียนโปรแกรมได้เองตามที่ธุรกิจต้องการ</p>
</blockquote>



<h2 class="wp-block-heading">ทำไมมี AI แล้ว process เดิมยังช้า</h2>



<p class="wp-block-paragraph">ในกระบวนการพัฒนา software แบบเดิม ความต้องการจาก user มักต้องผ่าน Product Owner, Business Analyst, System Analyst หรือตำแหน่งอื่นตามโครงสร้างของแต่ละองค์กร คนเหล่านี้ช่วยแปลง idea ให้เป็น requirement, function, design และเอกสารที่ programmer ใช้ทำงานต่อ</p>



<p class="wp-block-paragraph">จากนั้น requirement ยังอาจต้องถูกแปลงอีกรอบเป็น technical spec, API contract, application design, data model และงานย่อยต่างๆ แต่ละทอดมีทั้งเวลารอ เวลาคุย และความหมายบางส่วนที่อาจหายระหว่างทาง เหมือนเกมกระซิบที่ทุกคนตั้งใจดี แต่ประโยคปลายทางไม่เหมือนต้นทางเสียทีเดียว</p>



<p class="wp-block-paragraph">ถ้า workflow ยังเป็น user อธิบายให้คนกลาง คนกลางเขียนเอกสาร แล้ว programmer เอาเอกสารไปสั่ง AI ความเร็วจะเพิ่มชัดเจนเฉพาะช่วงเขียน code ครับ ช่วงคิด ตัดสินใจ ขอข้อมูล ทำ spec และรอความเห็นยังใช้เวลาใกล้เคียงเดิม</p>



<p class="wp-block-paragraph">AI อาจช่วยเขียนเอกสารให้ละเอียดขึ้น แต่เอกสารเยอะไม่ได้รับประกันว่าคนจะอ่านครบ สุดท้าย programmer อาจใช้ AI อ่านเอกสารอีกที ถ้าเอกสารต้นทางสื่อความต้องการผิด AI ก็เพียงช่วยอ่านความเข้าใจผิดนั้นให้เร็วขึ้น แล้วผลิตของที่ไม่ตรงเร็วขึ้นตามไปด้วย เจ็บปวดแบบประสิทธิภาพสูง ฮาาา</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ถ้าความเข้าใจต้นทางผิด AI จะไม่ได้แก้ปัญหาให้เรา มันอาจช่วยขยายความผิดนั้นให้กลายเป็นระบบได้เร็วกว่าเดิม</p>
</blockquote>



<h2 class="wp-block-heading">อนาคตอาจเหลือ workflow หลักอยู่ 2 แบบ</h2>



<p class="wp-block-paragraph">จากสิ่งที่ผมเห็นภายในเวลาไม่ถึงปี ผมคิดว่า 5 กลุ่มนี้จะค่อยๆ ขยับเข้าหากัน และเหลือ workflow เด่นอยู่ประมาณ 2 แบบครับ</p>



<h3 class="wp-block-heading">แบบแรก User สร้างเอง แล้วให้ Programmer ช่วยไกด์</h3>



<p class="wp-block-paragraph">User ใช้ AI ทำ prototype หรือระบบที่ทำงานได้เอง ส่วน programmer เข้ามาช่วย review, consult และจัดการเรื่องที่ต้องใช้ความรู้ลึก วิธีนี้ทำให้คนที่รู้ความต้องการที่สุดได้ทดลองของเร็ว และยังมีคนช่วยกันไม่ให้ prototype หลุดไปเป็น production แบบไม่มีรั้ว</p>



<h3 class="wp-block-heading">แบบที่สอง User ทำ Prototype ที่ชัด แล้วให้ Programmer ทำต่อ</h3>



<p class="wp-block-paragraph">User ไม่จำเป็นต้องเขียนระบบจนเสร็จ แต่ควรนำความต้องการไปให้ไกลกว่าคำอธิบาย ทำ flow, UI และ behavior หลักให้เห็นจริง จากนั้น programmer เข้าไปประกบและทำให้เป็นระบบที่ใช้งานได้ วิธีนี้คล้ายการทำงานแบบ FDE ในมุมที่ engineer อยู่ใกล้ปัญหาและ feedback มากขึ้น</p>



<p class="wp-block-paragraph">สองแบบนี้ลดจำนวนครั้งที่ความต้องการต้องถูกแปลครับ จากประสบการณ์การคุมงาน วางแผน และทำ project management ของผม ผมเชื่อว่ามันทำให้การพัฒนาเร็วกว่า process เดิมได้มาก และในบางกรณีอาจเกินเท่าตัว แต่ตัวเลขนี้เป็นข้อสังเกตจากงานที่ผมเห็น ไม่ใช่ benchmark ที่ใช้แทนทุกทีม</p>



<h2 class="wp-block-heading">บทสรุป</h2>



<p class="wp-block-paragraph">สิ่งที่ผมตกผลึกวันนี้คือ AI ไม่ได้ทำให้คอขวดของการพัฒนา software หายไปครับ มันย้ายคอขวดจากการพิมพ์ code ไปอยู่ที่การรู้ความต้องการ การอธิบายให้ชัด และการตรวจว่าสิ่งที่สร้างตรงกับปัญหาจริงหรือไม่</p>



<p class="wp-block-paragraph">เมื่อก่อนคนที่มี idea ต้องรอให้หลายบทบาทช่วยแปล idea นั้นจน programmer เริ่มลงมือได้ วันนี้ user สามารถใช้ AI ทำให้ความคิดกลายเป็นของที่เห็นและทดลองได้เร็วขึ้น ระยะห่างระหว่างคนที่เจอปัญหากับคนที่สร้างคำตอบกำลังสั้นลงมาก</p>



<p class="wp-block-paragraph">ผมไม่ได้คิดว่า programmer จะหายไป แต่ตำแหน่งของ programmer ใน workflow จะเปลี่ยน จากคนที่รอรับ requirement ปลายทาง ไปเป็นคนที่เข้าใกล้ user มากขึ้น ช่วยถาม ช่วยไกด์ ช่วยตรวจ และจัดการส่วนที่ความเร็วอย่างเดียวเอาไม่อยู่</p>



<p class="wp-block-paragraph">สุดท้ายทีมที่ได้ประโยชน์จาก AI มากที่สุดอาจไม่ใช่ทีมที่ generate code ได้เยอะที่สุด แต่เป็นทีมที่ลดจำนวนครั้งของการแปลความต้องการลงได้มากที่สุดครับ</p>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/8478/ai-coding-bottleneck-requirement-workflow/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>แกะรูปแบบการเขียน Requirement ระบบ LLM Wiki ของ Karpathy</title>
		<link>https://myifew.com/7879/karpathy-llm-wiki-requirement-context-engineering/</link>
					<comments>https://myifew.com/7879/karpathy-llm-wiki-requirement-context-engineering/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Mon, 27 Jul 2026 15:02:01 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7879</guid>

					<description><![CDATA[วิเคราะห์รูปแบบการเขียน LLM Wiki gist ของ Andrej Karpathy ว่าทำไมอ่านง่ายสำหรับมนุษย์ แต่ยังให้ AI agent เอาไป implement ต่อได้ในฐานะ requirement และ context engineering]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ผมชอบเอกสารชิ้นหนึ่งของ Andrej Karpathy เรื่อง <a href="https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f" target="_blank" rel="noreferrer noopener">LLM Wiki</a> มากครับ (อยากรู้ว่าคืออะไร ผมเคยเขียนไว้ที่ <a href="https://myifew.com/7636/llm-wiki-karpathy/" data-type="link" data-id="https://myifew.com/7636/llm-wiki-karpathy/">LLM Wiki : คลังความรู้ส่วนตัว ตามแบบฉบับของ Karpathy</a>) ไม่ใช่แค่เพราะไอเดียเรื่อง LLM Wiki น่าสนใจ แต่เพราะวิธีเขียนของมันดีมาก คือมันอ่านเหมือนบทความให้มนุษย์เข้าใจ แต่ขณะเดียวกันก็เป็นเอกสารที่ส่งให้ AI agent เอาไป implement ต่อได้เลย</p>



<p class="wp-block-paragraph">นี่เป็นรูปแบบที่ผมคิดว่าน่าสนใจมากสำหรับคนที่ต้องเขียน requirement, product spec, technical spec หรือแม้แต่ working agreement ให้ AI ทำงานด้วย เพราะมันไม่ได้เขียนเป็น requirement แข็งๆ แบบที่เคยทำกันมา หรือแบบเอกสารราชการ แต่ก็ไม่ได้หลวมจน AI หรือคนต้องเดาเองทั้งหมด</p>



<p class="wp-block-paragraph">บทความนี้เลยอยากลองแกะรูปแบบการเขียนของเอกสารชิ้นนี้ว่า ทำไมมันถึงอ่านง่ายสำหรับคน และยังทำหน้าที่เป็น context engineering สำหรับ AI ได้ดีในเวลาเดียวกัน</p>



<span id="more-7879"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้เป็นงานเขียนร่วมกันระหว่างผมกับ AI agent โดยอิงจากมุมมองและโจทย์ที่ผมสนใจจริง ส่วนข้อมูลเชิงอ้างอิงนำมาประกอบจากเอกสาร LLM Wiki gist ของ Andrej Karpathy และแหล่งที่มาที่ลิงก์ไว้ท้ายบทความ</em></p>



<h2 class="wp-block-heading">เอกสารนี้ไม่ได้บอกแค่ “ต้องทำอะไร” แต่บอกว่า “ทำไมต้องทำ”</h2>



<p class="wp-block-paragraph">จุดแรกที่ผมชอบคือเอกสารไม่ได้เปิดด้วย technical อย่างการบอกโครงสร้าง directory structure, schema, command หรือ implementation detail ทันที แต่เปิดด้วยปัญหาของวิธีเดิมก่อน</p>



<p class="wp-block-paragraph">Karpathy เริ่มจากภาพที่คนส่วนใหญ่คุ้นเคย คือการใช้ LLM กับเอกสารแบบ RAG หรือการ upload file แล้วให้โมเดลดึง chunk มาตอบคำถาม จากนั้นค่อยชี้ให้เห็นข้อจำกัดว่า วิธีนี้ทำให้ LLM ต้อง rediscover knowledge ใหม่ทุกครั้ง ไม่มีการสะสม ไม่มีการ build up ของความรู้</p>



<p class="wp-block-paragraph">พอวาง problem แบบนี้แล้ว เขาค่อยเสนอ idea ใหม่ว่า แทนที่จะ retrieve raw document ทุกครั้ง ให้ LLM ค่อยๆ สร้างและ maintain wiki ที่เป็น markdown files อยู่ระหว่างผู้ใช้กับ raw sources</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">นี่คือ pattern การเขียน requirement ที่ดีมาก คือเริ่มจาก pain ของโลกเดิม แล้วค่อยพาไปสู่ architecture ของโลกใหม่</p>
</blockquote>



<p class="wp-block-paragraph">สำหรับมนุษย์ วิธีนี้ทำให้อ่านแล้วเข้าใจเหตุผล ไม่ใช่แค่รับคำสั่ง ส่วนสำหรับ AI มันทำให้โมเดลเข้าใจ intent ของระบบ ไม่ใช่ทำตาม checklist แบบไม่รู้บริบท</p>



<h2 class="wp-block-heading">โครงสร้างหลักของเอกสาร</h2>



<p class="wp-block-paragraph">ถ้าแกะเป็นโครง เอกสารนี้มีลำดับที่ค่อนข้างชัดครับ</p>



<figure class="wp-block-table"><table><thead><tr><th>ลำดับ</th><th>Section</th><th>หน้าที่ของ section</th></tr></thead><tbody><tr><td>1</td><td>Title + one-line description</td><td>บอกชื่อ pattern และคำอธิบายสั้นมาก</td></tr><tr><td>2</td><td>Meta intent</td><td>บอกว่าเอกสารนี้ออกแบบมาให้ copy ไปให้ LLM agent อ่าน</td></tr><tr><td>3</td><td>The core idea</td><td>อธิบาย problem, contrast กับวิธีเดิม, แล้วเสนอ idea ใหม่</td></tr><tr><td>4</td><td>Examples</td><td>ยก use case หลาย domain เพื่อให้คนเห็น applicability</td></tr><tr><td>5</td><td>Architecture</td><td>แตกเป็น 3 layer: raw sources, wiki, schema</td></tr><tr><td>6</td><td>Operations</td><td>อธิบาย workflow: ingest, query, lint</td></tr><tr><td>7</td><td>Indexing and logging</td><td>ระบุ artifact สำคัญที่ช่วยให้ระบบทำงานต่อเนื่อง</td></tr><tr><td>8</td><td>Optional tools</td><td>เสนอเครื่องมือเสริมโดยไม่บังคับ</td></tr><tr><td>9</td><td>Tips and tricks</td><td>เก็บ practical notes จากประสบการณ์ใช้งานจริง</td></tr><tr><td>10</td><td>Why this works</td><td>อธิบายเหตุผลเชิงระบบว่าทำไม LLM เหมาะกับงานนี้</td></tr><tr><td>11</td><td>Note</td><td>ปิดท้ายด้วยขอบเขตและวิธีนำไป adapt</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">สิ่งที่น่าสนใจคือมันไม่ได้เป็น spec แบบ sequence เดียวจาก requirement ไป design ไป implementation แต่เป็น “idea file” ที่ค่อยๆ เพิ่มระดับความชัดจาก concept ไปสู่ architecture และ operation</p>



<h2 class="wp-block-heading">Pattern ใหญ่: Context ก่อน Requirement</h2>



<p class="wp-block-paragraph">ถ้าเขียน requirement แบบเดิม เราอาจเริ่มด้วยประโยคประมาณนี้</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ระบบต้องสามารถ ingest เอกสาร, สร้าง wiki page, update index และตอบคำถามจาก wiki ได้</p>
</blockquote>



<p class="wp-block-paragraph">ประโยคนี้ไม่ได้ผิด แต่สำหรับ AI มันยังเปิดช่องให้เดาเยอะมาก เพราะยังไม่รู้ว่า ingest เพื่ออะไร, wiki ต่างจาก raw source อย่างไร, index สำคัญแค่ไหน, และใครเป็นเจ้าของ layer ไหน</p>



<p class="wp-block-paragraph">เอกสารของ Karpathy ทำอีกแบบ คือให้ context ก่อน แล้ว requirement ค่อยโผล่ออกมาจาก context นั้น เช่นเมื่อเขาบอกว่า raw sources เป็น immutable และเป็น source of truth ส่วน wiki เป็น LLM-generated markdown ที่ LLM owns entirely เราจะเริ่มเข้าใจ rule ตามมาทันทีว่า AI อ่าน raw ได้แต่ไม่ควรแก้ raw, AI แก้ wiki ได้, schema เป็นตัวกำกับ behavior</p>



<p class="wp-block-paragraph">นี่คือหัวใจของ context engineering ครับ ไม่ใช่ยัด requirement เยอะๆ แต่จัดบริบทให้ AI เห็น mental model ที่ถูกก่อน</p>



<h2 class="wp-block-heading">โครงภาษาที่ทำให้มนุษย์อ่านง่าย</h2>



<p class="wp-block-paragraph">ในเชิงภาษาศาสตร์ เอกสารนี้มีหลายอย่างที่ทำให้อ่านง่ายมาก แม้จะเป็นเรื่องค่อนข้าง technical</p>



<h3 class="wp-block-heading">1. ใช้ contrast ชัดเจน</h3>



<p class="wp-block-paragraph">เขาใช้คู่ตรงข้ามซ้ำๆ เช่น RAG แบบเดิมกับ wiki แบบใหม่, raw sources กับ wiki, human กับ LLM, index กับ log, required core กับ optional tools วิธีนี้ช่วยให้ผู้อ่านสร้างแผนที่ในหัวได้เร็ว</p>



<h3 class="wp-block-heading">2. ใช้ sentence ที่มี thesis ชัด</h3>



<p class="wp-block-paragraph">หลายย่อหน้ามีประโยคแกนกลางที่จับใจความได้ทันที เช่น “the wiki is a persistent, compounding artifact” หรือ “Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.” ประโยคแบบนี้ทำให้ idea จำง่ายและ quote ได้</p>



<h3 class="wp-block-heading">3. ใช้ metaphor ที่แม่น</h3>



<p class="wp-block-paragraph">การเปรียบ Obsidian เป็น IDE, LLM เป็น programmer และ wiki เป็น codebase ช่วยย้ายเรื่อง knowledge management ที่อาจ abstract ให้กลายเป็นภาพที่ developer เข้าใจทันที</p>



<h3 class="wp-block-heading">4. ใช้ bullet เพื่อเปิดพื้นที่ของ domain</h3>



<p class="wp-block-paragraph">แทนที่จะอธิบาย use case ยาวๆ เขาใช้ bullet list เช่น personal, research, reading a book, business/team, competitive analysis วิธีนี้ทำให้คนอ่าน map เข้ากับชีวิตตัวเองได้เร็ว</p>



<h3 class="wp-block-heading">5. ใช้คำกริยาเชิง operation</h3>



<p class="wp-block-paragraph">คำอย่าง ingest, query, lint, update, maintain, file back, append, cross-reference เป็นภาษาที่มนุษย์อ่านแล้วเห็น workflow และ AI อ่านแล้วแปลงเป็น action ได้ง่าย</p>



<h2 class="wp-block-heading">โครงสร้างแบบ Requirement + Context Engineering</h2>



<p class="wp-block-paragraph">ถ้ามองในมุม requirement engineering เอกสารนี้มีองค์ประกอบที่ครบกว่าที่เห็นตอนอ่านผ่านๆ ครับ</p>



<figure class="wp-block-table"><table><thead><tr><th>องค์ประกอบ</th><th>มีในเอกสารอย่างไร</th><th>ประโยชน์กับ AI</th></tr></thead><tbody><tr><td>Purpose</td><td>สร้าง personal knowledge base ด้วย LLM</td><td>รู้ goal ใหญ่</td></tr><tr><td>Problem statement</td><td>RAG ต้อง rediscover knowledge ทุกครั้ง</td><td>รู้ว่าต้อง optimize อะไร</td></tr><tr><td>Core concept</td><td>Persistent, compounding wiki</td><td>รู้ object ที่ต้องรักษา</td></tr><tr><td>Domain examples</td><td>personal, research, business, trip planning</td><td>รู้ว่า pattern ใช้ได้กว้าง</td></tr><tr><td>Architecture</td><td>raw sources, wiki, schema</td><td>รู้ boundaries และ ownership</td></tr><tr><td>Operations</td><td>ingest, query, lint</td><td>รู้ workflow หลัก</td></tr><tr><td>Artifacts</td><td>index.md, log.md</td><td>รู้ไฟล์ที่ต้อง maintain</td></tr><tr><td>Optionality</td><td>tools, Obsidian, Marp, Dataview เป็น optional</td><td>รู้ว่าอะไร core อะไรปรับได้</td></tr><tr><td>Rationale</td><td>LLM ไม่เบื่อ bookkeeping</td><td>เข้าใจว่าทำไม solution นี้เหมาะ</td></tr><tr><td>Adaptation note</td><td>รายละเอียดขึ้นกับ domain และ preference</td><td>ไม่ overfit กับ implementation เดียว</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">สำหรับ AI นี่คือ context ที่ดีมาก เพราะไม่ได้บอกแค่ output ที่ต้องการ แต่บอก ontology ของระบบด้วยว่ามี object อะไรบ้าง, object แต่ละตัวสัมพันธ์กันอย่างไร, operation หลักคืออะไร, และอะไรเป็น optional</p>



<h2 class="wp-block-heading">สิ่งที่ทำให้ AI เอาไป implement ได้</h2>



<p class="wp-block-paragraph">เอกสารนี้ไม่ได้ให้ code แต่ AI เอาไป implement ต่อได้ เพราะมันให้ constraint ที่สำคัญครบครับ</p>



<ul class="wp-block-list">
<li><strong>มี layer ชัด</strong> raw sources, wiki, schema ทำให้ AI รู้ว่าจะสร้าง folder และไฟล์ประเภทไหน</li>



<li><strong>มี ownership ชัด</strong> raw immutable, wiki LLM-generated, schema co-evolved</li>



<li><strong>มี workflow verbs</strong> ingest, query, lint เอาไปแตกเป็น command หรือ task ได้</li>



<li><strong>มี artifact names</strong> index.md และ log.md ทำให้ implement ได้ทันที</li>



<li><strong>มี health check criteria</strong> contradictions, stale claims, orphan pages, missing cross-references</li>



<li><strong>มี adaptation boundary</strong> บอกว่า abstract และ modular จึงไม่บังคับ implementation เดียว</li>
</ul>



<p class="wp-block-paragraph">ถ้า AI อ่านเอกสารนี้แล้วต้องสร้างระบบ มันสามารถ infer ต่อได้ค่อนข้างดีว่าต้องมี directory เช่น raw, wiki, schema, index, log และ workflow สำหรับ ingest/query/lint แม้เอกสารจะไม่ได้ specify exact command ทุกอย่าง</p>



<h2 class="wp-block-heading">สูตรการเขียนแบบนี้</h2>



<p class="wp-block-paragraph">ถ้าผมจะสรุปเป็นสูตรสำหรับเขียน requirement ที่คนอ่านเข้าใจและ AI เอาไปทำต่อได้ ผมจะใช้โครงนี้ครับ</p>



<pre class="wp-block-code"><code># Title
One-line description

## Intent
เอกสารนี้ใช้เพื่ออะไร ใครเป็นผู้อ่าน มนุษย์หรือ AI หรือทั้งคู่

## The problem
โลกเดิมทำงานอย่างไร และติดปัญหาอะไร

## The core idea
แนวคิดใหม่คืออะไร ต่างจากเดิมอย่างไร

## Examples / use cases
ใช้กับสถานการณ์ไหนได้บ้าง

## Architecture
มี layer, object, actor, ownership อะไรบ้าง

## Operations
workflow หลักคืออะไร เช่น create, ingest, update, query, lint, approve

## Artifacts
ไฟล์ ตาราง log index หรือ output ที่ต้องมีคืออะไร

## Rules and constraints
อะไรทำได้ อะไรห้ามทำ อะไรต้องขอ approval

## Optional tools
อะไรเป็นตัวช่วย แต่ไม่ใช่ core requirement

## Why this works
ทำไมแนวทางนี้ถึงเหมาะ

## Adaptation note
อะไรต้องปรับตาม domain และอะไรควรคงไว้</code></pre>



<p class="wp-block-paragraph">โครงนี้ไม่จำเป็นต้องใช้ทุก section ทุกครั้ง แต่ถ้าเป็นงานที่ต้องให้ทั้งคนและ AI เข้าใจร่วมกัน ผมว่ามันเป็น template ที่ดีมาก</p>



<h2 class="wp-block-heading">ตัวอย่าง rewrite requirement แบบเดิมให้เป็นสไตล์นี้</h2>



<p class="wp-block-paragraph">ลองดู requirement แบบสั้นที่ยังไม่ค่อยมี context ก่อน</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ระบบต้องบันทึก requirement และสร้าง traceability ระหว่าง requirement, API, database และ test case</p>
</blockquote>



<p class="wp-block-paragraph">ถ้าเขียนแบบ context-first อาจเปลี่ยนเป็นประมาณนี้</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ทีมเรามีปัญหาว่า requirement, API, database change และ test case กระจายอยู่คนละที่ เวลามี change ใหม่ เรามักไม่รู้ว่าต้องแก้ endpoint ไหน table ไหน และ test ไหนตามไปด้วย แนวคิดของระบบนี้คือสร้าง requirement knowledge graph ที่เก็บ change เป็นแกนกลาง แล้วเชื่อม requirement, UX, API, table, field, test และ approval เข้าด้วยกัน เพื่อให้ทั้งคนและ AI ตรวจ impact ได้ก่อนเริ่ม implement</p>
</blockquote>



<p class="wp-block-paragraph">แบบหลังยาวกว่า แต่ AI เข้าใจมากกว่าเยอะ เพราะมันเห็น problem, object, relation และ goal ของระบบพร้อมกัน ไม่ใช่แค่เห็น feature ที่ต้องทำ</p>



<h2 class="wp-block-heading">Checklist ก่อนส่งเอกสารให้ AI implement</h2>



<p class="wp-block-paragraph">เวลาผมจะเขียนเอกสารแนวนี้ ผมน่าจะใช้ checklist นี้เช็กตัวเองครับ</p>



<ul class="wp-block-list">
<li>คนอ่านรู้ไหมว่าปัญหาเดิมคืออะไร</li>



<li>มีประโยค core idea ที่จำได้ใน 1-2 บรรทัดไหม</li>



<li>มี actor และ ownership ชัดไหม</li>



<li>มี layer หรือ entity หลักครบไหม</li>



<li>มี operation verbs ที่ AI แปลงเป็น task ได้ไหม</li>



<li>มี artifact ชัดไหม เช่น file, index, log, schema, report</li>



<li>มี rule ว่าอะไรห้ามแก้ หรืออะไรต้องขอ approval ไหม</li>



<li>มีตัวอย่าง use case ให้มนุษย์เห็นภาพไหม</li>



<li>มี note ว่าอะไร optional และอะไร core ไหม</li>



<li>อ่านแล้วคนเข้าใจโดยไม่ต้องถามเพิ่ม และ AI มี context พอจะเริ่ม plan ได้ไหม</li>
</ul>



<h2 class="wp-block-heading">สรุป</h2>



<p class="wp-block-paragraph">สิ่งที่ผมชอบในเอกสาร LLM Wiki ของ Karpathy คือมันอยู่ตรงกลางระหว่าง essay กับ spec ครับ มันไม่ได้แข็งแบบ requirement document เต็มรูปแบบ แต่ก็ไม่ได้เป็นบทความเล่าไอเดียลอยๆ</p>



<p class="wp-block-paragraph">มันเขียนให้มนุษย์เข้าใจผ่าน problem, contrast, metaphor และตัวอย่าง แต่ในขณะเดียวกันก็ใส่ architecture, operation, artifact และ constraint พอให้ AI agent เอาไป instantiate ต่อได้</p>



<p class="wp-block-paragraph">ถ้าต้องเขียน requirement ในยุคที่ AI เป็นคนช่วย implement ผมว่าเราอาจต้องเขียนเอกสารแบบนี้มากขึ้น คือไม่ใช่แค่ “ระบบต้องทำอะไร” แต่ต้องเขียนให้เห็นว่า “โลกนี้ทำงานอย่างไร, ปัญหาอยู่ตรงไหน, object สำคัญคืออะไร, ใครเป็นเจ้าของอะไร, workflow ควรไหลอย่างไร, และอะไรคือกติกาที่ห้ามหลุด”</p>



<p class="wp-block-paragraph">พูดอีกแบบคือ requirement ที่ดีสำหรับ AI ไม่ใช่ requirement ที่ละเอียดที่สุดเสมอไป แต่คือ requirement ที่จัด context ได้ถูกที่สุดครับ</p>



<h2 class="wp-block-heading">แหล่งอ้างอิง</h2>



<ul class="wp-block-list">
<li><a href="https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f" target="_blank" rel="noreferrer noopener">Andrej Karpathy: LLM Wiki gist</a></li>



<li><a href="https://gist.githubusercontent.com/karpathy/442a6bf555914893e9891c11519de94f/raw" target="_blank" rel="noreferrer noopener">Raw text version of the LLM Wiki gist</a></li>



<li><a href="https://news.ycombinator.com/item?id=47963913" target="_blank" rel="noreferrer noopener">Hacker News discussion: Karpathy LLM Wiki gist</a></li>
</ul>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7879/karpathy-llm-wiki-requirement-context-engineering/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Working Agreement กับ AI: กติกาเล็กๆ ที่ทำให้ Coding Agent ไม่หลุดทาง</title>
		<link>https://myifew.com/7871/working-agreement-with-ai/</link>
					<comments>https://myifew.com/7871/working-agreement-with-ai/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Fri, 24 Jul 2026 07:38:34 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI]]></category>
		<category><![CDATA[AI Agent]]></category>
		<category><![CDATA[ChatGPT]]></category>
		<category><![CDATA[Claude]]></category>
		<category><![CDATA[Working Agreement]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7871</guid>

					<description><![CDATA[ทำไมทีมที่ใช้ AI coding agent ควรมีกติกาการทำงานร่วมกัน เช่น test ก่อน push, create issue หลังตกลง plan และห้าม merge dev โดยไม่ขอ approve]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ผมใช้ AI มาพักใหญ่ๆ แล้วเริ่มรู้สึกว่ามีเรื่องหนึ่งที่ตอนแรกดูเหมือนเล็ก แต่พอใช้งานจริงไปเรื่อยๆ กลับสำคัญมาก คือการมี <strong>Working Agreement กับ AI</strong> หรือข้อตกลงวิธีทำงานร่วมกันระหว่างเรากับ AI</p>



<p class="wp-block-paragraph">ช่วงแรกๆ ผมก็สั่งเป็นรอบๆ ไปเหมือนกันครับ วันนี้ให้ช่วยแก้ bug พรุ่งนี้ให้ช่วย refactor อีกวันให้ช่วยเขียน test แต่พอใช้ไปนานๆ จะเริ่มเห็น pattern ว่า หลายเรื่องเราสั่งซ้ำๆ อยู่ตลอด เช่น ก่อน push ต้อง test ก่อน, ถ้าตกลง plan แล้วให้ create task เป็น issue, ห้าม merge dev เอง ต้องขอ approve ก่อน</p>



<p class="wp-block-paragraph">จนวันหนึ่งผมสังเกตน้องในทีมใช้งาน AI แล้วไม่ได้คุยเรื่องข้อตกลงกันก่อน ผลคือ AI ทำบ้างไม่ทำบ้าง บางรอบจำได้ บางรอบลืม พอปิด session ก็เหมือนต้องเริ่มใหม่ ทั้งที่ขั้นตอนส่วนใหญ่เป็นเรื่องเดิมๆ นั่นแหละครับ</p>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้เป็นงานเขียนร่วมกันระหว่างผมกับ AI agent โดยอิงจากประสบการณ์ใช้งานจริงของผมเอง ส่วนข้อมูลเชิงอ้างอิงนำมาประกอบจากเอกสารและแหล่งที่มาที่ลิงก์ไว้ท้ายบทความ</em></p>




<span id="more-7871"></span>




<h2 class="wp-block-heading">Working Agreement กับ AI คืออะไร</h2>



<p class="wp-block-paragraph">ถ้าแปลตรงตัว Working Agreement คือข้อตกลงในการทำงานร่วมกัน ในทีมคน เราอาจตกลงกันว่า pull request ต้องมี review, ต้องเขียน test, ห้าม push เข้า main ตรงๆ หรือถ้างานใหญ่ต้องแตก task ก่อนทำ</p>



<p class="wp-block-paragraph">พอมาเป็น AI coding agent แนวคิดเดียวกันก็ใช้ได้ครับ เพียงแต่คู่สนทนาของเราเป็น AI ที่อ่าน instruction แล้วพยายามทำตาม ถ้าเราไม่เขียนกติกาไว้ให้ชัด มันก็จะใช้ default behavior ของตัวเอง หรือเดาจาก prompt รอบนั้นๆ</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>Working Agreement กับ AI คือการเปลี่ยนสิ่งที่เราต้องสั่งซ้ำทุกวัน ให้กลายเป็นกติกาประจำโปรเจกต์</p></blockquote>



<p class="wp-block-paragraph">สำหรับผม มันไม่ใช่เรื่องสวยหรูหรือ process หนักๆ แต่เป็น trick เล็กๆ ที่ช่วยลดการหลุด ลดการลืม และทำให้ AI ทำงานใกล้เคียงกับวิธีที่ทีมต้องการมากขึ้น</p>



<h2 class="wp-block-heading">ทำไมสั่งเป็นรอบๆ แล้ว AI ถึงหลุดง่าย</h2>



<p class="wp-block-paragraph">AI เก่งขึ้นมากก็จริง แต่การคุยแบบ chat มีข้อจำกัดตามธรรมชาติอยู่ครับ เช่น context ยาวขึ้นเรื่อยๆ, session ถูกปิด, prompt รอบใหม่ไม่เหมือนรอบเดิม หรือบางคำสั่งถูกกลืนไปกับรายละเอียดอื่น</p>



<p class="wp-block-paragraph">ถ้าเราบอกแค่รอบนี้ว่า “ช่วยแก้ให้แล้ว test ด้วยนะ” AI ก็อาจทำตามในรอบนี้ แต่ไม่ได้แปลว่ารอบหน้ามันจะจำได้ว่า project นี้ต้อง test ก่อน push เสมอ หรือห้าม merge เองทุกครั้ง</p>



<p class="wp-block-paragraph">เอกสารของ <strong>Claude Code</strong> มีแนวคิดเรื่อง memory files เช่น <code>CLAUDE.md</code> ที่ใช้เก็บ project instructions และบอกด้วยว่าสามารถใช้คำสั่ง <code>/init</code> เพื่อสร้างไฟล์เริ่มต้นจาก project ได้ ส่วน <strong>OpenAI Codex</strong> ก็มีแนวทางใช้ <code>AGENTS.md</code> เพื่อให้ coding agent รู้กติกา repo เช่น setup, test และ convention ของโปรเจกต์</p>



<p class="wp-block-paragraph">พอผมเห็นแนวทางนี้แล้ว มันทำให้คิดง่ายขึ้นว่า เราไม่ควรเอากติกาประจำโปรเจกต์ไปซ่อนอยู่ใน chat ชั่วคราว แต่ควรยกมันขึ้นมาเป็นไฟล์หรือ instruction ที่ AI อ่านซ้ำได้ทุกครั้ง</p>



<h2 class="wp-block-heading">เริ่มง่ายสุด: init project แล้วเขียนกติกาไว้</h2>



<p class="wp-block-paragraph">วิธีที่ง่ายที่สุดสำหรับคนใช้ Claude Code คือเริ่มจาก <code>/init</code> เพื่อให้ Claude อ่าน repo แล้วสร้าง <code>CLAUDE.md</code> เป็น project memory ตั้งต้นก่อน จากนั้นค่อยเติม Working Agreement ของทีมลงไป</p>



<pre class="wp-block-code"><code>/init</code></pre>



<p class="wp-block-paragraph">สำหรับเครื่องมืออื่น แนวคิดเหมือนกันครับ เช่น Codex ใช้ <code>AGENTS.md</code>, บางทีมใช้ <code>.cursorrules</code>, บางทีมใช้ project instructions หรือ docs เฉพาะของตัวเอง ชื่อไฟล์อาจต่างกัน แต่หน้าที่คล้ายกัน คือบอก AI ว่า “โปรเจกต์นี้ทำงานกันแบบนี้นะ”</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>อย่าปล่อยให้ rule สำคัญอยู่ในหัวคน หรืออยู่ใน chat รอบเดียว ถ้ามันเป็นกติกาซ้ำๆ ให้เขียนลง project instruction</p></blockquote>



<h2 class="wp-block-heading">ควรเขียน Working Agreement อะไรไว้บ้าง</h2>



<p class="wp-block-paragraph">จากที่ผมใช้มา กติกาที่ควรเขียนไว้ไม่จำเป็นต้องเยอะมาก แต่ควรครอบคลุมจุดที่ถ้า AI หลุดแล้วจะกระทบ workflow หรือทำให้ทีมเสียเวลา</p>



<figure class="wp-block-table"><table><thead><tr><th>หมวด</th><th>ตัวอย่างข้อตกลง</th><th>ทำไมสำคัญ</th></tr></thead><tbody><tr><td>Safety</td><td>ห้าม merge dev/main อัตโนมัติ ต้องขอ approve ก่อน</td><td>กัน side effect ที่กระทบ repo จริง</td></tr><tr><td>Testing</td><td>ก่อน push ต้องรัน test ที่เกี่ยวข้อง และรายงานผลจริง</td><td>ลด bug จาก patch ที่ยังไม่ verify</td></tr><tr><td>Task management</td><td>หลังตกลง plan แล้วให้ create issue/task เสมอ</td><td>กันงานหายและทำให้ทีมตามต่อได้</td></tr><tr><td>Code change</td><td>แก้แบบ minimal diff ไม่ rewrite ทั้งไฟล์ถ้าไม่จำเป็น</td><td>ลด regression และลด review cost</td></tr><tr><td>Communication</td><td>ถ้า scope ไม่ชัด ให้ถามก่อนแก้ส่วนที่เสี่ยง</td><td>กัน AI เดาแล้วแตะผิดจุด</td></tr><tr><td>Verification</td><td>ทุก final response ต้องบอกไฟล์ที่แก้และ command ที่รัน</td><td>ทำให้ตรวจสอบย้อนหลังได้</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">ตัวอย่าง CLAUDE.md / AGENTS.md แบบสั้น</h2>



<p class="wp-block-paragraph">ตัวอย่างนี้เป็นแนวทางที่ผมคิดว่าเริ่มใช้ได้ทันที แล้วค่อยปรับตามทีมครับ</p>



<pre class="wp-block-code"><code># AI Working Agreement

## Goal
ช่วยพัฒนา project นี้แบบปลอดภัย ตรวจสอบได้ และไม่ทำ side effect โดยไม่ขออนุญาต

## Before coding
- ถ้างานเกิน 1 ไฟล์ ให้เสนอ plan สั้นๆ ก่อนแก้
- ถ้า scope ไม่ชัด ให้ถามก่อน ไม่เดาเองในจุดเสี่ยง
- หลังตกลง plan แล้ว ให้สร้างหรืออัปเดต issue/task เสมอ

## Coding rules
- แก้แบบ minimal diff
- ห้าม rewrite ทั้งไฟล์ถ้าไม่จำเป็น
- ทำตาม style เดิมของ repo
- ถ้าเปลี่ยน behavior ต้องเพิ่มหรือแก้ test ที่เกี่ยวข้อง

## Verification
- ก่อนเสนอว่าเสร็จ ต้องรัน targeted test ที่เกี่ยวข้อง
- ถ้าแก้หลายส่วน ให้รัน lint/typecheck ตามที่เหมาะสม
- final response ต้องบอก command ที่รันและผลจริง

## Git safety
- ห้าม merge dev/main/master อัตโนมัติ
- ห้าม push โดยไม่ขอ approve
- ห้ามลบไฟล์หรือ migration สำคัญโดยไม่ถามก่อน

## Output
- สรุป changed files
- สรุป tests ที่รัน
- บอก risk หรือสิ่งที่ยังไม่ได้ verify</code></pre>



<p class="wp-block-paragraph">แค่นี้ก็ช่วยได้เยอะแล้วครับ เพราะมันเปลี่ยนจากการสั่งซ้ำทุกครั้ง เป็นข้อตกลงที่ AI อ่านก่อนเริ่มงาน</p>



<h2 class="wp-block-heading">Working Agreement ไม่ใช่ prompt ยาวๆ แต่คือ guardrail</h2>



<p class="wp-block-paragraph">จุดที่ต้องระวังคืออย่าเขียน instruction ยาวจนกลายเป็น manual ที่ไม่มีใครอ่าน ทั้งคนและ AI ควรเขียนให้สั้น ชัด และ actionable</p>



<ul class="wp-block-list"><li>เขียนเป็น bullet</li><li>แยกหมวดชัดเจน</li><li>ระบุ command ที่ต้องใช้จริง</li><li>แยกสิ่งที่ทำได้เอง กับสิ่งที่ต้องขอ approve</li><li>มี verification rule ทุกงาน</li></ul>



<p class="wp-block-paragraph">ผมชอบคิดว่ามันคือ guardrail ไม่ใช่ prompt สวยๆ หน้าที่ของมันคือกันไม่ให้ AI หลุดออกจากวิธีทำงานที่ทีมตกลงกันไว้</p>



<h2 class="wp-block-heading">แยกกติกาเป็น 3 ระดับ</h2>



<p class="wp-block-paragraph">ถ้าใช้จริงในทีม ผมแนะนำให้แยก rule เป็น 3 ระดับ จะดูแลง่ายกว่าเขียนทุกอย่างกองไว้ที่เดียว</p>



<figure class="wp-block-table"><table><thead><tr><th>ระดับ</th><th>ตัวอย่าง</th><th>ควรอยู่ที่ไหน</th></tr></thead><tbody><tr><td>Team rule</td><td>ห้าม merge เอง, ต้องขอ approve ก่อน push</td><td>global/team instruction</td></tr><tr><td>Project rule</td><td>วิธีรัน test, build, lint, naming convention</td><td>CLAUDE.md / AGENTS.md ใน repo</td></tr><tr><td>Task rule</td><td>งานนี้แก้เฉพาะ payment flow ห้ามแตะ auth</td><td>prompt หรือ issue ของงานนั้น</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">การแยกแบบนี้ช่วยให้ rule ที่ถาวรไม่ปนกับรายละเอียดงานชั่วคราว และช่วยลดโอกาสที่ AI จะเอา instruction เฉพาะ task ไปใช้ผิดบริบทในงานอื่น</p>



<h2 class="wp-block-heading">ตัวอย่าง rule ที่ผมว่าน่าใส่แทบทุก repo</h2>



<p class="wp-block-paragraph">ถ้าจะเริ่มแบบ practical ผมว่าสามารถ copy แนวนี้ไปปรับได้เลยครับ</p>



<ul class="wp-block-list"><li><strong>ต้อง search ก่อนอ่านไฟล์เยอะๆ</strong> เพื่อประหยัด token และลด noise</li><li><strong>ต้องอ่านไฟล์ที่เกี่ยวข้องจริงก่อน patch</strong> ห้ามเดา code จากชื่อไฟล์อย่างเดียว</li><li><strong>ต้องเสนอ plan ก่อนงานใหญ่</strong> โดยเฉพาะงานที่แตะหลาย module</li><li><strong>ต้องทำ minimal diff</strong> ถ้าไม่ได้สั่ง refactor ใหญ่</li><li><strong>ต้องรัน test ก่อนบอกว่าเสร็จ</strong> และรายงาน output จริง</li><li><strong>ห้าม push/merge/delete/migrate โดยไม่ขอ approve</strong></li><li><strong>ถ้า command fail ต้องรายงานตรงๆ</strong> ห้ามบอกว่าสำเร็จจากการเดา</li><li><strong>ถ้าเจอ requirement ใหม่ ให้บันทึกเป็น issue/task</strong> ไม่ปล่อยหายใน chat</li></ul>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>AI ที่เก่งแต่ไม่มี working agreement จะทำงานเร็ว แต่ทีมอาจต้องเสียเวลาตามเก็บทีหลัง</p></blockquote>



<h2 class="wp-block-heading">ควรทบทวนกติกานี้เมื่อไร</h2>



<p class="wp-block-paragraph">Working Agreement ไม่ควรเขียนครั้งเดียวแล้วจบครับ เพราะวิธีทำงานของทีมเปลี่ยนได้ตลอด เครื่องมือ AI ก็เปลี่ยนเร็วมากเหมือนกัน</p>



<p class="wp-block-paragraph">ผมคิดว่าน่าทบทวนเมื่อมีเหตุการณ์พวกนี้</p>



<ul class="wp-block-list"><li>AI หลุด rule เดิมซ้ำๆ</li><li>ทีมเริ่มใช้ AI agent หลายตัวพร้อมกัน</li><li>มี incident จากการแก้ code โดยไม่ได้ verify</li><li>เปลี่ยน test command หรือ build pipeline</li><li>มีคนใหม่เข้าทีมแล้วใช้ AI ไม่เหมือนคนอื่น</li><li>เริ่มใช้เครื่องมือใหม่ เช่น Claude Code, Codex, Cursor หรือ Gemini CLI</li></ul>



<p class="wp-block-paragraph">พูดง่ายๆ คือถ้าเป็นบทเรียนที่ไม่อยากให้เกิดซ้ำ ให้ย้ายมันเข้า Working Agreement ครับ</p>



<h2 class="wp-block-heading">ข้อควรระวัง: อย่าเชื่อว่าเขียน rule แล้ว AI จะไม่พลาดอีกเลย</h2>



<p class="wp-block-paragraph">การมี Working Agreement ช่วยได้มาก แต่ไม่ได้ทำให้ AI กลายเป็นระบบ deterministic 100% ครับ เรายังต้องมี verification, test, review และ approval gate อยู่ดี</p>



<p class="wp-block-paragraph">โดยเฉพาะ rule ที่มีผลกับ production หรือ source control เช่น merge, push, deploy, migration, delete data อันนี้ไม่ควรปล่อยให้ AI ตัดสินใจเองจาก prompt อย่างเดียว ต้องมี human approval หรือ branch protection ช่วยล็อกอีกชั้น</p>



<p class="wp-block-paragraph">ผมมองว่า Working Agreement เป็นชั้นแรกที่ช่วยให้ AI ทำถูกทางมากขึ้น ส่วน test, CI, review และ approval เป็นชั้นถัดมาที่ช่วยจับความผิดพลาดก่อนกระทบของจริง</p>



<h2 class="wp-block-heading">สรุป</h2>



<p class="wp-block-paragraph">หลังจากใช้ AI มาพักใหญ่ ผมเริ่มรู้สึกว่าเราไม่ควรมอง AI เป็นแค่ chatbot ที่สั่งทีละรอบ แต่ควรมองเป็นผู้ช่วยทำงานที่ต้องมี working agreement เหมือนสมาชิกทีมคนหนึ่ง</p>



<p class="wp-block-paragraph">ถ้ามีเรื่องที่เราต้องสั่งซ้ำๆ เช่น test ก่อน push, create issue หลังตกลง plan, ห้าม merge dev เอง หรือรายงานผล verify ทุกครั้ง ก็ไม่ควรปล่อยให้มันอยู่ในความทรงจำชั่วคราวของ session ครับ เขียนมันลง project instruction ไปเลย</p>



<p class="wp-block-paragraph">เริ่มจากเล็กๆ ก็พอ เช่นใช้ <code>/init</code> ใน Claude Code เพื่อสร้าง <code>CLAUDE.md</code> แล้วเติมกติกาของทีมลงไป หรือถ้าใช้ Codex ก็ทำ <code>AGENTS.md</code> ใน repo ให้ชัด แค่นี้ก็ช่วยลดการหลุด ลดการสั่งซ้ำ และทำให้ AI ทำงานเข้ากับทีมได้ดีขึ้นมากแล้วครับ</p>



<h2 class="wp-block-heading">แหล่งอ้างอิง</h2>



<ul class="wp-block-list"><li><a href="https://code.claude.com/docs/en/memory" target="_blank" rel="noreferrer noopener">Claude Code Docs: How Claude remembers your project</a></li><li><a href="https://developers.openai.com/codex/guides/agents-md" target="_blank" rel="noreferrer noopener">OpenAI Codex: Custom instructions with AGENTS.md</a></li><li><a href="https://agents.md/" target="_blank" rel="noreferrer noopener">AGENTS.md: open format for coding agent instructions</a></li><li><a href="https://www.augmentcode.com/guides/ai-agent-pre-merge-verification" target="_blank" rel="noreferrer noopener">Augment Code: AI Agent Pre-Merge Verification</a></li></ul>

]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7871/working-agreement-with-ai/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>MaTamNud: ระบบนัดหมายช่วยโหวตหาวันว่างตรงกันของกลุ่มเพื่อน</title>
		<link>https://myifew.com/7865/matamnud-group-scheduling-poll-review/</link>
					<comments>https://myifew.com/7865/matamnud-group-scheduling-poll-review/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Fri, 24 Jul 2026 07:26:31 +0000</pubDate>
				<category><![CDATA[Lifestyle]]></category>
		<category><![CDATA[Review]]></category>
		<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI Coding]]></category>
		<category><![CDATA[matamnud]]></category>
		<category><![CDATA[Vibe Coding]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7865</guid>

					<description><![CDATA[แนะนำ MaTamNud ระบบนัดหมายออนไลน์สำหรับสร้างนัด แชร์ลิงก์ ให้เพื่อนโหวตวันหรือช่วงเวลาที่ว่างตรงกัน เหมาะกับนัดกิน นัดเที่ยว จัดทริป และกิจกรรมกลุ่ม]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ผมมีปัญหาหนึ่งที่เจอบ่อยมาก เวลาเพื่อนๆ ในกลุ่มจะนัดกินข้าว นัดเที่ยว นัดดื่ม หรือจัดทริปกัน คือก่อนจะได้วันนัดจริง ต้องตบตีกันในแชตนานอยู่ ฮ่าๆ</p>



<p class="wp-block-paragraph">คนนี้ว่างเสาร์ อีกคนว่างอาทิตย์ คนนั้นว่างแค่ช่วงเย็น แฟนอีกคนอ่านแล้วลืมตอบ สุดท้ายต้องมีใครสักคนรับบทเป็นเลขากลุ่ม ไล่ถาม ไถอ่าน คอยสรุป แล้วก็วนกลับมาถามซ้ำอีกทีว่า “ตกลงเอาวันไหนดี!” ฮ่าๆ</p>



<p class="wp-block-paragraph">ผมเลยทำเว็บเล็กๆ ชื่อ <strong>มาตามนัด (MaTamNud)</strong> ไว้ช่วยแก้ปัญหานี้แหละ (ใครอยู่ Gen Y คงคุ้นชื่อนี้ ฮ่าๆ) ไอเดียตรงไปตรงมาครับ แทนที่จะไล่ถามทีละคน ก็สร้างนัด แชร์ลิงก์ แล้วให้ทุกคนโหวตวันหรือช่วงเวลาที่ตัวเองว่าง จากนั้นค่อยดูพร้อมกันว่าวันไหนเวลาตรงกันที่สุด ไม่ต้องถาม ไม่ต้องย้อนแชตรวบรวมเพื่อมาสรุป ใครไม่ตอบ ก็ไม่มีชื่ออยู่ในนั้นแหละ ประจานกันไปเงียบๆ </p>



<p class="wp-block-paragraph">หากอยากลองเล่นเลย กดที่นี่ 👉 <a href="https://tamnud.com/" target="_blank" rel="noreferrer noopener"><strong>https://tamnud.com/</strong></a></p>



<ul class="wp-block-list">
<li>ใช้ฟรี (ขี้เกียจทำระบบเก็บตัง)</li>



<li>สร้างนัดแล้วแชร์ลิงก์ได้เลย</li>



<li>ใช้โหวตเป็นช่วงวันว่าง หรือโหวตเป็นเวลาก็ได้</li>



<li>เหมาะกับนัดกิน นัดเที่ยว ปาร์ตี้ สังสรรค์ จัดทริป หรือกิจกรรมกลุ่ม</li>



<li>ไม่เก็บข้อมูลใดๆ ใน Server ทั้งสิ้น (มีเก็บ profile ในอุปกรณ์ของผู้ใช้เท่านั้น เพื่อยืนยันว่าเป็นคนดีคนเดิม คนโหวตหรือคนสร้างนัด)</li>
</ul>



<p class="wp-block-paragraph">อ่ะ ใครอยากรู้รายละเอียดเพิ่มเติม ก็ไปอ่านกันต่อ&#8230;</p>



<span id="more-7865"></span>



<h2 class="wp-block-heading">เลือกได้ทั้งนัดเป็นวัน และนัดเป็นเวลา</h2>



<p class="wp-block-paragraph">จุดที่ผมอยากให้มีตั้งแต่แรกคือ ระบบไม่ควรจำกัดแค่การโหวต “วัน” อย่างเดียว เพราะในชีวิตจริง หลายครั้งวันเดียวกันแต่ว่างคนละช่วงเวลาก็มี</p>



<p class="wp-block-paragraph">MaTamNud เลยมีประเภทนัดให้เลือก 2 แบบ</p>



<ul class="wp-block-list">
<li><strong>นัดเป็นวัน</strong> เหมาะกับการเลือกวันแบบกว้างๆ เช่น เสาร์นี้ อาทิตย์หน้า หรือวันหยุดยาว</li>



<li><strong>นัดเป็นเวลา</strong> เหมาะกับนัดที่ต้องรู้ช่วงเวลาชัด เช่น 18:00, 19:30 หรือหลายช่วงเวลาในวันเดียวกัน</li>
</ul>



<p class="wp-block-paragraph">ในหน้า create นัด จะมีปฏิทินให้เลือกวัน และถ้าเลือกนัดเป็นเวลา ก็จะมีช่องเลือกเวลาเป็นชั่วโมงและนาที พร้อมปุ่มเพิ่มเวลาได้ ผมว่าอันนี้สำคัญ เพราะหลายงานไม่ได้ต้องการแค่ “วันไหนว่าง” แต่ต้องการรู้ว่า “ช่วงไหนที่ทุกคนชนกันน้อยที่สุด”</p>



<h2 class="wp-block-heading">วิธีใช้งานแบบเร็วๆ</h2>



<ol class="wp-block-list">
<li>เข้าเว็บ <a href="https://tamnud.com/" target="_blank" rel="noreferrer noopener">tamnud.com</a></li>



<li>กด <strong>สร้างนัดหมาย</strong></li>



<li>เลือกประเภทนัดว่าจะเป็นวันหรือเป็นเวลา</li>



<li>ใส่ชื่อนัด เช่น “กินข้าววันเกิด”, “ทริปเขาใหญ่”, “ดริ๊งที่อารีย์”</li>



<li>เลือกวันหรือช่วงเวลาที่อยากเสนอ</li>



<li>ตั้งค่าที่จำเป็น เช่น จำกัดจำนวนคน, ให้เพื่อนเสนอเวลาเองได้, กำหนดปิดโหวต หรือ timezone</li>



<li>แชร์ลิงก์หรือรหัสนัดหมายให้เพื่อน</li>



<li>ทุกคนเข้ามาโหวต แล้วผู้สร้างนัดค่อยเคาะวันที่ว่างตรงกันมากที่สุด</li>
</ol>



<h2 class="wp-block-heading">ฟีเจอร์เล็กๆ ที่ทำให้ใช้กับชีวิตจริงได้</h2>



<p class="wp-block-paragraph">จากที่ลองดูหน้าเว็บและ flow การสร้างนัด มีรายละเอียดบางอย่างที่ผมคิดว่าเหมาะกับการใช้งานจริงมาก</p>



<figure class="wp-block-table"><table><thead><tr><th>ฟีเจอร์</th><th>ใช้ทำอะไร</th><th>ทำไมถึงมีประโยชน์</th></tr></thead><tbody><tr><td>นัดเป็นวัน</td><td>ให้เพื่อนโหวตวันที่ว่าง</td><td>เหมาะกับนัดเที่ยว นัดกินข้าว ทริปสั้นๆ</td></tr><tr><td>นัดเป็นเวลา</td><td>ให้เลือกวันพร้อมเวลา</td><td>เหมาะกับนัดที่ต้องหาช่วงเวลาว่างตรงกัน</td></tr><tr><td>จำกัดจำนวนคน</td><td>กำหนดจำนวนผู้ร่วมได้</td><td>เหมาะกับโต๊ะอาหาร ห้องประชุม หรือกิจกรรมที่รับคนจำกัด</td></tr><tr><td>ให้เพื่อนเสนอเวลาเองได้</td><td>เปิดให้คนอื่นเพิ่มตัวเลือก</td><td>ไม่ต้องให้เจ้าของนัดคิดทุก slot เอง</td></tr><tr><td>กำหนดปิดโหวต</td><td>ตั้ง deadline การเลือกวัน</td><td>ช่วยกันไม่ให้นัดลากยาวจนลืม</td></tr><tr><td>Timezone</td><td>เลือกโซนเวลา เช่น Asia/Bangkok</td><td>ใช้ได้กับกลุ่มที่อาจอยู่คนละประเทศหรือคนละ timezone</td></tr><tr><td>หลายภาษา</td><td>หน้าเว็บมีตัวเลือกภาษาไทย อังกฤษ จีน เวียดนาม</td><td>เหมาะกับกลุ่มเพื่อนหรือทีมที่มีหลายภาษา</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">เหมาะกับใครบ้าง</h2>



<p class="wp-block-paragraph">ผมว่า MaTamNud เหมาะกับกลุ่มที่มีปัญหาแบบนี้ครับ</p>



<ul class="wp-block-list">
<li><strong>กลุ่มเพื่อนที่นัดกินข้าวบ่อย</strong> ไม่ต้องไล่ถามทีละคนว่าวันไหนว่าง</li>



<li><strong>แก๊งเที่ยวหรือเดินทาง</strong> เลือกวันจัดทริปได้ง่ายขึ้น</li>



<li><strong>กลุ่มปาร์ตี้หรือสังสรรค์</strong> เห็นวันว่างร่วมกันก่อนจองร้าน</li>



<li><strong>ทีมงานเล็กๆ</strong> ใช้หาช่วงประชุมแบบไม่ต้องเปิด calendar ซับซ้อน</li>



<li><strong>ครอบครัวหรือญาติๆ</strong> เวลานัดกินข้าว นัดรวมตัว หรือไปทำธุระด้วยกัน</li>
</ul>



<p class="wp-block-paragraph">โดยเฉพาะกลุ่มที่ไม่ได้อยู่ในระบบ calendar เดียวกัน เช่น เพื่อนคนละบริษัท ญาติคนละบ้าน หรือกลุ่มทริปที่มีคนใช้คนละ platform แบบนี้การส่งลิงก์โหวตง่ายๆ มัก practical กว่ามาก</p>



<h2 class="wp-block-heading">ต่างจากการถามในแชตยังไง</h2>



<p class="wp-block-paragraph">ถ้าถามในแชต ข้อมูลจะเป็นข้อความเรียงตามเวลา คนตอบก่อนอาจโดนข้อความใหม่กลบ คนตอบทีหลังอาจไม่ได้อ่านของคนก่อน และคนสรุปต้องเป็นคนเชื่อมทุกอย่างเอง</p>



<p class="wp-block-paragraph">แต่ถ้าใช้ระบบโหวต ทุกคนตอบลงที่เดียวกัน ตัวเลือกอยู่ในรูปแบบเดียวกัน และผลลัพธ์รวมอยู่หน้าเดียว พูดง่ายๆ คือเปลี่ยนจาก “บทสนทนา” ให้กลายเป็น “ข้อมูลที่ตัดสินใจร่วมกันได้”</p>



<figure class="wp-block-table"><table><thead><tr><th>วิธีเดิมในแชต</th><th>ใช้ MaTamNud</th></tr></thead><tbody><tr><td>ต้องไล่อ่านข้อความย้อนกลับ</td><td>ดูผลโหวตจากหน้าเดียว</td></tr><tr><td>มีคนต้องจดเอง</td><td>ระบบเก็บคำตอบไว้ให้</td></tr><tr><td>คำตอบกระจัดกระจาย</td><td>ทุกคนตอบในรูปแบบเดียวกัน</td></tr><tr><td>ลืมง่าย</td><td>แชร์ลิงก์กลับมาดูซ้ำได้</td></tr><tr><td>ยิ่งคนเยอะยิ่งวุ่น</td><td>ยิ่งคนเยอะยิ่งเห็นประโยชน์ของการรวมผล</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">สุดท้าย ในฐานะคนทำ</h2>



<p class="wp-block-paragraph">เหมือนตอนที่ผมทำ <a href="https://kaiten.myifew.com/" target="_blank" rel="noreferrer noopener">Kaiten Share Calculator</a> เพื่อแก้ปัญหาแยกบิลซูชิสายพาน ตัวระบบไม่ได้ซับซ้อนมาก แต่ตอบโจทย์สถานการณ์ที่เจอบ่อยจริงๆ และสะท้อนออกมาจากเพื่อนๆใน Internet เข้ามามากกว่าวันละ 500 page views</p>



<p class="wp-block-paragraph">MaTamNud ก็คล้ายกันครับ ผมไม่พยายามให้มันเป็น calendar หรือระบบ event ใหญ่โต อยากทำเล็กๆ ง่ายๆ แก้ปัญหาเฉพาะจุด คือ “ช่วยให้กลุ่มเห็นวันว่างร่วมกันเร็วขึ้น” ช่วยลดเวลาคุยวนๆ เรื่องวันนัด ซึ่งเป็นปัญหาที่หลายคนเจอแต่ปล่อยให้กลายเป็นความวุ่นวายประจำกลุ่ม</p>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7865/matamnud-group-scheduling-poll-review/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Open Knowledge Format ฟอร์แมตกลางของ Knowledge/Dataset สำหรับ AI จาก Google Cloud</title>
		<link>https://myifew.com/7843/open-knowledge-format-okf-llm-wiki/</link>
					<comments>https://myifew.com/7843/open-knowledge-format-okf-llm-wiki/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Tue, 21 Jul 2026 17:29:47 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI Agent]]></category>
		<category><![CDATA[Data Analytics]]></category>
		<category><![CDATA[Google Cloud]]></category>
		<category><![CDATA[LLM Wiki]]></category>
		<category><![CDATA[OKF]]></category>
		<category><![CDATA[Open Knowledge Format]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7843</guid>

					<description><![CDATA[Open Knowledge Format (OKF) คือความพยายามของ Google Cloud ในการทำให้ LLM Wiki และคลังความรู้แบบ markdown กลายเป็น format กลางที่ AI agent และมนุษย์ใช้ร่วมกันได้]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ช่วงนี้ผมสนใจเรื่อง knowledge base สำหรับ AI agent มากขึ้น อาจจะต้องใช้ในเรื่องส่วนตัว และใช้เอาไปทำงานด้วย โดยเฉพาะปัญหาที่เอามาคิดว่า ถ้าองค์กรมีข้อมูล business condition, schema, document, changelog และเอกสารกระจัดกระจายอยู่เต็มไปหมด เราจะทำให้ AI เข้าใจ context เหล่านี้ได้อย่างไร</p>



<p class="wp-block-paragraph">หนึ่งในแนวคิดที่น่าสนใจคือ <strong>Open Knowledge Format</strong> หรือ OKF จาก Google Cloud ที่เพิ่งเผยแพร่เป็นบทความเมื่อ 13 มิ.ย. ที่ผ่านมานี่เองครับ ซึ่งผมมองว่าแก่นของมันไม่ใช่การสร้าง LLM Wiki ตัวใหม่ แบบของ Karpathy แต่คือการเสนอ <strong>ฟอร์แมตกลางสำหรับชุด </strong><strong> knowledge/context ให้ AI, agent, data catalog และเครื่องมืออื่นๆ อ่านร่วมกันได้</strong></p>



<span id="more-7843"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้ฟิวส์กับเอเจ้นชมพูช่วยกันเรียบเรียงจากเรื่อง <a href="https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing">Introducing the Open Knowledge Format</a> ของ Google Cloud Blog ที่เล่าถึงหลักการและมุมมองการนำ OKF ไปใช้กับงาน AI / knowledge base</em></p>



<h2 class="wp-block-heading">สรุปสั้นๆ ก่อน: OKF คืออะไร</h2>



<p class="wp-block-paragraph">OKF หรือ <strong>Open Knowledge Format</strong> คือ รูปแบบ specification ที่ Google Cloud เสนอให้ใช้จัดเก็บ “knowledge” ให้อยู่ในรูปที่ทั้งคนและ AI อ่านได้ง่าย โดยใช้หลักการง่ายๆ และวิธีง่ายๆ  คือ:</p>



<ul class="wp-block-list">
<li>เก็บข้อมูลความรู้เป็น Markdown file</li>



<li>กำหนดรูปแบบด้วย YAML frontmatter</li>



<li>จัดการโครงสร้าง Directory structure</li>



<li>จัดทำ Markdown links หาเรื่องที่เกี่ยวข้อง</li>



<li>และมีไฟล์เสริมอย่าง <code>index.md</code> และ <code>log.md เพื่อบันทึกการทำงาน</code></li>
</ul>



<p class="wp-block-paragraph">ถ้าอธิบายแบบบ้านๆ OKF คือการบอกว่า “ถ้าเราจะส่ง knowledge ก้อนหนึ่งให้ AI หรือระบบอื่นเอาไปอ่านต่อ เราควรแพ็กมันเป็นไฟล์แบบไหนดี”</p>



<p class="wp-block-paragraph">และคำตอบของ Google คือ ไม่ต้องสร้างฐานข้อมูลใหม่ ไม่ต้องมี SDK เฉพาะ ไม่ต้องบีบอัดเป็น format แปลกๆ แต่ให้ใช้ markdown + YAML + link + folder แบบที่คนอ่านก็ได้ เครื่องอ่านก็ดี</p>



<p class="wp-block-paragraph">ถ้าสังเกตให้ดี  LLM Wiki ของ Karpathy ก็ใช้หลักการแบบนี้เช่นกัน แต่แค่มันไม่เคยมีใคร (แม้แต่ Andrej Karpathy) ออกมาบอกว่ามันเป็นสิ่งที่ดีหรือควรเป็นมาตรฐานนะ และคราวนี้ Google เลยออกมาบอกแทน ว่า เออ ทำแบบนี้ก็ดีแล้ว ง่ายๆ ได้ใจความ และขอเสนอเพิ่มเติมนิดหน่อยเพื่อให้มันดีขึ้น ประมาณนั้นครับ</p>



<h2 class="wp-block-heading">จุดที่ต้องแยกให้ชัด: OKF กับ LLM Wiki ไม่ใช่สิ่งเดียวกัน</h2>



<p class="wp-block-paragraph">เพื่อความกระจ่างขึ้น ขอชี้แจงเพิ่มเติมอีกนิดว่า OKF กับ LLM Wiki มีหน้าตาคล้ายกันมาก เพราะทั้งคู่ใช้ markdown, มี link, มี index, มี log และให้ AI อ่านความรู้ที่คนหรือ agent รวบรวมไว้ แต่บทบาทของสองอย่างนี้ไม่เหมือนกัน</p>



<p class="wp-block-paragraph">แต่พอคิดดีๆ แล้วมันคนละระดับกัน</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph"><strong>LLM Wiki คือ แนวทางหรือระบบการสะสมความรู้ระยะยาว</strong><br><strong>OKF คือ ฟอร์แมตกลางสำหรับแลกเปลี่ยน knowledge/context บางชนิด</strong></p>
</blockquote>



<p class="wp-block-paragraph">พูดอีกแบบคือ LLM Wiki เป็นเหมือน “คลังความรู้ที่ AI ช่วยดูแล” ส่วน OKF เป็นเหมือน “กล่องมาตรฐานสำหรับแพ็กความรู้บางส่วนให้ส่งต่อได้” และเอาจริงๆ ส่วนตัวผมคิดว่า Google เน้นให้ใช้ในเชิงการเก็บชุดข้อมูล (dateset) และความสัมพันธ์ด้วยซ้ำ เดี๋ยวลองดูจากตัวอย่างด้านล่างได้</p>



<p class="wp-block-paragraph">ดังนั้น OKF ไม่ได้เกิดมาเพื่อแทน Notion, Obsidian, Wiki หรือ LLM Wiki ทั้งระบบ แต่มันเกิดมาเพื่อแก้ปัญหาว่า dateset หรือ knowledge ที่กระจัดกระจายอยู่ตาม data catalog, schema, runbook, doc, wiki, notebook หรือในหัว senior engineer จะถูกแพ็กให้อยู่ในรูปที่ AI ใช้ได้อย่างไร</p>



<h2 class="wp-block-heading">ที่มาของ OKF: ปัญหาไม่ใช่ model ไม่เก่ง แต่ context กระจัดกระจาย</h2>



<p class="wp-block-paragraph">ในบทความ Google Cloud เขาเปิดด้วยประเด็นที่ผมเห็นด้วยมาก คือ foundation model เก่งขึ้นเรื่อยๆ แต่พอใช้งานจริง โดยเฉพาะงานแบบ agentic system ปัญหามักไม่ใช่ model ทำไม่ได้ แต่เป็น model ไม่มี context ที่ถูกต้องพอ</p>



<p class="wp-block-paragraph">ตัวอย่างเช่น ถ้า AI agent ต้องตอบคำถามว่า “จะคำนวณ weekly active users จาก event stream ยังไง” มันไม่ได้ต้องการแค่ SQL syntax แต่มันต้องรู้หลายอย่างพร้อมกัน:</p>



<ul class="wp-block-list">
<li>table ไหนเก็บ event</li>



<li>field ไหนคือ user id จริง</li>



<li>business definition ของ active user คืออะไร</li>



<li>join กับ table ไหนได้บ้าง</li>



<li>metric นี้เคยเปลี่ยนนิยามหรือไม่</li>



<li>มี runbook หรือ caveat อะไร</li>



<li>ข้อมูลนี้ deprecated หรือยัง</li>
</ul>



<p class="wp-block-paragraph">ข้อมูลพวกนี้ในองค์กรจริงมักกระจายอยู่หลายที่มาก บางส่วนอยู่ใน data catalog บางส่วนอยู่ใน wiki บางส่วนอยู่ใน code comment บางส่วนอยู่ใน dashboard บางส่วนอยู่ใน ticket และบางส่วนอยู่ในหัวคน</p>



<p class="wp-block-paragraph">OKF จึงพยายามเสนอ format กลางให้ knowledge เหล่านี้กลายเป็นก้อนที่ส่งต่อได้ อ่านได้ และเชื่อมโยงกันได้</p>



<h2 class="wp-block-heading">ภาพที่เข้าใจง่าย: producer กับ consumer</h2>



<p class="wp-block-paragraph">ภาพที่เข้าใจง่ายคือ OKF คล้ายกับ NotebookLM, Notion หรือ Obsidian ที่ช่วงหลังเริ่มเชื่อม AI เข้ามาอ่านและสรุปเนื้อหา</p>



<p class="wp-block-paragraph">ประเด็นสำคัญคือโลกเริ่มแยกเป็นสองฝั่ง:</p>



<ul class="wp-block-list">
<li><strong>Producer</strong> คือ คนหรือระบบที่สร้างและเก็บ knowledge</li>



<li><strong>Consumer</strong> คือ AI, agent, app หรือเครื่องมือที่อ่าน knowledge นั้นไปใช้งานต่อ</li>
</ul>



<p class="wp-block-paragraph">ปัญหาคือแต่ละแอพมีวิธีเก็บของตัวเอง พอจะย้ายข้ามแอพหรือให้ agent คนละตัวอ่านร่วมกัน ก็ต้องแปลงไปแปลงมา ดังนั้น OKF จึงเข้ามาเสนอว่าอย่างน้อยเราควรมีฟอร์แมตไฟล์กลางที่ทุกฝ่ายเข้าใจร่วมกันได้</p>



<h2 class="wp-block-heading">OKF หน้าตาเป็นอย่างไร</h2>



<p class="wp-block-paragraph">Google บอกว่า OKF v0.1 แทน knowledge เป็น directory ของ markdown files ที่มี YAML frontmatter กำกับรูปแบบการเก็บ และข้อมูลแต่ละไฟล์คือ concept document หนึ่งเรื่อง</p>



<p class="wp-block-paragraph">ตัวอย่างแบบง่ายๆ อาจเป็นแบบนี้:</p>



<pre class="wp-block-code"><code>knowledge-bundle/
├── index.md
├── log.md
├── datasets/
│   └── ecommerce.md
├── tables/
│   ├── orders.md
│   └── customers.md
└── metrics/
    └── weekly-active-users.md</code></pre>



<p class="wp-block-paragraph">และในไฟล์หนึ่งอาจมี frontmatter ประมาณนี้:</p>



<pre class="wp-block-code"><code>---
type: table
title: orders
description: Orders table for ecommerce transactions
resource: bigquery://project.dataset.orders
tags: &#91;ecommerce, transaction, order]
timestamp: 2026-06-13
---

# orders

ตารางนี้เก็บ order transaction ของลูกค้า

## Important fields

| Field | Meaning |
|---|---|
| order_id | unique order identifier |
| customer_id | reference to customers |
| status | order lifecycle status |

## Relationships

- Join with &#91;customers](../tables/customers.md) by `customer_id`
- Used by &#91;weekly-active-users](../metrics/weekly-active-users.md)</code></pre>



<p class="wp-block-paragraph">สิ่งที่น่าสนใจคือ OKF ไม่ได้บังคับ schema ลึกมาก เขาบังคับพื้นฐานน้อยมาก โดย Google บอกว่าทุก concept ต้องมีอย่างน้อย <code>type</code> ส่วน field อื่นๆ เช่น <code>title</code>, <code>description</code>, <code>resource</code>, <code>tags</code>, <code>timestamp</code> เป็นส่วนที่ช่วยให้ query และ consume ได้ง่ายขึ้น</p>



<p class="wp-block-paragraph">จากตัวอย่าง ถ้าใครเป็นโปรแกรมเมอร์และทำเรื่อง database มาก่อน จะพอมองภาพออกได้ไม่ยาก</p>



<h2 class="wp-block-heading">สามหลักการสำคัญของ OKF</h2>



<h3 class="wp-block-heading">1. Minimally opinionated</h3>



<p class="wp-block-paragraph">OKF ไม่ได้พยายามบอกว่าองค์กรต้องมี type อะไรบ้าง หรือแต่ละไฟล์ต้องมี section อะไรบ้าง มันบอกแค่ขอมูลขั้นต่ำที่ทำให้ระบบอื่นอ่านได้ นี่เป็นจุดสำคัญ เพราะถ้ากำหนดมาตรฐานเป๊ะจนเกินไป เราก็อาจจะใช้ยากมาก</p>



<h3 class="wp-block-heading">2. Producer กับ Consumer แยกจากกัน</h3>



<p class="wp-block-paragraph">ความรู้ก้อนหนึ่งอาจถูกเขียนโดยคน, export จาก metadata catalog, generate จาก LLM, หรือสรุปจากเอกสารเดิม ส่วนคนอ่านอาจเป็น AI agent, search index, visualizer หรือระบบ catalog คนละตัวกัน OKF ทำหน้าที่เป็น contract ระหว่างสองฝั่งนี้</p>



<h3 class="wp-block-heading">3. Format ไม่ใช่ platform</h3>



<p class="wp-block-paragraph">OKF ไม่ผูกกับ Google Cloud, database, model provider หรือ agent framework ใดๆ สิ่งนี้สำคัญมาก เพราะถ้าจะเป็นฟอร์แมตกลางจริง มันต้องอ่านเขียนได้โดยไม่ต้องมีบัญชีเฉพาะหรือ SDK เฉพาะ</p>



<h2 class="wp-block-heading">แล้ว OKF เกี่ยวอะไรกับ LLM Wiki</h2>



<p class="wp-block-paragraph">ผมคิดว่า OKF เกี่ยวกับ LLM Wiki ในฐานะ “หยิบ pattern บางอย่างมา formalize” ไม่ใช่ “เอา LLM Wiki ทั้งระบบมาทำเป็นมาตรฐาน”</p>



<p class="wp-block-paragraph">LLM Wiki ของ Karpathy เน้นแนวคิดว่าเราควรให้ LLM ช่วย build knowledge base แบบสะสมไปเรื่อยๆ จาก source ต่างๆ แล้วเชื่อมโยงเป็น wiki ที่ query ได้ ไม่ต้อง RAG จากศูนย์ทุกครั้ง ผมเคยเขียนเรื่องนี้ไว้ในบทความ <a href="https://myifew.com/7636/llm-wiki-karpathy/" target="_blank" rel="noreferrer noopener">LLM Wiki: คลังความรู้ส่วนตัว ตามแบบฉบับของ Karpathy</a></p>



<p class="wp-block-paragraph">ส่วน OKF เอารูปแบบที่คล้ายกัน เช่น markdown, frontmatter, link, directory, index, log มาใช้เป็นฟอร์แมตกลางสำหรับ knowledge bundle โดยเฉพาะสำหรับเรื่อง metadata, data catalog, dataset context และความรู้ที่ต้องส่งต่อข้าม tool หรือข้าม agent</p>



<figure class="wp-block-table"><table><thead><tr><th></th><th>LLM Wiki</th><th>OKF</th></tr></thead><tbody><tr><td>หลักการ</td><td>แนวทางทำ knowledge base ที่ LLM ช่วยดูแล</td><td>ฟอร์แมตกลางสำหรับแพ็ก knowledge/context</td></tr><tr><td>เป้าหมาย</td><td>สะสม, สรุป, cross-link และ query ความรู้ระยะยาว</td><td>ทำให้ knowledge ส่งต่อและ consume ข้ามระบบได้</td></tr><tr><td>ขอบเขต</td><td>กว้างมาก ใช้กับบทความ, paper, notes, project memory, research ได้</td><td>เหมาะมากกับ metadata, dataset, schema, metric, runbook, catalog</td></tr><tr><td>หน่วยหลัก</td><td>wiki page / concept page / source summary</td><td>concept document ใน bundle</td></tr><tr><td>schema</td><td>ขึ้นกับ repo หรือทีมที่ออกแบบ</td><td>มีข้อมูลพื้นฐานขั้นต่ำ เช่น type และ frontmatter</td></tr><tr><td>คนสร้างและคนใช้</td><td>มักอยู่ใน workflow เดียวกัน เช่น agent ช่วย maintain wiki</td><td>producer และ consumer แยกกันชัดเจนกว่า</td></tr><tr><td>การนำไปใช้</td><td>ทำ second brain, research wiki, project knowledge, internal KB</td><td>ทำ exchange format สำหรับ data catalog, enrichment pipeline, AI agent context</td></tr><tr><td>สรุปสั้น</td><td>ระบบความรู้</td><td>ฟอร์แมตแลกเปลี่ยนความรู้ หรือแลกเปลี่ยน dataset</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">OKF เหมาะกับ knowledge แบบไหน</h2>



<p class="wp-block-paragraph">จากที่อ่าน ผมว่า use case ที่ตรงที่สุดของ OKF คือ knowledge ที่มีลักษณะ “เป็น context ให้ AI ใช้ reasoning ต่อ” โดยเฉพาะ knowledge ที่มาเป็นชุด data เช่น</p>



<ul class="wp-block-list">
<li>dataset description</li>



<li>table schema</li>



<li>field meaning</li>



<li>business metric definition</li>



<li>join path</li>



<li>runbook</li>



<li>API deprecation note</li>



<li>data lineage</li>



<li>usage guide ของ table หรือ report</li>



<li>context สำหรับ agent ที่ต้องทำงานกับข้อมูล</li>
</ul>



<p class="wp-block-paragraph">ตัวอย่างที่ Google ปล่อยมาก็ไปทางนี้ชัดเจน เช่น enrichment agent ที่เดิน BigQuery dataset แล้วร่าง OKF concept document สำหรับ table และ view จากนั้นใช้ LLM อีกส่วน ไปหา documentation มา enrich ด้วย citation, schema และ join path</p>



<p class="wp-block-paragraph">เขายังมี static HTML visualizer ที่เปลี่ยน OKF bundle เป็น graph view ได้ในไฟล์เดียว และมี sample bundle เช่น <a href="https://developers.google.com/analytics/bigquery/web-ecommerce-demo-dataset" target="_blank" rel="noreferrer noopener">GA4 e-commerce</a>, <a href="https://console.cloud.google.com/bigquery?ws=!1m4!1m3!3m2!1sbigquery-public-data!2sstackoverflow" target="_blank" rel="noreferrer noopener">Stack Overflow</a>, และ <a href="https://cloud.google.com/blog/topics/public-datasets/bitcoin-in-bigquery-blockchain-analytics-on-public-data?e=48754805">Bitcoin public datasets</a></p>



<h2 class="wp-block-heading">ตัวอย่างการใช้ในองค์กร</h2>



<p class="wp-block-paragraph">สมมติองค์กรมี data warehouse และมี table ชื่อ <code>orders</code>, <code>customers</code>, <code>events</code> อยู่แล้ว ปัญหาคือคนรู้จริงว่า table ไหนใช้ทำอะไรอาจมีไม่กี่คน และนิยาม business metric อาจอยู่กระจัดกระจาย</p>



<p class="wp-block-paragraph">ถ้าใช้แนว OKF เราอาจ export หรือเขียน knowledge bundle แบบนี้:</p>



<pre class="wp-block-code"><code>company-data-context/
├── index.md
├── log.md
├── datasets/
│   └── ecommerce.md
├── tables/
│   ├── orders.md
│   ├── customers.md
│   └── events.md
├── metrics/
│   ├── gross-merchandise-value.md
│   └── weekly-active-users.md
└── runbooks/
    └── data-quality-incident.md</code></pre>



<p class="wp-block-paragraph">พอ agent ต้องเขียน SQL, ตรวจ data quality, อธิบาย dashboard หรือช่วย analyst หา join path มันก็ไม่ได้อ่านแค่ schema ดิบ แต่ได้อ่าน business context ที่ curated แล้วด้วย</p>



<p class="wp-block-paragraph">นี่คือจุดที่ผมคิดว่า OKF มีประโยชน์มาก เพราะมันไม่ได้พยายามเป็น app ใหม่ แต่มันเป็น format ที่อยู่ตรงกลางระหว่าง data source, documentation, catalog และ AI agent</p>



<h2 class="wp-block-heading">ถ้าจะเอา OKF มาใช้กับ LLM Wiki ควรทำยังไง</h2>



<p class="wp-block-paragraph">ความเห็นผมตอนนี้คือ ไม่ควรเอา OKF ไปครอบ LLM Wiki ทั้งหมด แต่ควรใช้ OKF เป็น subset หรือ format สำหรับ knowledge บางกลุ่ม</p>



<p class="wp-block-paragraph">ตัวอย่างเช่น LLM Wiki ส่วนตัวหรือของทีมอาจมีหลายเรื่องมาก:</p>



<ul class="wp-block-list">
<li>บทความที่อ่าน</li>



<li>paper summary</li>



<li>project notes</li>



<li>decision log</li>



<li>people/company/entity</li>



<li>research synthesis</li>



<li>requirement spec</li>



<li>API/database/UX knowledge</li>
</ul>



<p class="wp-block-paragraph">ส่วนที่ควรทำให้ OKF-compatible อาจเป็นเฉพาะส่วนที่ต้องแลกเปลี่ยนกับระบบอื่น เช่น:</p>



<ul class="wp-block-list">
<li>dataset catalog</li>



<li>API catalog</li>



<li>data dictionary</li>



<li>business metric glossary</li>



<li>requirement knowledge graph</li>



<li>runbook ที่ agent ต้องใช้ทำงาน</li>
</ul>



<p class="wp-block-paragraph">พูดง่ายๆ คือ LLM Wiki เป็นระบบใหญ่ ส่วน OKF เป็น format ที่ช่วยให้บางส่วนของระบบใหญ่ส่งต่อได้ง่ายขึ้น</p>



<h2 class="wp-block-heading">แล้ว Requirement Spec Center ใช้แนวนี้ได้ไหม</h2>



<p class="wp-block-paragraph">ผมว่าตรงนี้น่าสนใจมาก เพราะช่วงนี้ผมกำลังคิดเรื่อง requirement/spec center ที่ให้ AI ช่วย maintain ความรู้ของระบบ เช่น product, change, API, database, table, field, UX/UI, test case, approval และ release</p>



<p class="wp-block-paragraph">สำหรับงานแบบนี้ ผมไม่คิดว่า OKF คือคำตอบทั้งหมด แต่แนวคิด OKF เอามาใช้ได้เยอะมาก โดยเฉพาะการทำให้แต่ละ entity เป็น markdown file ที่มี frontmatter และ link ถึงกัน</p>



<p class="wp-block-paragraph">เช่น change หนึ่งอาจเชื่อมไปหา API, table, field, UX screen, test case และ approval record:</p>



<pre class="wp-block-code"><code>product-change-kb/
├── changes/
│   └── HOME-25Q3-FEA-01.md
├── apis/
│   └── API-HOME-POST-BOOKINGS.md
├── databases/
│   └── HOME/tables/bookings.md
├── ux-ui/
│   └── HOME/booking-form.md
└── tests/
    └── HOME-25Q3-FEA-01-test-case.md</code></pre>



<p class="wp-block-paragraph">สิ่งนี้ไม่ใช่ OKF ตาม Google ตรงๆ ทั้งหมด แต่มันใช้แนวเดียวกัน คือ knowledge เป็น file, มี metadata, มี link, มี graph และ AI อ่านความสัมพันธ์ได้</p>



<p class="wp-block-paragraph">และจากที่ผมเอา LLM Wiki มาดัดแปลงเพื่อลองทำ Requirement Spec Center ก็พบว่าคล้ายกับสิ่งที่ OKF กำหนดมาก แต่ก็ยังพบว่าต้องปรับอะไรอีกหลายอย่าง ถ้าจะใช้งานจริงๆ ซึ่ง OKF พอมาเสริมไอเดียได้</p>



<h2 class="wp-block-heading">ความเห็นส่วนตัวของผม</h2>



<p class="wp-block-paragraph">สิ่งที่ทำให้ OKF น่าสนใจไม่ใช่เพราะมันมีเทคนิคซับซ้อน แต่เพราะมันเรียบง่ายมากจนมีโอกาสถูกใช้จริง</p>



<p class="wp-block-paragraph">โลก AI ตอนนี้มีปัญหาใหญ่คือทุกคนพยายามสร้าง agent แต่ context ที่ agent ต้องใช้กลับกระจัดกระจายและไม่ portable เท่าไร ถ้าแต่ละองค์กรเริ่มมีวิธีแพ็ก context เป็น markdown bundle ที่มี metadata และ link ชัดเจน AI จะทำงานกับ knowledge ได้ดีขึ้นมาก</p>



<p class="wp-block-paragraph">แต่ผมก็ยังคิดว่า OKF v0.1 ยังเป็นจุดเริ่มต้นมากๆ ต้องดูต่อว่าจะมี tool, producer, consumer และ adoption จริงแค่ไหน โดยเฉพาะนอก Google Cloud</p>



<p class="wp-block-paragraph">สำหรับผม takeaway ที่สำคัญที่สุดคือ:</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph"><strong>OKF ไม่ได้มาแทน LLM Wiki แต่มาช่วยให้ knowledge บางส่วนของ LLM Wiki หรือ data catalog ถูกแลกเปลี่ยนและใช้งานโดย AI ได้ง่ายขึ้น</strong></p>
</blockquote>



<p class="wp-block-paragraph">ถ้าจะใช้จริง ผมจะเริ่มจาก use case ที่ชัดก่อน เช่น data dictionary, metric glossary, API catalog หรือ requirement traceability แล้วค่อยดูว่าควร เชื่อมโยงกันอย่างไร และนำไปปลั๊กกับ AI อย่างไรต่อ</p>



<h2 class="wp-block-heading">แหล่งอ้างอิง</h2>



<ul class="wp-block-list">
<li><a href="https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing" target="_blank" rel="noreferrer noopener">Google Cloud: How the Open Knowledge Format can improve data sharing</a></li>



<li><a href="https://www.blognone.com/node/150909" target="_blank" rel="noreferrer noopener">Blognone: กูเกิลเปิดตัว Open Knowledge Format (OKF)</a></li>



<li><a href="https://www.facebook.com/peesamac/posts/google-%E0%B9%80%E0%B8%9E%E0%B8%B4%E0%B9%88%E0%B8%87%E0%B8%9B%E0%B8%A5%E0%B9%88%E0%B8%AD%E0%B8%A2%E0%B8%A1%E0%B8%B2%E0%B8%95%E0%B8%A3%E0%B8%90%E0%B8%B2%E0%B8%99%E0%B9%83%E0%B8%AB%E0%B8%A1%E0%B9%88%E0%B8%97%E0%B8%B5%E0%B9%88%E0%B8%8A%E0%B8%B7%E0%B9%88%E0%B8%AD-open-knowledge-format-okf-%E0%B9%81%E0%B8%A5%E0%B9%89%E0%B8%A7%E0%B8%9E%E0%B8%AD%E0%B8%9C%E0%B8%A1%E0%B9%84%E0%B8%9B%E0%B8%AD%E0%B9%88%E0%B8%B2%E0%B8%99%E0%B8%88%E0%B8%A3%E0%B8%B4%E0%B8%87/122167457078655322/" target="_blank" rel="noreferrer noopener">โพสต์อธิบาย OKF จาก AI กับ Peesamac</a></li>



<li><a href="https://myifew.com/7636/llm-wiki-karpathy/" target="_blank" rel="noreferrer noopener">บทความเดิมของผมเรื่อง LLM Wiki ของ Andrej Karpathy</a></li>
</ul>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7843/open-knowledge-format-okf-llm-wiki/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>AI Spec Writing Checklist: เขียนสเปกให้ AI เดาถูกขึ้น</title>
		<link>https://myifew.com/7820/ai-spec-writing-checklist/</link>
					<comments>https://myifew.com/7820/ai-spec-writing-checklist/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Sat, 11 Jul 2026 18:44:35 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI]]></category>
		<category><![CDATA[AI Coding]]></category>
		<category><![CDATA[Requirements]]></category>
		<category><![CDATA[Software Engineering]]></category>
		<category><![CDATA[Spec-Driven Development]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7820</guid>

					<description><![CDATA[บันทึกจากบทความ How to write specs for AI ว่าทำไม spec ที่ดีช่วยให้ AI coding agent เดาผิดน้อยลง พร้อม checklist ก่อนส่งงานให้ AI ลงมือเขียนโค้ด]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">หลังๆ มานี้ผมใช้ skill พวก grill-me ในการ discovery ความต้องการตนเอง หรือเขียน reqruiement ตั้งต้นแล้วให้ grill-me มาถามเติมต่อ แต่ถึงกระนั้น ในตอนที่ผมเขียน requriement ตั้งต้นเอง ผมก็จะพยามเขียนให้ละเอียดที่สุดเท่าที่ตนเองจะทำได้ โดยเฉพาะ Features และ Business Condition ต่างๆ เพื่อให้ AI ไม่ต้องเดาใจความสำคัญของระบบที่ผมต้องการให้มันทำ และไม่ต้องหงุดหงิดความหลอน (hallucinate) ของมันด้วย</p>



<p class="wp-block-paragraph">ผมไปอ่านบทความของ <strong>Jaroslaw Wasowski</strong> เรื่อง <strong>How to write specs for AI</strong> แล้วรู้สึกว่าตรงกับสิ่งที่ผมทำอยู่ แต่ก็มีบางข้อน่าสนใจที่ผมต้องปรับเพิ่ม โดยเขาพูดตรงๆ ว่า หลายครั้งปัญหาไม่ได้อยู่ที่ model อย่างเดียว แต่อยู่ที่ spec ที่เราเขียนให้มันต่างหาก</p>



<p class="wp-block-paragraph">เพราะ AI ไม่ได้อ่านใจเราออก ดังนั้นถ้าเราเขียน requirement แบบคลุมเครือ มันก็ไม่ได้หยุดแล้วถามเหมือน senior developer ที่นั่งข้างๆ แต่มันจะเดาต่อจาก pattern ที่มันเคยเห็นมาใน training data แล้วบางทีเดาได้เนียนมาก เนียนจนสรุปออกมา หรือ code ดูเหมือนจะถูกต้อง แต่การใช้งานผิด (เป็นเหตุผลว่าผมต้องมี skill ให้มันตั้งคำถามผมไปเรื่อยๆ นอกจากช่วยคิดแล้ว ผมใช้เพื่อคอยเช็กความเข้าใจของมัน)</p>



<span id="more-7820"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้อ้างอิงจาก<em>ประสบการณ์</em>ฟิวส์กับเอเจ้นชมพู เพื่อเรียบเรียงและแปลจากต้นฉบับของ Jaroslaw Wasowski เรื่อง <a href="https://levelup.gitconnected.com/how-to-write-specs-for-ai-7-rules-and-a-checklist-for-better-code-a5af2b2c6205" target="_blank" rel="noopener">How to write specs for AI: 7 rules and a checklist for better code</a></em></p>



<h2 class="wp-block-heading">ปัญหาไม่ใช่แค่ AI เขียนโค้ดผิด แต่คือมันไม่รู้ว่าอะไรห้ามเดา</h2>



<p class="wp-block-paragraph">ตั้งแต่ปีก่อนที่ vibe code มาใหม่ๆ จนถึงปัจจุบัน เรามักใส่ความต้องการของเราว่าอยากได้อะไร แต่ไม่ได้ใส่ว่ามันห้ามทำอะไร </p>



<p class="wp-block-paragraph">ซึ่งประโยคที่ผมชอบที่สุดในบทความนี้คือ AI ไม่มีสถานะว่า “อันนี้ไม่แน่ใจ ขอถามเพิ่มก่อน” เวลา requirement ขาดอะไรไป มันจะไม่หยุด และมันจะเติมเอง</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">สิ่งที่ไม่อยู่ spec เราในตอนแรก แต่จู่ๆ มันก็โผล่มา เพราะ AI จะเอา pattern จาก training data มาเติมแทนเจตนาของเรา (ซึ่งอาจจะผิด)</p>
</blockquote>



<p class="wp-block-paragraph">นี่แหละครับที่น่ากลัว เพราะ code ที่ออกมาอาจ compile ผ่าน, test ผ่าน หน้าตาดูดี แต่จริงๆ มันกำลังทำระบบที่มีการใช้งานหรือ behavior คนละแบบกับที่เราต้องการ</p>



<p class="wp-block-paragraph">เหมือนเราจ้างช่างมาทำบ้าน แล้วบอกแค่ว่า “ทำครัวให้ดีๆ หน่อย” ถ้าช่างทำครัวสวยมาก แต่ไม่มีปลั๊ก ไม่มีที่วางเตา หรือเปิดประตูตู้แล้วชนผนัง ปัญหาไม่ได้อยู่ที่ช่างไม่ขยันอย่างเดียว แต่อยู่ที่แบบบ้านของเราก็ไม่ได้บอกอะไรเขาเลย (อยากได้ครัวฝรั่งเตาไฟฟ้า แต่เอไอตั้งเตาอั่งโล่มาให้เพราะสเปกบอกว่ามีเตา 555)</p>



<h2 class="wp-block-heading">Spec ที่ดีต้องปิด 5 เรื่อง ที่ AI ชอบเดาเอง</h2>



<p class="wp-block-paragraph">บทความนี้สรุป 5 เรื่องหลักๆ ซึ่งผมว่าตรงนี้เอาไปใช้กับ Jira ticket, GitHub/GitLab issue, Markdown spec หรือ prompt ตรงๆ ได้เลย</p>



<h3 class="wp-block-heading">1. Outcome ต้องชัดว่าอยากได้พฤติกรรมอะไร</h3>



<p class="wp-block-paragraph">เริ่มจากบอกผลลัพธ์ที่ต้องการ ไม่ใช่บอกให้มันไปเขียน code แบบกว้างๆ เช่น แทนที่จะบอกว่า “ทำ endpoint export users เป็น CSV” ให้บอกว่า &#8220;endpoint นี้ต้องคืน active users เป็นไฟล์ CSV ที่ download ได้&#8221; และต้องมีเงื่อนไขความสำเร็จอะไรบ้าง (ภาษาเทคนิคจะเรียกว่า Acceptance Criteria)</p>



<p class="wp-block-paragraph">จุดนี้ช่วยแยก what ออกจาก how ได้ดีมาก เพราะ AI จะได้ไม่รีบเลือก implementation pattern ที่มันคุ้น แต่เริ่มจาก behavior ที่เราต้องการก่อน</p>



<h3 class="wp-block-heading">2. Scope กับ non-goals ต้องเขียนคู่กัน</h3>



<p class="wp-block-paragraph">อันนี้ผมว่าเป็นจุดที่หลายคนพลาด รวมถึงผมเองก็เคยและก็ยังพลาดบ่อย เราชอบเขียนว่า change นี้ต้องทำอะไร แต่ไม่ค่อยเขียนว่า change นี้ไม่ต้องทำอะไร</p>



<p class="wp-block-paragraph">เช่น ถ้าให้ AI ทำ export users ก็ควรบอกไปเลยว่า export เฉพาะ active users เท่านั้น ไม่ export deleted accounts ไม่ export billing data และไม่แก้ database schema</p>



<p class="wp-block-paragraph">เพราะถ้าไม่บอก มันอาจ “ใจดี” เพิ่ม feature ให้เอง ซึ่งฟังดูดี แต่ทำให้ diff บวม และบางทีไปแตะของที่ไม่ควรแตะ</p>



<p class="wp-block-paragraph">จากประสบการณ์ผมเองที่สังเกต โมเดลฉลาดๆ อย่าง Claude Opus 4.8+ / ChatGPT 5.5+ มักจะบอกเลยว่า ผมจะทำสิ่งนี้ แต่ไม่ทำสิ่งนี้เพราะจะกระทบอะไรก็ว่าไป ซึ่งมันไม่เป็นกับบางโมเดลอื่นๆ ตรงนี้เราโดนพวก Frontier Model สปอยจนมองข้ามไป ฮ่าๆ</p>



<h3 class="wp-block-heading">3. Constraints คือรั้วกัน AI หลุดโลก</h3>



<p class="wp-block-paragraph">AI ไม่ได้รู้จัดโค้ดทั้ง repo ของเราจริงๆ ถ้าเราไม่ได้ให้ context มันแต่แรก, มันไม่รู้ว่าใช้ framework เวอร์ชันไหน มี convention อะไร library ไหนห้ามใช้ response format ต้องเป็นแบบไหน หรือ performance limit คือเท่าไร (แต่ก็ได้ยินบ่อยจากคนรอบข้าง (ระดับมหาราชา/มหาราชินี) คือให้ AI อ่านโค้ดทั้ง repo ก่อนเลย)</p>



<p class="wp-block-paragraph">ดังนั้น constraints ควรมีของพวกนี้:</p>



<ul class="wp-block-list">
<li>stack และ version ที่ใช้</li>



<li>repo convention ที่ต้องตาม</li>



<li>library ที่ใช้ได้หรือห้ามใช้</li>



<li>output format เช่น UTF-8, JSON shape, CSV delimiter</li>



<li>security หรือ performance limit</li>



<li>integration boundary เช่นห้ามแก้ schema หรือห้ามกระทบ API เดิม</li>
</ul>



<p class="wp-block-paragraph">คือถ้าไม่มีสิ่งเหล่านี้ เราจะตรวจสอบได้ยากมากว่า AI ทำอะไรไป เพราะไฟล์อาจจะเยอะมาก รวมถึงถ้าต้องแก้ บางเรื่องอาจต้องรื้อทั้งโครงสร้างเลย เสียเวลา เสียโทเค็นไปเปล่าๆ</p>



<h3 class="wp-block-heading">4. Acceptance criteria ต้องพิสูจน์ได้ ไม่ใช่แค่ฟังดูดี</h3>



<p class="wp-block-paragraph">คำว่า “ใช้งานได้ดี” หรือ “make it work nicely” เป็นประโยคที่น่ากลัวมากสำหรับ AI เพราะมันไม่มีทางรู้ว่า nicely ของเราคืออะไร ดังนั้นเราต้องบอกมันว่า เงื่อนไขการรับงาน (Acceptance criteria) ของเราคืออะไร</p>



<p class="wp-block-paragraph">ซึ่ง Acceptance criteria ที่ดีควรเป็นแบบตรวจสอบได้ เช่น:</p>



<ul class="wp-block-list">
<li>ถ้ามี active users 3 คน ต้องได้ CSV 3 data rows และ header 1 แถว</li>



<li>ถ้าไม่มี users ต้องได้ header อย่างเดียวและ status 200</li>



<li>ถ้า user ไม่มี admin role ต้องได้ 403 และไม่ส่ง CSV body</li>



<li>ถ้ามีข้อมูล 50,000 records ต้องใช้ streaming และ response ไม่เกินเวลาที่กำหนด</li>
</ul>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph">ถ้าไม่มีเกณฑ์ตรวจสอบได้ (ไม่ว่าจะมนุษย์ไม่เขียน หรือเอไอไม่ทำให้) ยังถือว่าเป็น Draft Requirement ไม่ใช่ Requirement จริง</p>
</blockquote>



<p class="wp-block-paragraph">เพราะการที่ Spec มี acceptance criteria มันจะเปลี่ยนจากคำอธิบายสวยๆ ให้กลายเป็น Goal ที่ AI ทำให้สำเร็จ และระบบเราจะใช้งานได้ตามที่ต้องการ</p>



<h3 class="wp-block-heading">5. Edge case กับ failure path ต้องมีตั้งแต่ก่อนเขียน code</h3>



<p class="wp-block-paragraph">Happy path เป็นแค่ส่วนหนึ่งของ production เท่านั้น แต่ spec จำนวนมากเขียนเหมือนโลกมีแต่ happy path ฮาาา</p>



<p class="wp-block-paragraph">อย่างน้อย spec ที่ส่งให้ AI ควรมี:</p>



<ul class="wp-block-list">
<li>error path 1 กรณี</li>



<li>edge case 1 กรณี</li>



<li>empty state หรือ permission case 1 กรณี</li>
</ul>



<p class="wp-block-paragraph">เพราะถ้าเราไม่เขียน มันจะเดาวิธี handle error จาก pattern ที่มันเห็นบ่อย ซึ่งอาจไม่ตรงกับระบบเราเลย</p>



<h2 class="wp-block-heading">Checklist ก่อนโยนงานให้ AI coding agent</h2>



<p class="wp-block-paragraph">ผมลองเอาแนวคิดในบทความมาจัดเป็น checklist table แบบที่น่าจะใช้จริงกับงานประจำวันได้ประมาณนี้ครับ</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>คำถาม</th><th>ผ่านหรือยัง</th></tr></thead><tbody><tr><td>Outcome ชัดไหมว่าระบบต้องทำพฤติกรรมอะไร</td><td>ถ้ายังตอบเป็นคำกว้างๆ เช่น ดีขึ้น เร็วขึ้น ใช้งานง่าย ให้เขียนใหม่</td></tr><tr><td>มี scope และ non-goals ไหม</td><td>ต้องบอกทั้งทำอะไร และไม่ทำอะไร</td></tr><tr><td>มี constraints ของ repo, stack, format, security, performance ไหม</td><td>ถ้าไม่มี AI จะเดาจากโลกทั่วไป ไม่ใช่จากระบบเรา</td></tr><tr><td>Acceptance criteria พิสูจน์ได้ไหม</td><td>ควรตรวจด้วย test, log, screenshot หรือ metric ได้</td></tr><tr><td>มี error path หรือ edge case ไหม</td><td>อย่างน้อยต้องมี 1 เคสที่ไม่ใช่ happy path</td></tr><tr><td>มีตัวอย่าง input/output ไหม</td><td>ตัวอย่างดีๆ หนึ่งชุด ลด ambiguity ได้เยอะมาก</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">checklist นี้ไม่ได้บอกให้เขียน spec ยาวเสมอไป แต่มันบอกให้ AI เขียน spec แบบเดาน้อยลง</p>



<h2 class="wp-block-heading">Spec ไม่ได้ต้องยาว แต่ต้องมี signal พอ</h2>



<p class="wp-block-paragraph">บทความต้นฉบับใช้คำว่า signal redundancy matched to complexity ซึ่งผมแปลแบบบ้านๆ ว่า รายละเอียดต้องพอดีกับความเสี่ยงของงาน</p>



<p class="wp-block-paragraph">ถ้าแค่แก้ margin หรือเปลี่ยน text เล็กๆ จะเขียน spec ยาว 3 หน้า ก็อาจเกินไป แต่ถ้างานแตะ authorization, payment, data integrity, migration, report export หรือ performance ตรงนี้ผมว่าไม่ควรประหยัด spec</p>



<p class="wp-block-paragraph">เพราะงานพวกนี้ถ้าพลาด ไม่ใช่แค่ UI เพี้ยน แต่มันอาจกระทบข้อมูล สิทธิ์ผู้ใช้ หรือ logic สำคัญของระบบ</p>



<h2 class="wp-block-heading">Workflow ที่ผมคิดว่าเอาไปใช้ได้ทันที</h2>



<p class="wp-block-paragraph">ถ้าจะเอาเรื่องนี้ไปใช้กับทีม software จริงๆ ผมคิดว่าไม่ต้องเริ่มจาก process ใหญ่โต แต่เริ่มจากงานหนึ่งชิ้นก่อนก็พอ</p>



<ol class="wp-block-list">
<li>เลือก feature หรือ change ที่มีขอบเขตงานและโค้ดชัดเจน (boundary)</li>



<li>เขียน spec ให้มี 5 เรื่องหลัก: outcome, scope, constraints, acceptance criteria, edge cases</li>



<li>review spec ก่อนให้ AI ลงมือ</li>



<li>ให้ AI implement พร้อม test</li>



<li>ถ้า test fail หรือ reviewer ต้องถามเพิ่ม ให้กลับไปแก้ spec ก่อน ไม่ใช่แค่สั่ง AI แก้ code ไปเรื่อยๆ</li>
</ol>



<p class="wp-block-paragraph">จุดนี้ผมว่ามันต่อกับแนวคิด Spec-Driven Development มาก คือ spec ไม่ใช่เอกสารประกอบงาน แต่เป็น contract ของงาน ถ้า code กับ spec ขัดกัน ต้องถามก่อนว่า spec ยังถูกไหม ไม่ใช่ปล่อยให้ code ที่ AI generate มาเป็นความจริงใหม่ของระบบ</p>



<p class="wp-block-paragraph">ข้อสุดท้ายสำคัญมาก และทำให้ Spec มีการอัพเดทตลอดเวลา (หรือที่เรียกว่า Living documentation)</p>



<h2 class="wp-block-heading">เรื่องที่ต้องระวัง อย่าเอา checklist ไปทำให้ทีมเหนื่อยกว่าเดิม</h2>



<p class="wp-block-paragraph">ถึงผมจะชอบ checklist นี้มาก แต่ก็ไม่คิดว่าต้องใช้เต็มรูปแบบกับทุกงานนะครับ</p>



<p class="wp-block-paragraph">ถ้าเป็น bug fix เล็กๆ ที่ test เดียวพิสูจน์ได้ หรือ prototype ที่ตั้งใจ throw away อยู่แล้ว การเขียน spec ยาวอาจไม่คุ้ม</p>



<p class="wp-block-paragraph">อีกอย่างคือ spec ที่ดีไม่ได้แก้ทุกปัญหา AI ยังพลาดได้จาก model limitation, context retrieval ไม่ครบ, repo ใหญ่เกินไป หรือระบบเดิมซับซ้อนจน spec อธิบายไม่หมด</p>



<p class="wp-block-paragraph">ดังนั้นอย่าใช้ checklist นี้เป็นพิธีกรรมใหม่ของทีม แต่ใช้เป็นเครื่องมือถามตัวเองว่า “งานนี้มีอะไรที่ AI ไม่ควรเดาเองบ้าง”</p>



<h2 class="wp-block-heading">สรุปแบบฟิวส์ๆ</h2>



<p class="wp-block-paragraph">สิ่งที่ผมได้จากบทความนี้คือ AI ไม่ได้ทำให้ requirement หายไป แต่มันทำให้ requirement ที่คลุมเครือส่งผลแรงขึ้นกว่าเดิม</p>



<p class="wp-block-paragraph">เมื่อก่อนถ้า requirement คลุมเครือ senior developer อาจถามกลับ หรืออย่างน้อยก็รู้จาก context ของระบบว่าอะไรควรทำไม่ควรทำ แต่ AI coding agent ไม่ทำแบบนั้น ถ้าเราไม่บอก มันจะเดา</p>



<p class="wp-block-paragraph">และบางครั้งมันเดาแบบมั่นใจมากด้วยว่าจะถูก!</p>



<p class="wp-block-paragraph">ยิ่ง AI เขียน code เร็วเท่าไร เราก็ยิ่งต้องเขียนให้ชัดขึ้นเท่านั้นครับ</p>



<h2 class="wp-block-heading">แหล่งอ้างอิง</h2>



<ul class="wp-block-list">
<li><a href="https://levelup.gitconnected.com/how-to-write-specs-for-ai-7-rules-and-a-checklist-for-better-code-a5af2b2c6205" target="_blank" rel="noopener">How to write specs for AI: 7 rules and a checklist for better code</a> โดย Jaroslaw Wasowski, Level Up Coding</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7820/ai-spec-writing-checklist/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>วิธีใช้ Fable 5 แบบประหยัด Token</title>
		<link>https://myifew.com/7793/how-optimize-token-use-fable5-advisor/</link>
					<comments>https://myifew.com/7793/how-optimize-token-use-fable5-advisor/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Thu, 09 Jul 2026 16:18:24 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI Agent]]></category>
		<category><![CDATA[Anthropic]]></category>
		<category><![CDATA[Claude]]></category>
		<category><![CDATA[Fable 5]]></category>
		<category><![CDATA[Token Optimization]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7793</guid>

					<description><![CDATA[ผมไปเจอโพสต์ของ ClaudeDevs เรื่องการใช้ Fable 5 เป็น advisor ให้ Sonnet 5 ทำงานหลัก แล้วรู้สึกว่านี่คือ pattern ที่ตอบโจทย์ agent workload มาก เพราะเราไม่จำเป็นต้องเอาโมเดลแพงที่สุดไปเผา token กับงานอ่าน/ทำทุกบรรทัด]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">โพสต์ใน X ของ ClaudeDevs ที่พูดถึง pattern การใช้ Fable 5 แบบประหยัด token ผมรู้สึกว่าน่าสนใจมาก เพราะมันแตะปัญหาที่คนทำ AI agent เจอกันจริงๆ คือถ้าเราใช้โมเดลฉลาดสุดทำทุกอย่าง ทั้งคิด อ่านไฟล์ อ่านเว็บ เรียก tool แก้โค้ด รัน test และสรุปผล จะใช้โทเค็นเยอะมาก (ต้นทุนสูงมาก) ทั้งที่หลาย step ไม่ได้ต้องใช้ความฉลาดระดับสูงตลอดเวลา</p>



<p class="wp-block-paragraph">แนวคิดที่ Anthropic ยกมาคือ ให้ Sonnet 5 เป็น executor ทำงานหลักใน loop ปกติ แล้วให้ Fable 5 เป็น advisor ที่ถูกเรียกเฉพาะตอนต้องใช้ judgment สูง เช่น วางแผน ตัดสินใจ architecture แก้ทางเมื่อเริ่มหลุด หรือ review ก่อนจบงาน ผมว่ามันเป็น pattern ที่ practical มาก เพราะมันไม่ได้พยายามลดคุณภาพด้วยการใช้โมเดลเล็กอย่างเดียว แต่ใช้โมเดลฉลาดให้ถูกจังหวะมากกว่า</p>



<span id="more-7793"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้ฟิวส์กับเอเจ้นชมพูช่วยกันเรียบเรียง โดยอิงจาก<a href="https://x.com/claudedevs/status/2074606058128224365" target="_blank" rel="noreferrer noopener">โพสต์ของ ClaudeDevs บน X</a>, เอกสาร Advisor tool ของ Anthropic และ Claude Cookbook แล้วนำมาตีความเป็นแนวทางใช้งานจริงสำหรับคนทำ AI agent / coding agent</em></p>



<p class="wp-block-paragraph">ต้นทางของเรื่องนี้สรุปไว้สั้นมากว่า หนึ่งใน pattern ที่ Anthropic ใช้กับ Fable 5 คือ “ใช้ Fable 5 เป็น advisor” โดย executor อย่าง Sonnet 5 จะเรียก Fable 5 เพื่อขอคำแนะนำ ดังนั้นการทำงานส่วนใหญ่จะใช้ token ไปกับ executor ที่ Sonnet 5 ทำมากกว่า</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1992" height="872" src="https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern.jpg" alt="Fable 5 advisor pattern จากโพสต์ ClaudeDevs" class="wp-image-7791" srcset="https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern.jpg 1992w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-1024x448.jpg 1024w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-1200x525.jpg 1200w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-768x336.jpg 768w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-1536x672.jpg 1536w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-542x237.jpg 542w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-1084x475.jpg 1084w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-792x347.jpg 792w, https://myifew.com/wp-content/uploads/2026/07/fable5-advisor-pattern-1230x538.jpg 1230w" sizes="(max-width: 1992px) 100vw, 1992px" /><figcaption class="wp-element-caption">ภาพจากโพสต์ ClaudeDevs: Sonnet 5 ทำหน้าที่ executor ใน main loop และเรียก Fable 5 เป็น advisor แบบ on-demand</figcaption></figure>



<h2 class="wp-block-heading">ต้องเข้าใจก่อนว่า agent workload ไม่ต้องใช้โมเดลฉลาดทุกงาน</h2>



<p class="wp-block-paragraph">เวลาพูดถึง AI coding agent หรือ agent ที่ทำงานหลาย step ผมคิดว่าหลายคนมักติดกับดักว่า “ใช้โมเดลฉลาดสุดไปเลยจะได้จบ” ซึ่งจริงในบางงาน แต่ไม่จริงเสมอไป โดยเฉพาะงานยาวๆ ที่มี token จำนวนมากถูกใช้ไปกับงาน mechanical มากกว่า reasoning</p>



<p class="wp-block-paragraph">ในงานหนึ่งๆ มักมี 2 ส่วนปนกัน:</p>



<ul class="wp-block-list">
<li><strong>ส่วนที่ต้องคิดจริง:</strong> แตกโจทย์, ตีความ requirement, เลือก architecture, ประเมิน trade-off, หาทางออกตอนติดปัญหา</li>



<li><strong>ส่วนที่ต้องทำเยอะ:</strong> อ่านไฟล์, อ่านเว็บ, grep โค้ด, ดู log, แก้ไฟล์, รัน test, สรุป output จาก tool</li>
</ul>



<p class="wp-block-paragraph">ถ้าใช้โมเดลระดับ frontier ทำทั้งสองส่วนทั้งหมด ก็โครตจะเปลือง token เลยครับ เพราะถูกใช้ไปกับงานทั่วไปที่ไม่ต้องการ frontier reasoning ทุกบรรทัด เช่น อ่านหน้าเว็บยาวๆ หรือไล่ log หลายพันบรรทัด ตรงนี้เองที่ทำให้ค่าใช้จ่ายสูงโดยไม่จำเป็น</p>



<p class="wp-block-paragraph">ผมขอเปรียบให้เห็นภาพง่ายๆ เหมือนเอา senior engineer ไปนั่งอ่าน log ทุกบรรทัดเอง ซึ่งงานเขาควรเข้ามาตอนวางทิศทาง ตรวจจุดเสี่ยง หรือช่วยตัดสินใจเรื่องที่ถ้าผิดแล้วจะเสียเวลาเยอะ ส่วนงานอ่าน/เก็บข้อมูล/ทำตามขั้นตอนให้คนที่เร็วกว่าและต้นทุนต่ำกว่าช่วยทำได้</p>



<p class="wp-block-paragraph">หรือเทียบในงานก่อสร้าง ก็เหมือนเอาวิศะไปก่ออิฐฉาบปูนแทนคนงานก่อสร้าง แทนที่วิศวะจะออกแบบ วางแผน และคนงานจะเป็นคนทำ</p>



<figure class="wp-block-image size-large"><img alt="" loading="lazy" decoding="async" width="1200" height="622" src="https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1200x622.jpg" alt="" class="wp-image-7797" srcset="https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1200x622.jpg 1200w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1024x531.jpg 1024w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-768x398.jpg 768w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1536x797.jpg 1536w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-2048x1062.jpg 2048w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-542x281.jpg 542w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1084x562.jpg 1084w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-792x411.jpg 792w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ-1230x638.jpg 1230w, https://myifew.com/wp-content/uploads/2026/07/HMp6DWEa4AE10vQ.jpg 2194w" sizes="auto, (max-width: 1200px) 100vw, 1200px" /><figcaption class="wp-element-caption">วิธ๊พื้นฐานหน่อย คือ ใช้ Fable 5 ทำหน้าที่วางแผน แล้วมอบหมายงานให้ worker Sonnet 5 ทำ</figcaption></figure>



<h2 class="wp-block-heading">เแนวคิด: Sonnet 5 เป็นคนทำงานหลัก ส่วน Fable 5 เป็นคนให้คำปรึกษา</h2>



<p class="wp-block-paragraph">จาก diagram ในโพสต์ของ ClaudeDevs โครงสร้างคือ Sonnet 5 ทำหน้าที่ executor และรัน main loop ทุก turn ส่วน Fable 5 เป็น advisor ที่ถูกเรียกผ่าน tool call เฉพาะเมื่อจำเป็น พูดง่ายๆ คือ Sonnet ทำงานหนัก แต่ Fable ช่วยคิดตอนที่ต้องคิดอย่างมีเหตุมีผล</p>



<p class="wp-block-paragraph">เอกสาร <a href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool" target="_blank" rel="noreferrer noopener">Advisor tool ของ Anthropic</a> อธิบายแนวคิดนี้ว่า executor model ที่เร็วกว่า/ต้นทุนต่ำกว่า สามารถ consult advisor model ที่ฉลาดกว่า mid-generation ได้ โดย advisor จะเห็น conversation transcript ทั้งหมด แล้วส่งคำแนะนำกลับมาให้ executor ทำงานต่อ</p>



<p class="wp-block-paragraph">จุดที่ผมว่าสำคัญคือ advisor ไม่ได้มาแทน executor แต่เป็นเหมือน reviewer หรือ architect ที่ถูกเรียกในจังหวะที่ควรเรียก ทำให้เรายังได้คุณภาพจากโมเดลใหญ่ในการตัดสินใจสำคัญๆ แต่ไม่ต้องจ่ายราคาโมเดลใหญ่กับทุกการทำงานง่ายๆ หลายงาน</p>



<h2 class="wp-block-heading">แล้ว Advisor tool ทำงานยังไง?</h2>



<p class="wp-block-paragraph">เมื่อเราเพิ่ม advisor tool เข้าไปใน <code>tools</code> array แล้ว ตัว executor จะตัดสินใจเองว่าจะเรียก advisor เมื่อไรเหมือน tool อื่นๆ แต่การ call นี้เกิดฝั่ง server ภายใน request เดียว ไม่ใช่ client ต้อง orchestration เองหลายรอบ</p>



<ul class="wp-block-list">
<li>executor สร้าง <code>server_tool_use</code> ชื่อ <code>advisor</code></li>



<li>server ส่ง transcript ทั้งหมดให้ advisor model</li>



<li>advisor ส่งคำแนะนำกลับมาเป็น <code>advisor_tool_result</code></li>



<li>executor ใช้คำแนะนำนี้ทำงานต่อจนจบ</li>
</ul>



<p class="wp-block-paragraph">ตัวอย่างแบบย่อจากเอกสาร Anthropic:</p>



<pre class="wp-block-code"><code>client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=&#91;"advisor-tool-2026-03-01"],
    tools=&#91;
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-4-8",
        }
    ],
    messages=&#91;
        {
            "role": "user",
            "content": "Build a concurrent worker pool in Go with graceful shutdown.",
        }
    ],
)</code></pre>



<p class="wp-block-paragraph">ถ้านำ concept นี้มาเทียบกับโพสต์ Fable 5 ภาพในหัวจะประมาณนี้:</p>



<pre class="wp-block-code"><code>tools=&#91;
    {
        "type": "advisor_20260301",
        "name": "advisor",
        "model": "claude-fable-5",
        "max_tokens": 2048,
        "max_uses": 2,
    }
]</code></pre>



<p class="wp-block-paragraph">ตรงนี้ <code>max_tokens</code> กับ <code>max_uses</code> สำคัญมาก เพราะถ้าเปิด advisor ไว้แบบไม่จำกัด มันอาจกลายเป็น “เรียกโมเดลแพงบ่อยขึ้น” แทนที่จะช่วยประหยัด token</p>



<figure class="wp-block-image size-large"><img alt="" loading="lazy" decoding="async" width="1200" height="1072" src="https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-1200x1072.jpg" alt="" class="wp-image-7796" srcset="https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-1200x1072.jpg 1200w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-1024x915.jpg 1024w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-768x686.jpg 768w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-542x484.jpg 542w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-1084x968.jpg 1084w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-792x707.jpg 792w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q-1230x1099.jpg 1230w, https://myifew.com/wp-content/uploads/2026/07/HMp4vKMakAAEa3Q.jpg 1274w" sizes="auto, (max-width: 1200px) 100vw, 1200px" /><figcaption class="wp-element-caption">การใช้ Sonnet 5 เป็น Excutor แล้วมี Fable 5 เป็น advisor ทำคะแนนได้ 92% จากการใช้ Fable 5 อย่างเดียว แต่จะใช้เงินแค่ 63% เมื่อเทียบกับใช้ Fable 5 อย่างเดียวเช่นกัน</figcaption></figure>



<h2 class="wp-block-heading">วิธีใช้ให้ประหยัด token จริง</h2>



<h3 class="wp-block-heading">1. ให้ executor อ่านบริบทก่อน แล้วค่อยเรียก advisor</h3>



<p class="wp-block-paragraph">ผมคิดว่าเราไม่ควรเรียก Fable 5 ตั้งแต่ครั้งแรกที่ยังไม่รู้อะไรเลย เพราะคำแนะนำจะกว้างเกินไป วิธีที่ดีกว่าคือให้ Sonnet 5 อ่านทำความเข้าใจบริบทแรกของเราก่อน เช่น requirement, โครง repo, error log หรือไฟล์หลัก แล้วค่อยเรียก Fable 5 เพื่อช่วยวางแผน</p>



<h3 class="wp-block-heading">2. ใช้ advisor ในจุดที่ตัดสินใจผิดแล้วแพง</h3>



<p class="wp-block-paragraph">จุดที่คุ้มจะเรียก advisor คือจุดที่ถ้าคิดผิดแล้วต้องแก้งานเยอะ เช่น:</p>



<ul class="wp-block-list">
<li>เลือก architecture หรือ migration strategy</li>



<li>ตีความ requirement ที่กำกวม</li>



<li>เจอ test fail ซ้ำๆ แล้วแนวทางเดิมแก้ไม่ได้ หรือไม่ครอบคลุม</li>



<li>ก่อนจบงาน เพื่อ review ว่าหลุด security, edge case หรือ test อะไรไหม</li>
</ul>



<h3 class="wp-block-heading">3. จำกัดจำนวนครั้งด้วย <code>max_uses</code></h3>



<p class="wp-block-paragraph">ถ้างานหนึ่งควรเรียก advisor แค่ 1–2 ครั้ง ก็ตั้ง <code>max_uses</code> ไว้เลย จะช่วยไม่ให้ executor เรียก advisor ถี่เกินไปใน request เดียว</p>



<h3 class="wp-block-heading">4. จำกัดคำตอบของ advisor ด้วย <code>max_tokens</code></h3>



<p class="wp-block-paragraph">เอกสาร Anthropic แนะนำจุดเริ่มต้นที่ <code>max_tokens: 2048</code> สำหรับ advisor output cap โดยระบุว่าในการทดสอบของเขา การตั้ง cap นี้ลด output ของ advisor ได้มากเมื่อเทียบกับการไม่ตั้ง และยังไม่เห็นว่าคุณภาพลดลงเท่าไรอย่างชัดเจน (quality degradation) แต่ประโยคสำคัญคือ เราต้องตรวจสอบกับ workload ของตัวเองเสมอนะ เพื่อป้องกันความผิดพลาด เนื่องจากจำกัด token (ผมเคยเจอบ่อยว่า output งานออกมาได้ไม่ถูกต้อง หรือโค้ดไม่ครบ)</p>



<h3 class="wp-block-heading">5. เปิด caching เฉพาะงานที่เรียก advisor หลายครั้ง</h3>



<p class="wp-block-paragraph">ใน docs ระบุว่า advisor-side caching จะเริ่มคุ้มเมื่อคาดว่าจะมี advisor call ประมาณ 3 ครั้งขึ้นไปใน conversation เดียว ถ้างานสั้นๆ เรียกครั้งเดียวหรือสองครั้ง การเปิด cache อาจไม่คุ้ม เพราะ cache write ก็มีต้นทุนของมันเอง</p>



<h2 class="wp-block-heading">อีกแนวคิดที่คล้ายกัน คือ Plan big, execute small</h2>



<p class="wp-block-paragraph">ใน <a href="https://github.com/anthropics/claude-cookbooks/blob/main/managed_agents/CMA_plan_big_execute_small.ipynb" target="_blank" rel="noreferrer noopener">Claude Cookbook เรื่อง Coordinator pattern</a> Anthropic อธิบายอีก pattern ที่คล้ายกันมาก คือให้โมเดลใหญ่เป็น coordinator สำหรับวางแผนและสังเคราะห์คำตอบ ส่วน worker model ที่ถูกกว่าเป็นคนอ่านเว็บหรือดึงข้อมูลจำนวนมากใน context ของตัวเอง</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="2560" height="1309" src="https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-scaled.png" alt="Coordinator pattern: Fable 5 coordinator และ Sonnet 5 workers" class="wp-image-7792" srcset="https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-scaled.png 2560w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-1024x524.png 1024w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-1200x614.png 1200w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-768x393.png 768w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-1536x785.png 1536w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-2048x1047.png 2048w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-542x277.png 542w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-1084x554.png 1084w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-792x405.png 792w, https://myifew.com/wp-content/uploads/2026/07/anthropic-coordinator-pattern-1230x629.png 1230w" sizes="auto, (max-width: 2560px) 100vw, 2560px" /><figcaption class="wp-element-caption">ภาพจาก Anthropic Claude Cookbook: Fable 5 เป็น coordinator วางแผนและสังเคราะห์ ส่วน Sonnet 5 workers อ่านเว็บและส่ง distilled findings กลับมา</figcaption></figure>



<p class="wp-block-paragraph">ในการทดลองที่ Anthropic ยกตัวอย่าง ทีมแบบ split ราคาจะถูกลงกว่าประมาณ 2.5x และทำงานเร็วขึ้นประมาณ 3x โดยจำนวน input token 84–98% ถูกคิดที่ worker ที่ใช้ราคา Token ถูกกว่า </p>



<p class="wp-block-paragraph">แต่ๆๆ เขาบอกว่า นี่แค่ตัวอย่างนะ อย่าเอาตัวเลขนี้ไปใช้อ้างอิงว่าทุกงานจะประหยัดเท่านี้ เพราะมันขึ้นกับ workload แต่ละงาน </p>



<p class="wp-block-paragraph">แต่โครงสร้างวิธีการทำแบบนี้ก็ชัดเจนดี คือ งานอ่านเยอะๆ ให้ worker ทำ ส่วนโมเดลใหญ่แตะเฉพาะ planning/synthesis</p>



<h2 class="wp-block-heading">จากที่อ่าน ถ้าผมจะใช้จริง จะวาง flow แบบนี้</h2>



<ol class="wp-block-list">
<li><strong>เริ่มด้วย Sonnet 5:</strong> ให้ทำงานหลัก อ่านไฟล์ เรียก tool แก้โค้ด รัน test</li>



<li><strong>Orientation:</strong> เก็บบริบทขั้นต่ำก่อน เช่น requirement, repo structure, error หลัก</li>



<li><strong>Advisor call แรก:</strong> เรียก Fable 5 ให้ช่วยวางแผนและชี้ risk</li>



<li><strong>Execute:</strong> ให้ Sonnet 5 ลงมือทำตาม plan โดยไม่เรียก advisor ทุกจุด</li>



<li><strong>Replan เมื่อจำเป็น:</strong> ถ้า error วนหรือทางเดิมไม่ไปต่อ ค่อยเรียก Fable 5 อีกครั้ง</li>



<li><strong>Review ก่อนจบ:</strong> เรียก advisor ช่วยดูว่าตกหล่น test, security, edge case หรือ assumption อะไรไหม</li>



<li><strong>Finish:</strong> ให้ executor สรุปผลพร้อม evidence จาก test/diff/tool output</li>
</ol>



<p class="wp-block-paragraph">ต้องบอกว่า ผมยังแค่คิดนะ เพราะยังไม่มีโจทย์ซับซ้อนพอที่จะใช้ Fable ทำงาน และยังไม่อยากลองรันเทียบ เพราะต้องทำหลายครั้ง อาจจะเสีย Token เยอะ ฮาา, ไว้รอมีผลการทดสอบจากผู้กล้า หรือได้ลองจริงๆ แล้วจะเอามาเล่าให้ฟังอีกที หรือหากใครลองแล้วก็มาแชร์กันหน่อยครับ</p>



<h2 class="wp-block-heading">ข้อควรระวัง</h2>



<ul class="wp-block-list">
<li><strong>งานเล็กมากอาจไม่คุ้ม:</strong> ถ้าเป็น single-turn Q&amp;A หรือแก้ typo เล็กๆ advisor อาจเพิ่ม overhead มากกว่าประโยชน์</li>



<li><strong>ต้องวัดกับ workload จริง:</strong> ตัวเลขประหยัด token ไม่ใช่ค่าคงที่ ขึ้นกับชนิดงานและความยาวของ context</li>



<li><strong>อย่าแตกงานย่อยจนเกินพอดี:</strong> ใน cookbook เองก็เตือนว่าการแตก brief แคบเกินไปมี floor cost ของ worker thread (ขออธิบายเพิ่มเติมครับ: มันคือต้นทุนขั้นต่ำต่อ worker thread หมายถึง ทุกครั้งที่สร้าง worker หรือ sub-agent ใหม่ มันมี “ต้นทุนตั้งต้น” เสมอ ไม่ว่าจะงานเล็กหรือใหญ่ เช่น เปิด session ,รับ prompt, อ่าน context, เรียก Skill)</li>



<li><strong>advisor แก้โจทย์เท่าที่ได้รับจาก context:</strong> ถ้า executor ยังไม่ได้อ่านของสำคัญก่อนเรียก advisor คำแนะนำก็อาจกว้างหรือผิดทิศได้ เช่นเราใส่บริบทไม่ครบหรือไม่เข้าใจให้ advisor เองแต่แรก (นั่นคือเหตุผลของ Anthopic ว่าทำไมไม่ควรเอาตัวฉลาดมารับงานก่อน)</li>



<li><strong>ต้อง track cost แยก:</strong> usage ของ advisor อยู่ใน <code>usage.iterations</code> เป็น <code>advisor_message</code> เพราะถูก bill คนละ rate กับ executor</li>
</ul>



<p class="wp-block-paragraph">ผมขอขยายความข้อสุดท้ายนิดนึงคือ มันไม่สามารถคิด token cost แบบ usage.input_tokens + usage.output_tokens ทั่วไปนะ เพราะอาจจะเข้าใจผิดคิดว่าแพงทั้งหมด แต่ควรคิดจาก </p>



<p class="wp-block-paragraph">total_cost = executor_tokens × ราคา Sonnet 5 + advisor_tokens × ราคา Fable 5</p>



<p class="wp-block-paragraph">ดังนั้น ใน Anthropic API ที่ส่งค่า usage.iterations กลับมา เราต้องคิดราคาแยกตาม type ด้วย ว่าอะไรคือ executor (message) และอะไรคือ advisor (advisor_message)</p>



<h2 class="wp-block-heading">สรุป</h2>



<p class="wp-block-paragraph">ผมคิดว่า “Fable 5 เป็น advisor” เป็นแนวทางที่น่าลองมากสำหรับ agent workflow ที่เราจะให้มันทำงานยากๆ หรือต้องใช้การตัดสินใจอย่างมีเหตุมีผลสูงมาก ส่วนงานง่ายๆ อย่างการ อ่าน/ทำ/ตรวจซ้ำ ก็ให้ใช้โมเดลรองๆ ลงมา ทำก็คิดว่าเพียงพอแล้ว (อย่างน้องชมพูที่ผมให้แชต ก็ใช้แค่ ChatGPT mini แต่หาข้อมูลและเขียนบทความ ผมจะใช้ ChatGPT ปกติ</p>



<h2 class="wp-block-heading">อ้างอิง</h2>



<ul class="wp-block-list">
<li><a href="https://x.com/claudedevs/status/2074606058128224365" target="_blank" rel="noreferrer noopener">ClaudeDevs on X — Fable 5 as advisor pattern</a></li>



<li><a href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool" target="_blank" rel="noreferrer noopener">Anthropic Claude Platform Docs — Advisor tool</a></li>



<li><a href="https://github.com/anthropics/claude-cookbooks/blob/main/managed_agents/CMA_plan_big_execute_small.ipynb" target="_blank" rel="noreferrer noopener">Anthropic Claude Cookbooks — Coordinator pattern: big models for planning, small models for execution</a></li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7793/how-optimize-token-use-fable5-advisor/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Harness Design: ทำ AI Agent ให้ทำงานยาวๆ ได้โดยไม่ต้องมีคนเฝ้าตลอดเวลา</title>
		<link>https://myifew.com/7778/harness-design-by-anthopic/</link>
					<comments>https://myifew.com/7778/harness-design-by-anthopic/#respond</comments>
		
		<dc:creator><![CDATA[iFew]]></dc:creator>
		<pubDate>Wed, 08 Jul 2026 17:16:55 +0000</pubDate>
				<category><![CDATA[Technology]]></category>
		<category><![CDATA[AI Agent]]></category>
		<category><![CDATA[Anthropic]]></category>
		<category><![CDATA[Claude]]></category>
		<category><![CDATA[Harness Design]]></category>
		<category><![CDATA[Long-running Agents]]></category>
		<guid isPermaLink="false">https://myifew.com/?p=7778</guid>

					<description><![CDATA[ผมไปเจอบทความของ Anthropic เรื่อง harness design สำหรับ long-running application development ซึ่งตรงกับสิ่งที่กำลังทดลองอยู่ เลยเอามาเล่าในมุมที่นำไปพัฒนาต่อได้จริง]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">ไปเจอบทความของ Anthropic เรื่อง <a href="https://www.anthropic.com/engineering/harness-design-long-running-apps" target="_blank" rel="noopener">Harness design for long-running application development</a> แล้วรู้สึกว่าน่าสนใจมาก เพราะเขาพูดถึงการออกแบบ <strong>harness</strong> สำหรับให้ AI Agent ทำงานยาวๆ จนได้ของออกมา โดยไม่ต้องมีมนุษย์คอยเข้ามาเกี่ยวข้องตลอดเวลา</p>



<p class="wp-block-paragraph">เรื่องนี้ตรงกับสิ่งที่ผมเองก็กำลังทดลองและพัฒนาอยู่เหมือนกัน โจทย์คือจะทำยังไงให้ Agent ไม่ได้เป็นแค่ผู้ช่วยตอบคำถาม หรือช่วยเขียนโค้ดเป็นรอบๆ แต่สามารถรับโจทย์ยาวๆ วางแผน ทำงาน ตรวจงาน ส่งต่องาน และค่อยๆ ปรับปรุงผลลัพธ์ได้เองมากขึ้น (ยุคนี้เรียกว่า Loop Engineering)</p>



<p class="wp-block-paragraph">ผมเลยอยากเอาบทความนี้มาเล่าในมุมที่นำไปต่อยอดได้จริง โดยเฉพาะสำหรับคนที่กำลังสนใจเรื่อง AI Agent, coding agent, workflow automation หรือระบบที่ให้ AI ทำงานต่อเนื่องแทนการ prompt ทีละครั้ง</p>



<span id="more-7778"></span>



<p class="wp-block-paragraph"><em>หมายเหตุ: บทความนี้ฟิวส์กับเอเจ้นชมพู ได้เรียบเรียงและต่อยอดจากบทความต้นฉบับของ Anthropic Engineering เรื่อง <a href="https://www.anthropic.com/engineering/harness-design-long-running-apps" target="_blank" rel="noopener">Harness design for long-running application development</a> เขียนโดย Prithvi Rajasekaran</em></p>



<h2 class="wp-block-heading">Harness คืออะไรในบริบทของ AI Agent</h2>



<p class="wp-block-paragraph">ถ้าแปลแบบง่ายๆ harness คือชุดเครื่องมือที่หุ้ม AI Agent อีกทีเพื่อให้มันทำงานได้เป็นระบบ ไม่ใช่แค่โยน prompt ให้ model แล้วหวังว่ามันจะทำทุกอย่างถูกต้องเอง</p>



<p class="wp-block-paragraph">ซึ่งในโลกของการเขียนโปรแกรม เรามักคุ้นกับ test harness หรือ automation harness อยู่แล้ว คือชุดเครื่องมือที่ช่วยรัน ทดสอบ ตรวจผล และคุมการทำงานบางอย่างให้เป็นระบบ พอมาอยู่ในโลกของ AI Agent แนวคิดก็คล้ายกัน แต่ขยายใหญ่กว่าเดิม</p>



<p class="wp-block-paragraph">Harness ของ AI Agent อาจรวมหลายอย่าง เช่น</p>



<ul class="wp-block-list">
<li>วิธีแตกงานใหญ่ให้เล็กลง</li>



<li>วิธีให้ agent วางแผนก่อนลงมือทำ</li>



<li>วิธีเก็บ state ของงานไว้นอก context window</li>



<li>วิธีส่งต่องานระหว่าง agent หรือ session</li>



<li>วิธีตรวจคุณภาพของงานที่ทำเสร็จ</li>



<li>วิธีบังคับให้ agent แก้ไขงานตาม feedback</li>



<li>วิธีหยุดงานเมื่อถึงเงื่อนไขบางอย่าง</li>
</ul>



<p class="wp-block-paragraph">พูดอีกแบบคือ ถ้า model คือสมอง harness ก็คือระบบการทำงานรอบสมองนั้น</p>



<p class="wp-block-paragraph">และผมคิดว่านี่แหละคือประเด็นสำคัญมาก เพราะช่วงแรกๆ เรามักคิดกันว่า AI จะเก่งขึ้นเพราะ model ฉลาดขึ้นอย่างเดียว แต่พอเริ่มใช้งานจริงจะเห็นว่า model ที่เก่งมากๆ ถ้าไม่มีระบบคุมงานที่ดี ก็ยังหลุด ยังลืม ยังทำงานซ้ำ ยังประเมินตัวเองผิด และยังจบงานแบบไม่ครบได้เหมือนกัน</p>



<p class="wp-block-paragraph">จริงๆ ลองทดสอบได้ง่ายๆ ครับ ถ้าเอา prompt ใส่ใน Claude Web ตั้งโมเดลเป็น Opus 4.8 กับใส่ในระบบแชตแจกฟรีเช่น Langflow โดยต่อโมเดล Opus 4.8 ผ่าน Claude API, คำตอบที่ได้ออกมาจะไม่เหมือนกัน แม้ว่าใช้สมอง Opus 4.8 เหมือนกัน (เรื่องนี้ 9arm ก็มีเล่าให้ฟังตอนทำ 9arm AI Passport)</p>



<h2 class="wp-block-heading">ปัญหาของ Agent ที่ให้ทำงานยาวๆ</h2>



<p class="wp-block-paragraph">บทความนี้เริ่มจากโจทย์ที่ Anthropic ทดลองอยู่ 2 เรื่อง คือทำให้ Claude สร้าง frontend design ที่มีคุณภาพสูงขึ้น และทำให้ Claude สร้าง application เต็มรูปแบบได้โดยไม่ต้องมีมนุษย์เข้าไปช่วยระหว่างทาง</p>



<p class="wp-block-paragraph">สองงานนี้ดูเหมือนคนละเรื่อง งานแรกเป็นเรื่องรสนิยมและความสวยงาม งานหลังเป็นเรื่องซอฟต์แวร์ที่ใช้งานได้จริง แต่ทั้งคู่มีปัญหาร่วมกันอย่างหนึ่ง คือถ้าให้ AI ทำงานยาวๆ แบบ naive เกินไป คุณภาพจะเริ่มแกว่ง</p>



<h3 class="wp-block-heading">1. Context เต็มแล้วเริ่มหลุด</h3>



<p class="wp-block-paragraph">งานที่ยาวหลายชั่วโมงจะมีข้อมูลสะสมเยอะมาก ตั้งแต่ requirement, decision, bug, code, test result, feedback ไปจนถึงสิ่งที่ลองแล้วไม่เวิร์ก ถ้าทุกอย่างถูกกองอยู่ใน context window เดียว สุดท้าย agent จะเริ่มจับประเด็นไม่ครบ</p>



<p class="wp-block-paragraph">Anthropic ยังพูดถึงอาการที่น่าสนใจชื่อว่า <strong>context anxiety</strong> คือ model เริ่มเหมือนรู้ตัวว่าบริบทใกล้เต็ม แล้วพยายามรีบ wrap up งานก่อนเวลา ทั้งที่งานจริงยังไม่เสร็จดี</p>



<p class="wp-block-paragraph">ปัญหานี้ผมว่าคนที่ใช้ coding agent น่าจะเจอบ่อย บางทีมันทำงานดีมาตลอด แต่พอท้ายๆ เริ่มสรุปเองว่าทุกอย่างเรียบร้อย ทั้งที่ test ยังไม่ครบ หรือยังมี TODO ค้างอยู่</p>



<h3 class="wp-block-heading">2. Agent มักตรวจงานตัวเองใจดีเกินไป</h3>



<p class="wp-block-paragraph">อีกปัญหาหนึ่งที่ตรงมากคือ self-evaluation</p>



<p class="wp-block-paragraph">เวลาถาม agent ว่างานที่ตัวเองทำดีไหม มันมักตอบว่าดี ใช้ได้ พร้อมแล้ว หรือใกล้เสร็จแล้ว ทั้งที่ถ้ามนุษย์ลองใช้งานจริงอาจเห็นเลยว่ามีหลายจุดยังไม่ดีพอ</p>



<p class="wp-block-paragraph">งาน coding ยังพอมี test ช่วยจับได้บ้าง แต่งานอย่าง design, UX, product completeness หรือบทความนี่ตรวจยากกว่าเยอะ เพราะไม่มีคำตอบแบบ pass/fail ชัดเจน</p>



<p class="wp-block-paragraph">Anthropic เลยใช้แนวทางแยก agent ที่สร้างงาน ออกจาก agent ที่ตรวจงาน ซึ่งผมคิดว่าเป็น pattern ที่ควรใช้จริงในระบบ agent ที่ต้องการคุณภาพ</p>



<h2 class="wp-block-heading">แนวคิดหลัก: Planner, Generator, Evaluator</h2>



<p class="wp-block-paragraph">โครงสร้างที่บทความนี้พูดถึงคือการแบ่ง agent ออกเป็น 3 บทบาทหลัก</p>



<figure class="wp-block-table"><table><thead><tr><th>บทบาท</th><th>หน้าที่</th></tr></thead><tbody><tr><td><strong>Planner</strong></td><td>รับโจทย์สั้นๆ แล้วขยายเป็น product spec, plan, task list หรือแนวทางการทำงาน</td></tr><tr><td><strong>Generator</strong></td><td>ลงมือสร้าง feature, เขียนโค้ด หรือผลิต output ตามแผน</td></tr><tr><td><strong>Evaluator</strong></td><td>ตรวจงาน ทดลองใช้งาน ให้ feedback และบอกว่างานผ่านเกณฑ์หรือยัง</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">ถ้ามองในเชิงทีมซอฟต์แวร์ มันก็คล้ายๆ การแยก role ในทีมจริง</p>



<ul class="wp-block-list">
<li>Planner ทำหน้าที่คล้าย product/tech lead</li>



<li>Generator ทำหน้าที่คล้าย developer</li>



<li>Evaluator ทำหน้าที่คล้าย QA, reviewer และ product tester</li>
</ul>



<p class="wp-block-paragraph">ข้อดีคือเราไม่ต้องหวังให้ agent ตัวเดียวทำทุกอย่างเก่งหมด เพราะในความเป็นจริง มนุษย์เองก็ยังไม่ค่อยทำงานแบบนั้น เรามีคนคิด คนทำ คนตรวจ และ feedback loop ที่ทำให้งานดีขึ้น</p>



<h2 class="wp-block-heading">ทำเรื่อง subjective ให้ตรวจได้</h2>



<p class="wp-block-paragraph">ส่วนที่ผมชอบมากในบทความคือการทดลองกับ frontend design เพราะ design เป็นเรื่องที่วัดยาก</p>



<p class="wp-block-paragraph">Anthropic พบว่า Claude มักสร้าง UI ที่ technically ใช้งานได้ แต่ดู generic มาก เช่น layout ปลอดภัย card เยอะๆ gradient เดิมๆ หรือหน้าตาที่ดูเหมือน AI สร้างแบบไม่มี character</p>



<p class="wp-block-paragraph">เขาเลยสร้าง evaluator ที่มี criteria ชัดเจน เช่น</p>



<ul class="wp-block-list">
<li><strong>Design quality</strong> งานดูเป็นภาพรวมเดียวกันไหม</li>



<li><strong>Originality</strong> มีความคิดสร้างสรรค์จริงไหม หรือเป็น template</li>



<li><strong>Craft</strong> typography, spacing, contrast, color harmony ดีไหม</li>



<li><strong>Functionality</strong> ผู้ใช้เข้าใจและใช้งานได้จริงไหม</li>
</ul>



<p class="wp-block-paragraph">จุดสำคัญคือเขาไม่ได้ถามกว้างๆ ว่า “สวยไหม” แต่แตกคำว่าสวยให้กลายเป็น rubric ที่ตรวจได้</p>



<p class="wp-block-paragraph">ผมว่านี่เอาไปใช้กับงานอื่นได้เยอะมาก เช่นบทความดีไหม requirement ชัดไหม dashboard ใช้งานง่ายไหม หรือแม้แต่ระบบ automation ที่ agent สร้างขึ้นมามี failure mode อะไรบ้าง ถ้าเราไม่มี rubric evaluator ก็จะตอบกว้างๆ และหลุดง่าย</p>



<h2 class="wp-block-heading">Context Reset ไม่ใช่แค่ล้างแชท แต่ต้องมี Handoff</h2>



<p class="wp-block-paragraph">อีกเรื่องที่สำคัญมากคือ structured handoff</p>



<p class="wp-block-paragraph">ถ้า agent ทำงานยาวจนต้องเริ่ม session ใหม่ หรือให้ agent ตัวใหม่มารับช่วงต่อ เราไม่ควรส่งต่อด้วย chat history ยาวๆ อย่างเดียว แต่ควรมี artifact ที่สรุปสถานะงานอย่างเป็นระบบ</p>



<p class="wp-block-paragraph">handoff ที่ดีควรบอกอย่างน้อยว่า</p>



<ul class="wp-block-list">
<li>เป้าหมายของงานคืออะไร</li>



<li>ทำอะไรเสร็จแล้ว</li>



<li>ไฟล์ไหนถูกแก้</li>



<li>คำสั่งไหนรันแล้ว</li>



<li>ผลลัพธ์จริงคืออะไร</li>



<li>ยังเหลือปัญหาอะไร</li>



<li>next step คืออะไร</li>
</ul>



<p class="wp-block-paragraph">ถ้าเป็นงาน coding ก็ควรมี test result, git diff, known issue และคำอธิบาย decision ที่สำคัญด้วย</p>



<p class="wp-block-paragraph">ในมุมผม นี่คือจุดที่ทำให้ agent system เริ่มจริงจังขึ้นมาก เพราะเราเริ่มย้าย source of truth จาก “บทสนทนา” ไปอยู่ใน “artifact” ที่อ่านซ้ำได้ ตรวจได้ และส่งต่อได้</p>



<h2 class="wp-block-heading">Sprint Contract: ก่อนทำ ต้องรู้ก่อนว่า Done คืออะไร</h2>



<p class="wp-block-paragraph">อีกไอเดียที่น่าสนใจคือก่อนแต่ละ sprint ให้ Generator และ Evaluator ตกลงกันก่อนว่า sprint นี้จะทำอะไร และจะตรวจยังไงถึงเรียกว่าสำเร็จ</p>



<p class="wp-block-paragraph">ผมมองว่านี่คือ acceptance criteria สำหรับ agent โดยเฉพาะ</p>



<p class="wp-block-paragraph">ถ้าให้ agent “สร้างระบบ task management” เฉยๆ มันอาจทำหน้าจอสวย แต่ข้อมูลไม่ persist หรือ filter ใช้ไม่ได้ แต่ถ้ามี sprint contract เช่น</p>



<ul class="wp-block-list">
<li>สร้าง task ได้</li>



<li>แก้สถานะ task ได้</li>



<li>filter ตาม status ได้</li>



<li>refresh แล้วข้อมูลยังอยู่</li>



<li>Evaluator ต้องทดสอบผ่าน browser จริง</li>
</ul>



<p class="wp-block-paragraph">แบบนี้งานจะตรวจได้ชัดขึ้นมาก และลดโอกาสที่ agent จะทำ feature แบบดูเหมือนเสร็จ แต่ใช้งานจริงไม่ได้</p>



<h2 class="wp-block-heading">ผลลัพธ์ที่ Anthropic เจอ</h2>



<p class="wp-block-paragraph">บทความยกตัวอย่างให้ Claude สร้าง 2D retro game maker แล้วเทียบระหว่าง solo agent กับ full harness</p>



<figure class="wp-block-table"><table><thead><tr><th>วิธี</th><th>เวลา</th><th>ต้นทุน</th></tr></thead><tbody><tr><td>Solo agent</td><td>ประมาณ 20 นาที</td><td>ประมาณ $9</td></tr><tr><td>Full harness</td><td>ประมาณ 6 ชั่วโมง</td><td>ประมาณ $200</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">full harness แพงกว่ามาก แต่คุณภาพต่างกันชัดเจน solo agent ทำหน้าตาได้บางส่วน แต่เกมเล่นจริงไม่ได้ดีนัก ส่วน full harness ทำ feature ได้ลึกกว่า polished กว่า และ play mode ใช้งานได้จริงกว่า</p>



<p class="wp-block-paragraph">นี่เป็น trade-off ที่ต้องจำไว้ ไม่ใช่ว่าเราควรใช้ harness หนักๆ กับทุกงาน เพราะบางงาน single agent ก็พอ แต่ถ้างานสำคัญ งานซับซ้อน หรืองานที่ต้องการคุณภาพสูงมาก harness แบบนี้อาจคุ้ม</p>



<h2 class="wp-block-heading">เมื่อ Model เก่งขึ้น Harness ก็ต้องเปลี่ยน</h2>



<p class="wp-block-paragraph">อีกประเด็นที่ผมชอบคือ Anthropic บอกว่าเมื่อ model รุ่นใหม่เก่งขึ้น บางส่วนของ harness ที่เคยจำเป็นอาจไม่จำเป็นอีกต่อไป</p>



<p class="wp-block-paragraph">นี่เป็นความจริงที่สำคัญมาก ทุก component ใน harness คือสมมติฐานบางอย่างว่า model ยังทำเองได้ไม่ดีพอ เช่น ยังวางแผนไม่ดีพอ ยัง review ตัวเองไม่ดีพอ ยังทำงานยาวไม่ได้พอ หรือยังต้องแตกงานเป็น sprint เล็กๆ</p>



<p class="wp-block-paragraph">แต่เมื่อ model ดีขึ้น สมมติฐานเหล่านี้อาจหมดอายุ</p>



<p class="wp-block-paragraph">ดังนั้น harness ที่ดีไม่ควรเป็น pipeline แข็งๆ แต่ควรเป็นระบบที่ปรับได้ เช่น</p>



<ul class="wp-block-list">
<li>เปิดหรือปิด planner ได้</li>



<li>เลือก evaluator แบบเบาหรือหนักได้</li>



<li>ปรับจำนวนรอบ iteration ได้</li>



<li>เลือกใช้ context reset หรือ compaction ได้</li>



<li>ถอด component ที่ไม่ load-bearing ออกได้</li>
</ul>



<p class="wp-block-paragraph">ผมคิดว่านี่คือแนวคิดที่ดีมากสำหรับคนทำ agent platform เพราะเราไม่ได้ออกแบบระบบเพื่อ model รุ่นเดียว แต่ต้องออกแบบให้ evolve ตาม model ได้</p>



<h2 class="wp-block-heading">ถ้าจะเอามาพัฒนาต่อ ผมจะเริ่มจากอะไร</h2>



<p class="wp-block-paragraph">ถ้าเอาแนวคิดนี้มาใช้กับระบบ agent ที่ผมกำลังทำอยู่ ผมคิดว่าสิ่งที่ควรเริ่มมีคือ 5 เรื่องนี้</p>



<h3 class="wp-block-heading">1. Artifact-first workflow</h3>



<p class="wp-block-paragraph">อย่าให้ chat เป็นที่เก็บ state หลักของงาน แต่ให้ agent ทำงานผ่านไฟล์หรือ object ที่ชัดเจน เช่น</p>



<ul class="wp-block-list">
<li><code>SPEC.md</code></li>



<li><code>PLAN.md</code></li>



<li><code>TASKS.md</code></li>



<li><code>STATE.md</code></li>



<li><code>EVAL.md</code></li>



<li><code>HANDOFF.md</code></li>
</ul>



<p class="wp-block-paragraph">ไฟล์เหล่านี้ทำให้ agent ตัวถัดไปอ่านต่อได้ และมนุษย์ก็ตรวจได้ด้วย</p>



<p class="wp-block-paragraph">ซึ่งหากใครใช้ skill พวกทำ Spec Driven มันจะสร้างเอกสาร spec/plan/adr ให้อัตโนมัติ คอนเซ็ปประมาณนี้เลย</p>



<h3 class="wp-block-heading">2. Maker กับ Checker ต้องแยกกัน</h3>



<p class="wp-block-paragraph">งานสำคัญไม่ควรให้ agent ตัวเดียวสร้างและรับรองงานตัวเอง ควรมี reviewer หรือ evaluator แยกออกมาเสมอ โดยเฉพาะงานที่ต้อง publish, deploy หรือกระทบข้อมูลจริง</p>



<h3 class="wp-block-heading">3. Evaluator ต้องมี Rubric</h3>



<p class="wp-block-paragraph">rubric คือชุดเกณฑ์การให้คะแนน หรือเครื่องมือประเมินผลที่อธิบายระดับคุณภาพของชิ้นงาน </p>



<p class="wp-block-paragraph">ดังนั้น Evaluator ที่ไม่มี rubric จะตรวจแบบลอยๆ และมักใจดีเกินไป rubric ที่ดีควรบอกว่าอะไรคือ pass, อะไรคือ fail, ต้องลอง edge case ไหน และอะไรที่ห้ามมองข้าม</p>



<h3 class="wp-block-heading">4. Context Reset ต้องเป็น Feature ไม่ใช่ปล่อยให้แก้ตอนเต็ม</h3>



<p class="wp-block-paragraph">ถ้างานยาวพอ เราควรออกแบบไว้เลยว่า agent จะ reset ตอนไหน ส่งต่ออะไร และ agent ตัวใหม่ต้องอ่านอะไรบ้าง ไม่ใช่รอให้ context เต็มแล้วค่อยหาทางรอด</p>



<h3 class="wp-block-heading">5. ต้องมี Stop Condition</h3>



<p class="wp-block-paragraph">Agent ที่ทำงานเองได้ต้องรู้ด้วยว่าเมื่อไรควรหยุด ถ้าไม่มี stop condition มันอาจวนแก้ไปเรื่อยๆ ใช้ token ใช้เวลา แต่คุณภาพไม่ได้ดีขึ้นตามสัดส่วน</p>



<h2 class="wp-block-heading">ข้อควรระวัง</h2>



<p class="wp-block-paragraph">แนวทางนี้น่าสนใจมาก แต่ก็มีข้อควรระวังเยอะเหมือนกัน</p>



<ul class="wp-block-list">
<li><strong>Cost สูงขึ้น</strong> เพราะใช้หลาย agent ทำงานหลายรอบ และต้องมี evaluation loop</li>



<li><strong>สร้างงานได้ช้าขึ้น</strong> เพราะงานบางอย่างต้องรอ browser test, QA หรือ iteration</li>



<li><strong>ซับซ้อนขึ้น</strong> เพราะต้องดูแล state, artifact, prompt, rubric และ orchestration</li>



<li><strong>Evaluator ก็พลาดได้</strong> ถ้า rubric ไม่ดีหรือทดสอบไม่ลึกพอ</li>



<li><strong>Handoff ที่ไม่ดีอันตรายมาก</strong> เพราะ agent รุ่นถัดไปอาจสานต่อจากข้อมูลผิด</li>
</ul>



<p class="wp-block-paragraph">ดังนั้นผมคิดว่าควรใช้ harness หนักๆ เฉพาะงานที่คุ้มจริง เช่นงานที่มีผลลัพธ์สำคัญ งานที่ต้องใช้ซ้ำ หรืองานที่ถ้าพลาดแล้วเสียเวลามาก</p>



<h2 class="wp-block-heading">สรุป</h2>



<p class="wp-block-paragraph">บทความนี้ทำให้ผมยิ่งเชื่อว่าอนาคตของ AI Agent ไม่ได้อยู่ที่ prompt อย่างเดียว แต่อยู่ที่การออกแบบ harness รอบๆ model ให้ดีพอ</p>



<p class="wp-block-paragraph">Agent ที่ทำงานยาวได้จริงต้องมี plan ต้องมี state ต้องมี handoff ต้องมี evaluator ต้องมี rubric และต้องมีวิธีรู้ว่าเมื่อไรควรทำต่อหรือหยุด</p>



<p class="wp-block-paragraph">ถ้าทำได้ดี เราจะเริ่มเปลี่ยนจากการใช้ AI เป็นผู้ช่วยทีละคำสั่ง ไปสู่การมี AI operator ที่รับโจทย์ซับซ้อน ทำงานต่อเนื่อง ตรวจตัวเอง ส่งต่องาน และปรับปรุงผลลัพธ์ได้มากขึ้นเรื่อยๆ</p>



<p class="wp-block-paragraph">สำหรับผม นี่เป็นทิศทางที่น่าทดลองมาก และน่าจะเป็นแกนสำคัญของระบบ agent รุ่นถัดไปที่ไม่ได้แค่ “ตอบเก่ง” แต่ “ทำงานเป็นระบบ” ได้จริง</p>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://myifew.com/7778/harness-design-by-anthopic/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
