วิธีสร้างสมองส่วนที่สองด้วยแนวคิดของ Karpathy (Claude + Obsidian)

นี่คือการแจกแจงแบบ A–Z อย่างละเอียดของระบบความรู้ที่ Andrej Karpathy ทำให้โด่งดัง — และวิธีสร้างด้วยตัวเองโดยใช้ Claude Code

บุ๊กมาร์กบทความนี้ไว้ก่อนที่คุณจะลืม

ไอเดียที่มียอดวิว 21 ล้านครั้ง

Andrej Karpathy — ผู้ร่วมก่อตั้ง OpenAI และนักวิจัยของ Anthropic AI — โพสต์ไอเดียง่ายๆ ที่กลายเป็นไวรัลอย่างมาก

หยุดใช้ AI เพื่อเขียนโค้ด ใช้มันเพื่อสร้างสมองที่สองแทน

https://x.com/karpathy/status/2039805659525644595

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

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

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

นี่คือวิธีสร้างด้วย Claude Code

วิธีนี้แท้จริงแล้วคืออะไร

"สมองที่สอง" ของคนส่วนใหญ่คือสุสาน

โน้ตเข้าไป มันไม่เคยออกมา มุมมองกราฟดูน่าประทับใจ แต่คุณไม่เคยใช้ 95% ของสิ่งที่อยู่ในนั้นเลย มันคือการกักตุน ไม่ใช่ระบบ

Karpathy ได้วางกรอบความแตกต่างที่แท้จริงกับ RAG — วิธีมาตรฐานที่คนใช้เชื่อม AI เข้ากับโน้ตของพวกเขา

RAG ค้นหาเอกสารของคุณใหม่ตั้งแต่ต้นทุกครั้งที่มีคำถาม ไม่มีอะไรสะสม คุณถาม มันดึงข้อมูล มันตอบ แล้วมันก็ลืม — คำถามถัดไปเริ่มจากศูนย์ ความรู้ไม่เคยถูกเรียบเรียงจริงๆ มันแค่ถูกค้นหา ซ้ำแล้วซ้ำเล่า

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

อย่างที่ Karpathy พูด: Obsidian คือ IDE, LLM คือโปรแกรมเมอร์, wiki คือฐานโค้ด

ลิงก์ทางการ - https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f

คุณไม่ได้กำลังค้นหากองเอกสาร คุณกำลังดูแลรักษาฐานความรู้ที่มีชีวิตและถูกเรียบเรียง — วิธีเดียวกับที่ดูแลรักษาฐานโค้ด ไม่ใช่วิธีที่แฟ้มโฟลเดอร์วางนิ่งๆ

นั่นคือวงจร มันมีสามการดำเนินการ และแต่ละอย่างก็ป้อนกลับเข้าสู่ระบบ:

Ingest (รับข้อมูล) — คุณโยนแหล่งข้อมูลเข้ามา AI อ่านมัน แยกมันเป็นหน้าอะตอมมิก และบูรณาการมันเข้ากับวิกิ

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

Lint (ตรวจสอบ) — เป็นระยะๆ AI จะตรวจสอบสุขภาพของวิกิ: ความขัดแย้งระหว่างหน้า ข้อมูลที่ล้าสมัย หน้าที่ไม่มีลูกกี่ (orphan pages) ที่ไม่มีลิงก์เชื่อม ช่องว่างของเนื้อหา นี่คือการดำเนินการที่ทุกคนข้ามไป และเป็นสิ่งที่ทำให้ระบบมีชีวิตอยู่จริงๆ

ความแตกต่างระหว่างพื้นที่จัดเก็บกับวงจร: พื้นที่จัดเก็บใหญ่ขึ้น วงจรฉลาดขึ้น — และคงความสอดคล้องกัน

ทำไมวงจรถึงทบต้น

นี่คือคณิตศาสตร์ที่ทำให้สิ่งนี้ทำงาน

ห้องนิรภัยที่มี 10 โน้ต มีความเป็นไปได้ในการเชื่อมต่อสูงสุด 45 แบบ ห้องนิรภัยที่มี 100 โน้ต มี 4,950 แบบ ห้องนิรภัยที่มี 500 โน้ต มีการเชื่อมต่อที่เป็นไปได้มากกว่า 124,000 แบบ

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

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

Claude Code แก้ปัญหานี้ มันรักษาการเชื่อมต่อให้คุณ ทุกครั้งที่คุณรับแหล่งข้อมูล (ingest) Claude จะเชื่อมโยงมันใหม่กับห้องนิรภัยที่มีอยู่ทั้งหมด การบำรุงรักษาที่ฆ่าระบบที่ทำด้วยมือกลายเป็นอัตโนมัติ

นั่นคือเคล็ดลับทั้งหมด วงจรจะทบต้นก็ต่อเมื่อมีบางสิ่งรักษาการเชื่อมต่อไว้ มนุษย์ทำไม่ได้ Claude ทำได้

การตั้งค่า — โครงสร้างที่ Karpathy ใช้

โครงสร้างของ Karpathy จงใจให้เรียบง่าย สองสามโฟลเดอร์และไฟล์ schema

1. /raw — แหล่งข้อมูลของคุณ บทความ บทถอดเสียง PDF อะไรก็ได้ ยังไม่ผ่านการประมวลผล นี่คืออินบ็อกซ์
2. /wiki — หน้าของ AI โน้ตแบบอะตอมมิกที่ผ่านการประมวลผล เชื่อมโยง และสร้างจากแหล่งข้อมูลดิบของคุณ นี่คือสมองที่สองที่แท้จริง
3. index.md — แค็ตตาล็อก สารบัญของทุกหน้าในวิกิ เพื่อให้ทั้งคุณและ AI สามารถนำทางโครงสร้างทั้งหมดได้อย่างรวดเร็ว
4. log.md — ลำดับเหตุการณ์ บันทึกสิ่งที่ถูกนำเข้าและเมื่อไหร่ นี่คือประวัติการเติบโตของระบบ
5. CLAUDE.md (schema) — กฎเกณฑ์ ไฟล์ที่ AI อ่านทุกครั้งที่เริ่มเซสชัน ซึ่งกำหนดอย่างชัดเจนว่าจะรับข้อมูล (ingest) สอบถาม (query) และตรวจสอบ (lint) วิกิอย่างไร Karpathy เรียกสิ่งนี้ว่า schema — มันคือข้อกำหนดที่ AI ปฏิบัติตามเพื่อรักษาระบบทั้งหมดให้สอดคล้องกัน

แค่นั้น ไม่มีปลั๊กอิน ไม่มีเครื่องมือซับซ้อน สองสามโฟลเดอร์ ไฟล์ schema หนึ่งไฟล์ และ AI agent ที่รันในเทอร์มินัล

ขั้นตอนที่ 1 — ติดตั้ง Obsidian และ Claude Code

Obsidian — ฟรี จาก obsidian.md สร้าง vault ใหม่ นี่คือที่ที่สมองที่สองของคุณอาศัยอยู่

Claude Code — ติดตั้งผ่านเทอร์มินัล:

1npm install -g @anthropic-ai/claude-code

ไปที่โฟลเดอร์ vault ของคุณและเปิด Claude Code:

1cd your-vault-folder
2claude

ตอนนี้ Claude Code กำลังทำงานภายใน vault ของคุณ โดยสามารถเข้าถึงไฟล์ทุกไฟล์ได้โดยตรงทั้งอ่านและเขียน

ขั้นตอนที่ 2 — สร้าง CLAUDE.md Engine

นี่คือไฟล์ที่สำคัญที่สุดในทั้งระบบ มันคือสิ่งที่ทำให้วงจรทำงาน

สร้างไฟล์ CLAUDE.md ใน root ของ vault ของคุณ วางข้อความนี้:

1# Second Brain Schema
2
3## โครงสร้าง
4- /raw เก็บแหล่งข้อมูลที่ยังไม่ผ่านการประมวลผล
5- /wiki เก็บหน้าอะตอมมิกที่ผ่านการประมวลผลแล้ว
6- index.md คือแค็ตตาล็อกของหน้าวิกิทั้งหมด
7- log.md คือประวัติการรับข้อมูลตามลำดับเวลา
8- ไฟล์นี้คือ schema ที่ควบคุมระบบ
9
10## INGEST — เมื่อฉันพูดว่า "รับข้อมูลนี้" หรือวางไฟล์ใน /raw:
111. อ่านแหล่งข้อมูลทั้งหมด
122. แยกแนวคิดหลักออกเป็นหน้าอะตอมมิกแยกกัน
133. สำหรับแต่ละหน้า: ชื่อเรื่องที่ชัดเจน, สรุปหนึ่งประโยค,
14   แนวคิดในคำพูดของฉันเอง, การระบุแหล่งที่มา
154. เชื่อมโยงแต่ละหน้าใหม่กับหน้าที่เกี่ยวข้องที่มีอยู่แล้วใน /wiki
16   โดยใช้ [[wikilinks]]
175. ถ้าหน้าเชื่อมต่อกับหน้าที่มีอยู่แล้ว 3 หน้าขึ้นไป ให้ทำเครื่องหมายว่าเป็น hub
186. เพิ่มแต่ละหน้าใหม่ใน index.md
197. ผนวกรายการใน log.md พร้อมวันที่และแหล่งที่มา
208. ย้ายแหล่งข้อมูลไปที่ /raw/processed
21
22## QUERY — เมื่อฉันถามคำถาม:
23- ค้นหา /wiki ทั้งหมดก่อนตอบ
24- อ้างอิงว่าหน้าใดสนับสนุนคำตอบของคุณ
25- ถ้าหน้าขัดแย้งกัน ให้แสดงความขัดแย้งนั้น
26- จัดเก็บคำตอบกลับเป็นหน้าใหม่ถ้ามันคุ้มค่าที่จะเก็บไว้
27
28## LINT — เมื่อฉันพูดว่า "ตรวจสอบ wiki":
29- ค้นหาความขัดแย้งระหว่างหน้า
30- แจ้งข้อมูลที่ล้าสมัยหรือถูกแทนที่
31- ค้นหาหน้าที่ไม่มีลูกกี่ (orphan pages) ที่ไม่มีลิงก์ขาเข้า
32- ระบุช่องว่าง: หัวข้อที่ถูกอ้างถึงแต่ไม่เคยถูกพัฒนา
33- รายงานทุกอย่าง; อย่าลบอัตโนมัติ
34
35## กฎเกณฑ์
36- ทุกหน้าต้องเป็นอะตอมมิก: หนึ่งแนวคิดต่อหนึ่งหน้า
37- เขียนด้วยน้ำเสียงของฉัน ไม่ใช่น้ำเสียงของแหล่งที่มา
38- ห้ามสูญเสียการระบุแหล่งที่มา
39- ค้นหาการเชื่อมต่อที่ไม่ชัดเจนอย่างจริงจัง

AI อ่านไฟล์นี้ทุกครั้งที่เริ่มเซสชัน คุณไม่ต้องอธิบายระบบอีกเลย schema คือเครื่องยนต์

ขั้นตอนที่ 3 — ป้อนวงจร

ตอนนี้วงจรทำงานแล้ว วางแหล่งข้อมูลใดๆ ลงใน /raw แล้วบอก Claude:

1รับข้อมูลนี้

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

ทำแบบนี้กับทุกอย่าง บทความที่คุณอ่าน บทถอดเสียงพอดแคสต์ PDF ของเอกสาร บันทึกการประชุม ไฮไลท์จากหนังสือ

ทุกครั้งที่รับข้อมูล (ingestion) ทำให้ทั้งระบบฉลาดขึ้น — เพราะ Claude เชื่อมโยงเนื้อหาใหม่กับทุกอย่างที่มีอยู่แล้ว

ขั้นตอนที่ 4 — สอบถามข้ามทุกอย่าง

นี่คือจุดที่พื้นที่จัดเก็บกลายเป็นวงจร

เมื่อคุณมีเนื้อหาใน vault แล้ว คุณหยุดค้นหาและเริ่มถาม:

1ฉันรู้อะไรเกี่ยวกับ [หัวข้อ] บ้าง? ดึงมาจากทุกโน้ตที่เกี่ยวข้อง
2และสังเคราะห์เป็นคำตอบที่สอดคล้องกัน อ้างอิงโน้ตด้วย

1อะไรเชื่อมโยง [แนวคิด A] และ [แนวคิด B] ใน vault ของฉัน?
2ค้นหาการเชื่อมต่อที่ไม่ชัดเจน

1จากทุกอย่างใน vault ของฉัน อะไรคือคำถาม
2ที่ฉันควรถามแต่ไม่ได้ถาม?

1อะไรคือช่องว่างในความรู้ของฉันเกี่ยวกับ [หัวข้อ]?
2ฉันควรอ่านอะไรต่อไป?

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

ขั้นตอนที่ 5 — ตรวจสอบ Wiki (ขั้นตอนที่ทุกคนข้ามไป)

นี่คือการดำเนินการที่เกือบไม่มีใครทำ — และมันคือสิ่งที่ทำให้ทั้งระบบไม่เน่าเปื่อย

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

ปล่อยไว้ กราฟก็จะล่องลอย การเชื่อมต่อที่ให้คุณค่าค่อยๆ หายไป

การตรวจสอบ (Linting) แก้ไขปัญหานี้

สัปดาห์ละครั้ง ให้รัน:

1ตรวจสอบ wiki
21. ค้นหาหน้าที่ขัดแย้งกัน
32. แจ้งข้อมูลที่ล้าสมัยหรือถูกแทนที่โดยโน้ตที่ใหม่กว่า
43. ค้นหาหน้าที่ไม่มีลูกกี่ (orphan pages) ที่ไม่มีลิงก์ขาเข้า
54. ระบุช่องว่าง: หัวข้อที่ฉันอ้างถึงแต่ไม่เคยพัฒนา
65. รายงานทุกอย่าง อย่าลบอะไร —
7   แค่แสดงให้ฉันเห็นว่าอะไรต้องการความสนใจ

Claude เดินทั่วทั้งวิกิและรายงานสิ่งที่เสียหาย คุณตัดสินใจว่าจะแก้ไขอะไร

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

ขั้นตอนที่ 6 — การทบทวนวงจรประจำสัปดาห์

สัปดาห์ละครั้ง ควบคู่ไปกับการตรวจสอบ (lint pass) ให้รันการทบทวนที่ทำให้วงจรชี้ไปในทิศทางที่ถูกต้อง:

1ทบทวนทุกอย่างที่ฉันเพิ่มในสัปดาห์นี้
21. อะไรคือ 3 แนวคิดที่สำคัญที่สุดที่ฉันบันทึกไว้?
32. การเชื่อมต่อใหม่ๆ อะไรเกิดขึ้นระหว่างหน้าเก่าและหน้าใหม่?
43. หน้า Hub อะไรกำลังก่อตัว — แนวคิดที่หลายหน้า
5   ตอนนี้เชื่อมโยงไปหา?
64. ฉันสนใจอะไรอย่างชัดเจนจากสิ่งที่ฉันป้อนให้ระบบ?
75. ฉันควรสำรวจอะไรในสัปดาห์หน้าเพื่อ deepen เส้นที่แข็งแกร่งที่สุด?

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

ทำไมสิ่งนี้ถึงเอาชนะแอปจดโน้ตทุกตัว

Notion, Roam, Obsidian มาตรฐาน — พวกมันทั้งหมดคือพื้นที่จัดเก็บที่มี UI ดีกว่า

วิธีการของ Karpathy แตกต่างในแง่หนึ่งที่เฉพาะเจาะจง: การเชื่อมต่อดูแลรักษาตัวมันเอง

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

ในวงจร Claude สร้างการเชื่อมต่อนั้นโดยอัตโนมัติ ทุกครั้ง ทั่วทั้ง vault ของคุณ ตลอดไป สิ่งที่ฆ่าระบบที่ทำด้วยมือทุกระบบ — การบำรุงรักษาการเชื่อมต่อ — คือสิ่งที่ Claude Code ทำให้เป็นอัตโนมัติ

นั่นคือเหตุผลที่มันทบต้น และนั่นคือเหตุผลที่ 21 ล้านคนหยุดอ่านไอเดียของ Karpathy

โบนัส: รันสมองที่สองของคุณ 24/7

นี่คือข้อจำกัดที่ไม่มีใครพูดถึง

การรันวงจรบนแล็ปท็อปของคุณหมายความว่ามันจะทำงานก็ต่อเมื่อแล็ปท็อปของคุณเปิดอยู่เท่านั้น ปิดฝา แล้วสมองที่สองของคุณก็หยุดคิด คุณเจอบทความดีๆ ตอน 11 PM บนโทรศัพท์ มันก็แค่นั่งอยู่ในแท็บจนกว่าคุณจะกลับมาที่โต๊ะทำงาน

คุณต้องมี VPS — เซิร์ฟเวอร์คลาวด์ที่ออนไลน์ 24/7 ทำงานโดยไม่หยุดชะงัก และตอบสนองต่อการเปลี่ยนแปลงข้อมูลทันที

ฉันใช้ส่วนตัว

👉

https://ishosting.com/affiliate/NzE0MiM2

พวกเขามีสภาพแวดล้อม Linux ง่ายๆ พร้อมคู่มือการติดตั้งที่พร้อมใช้งาน — ง่ายแม้คุณไม่ใช่คนด้านเทคนิค

สมาชิกของฉันได้รับส่วนลดพิเศษ

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

การตั้งค่า:

1. รับ Ubuntu VPS พื้นฐาน (แนะนำ: Start - Linux SSD, Ubuntu 22.04, ตำแหน่ง Chicago หรืออื่นๆ)

$10.19/เดือน ในแผนรายปี

สำหรับงานที่ซับซ้อนมากขึ้น ฉันแนะนำให้ใช้: Medium หรือ Premium

เซิร์ฟเวอร์ขั้นต่ำ: Xeon 2x2.20GHz, 2GB RAM, 30GB SSD — งานหนักเกิดขึ้นบนเซิร์ฟเวอร์ Anthropic/Moonshot ผ่าน API VPS ของคุณแค่รัน agent และเก็บไฟล์ข้อความของคุณ ดังนั้นคุณไม่จำเป็นต้องมีอะไรที่ทรงพลังมาก สำหรับการรับข้อมูลเป็นชุด (batch-ingesting) หนักๆ 4GB RAM จะสบายกว่า

แนะนำ:

• 4 vCPU
• 8 GB RAM
• 80 GB SSD
• ตำแหน่งที่ตั้ง: นิวยอร์ก / ลอนดอน / แฟรงก์เฟิร์ต (เวลาแฝงต่ำกว่า)

การจ่ายล่วงหน้าทั้งปีจะคุ้มค่ากว่า

คุณสามารถรันบอทหลายตัวบนเซิร์ฟเวอร์เดียวนี้พร้อมกันได้ หนึ่ง VPS, กลยุทธ์ไม่จำกัด

เชื่อมต่อกับ VPS ของคุณ

ตรวจสอบอีเมลของคุณ

Windows: เปิด Remote Desktop (RDP) → ป้อน IP ของเซิร์ฟเวอร์ → เข้าสู่ระบบด้วยข้อมูลประจำตัว ถ้าคุณเลือกโฮสติ้ง Windows

Mac: เปิด Terminal → วาง IP → เชื่อมต่อ

1ssh root@SERVER_IP

คุณอยู่ภายในเครื่องคลาวด์ของคุณแล้ว เซิร์ฟเวอร์นี้รันบอทของคุณโดยไม่หยุด

ติดตั้ง Claude Code บนนั้น

https://code.claude.com/docs/en/setup - ตั้งค่า Claude

https://obsidian.md/help/install - ติดตั้ง Obsidian

1. วางโฟลเดอร์ vault Obsidian ของคุณบนเซิร์ฟเวอร์ ซิงค์กับ vault ในเครื่องของคุณ
2. ตั้ง cron job ที่รัน "รับข้อมูลนี้" บนโฟลเดอร์ /raw ทุกชั่วโมง

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

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

ทางเลือกที่ถูกกว่าที่น่ารู้

Claude Code คือเครื่องมือที่วิธีการของ Karpathy แพร่กระจายไป แต่ระบบเดียวกันนี้รันบน Kimi K2.7 — ด้วยบริบท 256K ที่เก็บ vault ของคุณได้มากขึ้นในครั้งเดียว ความสามารถในการอ่านไฟล์ได้ถึง 50 ไฟล์พร้อมกัน และต้นทุน API ที่เป็นเศษเสี้ยว

https://x.com/kirillk_web3/status/2071705181432266793

สำหรับระบบที่ใหญ่ขึ้นเรื่อยๆ เมื่อเวลาผ่านไป ซึ่งทุกครั้งที่รับข้อมูลจะต้องอ่านเทียบกับ vault ทั้งหมด ขนาดบริบทและต้นทุนมีความสำคัญ Kimi รันวงจรเดียวกันในราคาถูกกว่า

สามโฟลเดอร์เดียวกัน ไฟล์ config เดียวกัน คำสั่งเดียวกัน สลับ Claude Code เป็น Kimi Code CLI แล้ววงจรก็เหมือนกัน

ใช้อันไหนก็ได้ที่เหมาะกับงบประมาณของคุณ วิธีการคือสิ่งที่สำคัญ ไม่ใช่โมเดล

บทสรุป

ข้อมูลเชิงลึกของ Karpathy ไม่ได้เกี่ยวกับการจดโน้ต มันเกี่ยวกับวงจร

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

สามโฟลเดอร์ ไฟล์ config หนึ่งไฟล์ หนึ่งคำสั่ง: "รับข้อมูลนี้"

ใช้เวลาห้านาทีในการตั้งค่า และคุณไม่ต้องเริ่มจากการแชทเปล่าอีกต่อไป

ความรู้ที่คุณมีอยู่แล้วเริ่มทำงานให้คุณ แทนที่จะนั่งอยู่ในโฟลเดอร์ที่คุณลืมไปแล้ว

นั่นคือวิธีการของ Karpathy นั่นคือวิธีที่สมองที่สองควรทำงาน

ลิงก์

• Telegram ของฉัน: https://t.me/kirillk_web3
• Twitter/X ของฉัน: https://x.com/kirillk_web3
• โฮสติ้ง (รัน 24/7): https://ishosting.com/affiliate/NzE0MiM2

ติดตามเพื่อรับข้อมูล Vibe Coding เพิ่มเติม ขอบคุณที่อ่าน!