Autonomous Second Brain: จัดระเบียบและเชื่อมโยงบันทึกโดยอัตโนมัติในขณะที่คุณหลับด้วย Claude Code × Obsidian

ปีนี้ฉันบันทึกบทความไว้ประมาณ 200 เรื่อง แต่สิ่งที่เหลืออยู่คือโน้ต 40 รายการกับโฟลเดอร์ "ไว้จัดทีหลัง" ที่ฉันไม่เคยเปิดอีกเลย

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

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

ยิ่งไปกว่านั้น คุณสามารถสร้างระบบนี้ได้ด้วยตัวเองตอนนี้ โดยไม่ต้องมีสภาพแวดล้อมพิเศษใดๆ สิ่งที่คุณต้องมีคือ Claude Code และ Obsidian ซึ่งเป็นเครื่องมือมาตรฐานที่ทำงานบนเครื่องคอมพิวเตอร์ของคุณเอง ในบทความนี้ ผมจะอธิบายวิธีสร้างระบบนี้ทีละขั้นตอน เริ่มตั้งแต่วันนี้

ผมชื่อ tatsuki (@nobel_824) ผมสนับสนุนการใช้ AI สำหรับธุรกิจขนาดกลางและขนาดเล็ก ช่วยในการใช้งาน Claude/Codex และใช้ Claude Code เองตลอดทั้งวัน

แรงบันดาลใจสำหรับการออกแบบนี้มาจากคู่มือการสร้างชื่อ "How To Build a Second Brain That Runs Itself With Kimi & Obsidian (Full Course)" ซึ่งมียอดวิว 1.48 ล้านครั้งในต่างประเทศ แนวคิดนี้ยอดเยี่ยมมาก แต่เครื่องมือไม่จำเป็นต้องเป็น Kimi Work เสมอไป สิ่งสำคัญคือปรัชญาการออกแบบ "การมอบหมายงานจัดระเบียบให้กับกระบวนการแบตช์ในช่วงกลางคืน" ซึ่งไม่ขึ้นอยู่กับเครื่องมือใดๆ ดังนั้น ผมจึงสร้างมันขึ้นมาใหม่โดยใช้เครื่องมือที่ผมใช้ทุกวัน: Claude Code และ Obsidian

บทความที่เกี่ยวข้อง: คู่มือ Claude Code - พื้นฐาน -

https://note.com/nobel/n/n7d7a422f828f

บทที่ 1: การสร้าง "กะกลางคืน" ให้กับสมองที่สองของคุณ

ก่อนอื่น มาทำความเข้าใจมุมมองที่จะทำให้เห็นภาพรวมได้ง่ายขึ้น

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

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

ทีมกะกลางคืนไม่ได้มีแค่สำเนา 300 ชุดที่ทำงานเดียวกัน พลังของพวกเขามาจากการแบ่งหน้าที่กันทำ เหมือนแผนกวิจัยจริงๆ ขั้นตอนนั้นเรียบง่ายและประกอบด้วยสี่ขั้น

ขั้นแรก รวบรวม บทบาทนี้จะดึงข้อความของบทความหรือหน้าที่คุณต้องการอ่านและนำเข้ามาในระบบ

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

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

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

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

บทที่ 2: การเก็บความรู้ไว้ใน "โรงกลั่น" ไม่ใช่ลิ้นชัก

ตอนนี้ มาลงมือทำงานกัน เราจะเริ่มต้นด้วยการออกแบบห้องนิรภัย (Vault)

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

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

ขั้นตอน A: สร้างโฟลเดอร์ (ใช้เวลา 5 นาที)

รันคำสั่งบรรทัดเดียวนี้ในเทอร์มินัลของคุณเพื่อสร้างโรงกลั่น

1mkdir -p brain/{0-raw,1-desk,2-atoms,3-threads,sources,briefings,.claude/skills}
2touch brain/CLAUDE.md

นี่คือหน้าที่ของแต่ละโฟลเดอร์:

brain/

├── 0-raw/ # ที่ที่คุณโยนสิ่งต่างๆ เข้ามา อย่าแตะต้อง มันคืออินพุต

├── 1-desk/ # โต๊ะทำงานของกะกลางคืน ชั่วคราว จะถูกทำความสะอาดเมื่อสิ้นสุดกะ

├── 2-atoms/ # โน้ตถาวร: หนึ่งไอเดียต่อหนึ่งไฟล์ แกนกลาง

├── 3-threads/ # การบูรณาการ เอกสารที่มีชีวิตซึ่งถักทอจากอะตอมหลายตัว

├── sources/ # บทความต้นฉบับหรือ PDF พื้นที่จัดเก็บแบบอ่านอย่างเดียว

├── briefings/ # รายงานจากกะกลางคืนถึงคุณ

├── .claude/skills/ # "รายละเอียดงาน" สำหรับแต่ละกะ

└── CLAUDE.md # กฎบัตรการปฏิบัติงาน อ่านโดยเอเจนต์ทั้งหมดก่อนเริ่มทำงาน

มีสามการออกแบบที่สำคัญในโครงสร้างนี้

ประการแรก 0-raw และ sources เป็นแบบอ่านอย่างเดียวและจะไม่ถูกแก้ไข โน้ตดิบและไฟล์ต้นฉบับคือรากฐานของความจริง เอเจนต์สร้างข้อมูลที่แยกออกมาจากสิ่งเหล่านี้ แต่จะไม่แตะต้องต้นฉบับ สิ่งนี้ป้องกันความล้มเหลวที่ค่อยๆ ทำลายฐานความรู้ของ AI อย่างเงียบๆ: "โน้ตที่แยกออกมาอ้างอิงโน้ตที่แยกออกมาอื่นๆ ซึ่งค่อยๆ เบี่ยงเบนจากความหมายดั้งเดิมไปทีละนิดในการสร้างแต่ละครั้ง จนกระทั่ง AI พูดซ้ำสิ่งที่ตัวเองแต่งขึ้นมาอย่างมั่นใจ" เนื่องจากแหล่งที่มาไม่เปลี่ยนแปลง ความจริงก็ไม่คลาดเคลื่อน

ประการที่สอง 2-atoms ประกอบด้วยอะตอม (ไอเดียเดียว) ไม่ใช่บทความ หนึ่งไฟล์ หนึ่งไอเดีย นี่คือหลักการของ Zettelkasten และเป็นกุญแจสำคัญในการทำให้เว็บของการเชื่อมโยงใช้งานได้จริง ไม่ใช่แค่เพื่อการตกแต่ง โดยการแยกย่อยเป็นไอเดียเดียว คุณสามารถเชื่อมโยงมันไปยังหลายๆ สิ่ง นำมารวมกันใหม่ และระบุความขัดแย้งได้อย่างแม่นยำ คุณไม่สามารถทำเช่นนี้ได้ในห้องนิรภัยที่โยนบทความยาวๆ ทั้งเรื่องเข้าไป

ประการที่สาม 3-threads คือที่ที่ความเข้าใจอาศัยอยู่ อะตอมคือวัสดุ ส่วน threads คือการบูรณาการ เมื่ออะตอมที่เกี่ยวข้องสะสมในหัวข้อ เช่น "เส้นต้นทุนแบตเตอรี่" thread ก็จะเติบโตขึ้น นี่คือชั้นที่ขาดหายไปจากวิกิแบบแบน และมันคือความแตกต่างระหว่าง "ฐานความรู้" กับ "ความเข้าใจ"

ขั้นตอน B: เปิดโฟลเดอร์นี้ใน Obsidian

นี่คือพื้นฐานของการรวมเข้ากับ Obsidian คุณต้องทำสิ่งเดียวเท่านั้น

เปิด Obsidian และเลือก "เปิดโฟลเดอร์เป็น Vault" จากนั้นชี้ไปที่โฟลเดอร์ brain/ ที่คุณเพิ่งสร้าง เท่านั้นเอง คุณไม่จำเป็นต้องมีปลั๊กอินพิเศษหรือบริการซิงค์ เพราะ Obsidian vault ก็แค่ชุดของไฟล์ markdown โฟลเดอร์นั้นเองก็กลายเป็น vault

เมื่อคุณเขียน [[ชื่อโน้ต]] ในโน้ต มันจะกลายเป็นลิงก์ภายในมาตรฐานของ Obsidian ซึ่งหมายความว่าถ้าบทบาท "แยกย่อยและเชื่อมโยง" ของกะกลางคืนเชื่อมต่อโน้ตด้วย [[โน้ตที่เกี่ยวข้อง]] การเชื่อมต่อเหล่านั้นจะปรากฏใน Graph View ของ Obsidian โดยอัตโนมัติ คุณไม่ต้องทำอะไรเลย Obsidian จะแสดงภาพ markdown ที่เขียนโดยเอเจนต์

คุณอาจสงสัยว่า "ทำไมไม่ใช้ Vector DB หรือ RAG ล่ะ?" เพราะ markdown ธรรมดาและลิงก์ก็เพียงพอแล้ว มันเป็นระบบภายในเครื่อง พกพาได้ และคุณสามารถติดตามได้ว่าโน้ตไหนมาจากแหล่งไหน มันเหนือกว่า Vector DB บนคลาวด์ทั้งในด้านความสะดวกในการพกพาและความน่าเชื่อถือ Obsidian ทำงานเป็นตัวแสดงผลได้อย่างดีเพราะไฟล์เป็นข้อความธรรมดา

ขั้นตอน C: เขียนกฎบัตร

CLAUDE.md เป็นไฟล์เดียวที่ควบคุมกำลังคนทั้งหมดนี้ Claude Code อ่านไฟล์นี้ก่อนทำงาน ดังนั้นถ้าคุณเขียนกฎการทำงานที่นี่ ทุกกะจะปฏิบัติตาม จงเขียนให้สั้น ชัดเจน และแน่นอน

1# กฎการปฏิบัติงาน (ต้องอ่านก่อนดำเนินการ)
2
3## ท่อส่งงาน
4- 0-raw/    : อินพุต อ่านอย่างเดียว ห้ามแก้ไขโน้ตดิบเด็ดขาด
5- 1-desk/   : โต๊ะทำงาน ทำความสะอาดเมื่อสิ้นสุดกะ
6- 2-atoms/  : อะตอมถาวร หนึ่งไฟล์ หนึ่งไอเดีย
7- 3-threads/: เอกสารแบบบูรณาการ อัปเดต thread ที่มีอยู่โดยไม่สร้างซ้ำ
8- sources/  : ต้นฉบับ อ่านอย่างเดียว
9- briefings/: ที่ที่เขียนรายงานถึงมนุษย์
10
11## กฎเหล็ก (Prime Directive)
12ทุกอะตอมต้องสามารถสืบย้อนกลับไปยังแหล่งที่มาที่มีอยู่ใน sources/ หรือ 0-raw/ ได้
13ห้ามเขียนโน้ตถ้าไม่มีแหล่งที่มา ห้ามเขียนข้อกล่าวอ้างที่ไม่พบในเนื้อหา
14ห้ามเติมช่องว่างด้วยข้อมูลที่ฟังดูเป็นไปได้ เป็นอันขาด
15
16## กฎการทำงาน
171. หนึ่งอะตอม หนึ่งไอเดีย ถ้าแหล่งมี 8 ไอเดีย ให้สร้าง 8 อะตอม
182. ค้นหาใน 2-atoms/ ก่อนสร้างอะตอม เพื่อดูว่ามีโน้ตที่มีอยู่ที่สามารถขยายความได้หรือไม่
193. แต่ละอะตอมต้องเชื่อมโยงไปยังอะตอมที่เกี่ยวข้องอย่างน้อยสองอะตอม
204. ถ้ามันขัดแย้งกับโน้ตที่มีอยู่ ให้เพิ่มบล็อก [FRICTION] ลงในโน้ตใหม่ที่ชี้ไปยังโน้ตเก่า ห้ามเงียบๆ เขียนทับความเชื่อ
215. ห้ามลบ ถ้ามันล้าสมัย ให้เพิ่ม [RETIRED] แล้วย้ายไปที่ archive/
226. อัปเดต thread ที่เกี่ยวข้องและเขียนรายงานสรุปเมื่อสิ้นสุดกะ

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

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

บทที่ 3: การรันกะกลางคืนด้วย Claude Code

เมื่อพิมพ์เขียวพร้อมแล้ว มาติดตั้งเครื่องยนต์กัน Claude Code คือสิ่งที่รันกะกลางคืนจริงๆ มาประกอบมันกัน

การทำงานแบบไม่มีหัว: รันด้วยตนเองครั้งหนึ่ง

Claude Code สามารถทำงานได้โดยไม่มีหน้าจอแบบโต้ตอบ นี่คือโหมดไร้หัว (headless mode)

claude -p "อ่านไฟล์ที่ยังไม่ได้ประมวลผลหนึ่งไฟล์จาก 0-raw/ และสร้างอะตอมใน 2-atoms/ ตามกฎใน CLAUDE.md"

แฟล็ก -p (--print) เป็นโหมดสำหรับสคริปต์ที่รันคำสั่งเดียวแล้วออก (เอกสารทางการclaude -p มาตรฐานจะอ่าน CLAUDE.md และ skills โดยอัตโนมัติ ดังนั้นกฎเหล็กที่คุณเขียนในบทที่ 2 จะมีผลบังคับใช้ หากคุณต้องการความสามารถในการทำซ้ำที่สมบูรณ์แบบ มีโหมด --bare (ซึ่งข้ามการค้นหา CLAUDE.md และ skills อัตโนมัติ) แต่ในกรณีนั้น คุณต้องส่งกฎต่างๆ อย่างชัดเจนในพรอมพ์ เนื่องจากเราต้องการให้กฎเหล็กทำงาน เราจะใช้ -p มาตรฐาน

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

เขียนคู่มือการเล่นเป็น Skill

"รายละเอียดงาน" สำหรับแต่ละกะจะถูกเขียนเป็น Skill (ไฟล์ markdown ที่อธิบายเวิร์กโฟลว์ที่ใช้ซ้ำได้) ถ้าคุณวางมันไว้ใน .claude/skills/<ชื่อ>/SKILL.md คุณสามารถเรียกใช้มันได้ทุกเมื่อ (เอกสารทางการ

ตัวอย่างเช่น กะ "โรงกลั่น" ซึ่งจัดการกับการประมวลผลหลักในตอนกลางคืน เขียนได้ดังนี้ เมื่อเขียนเสร็จแล้ว คุณสามารถเรียกมันด้วยชื่อ skill เช่น claude -p "/refinery" คุณเขียนมันครั้งเดียวและแค่เรียกชื่อมันทุกคืน

name: refinery

description: กะกลางคืนหลักเพื่อกลั่นกรองรายการที่ยังไม่ได้ประมวลผลทั้งหมดใน 0-raw ให้เป็นอะตอม

1# การรันโรงกลั่น
2
3## งาน
4ประมวลผลรายการที่ยังไม่ได้ประมวลผลใน 0-raw/ กำหนดเอเจนต์ย่อยหนึ่งตัวต่อรายการ
5รันพวกมันแบบขนาน จากนั้นบูรณาการผลลัพธ์ แต่ละเอเจนต์จะ:
6
71. อ่านโน้ตดิบและแหล่งที่มาที่เกี่ยวข้องใน sources/
82. แยกเป็นหนึ่งไอเดียต่อไฟล์และวางใน 2-atoms/
93. ค้นหาใน 2-atoms/ สำหรับแต่ละอะตอมเพื่อดูว่ามีโน้ตที่มีอยู่ที่สามารถขยายความได้ก่อนสร้างใหม่หรือไม่
104. เชื่อมโยงแต่ละอะตอมไปยังอะตอมที่เกี่ยวข้องอย่างน้อยสองอะตอม
115. ถ้ามันขัดแย้งกับโน้ตที่มีอยู่ ให้เพิ่มบล็อก [FRICTION] ที่ชี้ไปยังโน้ตนั้น
126. ย้ายโน้ตดิบที่ประมวลผลแล้วไปที่ 0-raw/archive/
13
14## การปฏิบัติตามอย่างเคร่งครัด
15- ปฏิบัติตามกฎเหล็กใน CLAUDE.md ห้ามเขียนข้อกล่าวอ้างโดยไม่มีแหล่งที่มา
16- ห้ามแตะต้องต้นฉบับใน sources/ และ 0-raw/ ยกเว้นเพื่ออ่าน
17- ปล่อยให้การบูรณาการที่ต้องใช้ดุลยพินิจไว้ให้มนุษย์ ทำเครื่องหมายไว้ อย่าบังคับตัดสินใจ

ความขนาน: การกำหนดเอเจนต์ย่อย

เพื่อแบ่งงาน "การแยกย่อย" "การเชื่อมโยง" และ "การตรวจสอบความขัดแย้ง" เราใช้เอเจนต์ย่อย โดยการกำหนดพวกมันใน markdown ภายใต้ .claude/agents/ แต่ละตัวจะเคลื่อนที่ในบริบทที่เป็นอิสระแบบขนานและส่งคืนเฉพาะผลลัพธ์ให้กับเอเจนต์หลัก (เอกสารทางการ) ไฟล์นิยามจะเริ่มต้นด้วย frontmatter ที่ระบุชื่อและเครื่องมือที่พร้อมใช้งาน

name: cataloger

description: แยกย่อยหนึ่งแหล่งที่มาเป็นอะตอม (หนึ่งไอเดียต่อไฟล์)

tools: ["Read", "Write"]

อ่านแหล่งที่มาที่ให้มาและสร้างอะตอมใน 2-atoms/ (หนึ่งไอเดียต่อไฟล์) ค้นหาอะตอมที่มีอยู่ก่อนและขยายความอะตอมที่สามารถขยายความได้ เขียนแหล่งที่มาใน frontmatter เสมอ

บทความต้นฉบับอวดอ้างว่า "300 เอเจนต์" มาจากข้อกำหนดของโมเดล Kimi K2.6 ซึ่งสามารถปรับใช้เอเจนต์ย่อยได้สูงสุด 300 ตัวและ 4,000 ขั้นตอนแบบขนาน (บล็อกทางการของ Kimi) อย่างไรก็ตาม Claude Code ไม่ได้โฆษณาจำนวนคงที่เช่น "จำกัด 300" มันใช้วิธีการจัดออร์เคสตราเพื่อกำหนดและรวมเอเจนต์หลายตัวตามความจำเป็น และในความเป็นจริง คุณไม่จำเป็นต้องมี 300 เอเจนต์สำหรับกะกลางคืนของสมองที่สอง บทบาทสองสามประเภทและเอเจนต์สองสามตัวต่อแหล่งที่มาที่สะสมก็เพียงพอแล้ว ประโยชน์ที่ได้มาจากการแบ่งหน้าที่กันทำและรันแบบขนาน ไม่ใช่จากจำนวนที่มากมาย

การจัดตารางเวลา: การเรียกใช้ในเวลาที่กำหนดทุกคืน

สุดท้าย กระตุ้นกะต่างๆ ตามเวลา วิธีที่น่าเชื่อถือที่สุดคือการเรียกใช้ skill ด้วยชื่อโดยใช้ claude -p มาตรฐานจาก cron job ภายนอก ออกแบบให้สี่กะทำงานต่อเนื่องกันตลอดทั้งคืน

0 23 * 23:00 ทุกวัน Scout (รวบรวมวัสดุ ตอนนี้รันเองก่อน)

0 3 * 3:00 ทุกวัน Refinery (กลั่นกรองแบบขนาน งานหลัก)

0 6 * 6:00 ทุกวัน Editor (อัปเดต threads และรายงานสรุป)

0 22 0 22:00 วันอาทิตย์ Audit (ตรวจสุขภาพประจำสัปดาห์)

แค่ทำให้ Refinery ทำงานอัตโนมัติก็เพียงพอที่จะเริ่มต้นได้ นี่คือตัวอย่างสำหรับ crontab:

ตัวอย่างสำหรับ crontab -e (กะ Refinery เวลา 3:00)

0 3 * cd ~/brain && claude -p "/refinery" >> briefings/cron.log 2>&1

บทบาท Scout—การดึงข้อความบทความผ่านเบราว์เซอร์—เป็นกรณีพิเศษ ดังที่กล่าวไว้ในภายหลัง การทำงานของเบราว์เซอร์ของ Claude Code นั้นจำกัดอยู่เฉพาะเซสชันแบบโต้ตอบ ดังนั้น สำหรับตอนนี้ ให้รัน Scout ด้วยตนเองเพื่อบันทึกข้อความไปยัง sources/ และปล่อยให้ Refinery กลางคืนประมวลผลข้อความที่รวบรวมมา

เมื่อคุณชินแล้ว การย้ายไปใช้ Routines ในตัวของ Claude Code นั้นง่ายกว่า (เอกสารทางการ) การรัน /schedule ภายในเซสชันช่วยให้คุณลงทะเบียนการทำงานเป็นระยะ เช่น รายชั่วโมง รายคืน หรือรายสัปดาห์ (ณ เวลาที่เขียน นี่คือการแสดงตัวอย่างการวิจัยที่ต้องใช้แผนเฉพาะหรือ Claude Code บนเว็บ) Routines ทำงานบนคลาวด์ของ Anthropic ดังนั้นงานจะทำงานแม้ว่าแล็ปท็อปของคุณจะปิดอยู่ ช่วงเวลาขั้นต่ำคือหนึ่งชั่วโมง ผมแนะนำให้เริ่มต้นด้วย cron สำหรับหนึ่งกะก่อน แล้วค่อยย้ายไปใช้ Routines เมื่อคุณมั่นใจแล้ว

บทที่ 4: ทำให้ Obsidian เป็น "หน่วยความจำที่ใช้ร่วมกันสำหรับทุกเครื่องมือ"

จนถึงตอนนี้ Claude Code สามารถอ่านและเขียนไปยังโฟลเดอร์ brain/ ได้โดยตรง เนื่องจาก Obsidian กำลังเปิดโฟลเดอร์เดียวกันอยู่ การรวมพื้นฐานก็เสร็จสมบูรณ์แล้ว

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

สิ่งนี้จะกำจัดไซโลความรู้ที่กระจายอยู่ทั่วห้าแอป ทำให้ทุกอย่างสามารถใช้สมองเดียวกันได้ ซึ่งทำได้ผ่าน MCP (Model Context Protocol มาตรฐานทั่วไปสำหรับเชื่อมต่อเครื่องมือภายนอกเข้ากับ AI)

มีสามวิธีในการเชื่อมต่อ Obsidian เป็น MCP เรียงตามลำดับความยาก:

1. Filesystem MCP (ง่ายที่สุด ไม่ต้องใช้ปลั๊กอิน)

เนื่องจาก Vault เป็นเพียงโฟลเดอร์ คุณสามารถชี้เซิร์ฟเวอร์ Filesystem MCP ไปที่ Vault ได้ คุณไม่จำเป็นต้องติดตั้งอะไรใน Obsidian

claude mcp add obsidian-fs -- npx @modelcontextprotocol/server-filesystem ~/brain

2. Local REST API + mcp-obsidian (ฟีเจอร์เต็ม: ค้นหาและผนวก)

ถ้าคุณต้องการให้ AI ค้นหาข้อความแบบเต็ม หรือผนวกเข้ากับหัวเรื่อง/บล็อกที่เฉพาะเจาะจง ให้ใช้ปลั๊กอินชุมชน "Local REST API" ใน Obsidian แค่ติดตั้งและเปิดใช้งาน จากนั้นคัดลอกคีย์ API โฮสต์เริ่มต้นคือ 127.0.0.1 พอร์ต 27124 (HTTPS พร้อมใบรับรองที่ลงนามเอง) จากนั้นลงทะเบียน uvx mcp-obsidian พร้อมตัวแปรสภาพแวดล้อม (mcp-obsidian / Local REST API

OBSIDIAN_API_KEY=your_key OBSIDIAN_HOST=127.0.0.1 OBSIDIAN_PORT=27124 claude mcp add obsidian -- uvx mcp-obsidian

3. การใช้งานที่สมบูรณ์ยิ่งขึ้น (cyanheads/obsidian-mcp-server)

นอกจากนี้ยังมีการใช้งานเซิร์ฟเวอร์ MCP ที่ล้ำหน้ากว่าซึ่งครอบคลุมปลั๊กอิน Local REST API cyanheads/obsidian-mcp-server เป็นเซิร์ฟเวอร์ภายนอกที่ใช้ Node ซึ่งรองรับการจำกัดพาธและการแก้ไขตามหัวเรื่องที่แม่นยำ เช่นเดียวกับวิธีที่ 2 มันต้องใช้ปลั๊กอิน Local REST API และคีย์ API

การลงทะเบียน MCP ใน Claude Code เป็นไปตามรูปแบบ claude mcp add <name> -- <command> เสมอ และการตั้งค่าจะไปอยู่ใน ~/.claude.json (สำหรับตัวคุณเอง) หรือ .mcp.json (สำหรับการแชร์ในที่เก็บ) (เอกสารทางการ

ข้อควรระวังหนึ่ง: วิธีการทั้งหมดนี้จำกัดขอบเขตไว้ที่ localhost หรือโฟลเดอร์ที่ให้มา วิธี REST API ต้องใช้คีย์ API ของคุณเองและการสื่อสารจำกัดอยู่ที่ localhost อย่างไรก็ตาม เนื่องจากการให้สิทธิ์เขียนแก่เอเจนต์ วิธีที่ปลอดภัยที่สุดคือจำกัดให้ใช้กับ Vault ที่เชื่อถือได้เท่านั้น

ข้อผิดพลาดสามประการที่วิดีโอสาธิตมักข้ามไป

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

ประการแรก ทำความเข้าใจข้อจำกัดอย่างตรงไปตรงมา Routines ทำงานบนคลาวด์โดยมีช่วงเวลาขั้นต่ำหนึ่งชั่วโมง และกะ "Scout"—การดึงข้อความบทความผ่านเบราว์เซอร์—ต้องใช้ความระมัดระวัง การทำงานของเบราว์เซอร์ของ Claude Code (Claude ใน Chrome) ขณะนี้อยู่ในช่วงเบต้าและจำกัดเฉพาะเซสชันแบบโต้ตอบ มันยังใช้ไม่ได้ภายใน Routines บนคลาวด์ (เอกสารทางการ) ในทางปฏิบัติ จะสะอาดกว่าถ้ารัน Scout ด้วยตนเองเพื่อบันทึกข้อความไปยัง sources/ และปล่อยให้ Refinery กลางคืนประมวลผลข้อความที่รวบรวมมา

ประการที่สอง ความปลอดภัยและค่าใช้จ่าย Claude Code มีโหมดสิทธิ์หลายแบบ (เอกสารทางการ) โหมด default มาตรฐานจะขออนุมัติสำหรับสิ่งอื่นนอกเหนือจากการอ่าน acceptEdits จะอนุญาตให้แก้ไขโดยอัตโนมัติ plan จะตรวจสอบและเสนอแผนในโหมดอ่านอย่างเดียว bypassPermissions อนุญาตทุกอย่าง สำหรับการทำงานโดยไม่มีคนดูแล วิธีที่ปลอดภัยที่สุดคือตรวจสอบพฤติกรรมด้วย plan ก่อน จากนั้นย้ายไปใช้ dontAsk (โหมดสำหรับ CI ที่รันเฉพาะเครื่องมือที่ได้รับอนุญาตล่วงหน้า) พร้อมกับใช้กฎ Deny นอกจากนี้ จัดการ brain/ ด้วย git และคอมมิตทุกคืน ถ้ากะกลางคืนตัดสินใจแปลกๆ คุณสามารถย้อนกลับไปยังคืนก่อนหน้าได้ด้วยคำสั่งเดียว นี่คือเข็มขัดนิรภัย ควรรัดตั้งแต่วันแรกดีกว่ารอให้เกิดอุบัติเหตุ นอกจากนี้ Claude Code มีค่าใช้จ่าย API หรือค่าสมัครสมาชิก คุณอาจโฮสต์โมเดล open-weights ด้วยตัวเองเพื่อทำให้ค่าใช้จ่าย API เป็นศูนย์เหมือนในคู่มือต้นฉบับ แต่นั่นเป็นอีกหัวข้อหนึ่ง แค่เตรียมประมาณการค่าใช้จ่ายตามปริมาณการประมวลผลในแต่ละคืน

ประการที่สาม จงปฏิบัติตามกฎเหล็กต่อไป ถ้า Audit รายสัปดาห์พบ "โน้ตที่ไม่มีแหล่งที่มา" ให้จัดการทันที ทันทีที่โน้ตที่มีแหล่งที่มาสืบย้อนไม่ได้เริ่มสะสม สมองของคุณก็จะไร้ความน่าเชื่อถือ สมองที่สองที่ไร้ความน่าเชื่อถือนั้นแย่กว่าการไม่มีเลย เพราะคุณอาจลงมือทำตามเรื่องแต่งของเครื่องจักรโดยคิดว่ามันเป็นข้อสรุปของคุณเอง "ห้ามเขียนโน้ตถ้าไม่มีแหล่งที่มา" นี่คือกฎที่จะทำให้สมองของคุณเป็นของคุณเอง

สรุป: เลิกเป็นบรรณารักษ์ มาเป็นบรรณาธิการบริหาร

เป็นเวลานานแล้วที่ "การสร้างสมองที่สอง" เป็นวิธีการพูดที่สุภาพสำหรับ "การรับงานที่สองที่ไม่ได้รับค่าจ้างในฐานะบรรณารักษ์ของตัวเอง" นั่นคือสาเหตุที่มีสุสานแห่งความพยายามที่ล้มเหลวอยู่ทุกหนทุกแห่ง แรงงานมันไม่คุ้มค่า ดังนั้นกำลังใจจึงแพ้เสมอ

แต่แรงงานนั้นสามารถมอบหมายได้แล้ว ในระหว่างวัน คุณแค่โยนสิ่งต่างๆ เข้ามาไม่กี่วินาที ตกกลางคืน กองกำลังจะกลั่นกรองมัน คุณใช้เวลาเพียง 20 นาทีต่อสัปดาห์ในฐานะบรรณาธิการบริหาร เพื่อตัดสินใจ "จะนำความเชื่อใดมาใช้" และระบบจะฉลาดขึ้นเรื่อยๆ ยิ่งคุณปล่อยมันไว้ตามลำพังมากเท่าไหร่ เพราะคุณได้ส่งมอบแรงงานที่เคยลดลงตามเวลาให้กับกะกลางคืนโดยสิ้นเชิง

คุณไม่ได้จดโน้ตได้ไม่ดี คุณแค่พยายามบริหารแผนกวิจัยทั้งหมดด้วยตัวเอง

ขั้นตอนแรกตั้งแต่วันนี้ (3 ขั้นตอน):

• [ ] สร้างโรงกลั่นด้วย mkdir -p brain/{0-raw,1-desk,2-atoms,3-threads,sources,briefings,.claude/skills} และเปิดเป็น Vault ใน Obsidian เขียนกฎเหล็ก "ห้ามเขียนโน้ตถ้าไม่มีแหล่งที่มา" ในบรรทัดแรกของ CLAUDE.md
• [ ] เขียน SKILL.md หนึ่งไฟล์สำหรับ .claude/skills/refinery/ และลองประมวลผลแหล่งที่มาหนึ่งรายการด้วยตนเองโดยใช้ claude -p
• [ ] ถ้ามันได้ผล ให้ทำให้หนึ่งกะทำงานอัตโนมัติทุกคืนด้วย cron หรือ Routines

ผมแชร์ข้อมูลที่เป็นประโยชน์ซึ่งผมไม่สามารถโพสต์บน X ได้ใน LINE OpenChat

กรุณาเข้าร่วมกับเราผ่านลิงก์ด้านล่าง

https://t.co/9LOoUYvCbO

https://x.com/nobel_824/status/2066393004932559265