วิธีเชี่ยวชาญ AI ใน 30 วัน: แผนการเรียนรู้ฉบับสมบูรณ์

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

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

ความเชี่ยวชาญไม่ใช่การรู้พรอมต์มากขึ้น มันคือการมีระบบที่ทำซ้ำได้ซึ่งคุณใช้โดยไม่ต้องคิด

นี่คือระบบนั้น บีบอัดอยู่ใน 30 วัน สี่สัปดาห์ สิบสองท่าไม้ตายที่มีหมายเลขกำกับ แต่ละท่าจบลงด้วยสิ่งที่คุณต้องทำในวันนี้ พรอมต์ที่ลอกเลียนได้ โค้ด Python ที่ใช้งานได้จริง (ตรวจสอบแล้วกับ anthropic SDK, v0.109.1) ไม่มีทฤษฎีใดที่คุณไม่สามารถลงมือทำได้ภายในคืนนี้

ปืนเริ่มต้นทางวัฒนธรรมคือประโยคอันโด่งดังของ Andrej Karpathy เกี่ยวกับ "vibe coding" — "คุณยอมจำนนต่อไวยบ์อย่างเต็มที่... และลืมไปว่าโค้ดนั้นมีอยู่จริง" นั่นคือไวยบ์ นี่คือวินัยที่อยู่เบื้องหลังมัน ซึ่งทำให้ไวยบ์นั้นส่งมอบได้จริง

ส่วนที่ 1 · สัปดาห์ที่ 1 — กรอบความคิดและชัยชนะครั้งแรก (วันที่ 1–7)

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

01. ส่งมอบงานจริงหนึ่งอย่างด้วย AI — วันนี้

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

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

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

1คุณคือ <บทบาท เช่น "บรรณาธิการบริหารที่ตรงไปตรงมา"> ของฉัน
2งาน: <งานที่เป็นรูปธรรมหนึ่งงานในหนึ่งประโยค>
3บริบท: <2–3 บรรทัดที่โมเดลไม่สามารถรู้ได้ — กลุ่มเป้าหมาย เป้าหมาย ข้อจำกัด>
4ผลลัพธ์: <รูปแบบที่แน่นอน — ความยาว โครงสร้าง น้ำเสียง>
5หากมีสิ่งใดคลุมเครือ ให้ถามฉันก่อนแทนที่จะเดา

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

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

02. เรียนรู้กายวิภาคของพรอมต์ที่ใช้ได้ผล

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

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

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

1# อ่อนแอ (หัวข้อ ไม่ใช่ข้อมูลสรุป)
2เขียนเกี่ยวกับฟีเจอร์ใหม่ของเรา
3
4# แข็งแกร่ง (ความชัดเจน + บริบท + รูปแบบ)
5เขียนประกาศผลิตภัณฑ์ 120 คำสำหรับ "โหมดโฟกัส" ใหม่ของเรา
6กลุ่มเป้าหมาย: ผู้ใช้ปัจจุบันที่พบว่าแอปพลิเคชันมีเสียงรบกวน
7เป้าหมาย: ให้พวกเขาลองใช้อย่างน้อยหนึ่งครั้งในสัปดาห์นี้
8น้ำเสียง: สงบ มั่นใจ ไม่โอ้อวด
9รูปแบบ: 1 ย่อหน้าสั้น + คำกระตุ้นการตัดสินใจหนึ่งบรรทัด

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

03. ขโมยเทคนิคหลัก 6 อย่าง — และโค้ดหนึ่งบรรทัด

ทั้งหกอย่างนี้ปรากฏอยู่ในคู่มือการเขียนพรอมต์อย่างจริงจังทุกเล่ม เพราะมันใช้ได้ผลเสมอ: (1) ชัดเจนและตรงประเด็น (2) เพิ่มบริบท/แรงจูงใจ (3) ยกตัวอย่าง (4) จัดโครงสร้างด้วยแท็กสไตล์ XML (5) กำหนดบทบาท (6) บอกให้มันคิดก่อนตอบ คุณจะใช้เวลาสัปดาห์ที่ 2 ฝึกฝนแต่ละอย่าง — นี่คือแผนที่

สองอย่างที่ควรติดตั้งไว้ในมือคุณทันทีคือ บทบาท และ แท็ก บทบาทในคำแนะนำระบบจะชี้นำน้ำเสียงและการตัดสินสำหรับการสนทนาทั้งหมด แม้แต่ประโยคเดียวก็สร้างความแตกต่างได้ แท็กอย่าง <context> และ <examples> จะหยุดไม่ให้โมเดลสับสนระหว่างคำแนะนำของคุณกับข้อมูลของคุณ นี่คือเทคนิคบทบาทในรูปแบบโค้ดที่ใช้งานได้จริง — รสชาติแรกของคุณกับ API ที่คุณจะใช้ในสัปดาห์ที่ 3

ใช้เมื่อ: คุณต้องการพฤติกรรมที่สอดคล้องกันในการเรียกใช้หลายครั้ง (บทบาท) หรือคุณกำลังผสมคำแนะนำกับข้อมูลนำเข้าที่ไม่เป็นระเบียบ (แท็ก)

1import anthropic
2
3client = anthropic.Anthropic()  # อ่าน ANTHROPIC_API_KEY จาก environment ของคุณ
4
5msg = client.messages.create(
6    model="claude-opus-4-8",
7    max_tokens=1024,
8    system="คุณคือบรรณาธิการสำเนาอาวุโส คุณตัดส่วนที่ไม่จำเป็นออกและรักษาน้ำเสียงของผู้เขียน",  # บทบาท
9    messages=[
10        {"role": "user", "content": "แก้ไขย่อหน้านี้ จากนั้นระบุสิ่งที่คุณเปลี่ยนแปลง:\n\n<draft>...</draft>"}
11    ],
12)
13print(msg.content[0].text)

ทำสิ่งนี้ตอนนี้: เขียนพรอมต์หนึ่งอันใหม่โดยระบุบทบาทอย่างชัดเจนและใช้ <tags> รอบข้อมูลนำเข้า ตอนนี้คุณใช้ไปแล้ว 2 ใน 6 อย่าง — สัปดาห์ที่ 2 จะทำให้ครบชุด

ส่วนที่ 2 · สัปดาห์ที่ 2 — วิศวกรรมพรอมต์เพื่อผลลัพธ์จริง (วันที่ 8–14)

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

04. ล็อคน้ำเสียงและรูปแบบด้วยตัวอย่างหลายชุด

การบอกโมเดลว่าคุณต้องการอะไรนั้นดี แต่การ แสดง ให้มันดูนั้นดีกว่า ตัวอย่างที่เลือกสรรมาอย่างดีสองสามตัวอย่าง (เทคนิคนี้เรียกว่า few-shot หรือ multishot prompting) จะกำหนดรูปแบบ น้ำเสียง และกรณีขอบได้อย่างน่าเชื่อถือมากกว่าคำคุณศัพท์ใดๆ คำแนะนำมีความสอดคล้องกันในวงการ: รวม 3–5 ตัวอย่าง ทำให้หลากหลายเพื่อให้โมเดลไม่ยึดติดกับรูปแบบที่ไม่ตั้งใจ และห่อแต่ละตัวอย่างด้วยแท็กเพื่อให้ชัดเจนว่าเป็นตัวอย่าง ไม่ใช่คำสั่ง

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

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

1จำแนกตั๋วสนับสนุนแต่ละใบเป็นหนึ่งใน: bug | billing | feature อย่างแม่นยำ
2
3<examples>
4<example>
5ตั๋ว: "ฉันถูกเรียกเก็บเงินสองครั้งในเดือนนี้"
6หมวดหมู่: billing
7</example>
8<example>
9ตั๋ว: "ปุ่มส่งออกไม่ทำงานบน Safari"
10หมวดหมู่: bug
11</example>
12<example>
13ตั๋ว: "กรุณาเพิ่มโหมดมืด"
14หมวดหมู่: feature
15</example>
16</examples>
17
18ตั๋ว: "แอปค้างเมื่อฉันอัปโหลด PDF"
19หมวดหมู่:

ทำสิ่งนี้ตอนนี้: เลือกงานที่เกิดขึ้นประจำหนึ่งงาน เขียนตัวอย่างที่หลากหลาย 3 ตัวอย่างในแท็ก <example> แล้วดูผลลัพธ์ที่เข้าที่เข้าทาง

05. ทำให้โมเดลคิดก่อนตอบ

สำหรับอะไรก็ตามที่ต้องใช้การให้เหตุผล — การวิเคราะห์ คณิตศาสตร์ การวางแผน การตัดสินใจที่ยุ่งยาก — สิ่งที่แย่ที่สุดที่คุณสามารถทำได้คือการเรียกร้องคำตอบทันที ให้พื้นที่มันในการให้เหตุผลก่อน คุณสามารถปล่อยให้โมเดลรุ่นใหม่คิดแบบปรับตัวได้ หรือในการแชทธรรมดา บังคับมัน: ขอให้ใช้เหตุผลทีละขั้นตอนในบล็อก <thinking> จากนั้นให้คำตอบสุดท้ายที่กระชับในบล็อก <answer> การแยกทั้งสองอย่างออกจากกันหมายความว่าคุณจะได้รับประโยชน์จากการให้เหตุผลโดยไม่มีข้อความยาวเหยียด

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

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

1คำถาม: <คำถามที่มีข้อแลกเปลี่ยนจริง>
2
3ขั้นแรก ให้เหตุผลภายในแท็ก <thinking>: ระบุสิ่งที่คุณรู้ สิ่งที่ขาดหายไป
4และคำตอบที่เป็นไปได้สองคำตอบพร้อมข้อแลกเปลี่ยน
5จากนั้นให้การตัดสินใจของคุณภายในแท็ก <answer> — สูงสุด 3 ประโยค
6ก่อนที่คุณจะเสร็จ ให้ตรวจสอบว่าคำตอบของคุณไม่ขัดแย้งกับสิ่งใดข้างต้น

ทำสิ่งนี้ตอนนี้: นำการตัดสินใจที่คุณกำลังครุ่นคิดมา รันผ่านการแยกความคิด/คำตอบ แล้วอ่าน <thinking> — นั่นคือที่ที่คุณค่าซ่อนอยู่

06. สร้างคลังพรอมต์ที่ใช้ซ้ำได้

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

นี่คือจุดเปลี่ยนของทั้ง 30 วัน: มันคือช่วงเวลาที่พรอมต์ของคุณหยุดเป็นของใช้แล้วทิ้งและเริ่มทวีคูณ Python dict ธรรมดาและ str.format คือทั้งหมดที่คุณต้องใช้ในการเริ่มต้น — ไม่ต้องมีเฟรมเวิร์ก ไม่ต้องมี dependencies

ใช้เมื่อ: คุณรันพรอมต์ที่คล้ายกันสามครั้ง ครั้งที่สาม ให้ทำเป็นเทมเพลต

1# prompt_library.py — พรอมต์ของคุณในฐานะโครงสร้างพื้นฐานที่ใช้ซ้ำได้
2TEMPLATES = {
3    "summarize": (
4        "คุณคือ {role}\n"
5        "สรุปข้อความด้านล่างสำหรับ {audience}\n"
6        "รูปแบบ: {fmt}\n\n"
7        "<text>\n{text}\n</text>"
8    ),
9}
10
11def build(name: str, **kwargs) -> str:
12    return TEMPLATES[name].format(**kwargs)
13
14prompt = build(
15    "summarize",
16    role="นักเขียนเทคนิค",
17    audience="ผู้ใช้ที่ไม่ใช่เทคนิค",
18    fmt="3 หัวข้อย่อย สูงสุด 15 คำต่อหัวข้อ",
19    text="...วางบันทึกการเปิดตัวที่นี่...",
20)
21print(prompt)  # ป้อนสิ่งนี้เข้าไปใน client.messages.create(...) โดยตรง

ทำสิ่งนี้ตอนนี้: สร้าง prompt_library.py ย้ายพรอมต์ที่ดีที่สุด 3 อันของคุณลงไปเป็นเทมเพลตพร้อมตัวแปร ไฟล์นี้จะเติบโตตลอดทั้งเดือน

ส่วนที่ 3 · สัปดาห์ที่ 3 — ทำงานอัตโนมัติด้วย API (วันที่ 15–21)

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

07. ก้าวจากแชทไปสู่ API

API ก็แค่พรอมต์แชทของคุณในฟังก์ชันที่คุณเรียกใช้ได้ ถ้าคุณเขียนพรอมต์ได้ คุณก็เขียนสิ่งนี้ได้ — มันแค่สิบบรรทัด ตั้งค่าคีย์ของคุณเป็น environment variable (อย่าวางลงในโค้ดเด็ดขาด) ห่อการเรียกใช้ในฟังก์ชัน แล้วคุณจะมีคำสั่ง AI ที่ใช้ซ้ำได้ซึ่งคุณสามารถวางลงในสคริปต์ใดก็ได้

Simon Willison ผู้ซึ่งบันทึกการใช้งาน LLM ในทางปฏิบัติได้ดีกว่าเกือบทุกคน ชี้ให้เห็นว่าประโยชน์ไม่ได้อยู่ที่การตั้งค่าที่แปลกใหม่ — แต่อยู่ที่การเชื่อมต่อโมเดลเข้ากับเครื่องมือเล็กๆ ที่คุณใช้อยู่แล้ว ฟังก์ชันนี้คือสายเชื่อมต่อนั้น

ใช้เมื่อ: คุณต้องการให้พรอมต์เดียวกันพร้อมใช้งานได้ทุกที่ — ในสคริปต์, cron jobs, โปรแกรมอื่นๆ — ไม่ใช่แค่ในแท็บเบราว์เซอร์

1import os
2import anthropic
3
4client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
5
6def ask(prompt: str) -> str:
7    msg = client.messages.create(
8        model="claude-opus-4-8",
9        max_tokens=1024,
10        messages=[{"role": "user", "content": prompt}],
11    )
12    return msg.content[0].text
13
14if __name__ == "__main__":
15    print(ask("ให้หัวเรื่องอีเมลที่โดนใจ 5 หัวข้อสำหรับอีเมลเปิดตัวผลิตภัณฑ์"))

ทำสิ่งนี้ตอนนี้: ติดตั้ง SDK (pip install anthropic), ตั้งค่า ANTHROPIC_API_KEY, และรันไฟล์นี้ การเรียก API ครั้งแรกที่สำเร็จ = ปลดล็อคสัปดาห์ที่ 3

08. เปลี่ยนงานประจำวันให้เป็นสคริปต์

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

ใช้เมื่อ: คุณพบว่าตัวเองกำลังทำงาน AI เดิมซ้ำแล้วซ้ำเล่าด้วยมือ การทำซ้ำนั้นคือสคริปต์ที่คุณยังไม่ได้เขียน

1import pathlib
2import anthropic
3
4client = anthropic.Anthropic()
5INBOX = pathlib.Path("./inbox")        # วางไฟล์ .txt ที่นี่
6OUT = pathlib.Path("./summaries")
7OUT.mkdir(exist_ok=True)
8
9def summarize(text: str) -> str:
10    msg = client.messages.create(
11        model="claude-haiku-4-5",      # ถูก + เร็ว: เครื่องมือที่เหมาะสมสำหรับงานปริมาณมาก
12        max_tokens=300,
13        system="สรุปเป็น 3 หัวข้อย่อยที่เป็นรูปธรรม ไม่มีน้ำท่วมทุ่ง",
14        messages=[{"role": "user", "content": text}],
15    )
16    return msg.content[0].text
17
18for f in INBOX.glob("*.txt"):
19    (OUT / f"{f.stem}.md").write_text(summarize(f.read_text(encoding="utf-8")), encoding="utf-8")
20    print("สรุปแล้ว:", f.name)

ทำสิ่งนี้ตอนนี้: ค้นหางานประจำที่เป็นชุดหนึ่งงาน วางไฟล์ใน ./inbox รันลูป คุณเพิ่งทำงานหนึ่งชั่วโมงเสร็จภายในหนึ่งนาที

09. ลดต้นทุนและความหน่วงด้วยการแคช

เมื่อคุณรันปริมาณจริงๆ แล้ว สองสิ่งเริ่มมีความสำคัญ: ความเร็วและค่าใช้จ่าย คานงัดที่ใหญ่ที่สุดคือการแคชพรอมต์ ถ้าทุกการเรียกใช้มีคำนำหน้าที่ยาวและไม่เปลี่ยนแปลงร่วมกัน — คู่มือสไตล์, ฐานความรู้, คำแนะนำระบบขนาดใหญ่ — คุณกำลังจ่ายเงินเพื่ออ่านซ้ำทุกครั้ง ทำเครื่องหมายด้วย cache_control แล้วโมเดลจะใช้เวอร์ชันที่แคชไว้: การ อ่าน แคชมีค่าใช้จ่ายประมาณ 10% ของราคาอินพุตปกติ เทียบกับการเขียนครั้งเดียวที่ +25% สำหรับงานแบตช์ที่มีคำนำหน้าร่วมกัน Batch API จะเพิ่มส่วนลดอีก ~50% ทับลงไป

ใช้เมื่อ: การเรียกใช้หลายครั้งมีบริบทคงที่ขนาดใหญ่ร่วมกัน (กรณีคลาสสิก: คำแนะนำระบบยาวที่ใช้ซ้ำตลอดทั้งงาน)

1import anthropic
2
3client = anthropic.Anthropic()
4STYLE_GUIDE = open("style_guide.md").read()   # ยาว เหมือนกันทุกการเรียกใช้
5
6msg = client.messages.create(
7    model="claude-opus-4-8",
8    max_tokens=1024,
9    system=[
10        {
11            "type": "text",
12            "text": STYLE_GUIDE,
13            "cache_control": {"type": "ephemeral"},  # แคชคำนำหน้าขนาดใหญ่นี้
14        }
15    ],
16    messages=[{"role": "user", "content": "เขียนอีเมลนี้ใหม่ให้ตรงกับคู่มือ:\n\n..."}],
17)
18print(msg.usage)  # ดู cache_read_input_tokens เพิ่มขึ้นหลังจากการเรียกครั้งแรก

ทำสิ่งนี้ตอนนี้: ค้นหาพรอมต์ที่มีคำนำหน้าซ้ำขนาดใหญ่ ห่อมันในบล็อก cache_control แล้วรันสองครั้ง พิมพ์ msg.usage และดูการอ่านแคชทำงาน

ส่วนที่ 4 · สัปดาห์ที่ 4 — เครื่องมือ ข้อมูล และการส่งมอบ (วันที่ 22–30)

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

10. ให้เครื่องมือแก่โมเดล (การเรียกใช้ฟังก์ชัน)

โมเดลเพียงอย่างเดียวสามารถสร้างได้แค่ข้อความ ให้ เครื่องมือ แก่มัน แล้วมันจะสามารถดำเนินการได้ — ดูปฏิทินของคุณ, เรียก API, คำนวณ คุณอธิบายเครื่องมือแต่ละอย่างด้วยชื่อ คำอธิบาย และ schema JSON ของอินพุต โมเดลจะตัดสินใจเมื่อจะเรียกใช้และส่งอาร์กิวเมนต์ที่มีโครงสร้างให้คุณดำเนินการ นี่คือรากฐานภายใต้ทุก "AI agent" ที่คุณเคยได้ยิน

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

1import anthropic
2
3client = anthropic.Anthropic()
4
5tools = [
6    {
7        "name": "get_calendar_events",
8        "description": "ส่งคืนกิจกรรมของผู้ใช้สำหรับวันที่กำหนด",
9        "input_schema": {
10            "type": "object",
11            "properties": {
12                "date": {"type": "string", "description": "วันที่ในรูปแบบ YYYY-MM-DD"}
13            },
14            "required": ["date"],
15        },
16    }
17]
18
19msg = client.messages.create(
20    model="claude-opus-4-8",
21    max_tokens=1024,
22    tools=tools,
23    messages=[{"role": "user", "content": "มีอะไรในปฏิทินของฉันวันจันทร์หน้า?"}],
24)
25
26for block in msg.content:
27    if block.type == "tool_use":
28        print("โมเดลต้องการเรียก:", block.name, "ด้วย", block.input)
29        # ตอนนี้ คุณรัน get_calendar_events(**block.input) และส่งผลลัพธ์กลับ

ทำสิ่งนี้ตอนนี้: กำหนดเครื่องมือหนึ่งอย่างสำหรับสิ่งที่คุณใช้จริง (ปฏิทิน, สภาพอากาศ, การค้นหา) และดูโมเดลสร้างการเรียก tool_use ที่สะอาด คุณยังไม่ต้องรันมันด้วยซ้ำ — แค่เห็นว่ามันตัดสินใจ

11. เชื่อมต่อ AI กับข้อมูลของคุณด้วย MCP

การวางบริบทด้วยมือไม่สามารถขยายขนาดได้ Model Context Protocol (MCP) ซึ่งเปิดตัวโดย Anthropic ในเดือนพฤศจิกายน 2024 คือการแก้ไขมาตรฐาน — คิดว่ามันเป็นพอร์ต USB-C สำหรับ AI: ข้อกำหนดของตัวเชื่อมต่อเดียว และแอปพลิเคชันที่เข้ากันได้ใดๆ ก็สามารถเชื่อมต่อกับไฟล์ ฐานข้อมูล และเครื่องมือของคุณได้ มันเปลี่ยนจากแนวคิดภายในไปสู่มาตรฐานอุตสาหกรรมภายในไม่กี่เดือน โดยมีเซิร์ฟเวอร์ที่พร้อมใช้งานนับพันที่คุณสามารถวางลงผ่าน config

คุณไม่ต้องเขียนโค้ดเพื่อใช้เซิร์ฟเวอร์ส่วนใหญ่ — คุณเพิ่มรายการในไฟล์ config นี่คือเซิร์ฟเวอร์ระบบไฟล์ที่ให้โมเดลสามารถอ่านโฟลเดอร์บันทึก:

ใช้เมื่อ: คุณป้อนแหล่งความจริงเดียวกันให้โมเดลด้วยมือซ้ำแล้วซ้ำเล่า — เอกสารของคุณ, repo, ฐานข้อมูล, ฐานความรู้

1{
2  "mcpServers": {
3    "filesystem": {
4      "command": "npx",
5      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/notes"]
6    }
7  }
8}

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

12. บรรจุเวิร์กโฟลว์ที่คุณจะใช้ซ้ำตลอดไป

วันที่ 30 คุณมีพรอมต์ สคริปต์ และเครื่องมือ — ตอนนี้ทำให้มันเป็น สิ่งที่คุณเรียกใช้ตามชื่อ Anthropic Agent Skills (ซึ่งกลายเป็นมาตรฐานเปิดในเดือนธันวาคม 2025) เป็นรูปแบบที่สะอาดสำหรับสิ่งนี้: โฟลเดอร์ที่มี SKILL.md ซึ่งประกอบด้วยชื่อ คำอธิบายว่าเมื่อใดควรใช้ และขั้นตอนต่างๆ โมเดลจะโหลดมันเมื่อเกี่ยวข้องเท่านั้น (หลักการออกแบบที่เรียกว่า progressive disclosure) ดังนั้นคุณสามารถซ้อนกันได้หลายสิบอันโดยไม่ทำให้บริบทบวม แม้ว่าคุณจะไม่แตะ API อีกเลย การเขียนงานที่ทำซ้ำได้ของคุณเป็นสกิลคือนิสัยที่ทำให้คุณเร็ว

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

1---
2name: weekly-report
3description: เปลี่ยนบันทึกดิบของฉันเป็นรายงานประจำสัปดาห์มาตรฐาน ใช้เมื่อฉันวางบันทึกและขอ "รายงานประจำสัปดาห์"
4---
5
6# รายงานประจำสัปดาห์
7
8## ขั้นตอน
91. จัดกลุ่มบันทึกเป็น: ส่งมอบแล้ว, กำลังดำเนินการ, ถูกขัดขวาง
102. เขียน 2–3 หัวข้อย่อยต่อกลุ่ม อดีตกาล ไม่มีน้ำท่วมทุ่ง
113. จบด้วย "สัปดาห์หน้า" — 3 ลำดับความสำคัญพอดี
12
13## รูปแบบ
14- ชื่อเรื่อง: "รายงานประจำสัปดาห์ — <วันที่>"
15- ไม่เกิน 200 คำ ไม่โอ้อวด

ทำสิ่งนี้ตอนนี้: เลือกงานที่คุณทำซ้ำบ่อยที่สุด เขียนเป็น SKILL.md พร้อมคำอธิบายที่คมชัด คำอธิบายนั้นคือสิ่งที่ทำให้มันทำงานในเวลาที่เหมาะสม — ใช้ความพยายามจริงๆ กับมัน

ข้อผิดพลาดทั่วไป (และวิธีแก้ไข)

1. พรอมต์คลุมเครือ "เขียนเกี่ยวกับ X" ทำให้โมเดลเดาเจตนาของคุณ — และมันเดาแบบกลางๆ วิธีแก้ไข: ให้บทบาท + บริบท + รูปแบบเสมอ คุณคือ <บทบาท> งาน: <หนึ่งประโยค> ผลลัพธ์: <รูปแบบที่แน่นอน>

2. การใช้พรอมต์มากเกินไปด้วยความเร่งด่วนแบบตัวพิมพ์ใหญ่ทั้งหมด โมเดลรุ่นใหม่ปฏิบัติตามคำแนะนำอย่างแม่นยำและ ตอบสนองมากเกินไป ต่อ "สำคัญมาก!!! คุณต้อง" คำแนะนำของ Anthropic เอง: ลดระดับลงมาเป็นวลีปกติ เช่น "ใช้เครื่องมือนี้เมื่อ…" วิธีแก้ไข: เขียนคำแนะนำเหมือนคุณกำลังบอกผู้ใหญ่ที่มีความสามารถ ไม่ใช่ตะคอกใส่หมา

3. การบรรยายแทนการแสดง คำคุณศัพท์ ("ทำให้ดูเป็นมืออาชีพ") อ่อนแอ ตัวอย่างแข็งแกร่ง วิธีแก้ไข: เพิ่มตัวอย่างที่หลากหลาย 3–5 ตัวอย่างในแท็ก <example> และปล่อยให้รูปแบบทำงาน

4. การวางกรอบเป็น "อย่า" "อย่าพูดมาก" ทำให้โมเดลคิดเกี่ยวกับการพูดมาก วิธีแก้ไข: บอกว่าต้อง ทำ อะไร — "ตอบเป็น 2 ประโยคสั้นๆ" คำแนะนำเชิงบวกมีผลมากกว่าข้อห้าม

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

6. การทำด้วยมือในสิ่งที่ลูปทำได้ การรันพรอมต์เดียวกัน 50 ครั้งในแชทคือสิ่งที่แพงที่สุดที่คุณสามารถทำได้ในช่วงบ่ายของคุณ วิธีแก้ไข: ทันทีที่คุณพบการทำซ้ำ ให้เขียนลูปของบล็อก 08 เวลาของคุณคือทรัพยากรที่หายาก ไม่ใช่โทเค็น

บทสรุป: ระบบคือทักษะ

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

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

รายการตรวจสอบ 30 วันของคุณ — เริ่มวันนี้:

1. ส่งมอบงานจริงหนึ่งอย่าง ด้วยพรอมต์บทบาท + บริบท + รูปแบบ (บล็อก 01)
2. เริ่ม prompt_library.py และย้ายพรอมต์ที่ดีที่สุด 3 อันของคุณลงไปเป็นเทมเพลต (บล็อก 06)
3. เรียก API ครั้งแรกของคุณ ด้วยฟังก์ชัน ask() 10 บรรทัด (บล็อก 07)
4. ทำงานประจำที่เป็นชุดหนึ่งงานให้เป็นอัตโนมัติ ด้วยลูปโฟลเดอร์ (บล็อก 08)
5. เขียน SKILL.md หนึ่งอัน สำหรับเวิร์กโฟลว์ที่คุณทำซ้ำบ่อยที่สุด (บล็อก 12)

ทำห้าสิ่งนี้ แล้วคุณจะก้าวนำหน้า 90% ของคนที่ "ตั้งใจจะเริ่มใช้ AI" แล้วก็แค่รันลูปต่อไป