คำศัพท์

AI ที่ไม่ได้แค่ตอบแชต แต่ลงมือเองได้ เช่นอ่านไฟล์ รันคำสั่ง แก้โค้ด วนจนงานเสร็จ

AI agent หรือ coding agent อย่าง Claude Code, Codex, Cursor คือโมเดลที่ต่อกับ tool ให้ลงมือได้จริง อ่านและแก้ไฟล์ รันคำสั่ง เรียก API แล้ววนทำต่อจนคิดว่าจบ ความสามารถนี้ทำให้มันพังของจริงได้ด้วย เลยต้องมีกฎใน CLAUDE.md, hook และเงื่อนไขจบที่เช็คได้ ไม่งั้นมันจะหยุดตอนที่มันคิดเองว่าเสร็จ

งานที่ AI ทำแบบปล่อย default จนดูออก จืดและเหมือนกันหมด เช่น gradient text ทุกหน้า

AI slop คือ output ที่ได้จากการปล่อยให้ AI เลือก default เอง เช่นเว็บที่มี gradient text จัดกลางทุกอย่าง glassmorphism หรือโค้ดเยิ่นเย้อไร้เหตุผล มันไม่ผิดแต่ทุกคนได้หน้าตาเดียวกัน เพจนี้ทำ checklist ของ tell ไว้ไล่จับ แล้วแก้ด้วยการตัดสินใจเองแทนที่จะปล่อยให้ AI เลือกทางเซฟ

ช่องทางให้โปรแกรมเรียกใช้อีกระบบ เช่นเรียกโมเดลผ่านโค้ด ซึ่งจ่ายตามจำนวน token ที่ใช้

API คือประตูให้โค้ดเรียกใช้บริการของอีกระบบ เช่น Claude API, API ของ backend เราเอง หรือ API ของบริการภายนอก ในบริบท AI มักหมายถึงการเรียกโมเดลผ่านโค้ดแบบจ่ายตาม token แยกจากแพ็กเกจรายเดือน ส่วนในงานเว็บ frontend คุยกับ backend ผ่าน API ซึ่งรูปร่างของ request และ response ต้องตรงกันทั้งสองฝั่ง

ข้อตกลงว่า API มี endpoint อะไร ส่งอะไร ได้อะไรกลับ ซึ่ง frontend กับ backend ต้องตรงกัน

API contract คือนิยามร่วมของ endpoint, request body, response shape และ auth ที่สองฝั่งยึดถือ ถ้า backend เปลี่ยน response จาก array เป็น object แต่ frontend ไม่รู้ ระบบจะพังตอน runtime โดยไม่มีใครเห็นก่อน เวลาให้ agent ทำงานข้าม repo จึงต้องประกาศ contract ไว้ใน handoff แล้ว verify ว่าโค้ดจริงยังตรง

บนกระดานCrossing BoundariesSequence diagram as contract

รัศมีความเสียหายถ้าการแก้ครั้งนี้พัง ว่ากระทบกี่ไฟล์ กี่ระบบ กี่คน

blast radius คือการถามก่อนลงมือว่าถ้าเปลี่ยนจุดนี้แล้วผิด อะไรจะพังตามบ้าง แก้ helper ที่ถูกเรียกจากร้อยที่มีรัศมีกว้างกว่าแก้หน้าเดียวเยอะ ใช้คู่กับ R0/R1/R2 เพื่อตัดสินว่างานไหน AI ทำเองได้ งานไหนต้องให้คนดูก่อน

บนกระดานSingle ResponsibilitySmall PRs

เส้นแบ่งที่ข้างในมี model และคำศัพท์ของตัวเอง คำเดียวกันข้ามเส้นอาจแปลคนละอย่าง

bounded context คือขอบเขตที่ model หนึ่งใช้ได้ เช่น billing มองคนเป็น Customer ส่วน marketing มองคนเดียวกันเป็น Contact แต่ละฝั่งมีฟิลด์และความหมายของตัวเอง แชร์กันแค่ id พอใช้กับ agent หลายตัว หนึ่ง context มักเท่ากับหนึ่ง agent หรือหนึ่ง repo ที่มี CLAUDE.md บอกขอบเขตของมัน

บนกระดานBounded Context

เส้นงานแยกใน git ที่แก้โค้ดได้โดยไม่แตะ main

branch คือสำเนาของประวัติโค้ดที่แยกออกมาจาก main ให้ทำงานชิ้นหนึ่งได้โดยไม่กระทบคนอื่น ถ้า agent ทำงานใน branch ของตัวเอง ความพังจะอยู่ใน branch นั้น และถอยได้ด้วยการไม่ merge หรือปิด PR ไม่ต้องไปแก้ main ที่ทุกคนใช้อยู่

บนกระดานFeature branch + PR

ที่พัก context ก้อนเดิมให้โมเดลอ่านซ้ำได้ถูกกว่าหลายเท่า แต่หมดอายุถ้าทิ้งไว้นาน

เวลาคุยต่อเนื่อง context ส่วนที่ไม่เปลี่ยนจะถูกเก็บใน cache รอบถัดไปโมเดลอ่านจาก cache (cache read) ในราคาถูกกว่า input ปกติหลายเท่า แต่ต้องจ่ายตอนเขียนลง cache (cache write) และ cache มีอายุจำกัด ถ้าทิ้ง session ไว้นานแล้วกลับมาคุยต่อ ทั้งก้อนต้องเขียนใหม่ในราคาเต็ม งานหนักๆ บิลส่วนใหญ่จึงเป็นค่า cache read ไม่ใช่ output

ระบบที่รัน lint, test และ build อัตโนมัติทุกครั้งที่มีโค้ดใหม่

CI (continuous integration) คือเครื่องที่รันชุดตรวจเดิมทุกครั้งที่มี commit หรือ PR ใหม่ เช่น GitHub Actions ถ้าตั้ง branch protection ให้ merge ได้เมื่อ CI ผ่านเท่านั้น มันจะเป็นด่านที่ agent เถียงไม่ได้ ต่างจากคำว่า test ผ่านในแชทที่เป็นแค่คำพูด

บนกระดานCI as the fence

ไฟล์กฎประจำโปรเจกต์ที่ Claude Code อ่านทุกครั้งที่เปิด session บอกว่าทำอะไรได้ อะไรห้าม

CLAUDE.md คือไฟล์ข้อความที่วางไว้ที่ root ของ repo (หรือใน ~/.claude/ ให้ใช้ทุกโปรเจกต์) Claude Code โหลดมันเข้า context ทุก session เลยเหมาะกับกฎที่ต้องใช้ตลอด แต่มันเป็นแค่ข้อความให้ AI อ่าน ไม่ใช่ตัวบังคับ ยิ่งยาวยิ่งกิน token และยิ่งทำตามน้อยลง เรื่องที่ห้ามพลาดเด็ดขาดควรย้ายไปเป็น hook ส่วนวิธีทำงานเฉพาะเรื่องย้ายไปเป็น skill

คำสั่งล้าง context ทั้งหมดใน Claude Code แล้วเริ่ม session ใหม่สะอาดๆ

/clear ลบบทสนทนาทั้งหมดออกจาก context ทำให้รอบถัดไปเบาและถูกลง ไม่โดนของเก่าลากไปผิดทาง แต่ทุกอย่างที่ตกลงกันไว้ใน session หายหมด เพจนี้เลยสรุปงานลงไฟล์ก่อน /clear เสมอ เช่นอัปเดต spec.md หรือใช้ skill สรุป session แล้วให้ session ใหม่อ่านไฟล์นั้นต่อ

โปรแกรมที่สั่งงานด้วยการพิมพ์คำสั่งใน terminal แทนการคลิกหน้าจอ

CLI (command-line interface) คือเครื่องมือที่ใช้ผ่าน terminal เช่น Claude Code, Codex CLI หรือ twitter-cli ข้อดีกับงาน agent คือ AI เรียกใช้เองได้ทันทีผ่าน shell โดยไม่ต้องมีคนกดปุ่ม และเอาไปต่อกับ cron หรือ script ให้รันอัตโนมัติได้

การบันทึกการแก้โค้ดหนึ่งก้อนลง git พร้อมข้อความ เป็นจุดที่ย้อนกลับมาได้เสมอ

commit คือ snapshot ของการเปลี่ยนแปลงที่บันทึกลงประวัติของ repo พร้อมข้อความว่าแก้อะไร ตอนทำงานกับ AI ควร commit ทีละเรื่องเล็กๆ (atomic commit) พอมีอะไรพังจะได้ย้อนได้และไล่หาเจอว่า commit ไหนเป็นต้นเหตุ และควรมี commit เป็นจุดเซฟก่อนปล่อยให้ AI แก้ของใหญ่

บนกระดานCommits as context

คำสั่งย่อ session ยาวๆ ให้เหลือแค่บทสรุป เพื่อให้ context ว่างพอทำงานต่อ

/compact ใน Claude Code จะสรุปบทสนทนาที่ผ่านมาแล้วแทนที่ด้วยบทสรุปสั้นๆ ทำให้ context ว่างพอทำงานต่อ และระบบก็ compact ให้เองเมื่อใกล้เต็ม ข้อเสียคือรายละเอียดหรือข้อตกลงบางอย่างหายไปในการสรุป ของที่ห้ามลืมจึงควรอยู่ในไฟล์อย่าง spec.md หรือ handoff

ทุกอย่างที่ AI เห็นอยู่ในรอบนั้น ทั้งแชต ไฟล์ที่อ่าน และกฎที่โหลด ยิ่งยาวยิ่งแพงและยิ่งหลุดง่าย

context คือข้อมูลทั้งหมดที่โมเดลมองเห็นตอนตอบ ทั้งข้อความที่คุยกัน ไฟล์ที่อ่าน CLAUDE.md และ skill ที่โหลด ส่วน context window คือเพดานว่าใส่ได้มากสุดกี่ token ทุกรอบโมเดลต้องอ่าน context ทั้งก้อนใหม่ ยิ่งยาวยิ่งเผา token และพอใกล้เต็มก็ต้อง compact หรือ /clear ซึ่งรายละเอียดจะหาย ของสำคัญจึงควรเก็บในไฟล์แทนที่จะพึ่ง context

ตัวตั้งเวลาให้คำสั่งรันเองอัตโนมัติ เช่นทุกเช้า 7 โมง หรือทุก 4 ชั่วโมง

cron คือ scheduler ดั้งเดิมของ Linux/macOS ที่รันคำสั่งตามเวลาที่ตั้ง หนึ่งงานเรียกว่าหนึ่ง cron job เพจนี้ใช้ cron คู่กับ Claude Code แบบ headless (claude -p) ให้ AI ทำงานเองทุกวัน เช่นสรุปตลาดตอนเช้าหรือ refresh hot cache ข้อควรระวังคือต้องระบุ timezone ให้ชัด และต้องมีทางรู้เมื่อ job พังเงียบๆ

Domain-Driven Design แนวคิดของ Eric Evans ปี 2003 ที่ให้โค้ดใช้คำและเส้นแบ่งเดียวกับธุรกิจ

DDD หรือ Domain-Driven Design คือแนวคิดจากหนังสือของ Eric Evans ปี 2003 ว่าโค้ดควรสะท้อนธุรกิจที่มันรับใช้ ใช้คำเดียวกับที่ทีมพูด แบ่งระบบตามทีมหรือเรื่องที่ดูแล และกันระบบข้างนอกไม่ให้ภาษาของมันไหลเข้ามา ไฟล์อย่าง GLOSSARY.md ใน skill หลายตัวก็มาจากแนวคิดนี้

บนกระดานBounded Context

การเอาโค้ดขึ้นเซิร์ฟเวอร์จริงให้คนใช้ได้ บาง deploy ทำแล้วย้อนไม่ได้

deploy คือการปล่อยโค้ดจากเครื่องเราขึ้น environment ที่คนใช้จริง เช่น Vercel, Railway หรือ VPS ของที่รันในเครื่องผ่านหมดอาจพังทันทีตอนขึ้นจริงเพราะ config ต่างกัน และบาง deploy เช่น smart contract หรือ migration ฐานข้อมูลจริงถือเป็น R0 คือย้อนไม่ได้ ต้องหยุดถามก่อนเสมอ

บนกระดานRollback in one command

รูปทรงของโค้ดที่คนเจอปัญหาเดียวกันมาหลายครั้งแล้วตั้งชื่อให้ พูดชื่อเดียวก็รู้ว่าไฟล์ควรหน้าตาแบบไหน

design pattern คือวิธีแก้ปัญหาที่วนกลับมาซ้ำในการเขียนโปรแกรม ที่ถูกเขียนเป็นแบบฟอร์ม ชื่อ ปัญหา วิธีแก้ และสิ่งที่ต้องแลก ชุดที่ดังที่สุดคือ 23 ตัวในหนังสือของ Gamma, Helm, Johnson และ Vlissides ปี 1994 ที่คนเรียกว่า Gang of Four ประโยชน์ตอนใช้ agent คือคำสั่งสั้นลง พูดว่า Strategy หรือ Facade แล้ว agent รู้ว่าต้องมีไฟล์อะไรบ้าง และเราตรวจ diff ได้ว่ารูปทรงตรงกับชื่อไหม

บนกระดานStrategy

ชนิดข้อมูลที่มีค่าได้แค่ชุดที่ประกาศไว้ เช่นสถานะ draft, ready, posted

enum คือการประกาศว่าค่านี้เป็นได้แค่ไม่กี่แบบที่ระบุไว้ เช่นสถานะของออเดอร์หรือโพสต์ พอค่าทุกแบบถูกประกาศไว้ที่เดียว compiler หรือ test ก็เช็กได้ว่าโค้ดจัดการครบทุกแบบหรือยัง ถ้าลืมแบบไหน เช่นไม่มีค่าที่แปลว่าไม่เอาแล้ว ของจะค้างอยู่ในสถานะผิดโดยไม่มี error

บนกระดานState diagram as transition table

ค่าตั้งที่เปลี่ยนตามเครื่องหรือ environment เช่น URL ฐานข้อมูลและ API key มักเก็บในไฟล์ .env

env (environment variable) คือค่าที่โปรแกรมอ่านจากภายนอกแทนการ hardcode ในโค้ด เช่นที่อยู่ฐานข้อมูล API key หรือพอร์ต ทำให้โค้ดชุดเดียวรันได้ทั้งบนเครื่อง dev และ production ไฟล์ .env ที่มี secret ต้องอยู่ใน .gitignore และห้าม commit ขึ้น repo เด็ดขาด

ชุดทดสอบที่วัดว่าโมเดล agent หรือ skill ทำงานได้ดีแค่ไหน ออกมาเป็นคะแนนเทียบกันได้

eval คือการวัดผลโมเดลหรือ agent ด้วยชุดโจทย์ที่ตั้งไว้ เช่น benchmark ที่บริษัทประกาศคะแนน หรือเครื่องมือทดสอบว่า skill ทำตามที่ตั้งใจไหม ข้อควรระวังคือคะแนนที่เจ้าของประกาศเองอาจไม่ตรงกับงานของเรา ลองกับโจทย์ตัวเองก่อนเชื่อ

สัญญาณว่ามีบางอย่างเกิดขึ้นแล้ว เช่น จ่ายเงินแล้ว หรือ agent กำลังจะเรียก tool ใครสนใจก็มาลงชื่อรอฟัง

event คือการประกาศว่าเรื่องหนึ่งเกิดขึ้นแล้ว ตัวที่ประกาศไม่ต้องรู้ว่าใครฟังอยู่ ส่วนตัวที่สนใจก็ลงทะเบียน handler ไว้รับ เช่น hook ที่ผูกกับ tool.call ใน Claude Code หรือไฟล์ที่รอ order.paid ในร้านค้า ข้อดีคือเพิ่มคนฟังได้โดยไม่แก้ตัวประกาศ และตัวฟังที่พังไม่ลากตัวอื่น แต่ต้องมี log บอกว่าตัวไหนพัง ไม่งั้นมันจะเงียบ

บนกระดานObserver

หน้าเดียวที่คนเรียกใช้ ข้างหลังมีหลายระบบที่ต้องเรียกตามลำดับ คนเรียกไม่ต้องรู้ว่ามีกี่ตัว

Facade คือ design pattern จากหนังสือ Gang of Four ปี 1994 เมื่อของข้างในมีหลายชิ้นเกินกว่าที่คนเรียกควรต้องรู้ ก็ทำหน้าเดียวมาบังไว้ แล้วให้หน้านั้นเลือกและเรียกของข้างในตามลำดับให้ เช่นการซื้อคอร์สที่ต้องคิดราคา ตัดเงิน เปิดคอร์ส และส่งอีเมล ถ้าทุกช่องทางเรียกหน้าเดียวกัน แก้ลำดับครั้งเดียวก็ได้ทุกช่องทาง ถ้าต่างคนต่างเรียกเอง ลำดับจะเพี้ยนไปคนละทาง

บนกระดานFacade

สวิตช์ที่เปิดหรือปิดของใหม่ได้โดยไม่ต้อง deploy ใหม่

feature flag คือเงื่อนไขในโค้ดที่อ่านค่าจากข้างนอกว่าจะใช้ของใหม่หรือของเดิม ปล่อยของขึ้นระบบได้โดยยังไม่เปิดให้ทุกคน และถ้าพังก็ปิดสวิตช์คำสั่งเดียว ลูกค้ากลับไปใช้ flow เดิมทันที ไม่ต้องรอแก้โค้ดหรือ deploy

บนกระดานRollback in one command

ช่วงเวลาตั้งแต่ลงมือจนรู้ผลว่าถูกหรือผิด ยิ่งวงสั้นยิ่งชี้ได้ว่าอะไรทำพัง

feedback loop คือรอบ ลองแล้วรู้ผล ถ้ารู้ว่าพังภายในไม่กี่วินาทีด้วย test หรือ commit เล็กๆ จะชี้ได้ทันทีว่าการแก้ไหนเป็นต้นเหตุ แต่ถ้ารู้ตอนผ่านไปหนึ่งอาทิตย์ จะไล่ไม่ได้แล้วว่าอันไหนทำพัง ยิ่ง AI แก้โค้ดได้เร็ว ยิ่งต้องมีวงที่สั้นพอให้จับผิดทัน

บนกระดานHumble Object

หมุดที่ปักชื่อไว้บน commit หนึ่ง เช่น v0.1.4 ใช้เป็นจุดที่กลับไปได้

git tag คือชื่อที่ติดไว้กับ commit หนึ่ง มักใช้ตอนปล่อยของขึ้นแต่ละรอบ วันที่ของพังและหาไม่เจอ ก็กลับไปดูจุดที่ปักไว้ล่าสุดที่ยังดี แล้วเทียบว่ามีอะไรเปลี่ยนตั้งแต่นั้น tag แบบ annotated เก็บคนตัด วันที่ และข้อความไว้ในตัว และไม่ควรถูกย้าย

บนกระดานRollback in one command

กฎหรือด่านที่ตั้งไว้ล่วงหน้า กันไม่ให้ AI ทำพังในจุดที่รู้ว่าเสี่ยง

guardrail คือข้อจำกัดที่ใส่ไว้ก่อน เช่นกฎใน CLAUDE.md, hook ที่บล็อกคำสั่ง หรือจังหวะที่ระบบ permission ให้หยุดถามก่อนเขียนข้อมูลจริง ใส่ตรงจุดที่เคยพังหรือพังแล้วแพง เพื่อให้ปล่อย AI ทำงานเองได้มากขึ้นโดยไม่ต้องเฝ้าทุกบรรทัด

บนกระดานCI as the fence

อาการที่ AI แต่งข้อมูลขึ้นมาเองอย่างมั่นใจ เช่นตัวเลขหรือไฟล์ที่ไม่มีจริง

hallucination คือตอนที่โมเดลตอบสิ่งที่ฟังดูถูกแต่ไม่มีจริง เช่นอ้างไฟล์ที่ไม่มี ตัวเลขที่มั่ว หรือบอกว่าเสร็จแล้วทั้งที่ไม่ได้ทำ ทางกันคือบังคับให้มันระบุ assumption ให้ชัด แสดงหลักฐานก่อนบอกว่าเสร็จ และแยกขั้นดึงข้อมูลจริงออกจากขั้นที่ให้ AI เขียน

โน้ตส่งงานข้าม terminal หรือข้าม repo ว่าเปลี่ยนอะไรไป อีกฝั่งต้องทำอะไรต่อ

handoff คือไฟล์ที่ agent ตัวหนึ่งเขียนไว้ให้อีกตัวอ่าน เช่น backend เปลี่ยน API แล้วเขียนบอก frontend ว่า endpoint, request หรือ response shape เปลี่ยนยังไง โดย commit ลง repo แทนการให้คนนั่ง copy context ข้ามหน้าต่าง แล้วมีขั้น verify เทียบว่าโค้ดจริง drift ออกจากที่ handoff บอกไว้หรือยัง

บนกระดานCommits as context

เส้นทางปกติที่ทุกอย่างเป็นไปตามคาด ผู้ใช้กรอกถูก ระบบไม่ล่ม ไม่มีกรณีแปลก

happy path หรือ happy flow คือกรณีปกติที่ทุกอย่างราบรื่น ตอนโปรเจกต์ยังไม่มีผู้ใช้ เพจนี้แนะนำให้ทำ happy path ให้ใช้ได้ก่อนแล้วค่อยเติม error handling ทีหลัง แต่อย่าหลงว่าผ่าน happy path แล้วคือเสร็จ AI review ทั่วไปมักเดินแค่เส้นนี้ ไม่ได้ลองกดซ้ำหรือทำผิดลำดับแบบผู้ใช้จริง

บนกระดานSequence diagram as contract

โครงที่ห่อโมเดลให้ทำงานเป็น agent ได้ ทั้ง prompt ระบบ tool และ loop เช่นตัว Claude Code เอง

harness คือซอฟต์แวร์รอบตัวโมเดลที่ให้ prompt ตั้งต้น เชื่อม tool จัดการ context และวนรอบการทำงาน Claude Code หรือ Codex ก็คือ harness แบบหนึ่ง โมเดลเดียวกันใน harness ต่างกันได้ผลต่างกัน และกฎที่เราเขียนเพิ่มควรเช็คว่าไม่ขัดกับ prompt ของตัว harness เอง

การรัน agent โดยไม่มีหน้าจอโต้ตอบ สั่งทีเดียวให้ทำจนจบ เช่น claude -p ที่เรียกจาก cron

headless คือการรันเครื่องมือโดยไม่เปิดหน้าจอให้คนกด อย่าง claude -p ที่รับ prompt แล้วพิมพ์ผลออกมาเลย เหมาะกับ cron, bot หรือ pipeline ที่ไม่มีคนนั่งเฝ้า ข้อควรระวังคือถ้ามีขั้นไหนรอให้คนกด confirm มันจะค้างรอจนหมดเวลา และถ้าพังก็ไม่มีใครเห็นตรงหน้า

สคริปต์ที่รันเองเมื่อเกิด event เช่นก่อน agent เรียก tool ใช้บล็อกเรื่องที่ห้ามพลาดเด็ดขาด

hook คือโค้ดที่ตั้งไว้ใน settings.json ให้ Claude Code รันเองเมื่อเกิด event เช่นก่อนเรียก tool หรือตอนส่ง prompt ต่างจากกฎใน CLAUDE.md ที่เป็นแค่ข้อความให้ AI อ่าน hook บังคับได้จริง เลยเหมาะกับเรื่องที่ยอมให้เกิดไม่ได้สักครั้ง ข้อควรระวังคือ hook ที่พังอาจเงียบโดยไม่บอกใคร ต้องมีทางเช็คว่ามันยังทำงานอยู่

บนกระดานCI as the fence

ไฟล์ markdown ไฟล์เดียวที่สรุปสถานะล่าสุดไว้ให้ AI อ่านตอนเปิด session ใหม่

hot cache เป็นเทคนิคของเพจนี้ ใช้ cron refresh ไฟล์สรุปสั้นๆ ทุกไม่กี่ชั่วโมง รวม git log งานค้าง PR ที่เปิดอยู่ และการตัดสินใจล่าสุด แล้วให้ AI อ่านไฟล์เดียวนี้ตอนเริ่ม session แทนการไล่เปิดสิบไฟล์ ได้ context ปัจจุบันทันทีโดยเสีย token น้อย คนละอย่างกับ prompt cache ของ API

ออกแบบให้ส่งคำขอเดิมซ้ำกี่รอบก็ได้ผลเดียว เช่นกดจ่ายสิบครั้งได้ออร์เดอร์เดียว

idempotent คือคุณสมบัติที่ทำซ้ำแล้วผลไม่เปลี่ยน แทนที่จะพยายามห้ามคนกดซ้ำ ให้แนบ idempotency key ไปกับคำขอ เจอ key เดิมก็คืนผลเดิมไม่สร้างใหม่ แล้วล็อกอีกชั้นที่ฐานข้อมูลด้วย unique constraint โค้ดที่ AI เขียนมักถูกตอนกดครั้งเดียว แต่ไม่เผื่อการกดซ้ำหรือ race condition จนกว่าจะมีคนใช้จริง

บนกระดานCommand

สภาพที่โค้ดหรือ workflow ผูกกับ vendor หรือโมเดลตัวเดียวจนเปลี่ยนไม่ได้โดยไม่รื้อ

lock-in คือตอนที่ระบบรู้จักรูปแบบเฉพาะของ vendor ตัวเดียวไปทั่ว เช่น ชื่อ field ของ API, syntax เฉพาะของโมเดล หรือ key ที่ hardcode ไว้หลายที่ วันที่ vendor ขึ้นราคา ล่ม หรือเลิกทำ การย้ายต้องไล่แก้ทุกไฟล์ ทางกันคือเขียนสิ่งที่เราใช้ด้วยคำของเราเอง แล้วให้ตัวแปลงหนึ่งไฟล์ต่อ vendor เป็นที่เดียวที่รู้จักรูปแบบของมัน

บนกระดานAdapter

รูปแบบเขียนข้อความด้วย # หัวข้อ และ - รายการ ไฟล์ .md ที่ AI อ่านเกือบทั้งหมดเขียนแบบนี้

markdown คือวิธีจัดรูปแบบข้อความด้วยสัญลักษณ์ง่ายๆ เช่น # หัวข้อ, - รายการ, **ตัวหนา** ไฟล์ที่ใช้คุยกับ agent อย่าง CLAUDE.md, skill, spec.md หรือ hot cache ล้วนเป็น markdown เพราะทั้งคนและ AI อ่านง่าย แก้ด้วย editor ธรรมดาได้ และเก็บใน git ได้

มาตรฐานต่อ AI เข้ากับเครื่องมือภายนอก เช่น GitHub, Figma, ฐานข้อมูล ผ่าน MCP server

MCP (Model Context Protocol) คือรูปแบบกลางที่ทำให้ agent เรียก tool ภายนอกได้ ติดตั้งเป็น MCP server ทีละตัว เช่นตัวที่ดึง docs ล่าสุดของ library, ตัวที่อ่าน issue กับ PR บน GitHub หรือตัวที่เปิด browser ทดสอบหน้าเว็บ ทำให้ AI ทำงานกับระบบจริงได้โดยไม่ต้องให้เรา copy ข้อมูลมาแปะเอง

ที่ที่ AI จดบทเรียนหรือข้อมูลไว้ให้ session หน้าอ่าน เพราะปกติมันจำข้าม session ไม่ได้

memory ในโลก agent คือกลไกให้ AI จำของข้าม session เช่นไฟล์ MEMORY.md ที่จดว่าพลาดอะไรแล้วแก้ยังไง หรือ memory ที่ติดมากับเครื่องมืออย่าง Claude Code และ Copilot ถ้าไม่มี มันจะพังแบบเดิมซ้ำทุก session แต่ memory ก็จดของผิดได้ ถ้าคำตัดสินที่ผิดถูกจดลงไป มันจะหยิบมาพูดซ้ำอย่างมั่นใจ

ภาษาเขียนแผนภาพเป็น text เช่น flowchart, sequence diagram, state diagram แล้วให้เครื่องวาดเป็นรูป

Mermaid คือวิธีเขียนแผนภาพเป็นข้อความธรรมดา GitHub และเครื่องมือหลายตัววาดให้เป็นรูปเอง ข้อดีคือแผนภาพอยู่ใน repo ข้างโค้ด แก้แล้วเห็นใน diff และสคริปต์หรือ test อ่านมันได้ ต่างจากรูปที่ export มาจากโปรแกรมวาด

บนกระดานClass diagram as import rules

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

middleware คือชั้นที่ห่อการเรียกหนึ่งครั้งไว้ ทุกคำขอต้องวิ่งผ่านมันก่อนถึงของจริง มันเลือกได้ว่าจะปล่อยผ่าน บล็อก แก้ข้อมูล หรือตอบแทนเอง เช่น middleware ของ Express หรือ hook ที่ดัก tool call ใน Claude Code ข้อดีคือเพิ่ม log, retry หรือการตรวจสิทธิ์ได้ที่เดียว แทนที่จะเขียนซ้ำในทุกไฟล์ที่เรียก ข้อควรระวังคือถ้า middleware พังแบบเงียบ ทุกอย่างข้างหลังมันจะดูเหมือนปกติ

บนกระดานDecorator

การให้ AI หลายตัวแบ่งงานหรือคุยกันเอง แทนการใช้ agent ตัวเดียว

multi-agent คือระบบที่มี agent หลายตัว เช่นตัวหนึ่งเขียน ตัวหนึ่งรีวิว หรือแตก worker ไปทำงานขนานกัน ฟังดูดีแต่เพิ่มคำถามว่าใครถือความจริง ใครจับ drift และค่า token ก็คูณเข้าไป เพจนี้มองว่ามันคุ้มจริงเมื่อ tool, permission หรือ state ต้องแยกกันชัด ไม่ใช่แค่อยากมีทีม AI

การสร้างของซับซ้อนเกินปัญหาจริง เช่นแก้ bug บรรทัดเดียวด้วย service ใหม่ 250 บรรทัด

overengineering คือการใส่ abstraction, service, ชั้นป้องกัน หรือ infra ที่ปัญหายังไม่ต้องการ AI ชอบทำแบบนี้เพราะมันดูรอบคอบ และคนก็ชอบ setup CI/CD กับ monitoring ครบตั้งแต่ยังไม่มีผู้ใช้สักคน เพจนี้ใช้ skill อย่าง occam ให้เทียบทางที่ง่ายที่สุดกับทางที่เสนอก่อนลงมือ

ชุดขั้นตอนที่ต่อกันเป็นสาย ผลของขั้นหนึ่งส่งเข้าขั้นถัดไปจนได้ของสำเร็จ

pipeline คือการแตกงานใหญ่เป็นขั้นๆ แล้วต่อกันให้รันเองได้ เช่นดึงข้อมูล → ให้ AI สรุป → render → โพสต์ ข้อดีคือแต่ละขั้นเช็คและแก้แยกกันได้ เพจนี้ชอบแยกขั้นที่ต้องแม่น เช่นดึงตัวเลขหรือ render ตัวหนังสือไทย ออกจากขั้นที่ให้ AI gen เพื่อไม่ให้ตัวเลขมั่วหรือฟอนต์แตก

ระบบจริงที่ผู้ใช้จริงใช้อยู่ (prod) ต่างจากเครื่อง dev หรือ staging ที่ไว้ลอง

production หรือ prod คือ environment ที่ลูกค้าใช้งานจริง ข้อมูลจริง เงินจริง ของที่พังตรงนี้กระทบคนจริงทันที เพจนี้เลยให้ AI อีกตัวช่วย review ก่อนขึ้น prod และจัดงานที่แตะ prod เช่น deploy หรือ migration ไว้ในระดับที่ต้องถามก่อนทำ

คำขอรวมงานจาก branch เข้า main ที่ต้องผ่านรีวิวและ CI ก่อน

pull request หรือ PR คือคำขอเอางานจาก branch หนึ่งเข้า main บน GitHub จะเห็น diff ทั้งหมด คอมเมนต์ของคนรีวิว และผลของ CI ในที่เดียว PR ที่ทำเรื่องเดียวและเล็กพอ คนรีวิวอ่านจบได้จริง ส่วนคำอธิบาย PR คือที่ที่ agent ตัวถัดไปอ่านว่างานค้างตรงไหน

บนกระดานSmall PRs

การจัดระดับงานตามว่าย้อนได้แค่ไหน R0 ย้อนไม่ได้ต้องหยุดถาม R2 ย้อนง่ายทำเลย

R0/R1/R2 คือวิธีที่เพจนี้ใช้บอก AI ว่าเมื่อไหร่ต้องหยุดถาม R0 ย้อนไม่ได้ เช่น deploy contract, migration ฐานข้อมูลจริง, push to main ต้องหยุดถามก่อน R1 ย้อนได้แต่แพง เช่นเปลี่ยน API contract ทำได้แต่ต้องบอก R2 ย้อนง่าย ทำเลยไม่ต้องถาม ช่วยให้ AI ไม่ถามพร่ำเพรื่อเรื่องเล็ก แต่ไม่ลุยเองในเรื่องที่พังแล้วกู้ไม่ได้

บนกระดานRollback in one command

บั๊กที่เกิดเมื่อสองคำสั่งทำงานพร้อมกันแล้วเขียนทับกัน ทดสอบทีละครั้งจะไม่เจอ

race condition คือบั๊กที่ผลลัพธ์ขึ้นกับว่าคำสั่งไหนมาถึงก่อน เช่นสอง request อ่านจำนวนที่นั่งเป็น 26 พร้อมกัน แล้วต่างคนต่างเขียน 27 กลับไป ที่นั่งเลยถูกขายเกิน ทดสอบทีละคนจะผ่านเสมอ ทางแก้คือให้ฐานข้อมูลเป็นคนรับประกัน เช่น unique constraint หรือเช็ก version ก่อน save

บนกระดานAggregate

การจัดโครงสร้างโค้ดใหม่ให้ดีขึ้น โดยสิ่งที่โปรแกรมทำต้องเหมือนเดิม

refactor คือการจัดโค้ดใหม่ เช่นแยก module เปลี่ยนชื่อ ลดโค้ดซ้ำ โดยพฤติกรรมที่ผู้ใช้เห็นต้องไม่เปลี่ยน และควรมี test ยืนยัน ปัญหาที่เจอบ่อยกับ AI คือสั่งแก้ bug ตัวเดียวแต่มันไป refactor ทั้ง module ซึ่งเป็นอาการของ scope drift

ย่อจาก repository คือโฟลเดอร์โปรเจกต์ที่ใช้ git เก็บโค้ดพร้อมประวัติการแก้ทั้งหมด

repo คือที่เก็บโค้ดของโปรเจกต์หนึ่งพร้อมประวัติทุก commit มักฝากไว้บน GitHub agent อย่าง Claude Code ทำงานอยู่ใน repo ที่เปิดไว้ ถ้าโปรเจกต์แยกเป็นหลาย repo (เช่น frontend, backend, contract) แต่ละ terminal จะรู้แค่ repo ของตัวเอง เลยต้องมีวิธีส่งข่าวข้ามกันอย่าง handoff

สร้าง commit ใหม่ที่กลับค่าของ commit เดิม โดยไม่ลบประวัติ

git revert สร้าง commit ใหม่ที่ทำตรงข้ามกับ commit ที่เลือก ประวัติเดิมยังอยู่ครบ ต่างจาก reset --hard ที่ย้อนทั้ง branch และลากงานคนอื่นไปด้วย ถ้า PR ถูก squash เป็น commit เดียว การถอยทั้ง PR คือ revert ครั้งเดียว

บนกระดานRollback in one command

โครงสร้างของข้อมูล เช่นตารางในฐานข้อมูลมีคอลัมน์อะไร หรือ JSON ต้องมี field อะไร

schema คือแบบแปลนของข้อมูลที่ส่วนอื่นของระบบพึ่งพา เช่นตารางในฐานข้อมูลหรือ JSON schema ของ tool การเปลี่ยน schema ที่มีข้อมูลจริงอยู่แล้วมักย้อนไม่ได้ (R0) และถ้าเปลี่ยนแล้วไม่บอกส่วนที่ใช้อยู่ ฝั่งที่ยังใช้แบบเก่าจะพังทันที

บนกระดานCrossing BoundariesAnti-Corruption Layer

อาการที่สั่งแก้เรื่องเดียว แต่ AI ขยายงานไปไกล เช่นแก้ bug ตัวเดียวแล้ว refactor ทั้ง module

scope drift หรือ scope creep คืองานที่ค่อยๆ บานออกจากสิ่งที่ขอโดยไม่มีใครทันสังเกต ผลคือ diff ใหญ่เกินจะรีวิว และเสี่ยงพังของที่ไม่เกี่ยว เพจนี้แก้ด้วยกฎใน CLAUDE.md ให้ AI เทียบเป้าหมายเดิมกับสิ่งที่กำลังทำอยู่ ถ้าเริ่มเกินให้หยุดเตือนก่อน

บนกระดานSingle Responsibility

รอบการทำงานกับ agent หนึ่งรอบ ตั้งแต่เปิดจนปิดหรือ /clear เปิดใหม่ AI จะจำของเก่าไม่ได้

session คือช่วงทำงานต่อเนื่องหนึ่งรอบใน Claude Code หรือเครื่องมือ agent อื่น ทุกอย่างที่คุยและอ่านอยู่ใน context ของ session นั้นเท่านั้น โดย default AI ไม่มี memory ข้าม session พอเปิดใหม่ก็เริ่มจากศูนย์ เลยต้องมีของอย่าง CLAUDE.md, MEMORY.md, spec หรือ handoff ไว้ให้มันอ่านต่อ

เก็บความจริงแต่ละเรื่องไว้ที่เดียว ที่อื่นอ้างถึงแทนการ copy ไปวางซ้ำ

single source of truth คือหลักที่ว่าค่าหนึ่ง เช่นสีแบรนด์ URL หรือ config ต้องมีที่อยู่ที่เดียว ที่เหลือ import หรืออ้างไปหา ถ้าเขียนซ้ำไว้หลายที่ AI จะแก้แค่ที่ที่มันเจอแล้วบอกว่าเสร็จ ทั้งที่ที่อื่นยังเป็นค่าเก่า ยิ่งให้ AI แก้โค้ดบ่อย หลักนี้ยิ่งสำคัญ

บนกระดานThe Dependency Rule

ไฟล์ markdown ที่สอน agent ทำงานเรื่องหนึ่งเป็นขั้นตอน โหลดมาใช้เฉพาะตอนเจองานนั้น

skill คือไฟล์ markdown ที่เขียนวิธีทำงานเรื่องหนึ่งไว้ เช่น review โค้ด ทำปก หรือ commit แล้ว Claude Code จะโหลดเข้ามาเมื่อเจองานที่ตรงกัน หรือเราเรียกเองด้วย /ชื่อ skill ช่วยให้ไม่ต้องอธิบายวิธีทำซ้ำทุก session และต่างจาก CLAUDE.md ตรงที่ไม่ได้ถูกโหลดทุกครั้ง เลยไม่กิน context ตลอดเวลา

เอกสารที่เขียนก่อนลงมือว่าจะสร้างอะไร ตกลงอะไรไว้ AI อ่านต่อได้แม้ /clear ไปแล้ว

spec คือเอกสารบอกว่าระบบต้องทำอะไร ตกลง architecture ไว้ยังไง และอะไรห้ามเปลี่ยน แนว spec-driven development คือเขียน spec.md ก่อนเขียนโค้ด แล้วให้ AI อัปเดตเองเมื่อมีการตัดสินใจใหม่ พอ /clear หรือ /compact ไป AI อ่าน spec แล้วทำต่อได้เลยโดยไม่ต้องเล่าใหม่

agent ลูกที่ตัวหลักแตกออกไปทำงานย่อยใน context แยก แล้วส่งแค่บทสรุปกลับมา

subagent คือ agent ที่ตัวหลักสร้างขึ้นมาทำงานชิ้นหนึ่ง เช่นค้นโค้ด รีวิว หรือ audit โดยมี context ของตัวเอง พอเสร็จส่งกลับแค่ผลสรุป ช่วยให้ context ของตัวหลักไม่บวม แต่ถ้าไม่ระบุว่าให้ subagent ใช้โมเดลไหน มันอาจเลือกเองจนค่าใช้จ่ายเกินที่คิด

คำสั่งตั้งต้นที่โมเดลเห็นก่อนทุกข้อความ กำหนดบทบาท กฎ และสไตล์ของมันทั้งรอบ

system prompt คือข้อความชั้นบนสุดที่โมเดลเห็นก่อนแชตของเรา เครื่องมืออย่าง Claude Code มี system prompt ของตัวเอง แล้วต่อด้วย CLAUDE.md และ skill ที่เราใส่ ถ้ากฎของเราขัดกับ prompt ของเครื่องมือหรือขัดกันเอง ผลจะเดาไม่ได้ เวลาเขียน bot หรือ pipeline เองก็ใช้ system prompt วางบทบาทและรูปแบบ output

วิจารณญาณว่าอะไรดีหรือไม่ดี ซึ่ง AI ช่วย gen ได้ แต่ตัดสินแทนเราไม่ได้

taste ในเพจนี้คือความสามารถเลือกและตัดสิน ว่า output ไหนใช้ได้ feature ไหนควร build ดีไซน์ไหนไม่ generic AI gen ของออกมาได้ไม่จำกัด แต่ถ้าไม่มีคนถือ taste มันจะไหลไปหา default ที่ทุกคนได้เหมือนกัน เพจนี้เลยแปลง taste เป็นคำถามหรือ filter ที่เขียนเป็น skill ได้ เช่น design-taste และ product-taste

หน้าต่างพิมพ์คำสั่งเป็นข้อความแทนการคลิก ที่ Claude Code และ Codex รันอยู่

terminal คือโปรแกรมที่ให้พิมพ์คำสั่งแทนการคลิก Claude Code, Codex และ CLI ส่วนใหญ่ทำงานในนี้ คนที่ทำหลายงานพร้อมกันมักเปิดหลาย terminal แยกกันคนละ repo ซึ่งแต่ละหน้าต่างเป็น session แยก ไม่รู้ว่าอีกหน้าต่างเพิ่งเปลี่ยนอะไรไป

หน่วยนับข้อความที่โมเดลอ่านและเขียน ใช้คิดเงินและวัดว่า context ใกล้เต็มหรือยัง

token คือชิ้นข้อความย่อยๆ ที่โมเดลอ่านและเขียน ราคา API คิดตาม token แยกเป็น input, output และ cache เพราะทุกรอบโมเดลต้องอ่าน context ทั้งก้อนซ้ำ ของที่โหลดไว้ล่วงหน้าอย่าง CLAUDE.md หรือ skill จึงกิน token ทุกครั้ง แม้เราจะสั่งแค่คำเดียว

ตอนที่ agent เรียกใช้เครื่องมือ เช่นอ่านไฟล์ เขียนไฟล์ รันคำสั่ง แต่ละครั้งนับเป็นหนึ่ง tool call

tool call หรือ tool use คือกลไกที่โมเดลขอให้ระบบรันเครื่องมือแทนการตอบเป็นข้อความ เช่นอ่านไฟล์ เขียนไฟล์ รัน shell หรือเรียก tool จาก MCP งานหนึ่งของ agent อาจมีหลายร้อย tool call และจุดนี้คือที่ที่ hook ดักตรวจหรือบล็อกได้ก่อนมันจะทำจริง

คำชุดเดียวที่ทีมใช้ทั้งในการคุย ในโค้ด ในตาราง และบนหน้าจอ

ubiquitous language คือการตกลงว่าเรื่องหนึ่งเรียกด้วยคำเดียว แล้วใช้คำนั้นทุกที่ ทั้งในแชต ชื่อไฟล์ ชื่อตาราง และข้อความบนหน้าจอ สำหรับงานกับ agent สิ่งนี้สำคัญมาก เพราะ agent ค้นคำที่เราพิมพ์ ถ้าคำนั้นไม่มีในโค้ด มันจะสร้างของใหม่แทนที่จะแก้ของเดิม มักเก็บไว้ในไฟล์ GLOSSARY.md

บนกระดานUbiquitous Language

การสั่ง AI เขียนโค้ดตามความรู้สึก ไม่มี spec ไม่อ่านโค้ด เร็วตอนทำ prototype แต่พังตอนโต

vibe coding คือการให้ AI สร้างของจากคำสั่งกว้างๆ แล้วกด accept ไปเรื่อยๆ โดยไม่ได้วางโครงหรืออ่านโค้ด เหมาะกับ prototype หรือ validate ไอเดียในวันเดียว แต่พอเป็นของจริงที่ต้องดูแลต่อ ปัญหาจะโผล่ เช่นไม่มี spec ไม่มี test แก้ที่หนึ่งพังอีกที่ ทางแก้คือใส่โครงอย่าง spec, CLAUDE.md และ test ตั้งแต่ต้น

URL ของเราที่ระบบอื่นเรียกเข้ามาเมื่อมีเหตุการณ์ เช่นผู้ให้บริการจ่ายเงินแจ้งว่าเงินเข้าแล้ว

webhook คือ endpoint ที่เราเปิดไว้ให้บริการภายนอกยิงเข้ามาบอกเหตุการณ์ เช่น Stripe หรือ Omise แจ้งว่าการจ่ายเงินสำเร็จ เรื่องที่ต้องรู้คือมันอาจมาช้า มาซ้ำ หรือมาสลับลำดับ โค้ดที่รับ webhook เลยต้องเช็กว่าเหตุการณ์นี้ยังเปลี่ยนสถานะได้อยู่ไหม และต้องตรวจลายเซ็นว่ามาจากผู้ให้บริการจริง

บนกระดานState diagram as transition table

โฟลเดอร์ทำงานแยกจาก repo เดียวกัน ให้หลาย session แก้คนละ branch โดยไม่เขียนทับกัน

git worktree ทำให้ repo เดียวมีหลายโฟลเดอร์ทำงาน แต่ละอัน checkout branch ของตัวเอง เวลารันหลาย session หรือหลาย worker พร้อมกัน การแยก worktree ให้แต่ละตัวช่วยกันไม่ให้เขียนไฟล์ทับกัน เป็นของชิ้นเดียวที่เพจนี้แนะนำให้คนทำงานคนเดียวหยิบจากกระแส agent รันขนาน

บนกระดานFeature branch + PR