ติดอาวุธให้ Claude ตอนที่ 1: เลือกโมเดล + วางระบบความจำ

ซื้อรถแรงมาแล้วแต่ขับเกียร์ 2 ตลอดทาง หลายคนใช้ Claude แบบนั้นโดยไม่รู้ตัว บทแรกของซีรีส์นี้ขอจูน "ฐาน" สองอย่างก่อน คือเลือกโมเดลให้ถูกงาน แล้ววางระบบความจำให้ AI เลิกลืม

เคยไหมครับ จ่ายค่าแพ็กเกจ Claude มาเต็ม ๆ ใช้ทุกวัน แต่ลึก ๆ ก็รู้สึกว่า "มันน่าจะได้มากกว่านี้นะ" บิลค่า token ก็บาน คำตอบก็ยาวเกินจำเป็น สอนอะไรไปเดี๋ยวก็ลืม อาการทั้งหมดนี้เหมือนซื้อรถแรงมาแล้วขับเกียร์ 2 ตลอดทาง เครื่องแรงอยู่ แต่ของรอบคันยังไม่ได้จูนสักอย่าง

ในบทความก่อน ๆ ของซีรีส์นี้ เราคุยกันเรื่อง "วิธีสั่งงาน" AI มาเยอะแล้ว เขียน prompt ให้ชัด, ให้ AI ซักเราจนสเปกนิ่ง (/grill-me), กั้นห้อง context ด้วย sub-agent, ส่งไม้ต่อข้ามแชทด้วย /handoff คราวนี้ขอเปลี่ยนมุมมาเล่าเรื่องการ "จูนรอบคัน" ให้ตัว Claude เอง เพราะตัวโมเดลเก่ง ๆ อย่างเดียวยังไม่พอ คนที่ใช้ AI ได้คุ้มที่สุดมักไม่ใช่คนที่พิมพ์เก่งกว่า แต่เป็นคนที่ตั้งค่ารอบตัวมันได้ถูกจุด

เรื่อง "จูนรอบคัน" นี่มีของให้เล่าเยอะ ผมเลยขอแบ่งเป็น สองตอน ตอนแรก (บทนี้) ขอโฟกัสสองเรื่องที่เป็น "ฐาน" ก่อน เลือกโมเดลให้ถูกงาน กับ วางระบบความจำ ให้ AI เลิกลืม เพราะสองอย่างนี้ทำให้ Claude คุ้มขึ้นทันทีโดยยังไม่ต้องติดตั้งอะไรเพิ่มเลย ส่วนพวก "ของเสริม" นอกกล่อง (ต่อมือให้คุมเบราว์เซอร์ สแกนช่องโหว่ ลดโทเคน ฯลฯ) ยกไปเล่าใน ตอนที่ 2

อาวุธ 1: เลือกโมเดลให้ถูกงาน

Claude มีหลายรุ่น เรียงจากเบาไปหนักคร่าว ๆ คือ Haiku (เร็ว/ถูก) → Sonnet (สมดุล) → Opus (แรง/ฉลาด เอาไว้งานหนัก) → Fable (แรงสุด/แพงสุด ราคาราว 2 เท่าของ Opus เก็บไว้เฉพาะงานยาว ๆ ยาก ๆ ที่ Opus เอาไม่ค่อยอยู่จริง ๆ) ความเข้าใจผิดที่พบบ่อยคือ "ก็เลือกตัวแรงสุดไว้ก่อนสิ ดีที่สุดนี่นา" ซึ่งเปลืองทั้งเงินและเวลาโดยไม่จำเป็น เหมือนจ้างสถาปนิกมานั่งถ่ายเอกสาร มันทำได้แหละ แต่มันเกินตัวงาน

หัวใจคือจับคู่ "ชนิดงาน" กับ "รุ่นโมเดล" ให้พอดี งานยิ่ง "กลไก" (mechanical ทำตามขั้นตอนตายตัว ไม่ต้องใช้วิจารณญาณ) และตัดสินใจน้อย ยิ่งใช้รุ่นเล็กได้ งานยิ่งต้องคิดลึก ตัดสินใจเยอะ หรือเดิมพันสูง (เช่นตรวจงานคนอื่น) ค่อยขยับขึ้นรุ่นใหญ่

เคล็ดที่กำลังฮิตในช่วงนี้คือ "ให้คนละรุ่นทำกับตรวจ" ใช้ Sonnet ลุยเขียนโค้ดหรือร่างเนื้อหาให้เสร็จก่อน แล้วค่อยสลับไปให้รุ่นแรงกว่า (Opus หรือ Fable) มาสวมบทบาท "หัวหน้าที่พิถีพิถัน" คอยตรวจทาน หาช่องโหว่ หรือรีวิว ข้อดีคือมุมมองที่มาตรวจเป็นคนละหัว ไม่ใช่ตัวที่เพิ่งเขียนมาปกป้องงานตัวเอง มักเจอจุดพลาดที่ตัวเขียนมองข้าม

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

ลองมองไกลอีกนิด ทำไม Anthropic ถึงออกโมเดลเป็นไลน์อัปหลายรุ่น (Haiku → Sonnet → Opus → Fable) แทนที่จะทำ "โมเดลเทพตัวเดียว" ให้จบ ๆ? (ย้ำก่อนว่าอันนี้เป็นเลนส์ตีความ ไม่ใช่คำประกาศเจตนาแทนบริษัท) มองได้แบบนี้: การมีหลายรุ่นให้เลือก คือการยอมรับเชิงดีไซน์ว่า "คำตอบเร็ว-มั่นใจตัวเดียวสำหรับทุกงาน" มันเป็นกับดัก งานแต่ละแบบต้องการ "ความลึกของการคิด" ไม่เท่ากัน และการที่เราต้องเลือกรุ่นเอง ก็คือการถูกบังคับให้หยุดถามตัวเองสักวินาทีว่า "งานตรงหน้านี้ ต้องคิดลึกแค่ไหน" ซึ่งเป็นคำถามที่กัน Low-Order Thinking (การคิดตื้น รับคำตอบแรกโดยไม่ขุดลงไปตรวจ) ได้ดีที่สุด

เรื่องนี้เชื่อมกับ "jagged frontier" ในบทมุมมองโดยตรง: งานวิจัยพบว่า AI มักมั่นใจแม้ตอนมันผิด แล้วลากคนให้ผิดตาม cognitive fluency คือคำอธิบายเชิงจิตวิทยาว่าทำไมเราถึงโดนลากง่ายขนาดนั้น เพราะคำตอบที่ผิดแต่ลื่น มันข้ามด่านตรวจของสมองเราไปแบบเงียบ ๆ การเลือกโมเดลให้พอดีงานตั้งแต่ต้น จึงเป็นด่านแรกที่กันเราไม่ให้ตกหลุมนี้

อาวุธ 2: วางระบบความจำ Hot / Cold / learning.md

"สอน AI เท่าไหร่มันก็ไม่จำ" เป็นเสียงบ่นที่ได้ยินบ่อย ปัญหาส่วนหนึ่งอยู่ที่ memory (ความจำระยะยาวที่โหลดเข้ามาทุกครั้งที่เริ่มงานใหม่) ถูกใช้ผิดวิธี หลายคนสั่งให้จำโน่นจำนี่ปนกันมั่วไปหมด จนพอเปิดงานใหม่ทีเดียว memory ก็บวมกินพื้นที่ context ไปเยอะแล้วตั้งแต่ยังไม่ทันสั่งอะไร (ทำไม context เต็มแล้วถึงแย่ อ่านได้ในบทความ Context Pollution)

ก่อนจะไปเรื่องไฟล์ ขอชวนมองภาพ "ความจำ" แบบเด็ก CS (ย่อจาก computer science สาขาวิทยาการคอมพิวเตอร์) สักนิด เพราะพอเห็นภาพนี้แล้วที่เหลือจะง่ายขึ้นเยอะ ความจำของคนเราเองก็มีหลายชั้นอยู่แล้ว: working memory (อ่านว่า "เวิร์กกิ้ง เมมโมรี" แปลว่า "ความจำใช้งาน" สิ่งที่เรากำลังคิด/ท่องค้างไว้ในหัว ณ วินาทีนี้ เช่นเบอร์โทรที่เพิ่งได้ยินแล้วรีบกด), ความจำระยะสั้น (จำได้แค่ชั่วโมงนี้วันนี้ เดี๋ยวก็เลือน), และความจำระยะยาว (ฝังแน่นข้ามปี)

ที่สนุกคือคอมพิวเตอร์ลอกโครงนี้มาเป๊ะ ๆ เขาเรียกว่า memory hierarchy (อ่านว่า "เมมโมรี ไฮราร์คี" แปลว่า "ลำดับชั้นความจำ") กฎคือยิ่งอยู่ใกล้ "ตัวคิด" ยิ่งเร็วแต่เล็ก ยิ่งไกลยิ่งช้าแต่ใหญ่และถูกลง: CPU (อ่านว่า "ซีพียู" หน่วยประมวลผล ตัวที่คิดเลขจริง ๆ) มี cache (อ่านว่า "แคช" แปลว่า "ที่พักของใกล้มือ") จิ๋ว ๆ ติดตัวไว้ของที่ใช้บ่อยที่สุด · RAM (อ่านว่า "แรม") ใหญ่ขึ้นมาหน่อย เก็บของที่กำลังเปิดใช้อยู่ แต่ดับไฟปุ๊บหายเกลี้ยง · Harddisk / SSD ใหญ่สุด ช้าสุด แต่เก็บถาวร ปิดเครื่องแล้วของยังอยู่

ทีนี้พอมีลำดับชั้นแบบนี้ วงการจัดเก็บข้อมูลเลยตั้งชื่อเล่นให้แต่ละชั้นตามว่ามัน "ถูกเรียกใช้บ่อยแค่ไหน" ข้อมูลที่แตะบ่อย อยู่ใกล้ตัวคิด เรียกว่าร้อน (Hot) ส่วนข้อมูลที่นาน ๆ เปิดที นอนอยู่ในคลังลึก เรียกว่าเย็น (Cold) (Hot อ่านว่า "ฮอต", Cold อ่านว่า "โคลด์") พอเอาสามคอลัมน์ (คน / คอมพิวเตอร์ / Claude) มาวางเทียบกัน มันจะทับกันเป็นชั้น ๆ พอดีแบบนี้:

โฟกัสที่คอลัมน์ขวาสุด สองชั้นที่เราจัดการได้จริงบน Claude คือ Hot กับ Cold:

ตัว Cold Memory นี้เก็บที่ไหนก็ได้ที่เป็นไฟล์ในเครื่อง แต่เครื่องมือที่คนนิยมจับมาทำหน้าที่นี้มากที่สุดคือ Obsidian เดี๋ยวเจาะรายละเอียดวิธีใช้กันตอนท้ายบท ตอนนี้จำภาพคร่าว ๆ ไว้ก่อนว่ามันคือ "สมุดจดถาวร" ที่ทั้งเราและ AI เปิดอ่าน-เขียนได้ตรง ๆ เพราะมันเก็บเป็นไฟล์ข้อความธรรมดาในเครื่องเรา ไม่ได้ล็อกอยู่ในระบบปิดของใคร

ไฟล์ learning.md: ให้ AI จำ "บทเรียน" ไม่ใช่แค่ "ข้อมูล"

ส่วนที่ผมชอบที่สุดในแนวคิดนี้คือไฟล์เล็ก ๆ ชื่อ learning.md วิธีใช้คือเขียนกติกาไว้ใน CLAUDE.md ของทุกโปรเจกต์ว่า "ถ้าทำอะไรพลาดแล้วแก้ได้แล้ว ให้จดความผิดพลาดนั้น + วิธีแก้ ลงไฟล์นี้ด้วย และให้อ่านไฟล์นี้ทุกครั้งก่อนเริ่มงาน" ผลคือ AI จะค่อย ๆ สะสม "บทเรียน" ของมันเอง แล้วไม่เดินลงหลุมเดิมซ้ำ ๆ

แล้วลงมือจริงต้องทำอะไร?

คำถามที่ค้างหลังอ่านจบคือ "เข้าใจ concept แล้ว แต่ต้องนั่งสั่งเองทุกครั้งไหม?" ขอเคลียร์ก่อนว่าสามชั้นนี้เป็นไฟล์คนละไฟล์ คนละหน้าที่ ไม่ใช่ยัดรวมไว้ที่เดียว และมี 2 ทางให้เลือก: ใช้ระบบ memory ที่ Claude Code มีในตัว (อัตโนมัติสุด) หรือจัดไฟล์เองแบบมือ (ใช้ได้กับทุก agent และตรงกับที่โพสต์ต้นทางทำ)

ส่วนถ้าอยากคุมเอง ใช้ agent ที่ไม่มี auto memory หรือทำแบบ tool-agnostic ตามโพสต์ต้นทาง ก็จัด 3 ไฟล์แยก ตามนี้:

สเต็ป 1 (Hot): CLAUDE.md ต่อโปรเจกต์ จัดให้ผอม ไฟล์นี้ Claude Code auto-load ทุก session อยู่แล้ว หน้าที่เราคือกันไม่ให้มันบวม เก็บเฉพาะเรื่องของโปรเจกต์นี้

สเต็ป 2 (learning.md): เป็นไฟล์แยก แล้ว "เชื่อม" ให้โหลดจริง จุดที่คนมักพลาดคือแค่เขียนใน CLAUDE.md ว่า "ให้อ่าน learning.md" ซึ่งเป็นแค่คำเตือน ไม่การันตีว่าจะอ่าน วิธีที่ชัวร์กว่าคือใช้ import ที่ Claude Code รองรับ: ใส่บรรทัด @learning.md ใน CLAUDE.md มันจะดึงไฟล์เข้า context ตอนเริ่มงานจริง ๆ แล้วเขียนกติกาการจดกำกับไว้ด้วย

# ...ส่วนอื่น ๆ ของ CLAUDE.md...

# ดึง learning.md เข้ามาทุกครั้งที่เริ่มงาน
# (อย่าใส่ backtick คร่อม `@learning.md` ไม่งั้นมันจะกลายเป็นข้อความเฉย ๆ ไม่ import)
@learning.md

## กติกาการจดบทเรียน
- เมื่อแก้บั๊ก/ปัญหาที่ "ไม่ตรงไปตรงมา" สำเร็จ ให้ต่อท้าย learning.md หนึ่งย่อหน้า:
  (1) อาการ (2) สาเหตุจริง (3) วิธีแก้ (4) วิธีกันไม่ให้เกิดซ้ำ
- เขียนกระชับ ต่อท้ายเท่านั้น อย่าลบบทเรียนเก่า

(อีกทางที่ได้ผลพอกันคือวางไฟล์ไว้ใน .claude/rules/ ซึ่ง Claude Code โหลดให้อัตโนมัติทั้งไฟล์ทุก session เลือกอย่างใดอย่างหนึ่ง ไม่ต้องทำทั้งคู่)

สเต็ป 3 (Cold): คลังระยะยาว (เช่น Obsidian) ปล่อยเป็น on-demand ชั้นนี้อย่า import เข้า CLAUDE.md เพราะจะลาก context ให้บวมทุกครั้งที่เปิดงาน ตั้งใจให้มันเปิดเฉพาะตอนต้องใช้: จบงานใหญ่ค่อยสั่ง "สรุปลง vault ที่ <path>" กลับมาทำต่อค่อยสั่ง "อ่าน <path> ก่อน" ถ้าอยากให้ดึงเองอัตโนมัติต้องต่อด้วย hook หรือ MCP ของ Obsidian

เจาะ Obsidian: ทำไมมันเหมาะเป็น "คลังเย็น" ของ AI

ตะกี้เกริ่นชื่อ Obsidian ไปแล้วว่าคนนิยมใช้เป็น Cold Memory แต่หลายคนอาจยังไม่รู้จักมันเลย เลยขอเล่าให้เห็นภาพหน่อย เพราะพอเข้าใจว่ามัน "เป็น" อะไร จะเห็นทันทีว่าทำไมมันเข้าคู่กับ AI ได้ลงตัว

การเริ่มใช้ก็เบากว่าที่คิด โหลดตัวแอปฟรีจาก obsidian.md (มีทั้ง Windows / Mac / Linux และมือถือ) เปิดครั้งแรกมันจะให้ "สร้าง vault" ซึ่งจริง ๆ ก็คือชี้ไปที่โฟลเดอร์ว่าง ๆ สักอันในเครื่องแล้วตั้งชื่อ เท่านั้นเอง จากนั้นกด New note พิมพ์อะไรลงไปก็ได้ มันจะเซฟเป็นไฟล์ .md ในโฟลเดอร์นั้นให้อัตโนมัติ ไม่ต้องตั้งค่าอะไรเพิ่ม ถ้าเคยพิมพ์ข้อความในโปรแกรมจดโน้ตทั่วไปก็ใช้เป็นทันที ส่วนลูกเล่นพวกลิงก์/กราฟค่อย ๆ เก็บทีหลังได้

ที่ต้องจำไว้อย่างเดียวคือ "vault มันวางอยู่ตรงพาธไหนในเครื่อง" เพราะเดี๋ยวเราจะเอาพาธนั้นไปบอก AI ให้อ่าน-เขียนไฟล์ในโฟลเดอร์เดียวกัน พอมองแบบนี้ Obsidian ก็เป็นแค่ "หน้าจอสวย ๆ" ที่เราไว้เปิดดู/แก้โน้ตด้วยตาตัวเอง ส่วนตัวไฟล์จริงที่อยู่ในโฟลเดอร์ต่างหากที่เป็นสะพานเชื่อมกับ AI

หัวใจของมันมีอยู่ไม่กี่อย่าง แต่ทุกอย่างล้วนเป็นมิตรกับ AI พอดี:

ทีนี้พอมันเป็นแค่ "โฟลเดอร์ไฟล์ข้อความ" การต่อกับ AI เลยง่ายกว่าที่คิด มีตั้งแต่ท่าง่ายสุดไปจนอัตโนมัติเต็มตัว:

วิธีลง Claudian + ตั้งค่าใช้งาน แบบทีละขั้น

ก่อนอื่นเช็กของที่ต้องมีก่อน: (1) ลง Claude Code CLI ในเครื่องให้เรียบร้อย (วิธีลงอยู่ในบท Claude คืออะไร ใช้ยังไง) พร้อมสิทธิ์ใช้ Claude จะเป็น subscription หรือ API key ก็ได้ · (2) Obsidian เวอร์ชัน 1.7.2 ขึ้นไป · (3) เครื่อง desktop (Windows / Mac / Linux) เท่านั้น มือถือยังไม่รองรับ เพราะปลั๊กอินต้องเรียก CLI ในเครื่อง

ทีนี้ลงตามนี้ทีละขั้น:

• 1. เปิดโหมดปลั๊กอินชุมชนก่อน: ในหน้าต่าง Obsidian กดไอคอนเฟือง (Settings) มุมล่างซ้าย เพื่อเข้าตั้งค่า ของตัว Obsidian เอง แล้วไปที่หัวข้อ Community plugins ในเมนูซ้าย ครั้งแรก Obsidian จะปิดปลั๊กอินภายนอกไว้ (โหมด Restricted เพื่อความปลอดภัย) ให้กด Turn on community plugins เปิดใช้ก่อน
• 2. ค้นแล้วติดตั้ง: กด Browse เพื่อเปิดคลังปลั๊กอินชุมชนอย่างเป็นทางการ พิมพ์ค้น "Claudian" → กด Install → เสร็จแล้วกด Enable เปิดใช้งาน
• 3. ชี้ path ให้เจอ Claude CLI (ถ้าจำเป็น): ปกติปลั๊กอินหา CLI ให้เอง แต่ถ้าขึ้นว่าหาไม่เจอ ให้เข้า Settings ของ Claudian → Advanced → Claude CLI path แล้วใส่พาธเต็ม ๆ ของ claude ลงไป · หาพาธได้ด้วยคำสั่ง where.exe claude (Windows) หรือ which claude (Mac/Linux)
• 4. เปิดแชตแล้วเริ่มคุย: กดไอคอน Claudian ที่แถบ ribbon ด้านซ้ายของ Obsidian (หรือเรียกจาก Command palette) แถบแชตจะเด้งมาข้าง ๆ พิมพ์สั่งงานได้เลย เช่น "สรุป decision วันนี้ลง decisions/"

พอเปิดแชตได้แล้ว ลูกเล่นที่ใช้บ่อย: เลือกข้อความในโน้ตแล้วกดปุ่มลัดให้ AI แก้เฉพาะท่อนนั้น (เห็น diff ทีละคำก่อนรับ), พิมพ์ @ เพื่ออ้างอิงโน้ตอื่นใน vault, พิมพ์ / เรียกสแลชคอมมานด์ หรือ $ เรียกสกิล, และกด Shift+Tab สลับเข้า Plan Mode ให้มันวางแผนให้ดูก่อนลงมือจริง (แนวคิด Plan Mode เล่าไว้แล้วในบท ความลับที่ทำให้ Claude Code ได้ผลจริง)

ลัดกว่านั้น: ให้ Claude เป็นคนลงให้เอง

มีคนใช้ท่าที่เข้ากับบทนี้พอดี แทนที่จะกดลงเองตามขั้นบน ก็เปิด Claude Code (หรือ CLI ตัวที่ใช้) แล้วสั่งให้มันวางแผนติดตั้ง Claudian ลง Obsidian ให้ เข้า Plan Mode โดยใช้รุ่นคิดเยอะอย่าง Opus ร่างขั้นตอนก่อน พออนุมัติแผนแล้วค่อยให้รุ่นประหยัดกว่าอย่าง Sonnet ลงมือทำจริง นี่คือหลัก "จับคู่โมเดลให้ถูกงาน" ของบทนี้ตรง ๆ (ตอนวางแผนใช้ตัวคิดแพง ตอนลงมือใช้ตัวถูก) และเพราะยังไง Claudian ก็ต้องมี CLI อยู่แล้ว ท่านี้เลยไม่ได้ลงของเพิ่มเกินจำเป็น

ระหว่างทางจะมีจังหวะให้กดยืนยันสิทธิ์ ทั้งฝั่งเอเจนต์ที่ขอรันคำสั่ง/เขียนไฟล์ และฝั่ง Obsidian ที่เตือนก่อนเปิดปลั๊กอินภายนอก และเอเจนต์อาจถามว่าจะให้ทำงานกับ vault โฟลเดอร์ไหน จิ้มยืนยันให้ตรงกับที่เราตั้งใจ

ทิปสำหรับคนใช้หลาย CLI: ถ้าสลับใช้ทั้ง Claude Code และ Codex ลองแยก vault ของแต่ละตัวออกจากกัน แล้วทำ shortcut บนเดสก์ท็อป (เช่นตั้งชื่อ "Obsidian – Claude") ให้เปิดตรงเข้า vault ของตัวนั้นเลย จะได้ไม่ต้องมานั่งเลือก vault ใหม่ทุกครั้งที่เปิด

ความรู้เสริมปิดท้าย: ที่เก็บเป็นไฟล์ในเครื่องนี่แหละคือข้อได้เปรียบใหญ่สุดสำหรับงานนี้ มัน backup ได้ (ขึ้น git, cloud, หรือ Obsidian Sync ก็ได้) ต่อให้เครื่องพังหรือ session หาย "ประสบการณ์" ที่ AI สั่งสมมากับเราก็ยังอยู่ ยกกลับมาใช้ต่อได้เหมือนเดิม เหมือนย้ายสมองของทีมงานขึ้นที่ปลอดภัยไว้ และเพราะเป็น Markdown มาตรฐาน วันหลังอยากเปลี่ยนไปใช้แอปอื่นก็ยกไฟล์ไปได้เลย ไม่ติดล็อก

สรุปบรรทัดเดียว (ตอนที่ 1)

ก่อนจะไปหา "ของเสริม" ให้จูนสองอย่างที่เป็นฐานก่อน เลือกโมเดลให้พอดีงาน (ไม่ใช่แรงสุดไว้ก่อน) แล้วจัดความจำเป็นชั้น Hot / Cold / learning.md แค่นี้ Claude ก็ทำงานคุ้มขึ้นเยอะ ทั้งประหยัดเงินและเลิกลืมสิ่งที่เราสอน โดยยังไม่ต้องติดตั้งอะไรเพิ่มเลยสักตัว

แหล่งอ้างอิง

เรียบเรียงและอธิบายใหม่ด้วยคำตัวเอง โดยตรวจสอบข้อเท็จจริงกับแหล่งปฐมภูมิด้านล่าง

1. โพสต์สรุปเทคนิคใช้ Claude (agent harness, Hot/Cold memory, learning.md, การเลือกโมเดล) · Supadej Suthiphongkanasai, Facebook, สืบค้นเมื่อ 10 กรกฎาคม 2026
2. "Create custom subagents (การตั้งค่า model ต่อ sub-agent)" · Claude Code Docs, Anthropic, สืบค้นเมื่อ 10 กรกฎาคม 2026
3. "Manage Claude's memory (ลำดับชั้น CLAUDE.md, การ import ด้วย @path, auto memory)" · Claude Code Docs, Anthropic, สืบค้นเมื่อ 10 กรกฎาคม 2026
4. Reber, R., & Schwarz, N. (1999). "Effects of Perceptual Fluency on Judgments of Truth." Consciousness and Cognition, 8(3), 338–342 · ต้นทางการทดลอง cognitive/processing fluency (สีตัวอักษรกับการตัดสินว่าจริง), สืบค้นเมื่อ 12 กรกฎาคม 2026
5. Kruger, J., & Dunning, D. (1999). "Unskilled and Unaware of It." Journal of Personality and Social Psychology, 77(6), 1121–1134 · ต้นทาง Dunning-Kruger effect, สืบค้นเมื่อ 12 กรกฎาคม 2026
6. Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux · ต้นทางแนวคิด System 1 / System 2