กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว
เชื่อมพรอมต์สำหรับขั้นตอนที่ทราบแน่ชัด และใช้แบบปรับตัวสำหรับงานปลายเปิด
กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว เป็นบทเรียน Claude Architect ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Claude Architect และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน
สองวิธีในการแยกงาน
เมื่อคำสั่งมีขนาดใหญ่เกินกว่าจะใช้พรอมต์เดียว คุณต้องแยกงานออกเป็นส่วน ๆ มีกลยุทธ์พื้นฐานอยู่สองแบบ และการเลือกแบบที่เหมาะสมเป็นทักษะสำคัญด้านสถาปัตยกรรม
- กระบวนการแบบคงที่ (การต่อพรอมต์): คุณกำหนดลำดับขั้นที่รู้แน่นอนไว้ในโค้ด ขั้นที่ 1 ส่งต่อให้ขั้นที่ 2 และขั้นที่ 2 ส่งต่อให้ขั้นที่ 3
- การแยกงานแบบปรับตามสถานการณ์: โมเดลตัดสินใจว่าจะทำอะไรต่อโดยอิงจากสิ่งที่ค้นพบ และทำซ้ำจนกว่าจะบรรลุเป้าหมาย
หลักทั่วไปคือ ใช้กระบวนการแบบคงที่สำหรับขั้นตอนต่อเนื่องที่รู้แน่นอน และใช้การปรับตามสถานการณ์สำหรับการสืบค้นที่ไม่มีขอบเขตตายตัว บทเรียนนี้จะอธิบายการตัดสินใจดังกล่าวให้ชัดเจน
กระบวนการแบบคงที่ = การต่อพรอมต์
กระบวนการแบบคงที่ก็คือการต่อพรอมต์ คุณควบคุมลำดับที่กำหนดแน่นอนด้วยโค้ดของตนเอง คุณรู้ขั้นตอนล่วงหน้า จึงเชื่อมโยงขั้นตอนเหล่านั้นไว้อย่างชัดเจน การเรียกใช้แต่ละครั้งทำงานเฉพาะด้านหนึ่งอย่างมีสมาธิ และผลลัพธ์ของการเรียกใช้ครั้งนั้นจะกลายเป็นข้อมูลนำเข้าของครั้งถัดไป
เนื่องจากคุณควบคุมลำดับได้ กระบวนการจึงคาดการณ์ได้ แก้ไขข้อผิดพลาดได้ง่าย และทำความเข้าใจต้นทุนได้ง่าย ไม่มีการแตกแขนงที่โมเดลเป็นผู้ตัดสินใจว่าจะทำ อะไร ต่อไป — มีเพียงงานภายในแต่ละขั้น
# Fixed pipeline: extract -> classify -> summarize
from anthropic import Anthropic
client = Anthropic()
def step(system, user):
r = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
system=system,
messages=[{"role": "user", "content": user}],
)
return r.content[0].text
entities = step("Extract entities as JSON.", document)
category = step("Classify this record.", entities)
summary = step("Write a one-line summary.", category)เมื่อกระบวนการแบบคงที่เหมาะสมกว่า
เลือกใช้กระบวนการแบบคงที่เมื่องานมี รูปแบบที่คงที่และรู้แน่นอน:
- ขั้นตอนเหมือนเดิมทุกครั้งที่ทำงาน (ดึงข้อมูล จากนั้นตรวจสอบ แล้วจัดรูปแบบ)
- ลำดับมีความสำคัญและแทบไม่เปลี่ยนแปลง
- คุณต้องการต้นทุน เวลาแฝง และการแก้ไขข้อผิดพลาดที่คาดการณ์ได้ง่าย
- แต่ละช่วงมีหน้าที่ชัดเจนและจำกัดขอบเขต
ตัวอย่างคลาสสิกคือการดึงข้อมูลที่มีโครงสร้าง ดึงช่องข้อมูล จากนั้นตรวจสอบหรือทดลองใหม่ แล้วจึงแนบแหล่งที่มา คุณทำสามสิ่งนี้ตามลำดับเดิมเสมอ — จึงควรเชื่อมโยงเป็นกระบวนการเดียวกัน
การแยกงานแบบปรับตามสถานการณ์ = ขับเคลื่อนด้วยโมเดล
การแยกงานแบบปรับตามสถานการณ์มอบหมาย การวางแผน ให้โมเดล คุณมอบเครื่องมือและเป้าหมายให้โมเดล จากนั้นโมเดลจะตรวจสอบผลลัพธ์และเลือกการดำเนินการถัดไป นี่คือลูปแบบตัวแทน: ส่งคำขอ ตรวจสอบ stop_reason และหากเป็น tool_use ให้เรียกใช้เครื่องมือ เติมผลลัพธ์ต่อท้ายประวัติ แล้วทำซ้ำจนกว่าจะถึง end_turn
คุณไม่สามารถกำหนดเส้นทางไว้ล่วงหน้าได้ เพราะยังไม่รู้เส้นทางนั้น — เส้นทางจะขึ้นอยู่กับสิ่งที่แต่ละขั้นค้นพบ
# Adaptive: the model decides which tool to call next
while True:
resp = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
tools=tools,
messages=messages,
)
if resp.stop_reason == "tool_use":
results = run_tools(resp) # execute requested tools
messages.append({"role": "assistant", "content": resp.content})
messages.append({"role": "user", "content": results})
continue
break # terminate on stop_reason, never by parsing textเมื่อการแยกงานแบบปรับตามสถานการณ์เหมาะสมกว่า
เลือกการแยกงานแบบปรับตามสถานการณ์สำหรับ การสืบค้นที่ไม่มีขอบเขตตายตัว ซึ่งไม่สามารถรู้เส้นทางล่วงหน้าได้:
- การแก้ไขข้อผิดพลาดจากอาการที่คลุมเครือ — คุณค้นหาด้วย grep อ่านข้อมูล แล้วค้นหาการใช้งานด้วย grep อีกครั้งตามสิ่งที่พบ
- การค้นคว้าจากหลายแหล่ง ซึ่งคำค้นหาติดตามผลขึ้นอยู่กับคำตอบก่อนหน้า
- การสนับสนุนลูกค้า ซึ่งการดำเนินการถัดไปขึ้นอยู่กับผลลัพธ์จากการค้นข้อมูล
ในกรณีนี้ การแตกแขนงก็คืองาน กระบวนการที่ตายตัวจะพลาดบางเส้นทาง หรือไม่ก็ขยายเป็นเงื่อนไขจำนวนมากจนดูแลรักษาไม่ได้
ยุติเมื่อถึง stop_reason ไม่ใช่จากข้อความ
ข้อผิดพลาดที่พบบ่อยที่สุดในการทำลูปแบบปรับตามสถานการณ์ในข้อสอบคือการจบลูปด้วยการค้นหาคำในข้อความของโมเดล เช่น "เสร็จแล้ว" หรือ "เรียบร้อยแล้ว" อย่าทำเช่นนั้น การตัดสินใจขับเคลื่อนด้วยโมเดล ดังนั้นให้ยุติการทำงานเมื่อถึง stop_reason ของ API
ลูปจะจบเมื่อ stop_reason เป็น end_turn หากเป็น tool_use ให้ทำงานต่อ ขีดจำกัดรอบการทำงานเป็นเพียง กลไกความปลอดภัยสำรอง เท่านั้น — ห้ามใช้เป็นกลไกหลักในการหยุดการทำงาน ให้สงวนการควบคุมแบบกำหนดตายตัวไว้สำหรับการรับประกัน ไม่ใช่การตัดสินใจว่างานเสร็จสมบูรณ์ในเชิงแนวคิดเมื่อใด
# WRONG: parsing text for completion
if "done" in resp.content[0].text.lower():
break
# RIGHT: drive on stop_reason; cap is only a safety net
MAX_STEPS = 25
for _ in range(MAX_STEPS):
resp = client.messages.create(...)
if resp.stop_reason != "tool_use":
break # end_turn / max_tokens / stop_sequenceแบบผสม: กระบวนการที่มีช่วงปรับตามสถานการณ์
ระบบจริงมักผสมผสานทั้งสองรูปแบบ โฟลว์ภายนอกมักเป็นไปป์ไลน์แบบตายตัว แต่บางขั้นตอนอาจเป็นลูปเอเจนต์แบบปรับตัวได้ คุณจึงได้ความคาดเดาได้จากการเชื่อมขั้นตอนในระดับภาพรวม และได้ความยืดหยุ่นในจุดที่จำเป็นจริง ๆ
ตัวอย่างเช่น ไปป์ไลน์การสกัดข้อมูลที่มีขั้นตอนตรงกลางเป็นเอเจนต์แบบปรับตัวได้สำหรับ "แก้ความกำกวม" ซึ่งอาจเรียกใช้เครื่องมือค้นหาจำนวนครั้งที่ไม่แน่นอน โดยมีขั้นตอนตรวจสอบและจัดรูปแบบแบบกำหนดแน่นอนครอบอยู่ทั้งก่อนและหลัง
# Outer = fixed chain; one stage = adaptive loop
raw = extract_stage(document) # fixed
resolved = adaptive_resolver(raw) # agentic loop inside
final = validate_and_format(resolved) # fixedการตรวจสอบโค้ดหลายรอบ: ทางเลือกในการแยกงาน
การแยกงานไม่ได้มีแค่การเลือกระหว่างไปป์ไลน์กับลูปเท่านั้น แต่ยังเกี่ยวกับวิธีแบ่งงานเพื่อรักษาสมาธิของโมเดลด้วย การตรวจสอบโค้ดหลายไฟล์เป็นกรณีตัวอย่างที่ชัดเจนที่สุด
การตรวจสอบหลายไฟล์ในรอบเดียว ทำให้สมาธิกระจาย และพลาดทั้งข้อบกพร่องเฉพาะไฟล์กับปัญหาการทำงานร่วมกัน วิธีแก้คือการแยกงานอย่างตั้งใจ โดยเริ่มจาก การตรวจสอบเฉพาะไฟล์ แล้วจึงทำ การตรวจสอบการทำงานข้ามไฟล์แยกต่างหาก การตรวจสอบสองรอบที่มีจุดเน้นชัดเจนย่อมดีกว่ารอบเดียวที่ไร้จุดเน้น
# Decompose review into focused passes
for f in changed_files:
review_local(f) # pass 1: per-file, focused
review_cross_file(changed_files) # pass 2: integration concernsตัวประสานงานแยกงานแบบปรับตัวได้
ในระบบหลายเอเจนต์แบบศูนย์กลางและกิ่งก้าน ตัวประสานงานจะ แยกย่อย เป้าหมาย มอบหมายงานให้เอเจนต์ย่อย แล้วรวบรวมผลลัพธ์ นี่คือการแยกงานแบบปรับตัวได้ในชั้นการประสานงาน โดยตัวประสานงานจะตัดสินใจว่าจะแบ่งงานอย่างไรตามคำขอ
สิ่งสำคัญคือ เอเจนต์ย่อยจะ ไม่ สืบทอดประวัติการสนทนาของตัวประสานงาน พรอมต์ของเอเจนต์ย่อยแต่ละตัวต้องมีบริบททั้งหมดอย่างชัดเจน การเรียก Task หลายครั้งในคำตอบเดียวจะทำงานแบบขนาน ซึ่งมีประโยชน์เมื่อปัญหาย่อยเป็นอิสระต่อกัน
# Coordinator delegates with explicit, self-contained context
subagent_prompt = f"""You are researching ONE sub-topic.
Context (do not assume shared history):
Goal: {goal}
Sub-topic: {subtopic}
Constraints: {constraints}
Return findings with source citations."""เซสชัน: ดำเนินการต่อ แยกแขนง หรือเริ่มใหม่
งานแบบปรับตัวได้มักครอบคลุมหลายเซสชัน Claude Code มี --resume <name> สำหรับดำเนินเซสชันที่ตั้งชื่อไว้ต่อ และมี fork_session สำหรับแยกแขนงจากจุดร่วมเพื่อสำรวจทางเลือกต่าง ๆ แบบขนาน
แต่โปรดระวัง: ผลลัพธ์จากเครื่องมือที่นำกลับมาใช้ต่ออาจล้าสมัย หากฐานโค้ดมีการเปลี่ยนแปลงนับจากนั้น บางครั้ง เซสชันใหม่ที่เริ่มต้นด้วยสรุปแบบมีโครงสร้าง ก็ให้ผลดีกว่าการดำเนินเซสชันเดิมต่อ เพราะคุณจะได้ทั้งสถานะปัจจุบันและบริบทที่สรุปสาระสำคัญไว้ โดยไม่ต้องลากผลลัพธ์จากเครื่องมือที่ล้าสมัยติดมาด้วย
# Continue a named session
claude --resume refactor-auth
# Branch to explore an alternative path
# fork_session creates a sibling from the shared point
# When code moved on, prefer a fresh session + summary
claude -p "Here is a structured summary of prior work: ..."รายการตรวจสอบการตัดสินใจ
ก่อนสร้าง ให้ถามตัวเองว่า:
- ฉันรู้ขั้นตอนล่วงหน้าและรู้ลำดับที่ตายตัวหรือไม่? -> ไปป์ไลน์แบบตายตัว / การเชื่อมพรอมต์
- ขั้นตอนถัดไปขึ้นอยู่กับสิ่งที่ขั้นตอนก่อนหน้าค้นพบหรือไม่? -> ลูปเอเจนต์แบบปรับตัวได้
- ส่วนใหญ่ตายตัว แต่มีหนึ่งขั้นตอนที่ไม่แน่นอนหรือไม่? -> แบบผสม: เชื่อมโฟลว์ภายนอก แล้วฝังลูปแบบปรับตัวได้ไว้ภายใน
- กำลังตรวจสอบหลายไฟล์หรือไม่? -> แยกเป็นการตรวจสอบเฉพาะไฟล์ แล้วตามด้วยการตรวจสอบข้ามไฟล์
และต้องทำเสมอ: ยุติลูปแบบปรับตัวได้เมื่อถึง stop_reason โดยจำกัดจำนวนรอบไว้เป็นเพียงกลไกความปลอดภัย
ตรวจสอบความเข้าใจอย่างรวดเร็ว
การตัดสินใจเลือกกลยุทธ์การแยกงานจากสถานการณ์ตัวอย่าง
สรุปทบทวน
ประเด็นสำคัญ:
- ไปป์ไลน์แบบตายตัว (การเชื่อมพรอมต์) เหมาะกับขั้นตอนที่ทราบและมีลำดับแน่นอน — คาดเดาได้ แก้ไขข้อบกพร่องได้ง่าย และมีค่าใช้จ่ายต่ำ
- การแยกงานแบบปรับตัวได้ เหมาะกับการสืบค้นแบบปลายเปิด ซึ่งขั้นตอนถัดไปขึ้นอยู่กับสิ่งที่ค้นพบ
- แบบผสม พบได้บ่อย: โฟลว์ภายนอกแบบตายตัวที่ฝังขั้นตอนแบบปรับตัวได้ไว้ภายใน
- ต้อง ยุติลูปแบบปรับตัวได้เมื่อถึง
stop_reason(end_turn) เสมอ การจำกัดจำนวนรอบเป็นเพียงกลไกความปลอดภัย ไม่ใช่เงื่อนไขหยุดหลัก ห้ามแยกวิเคราะห์ข้อความเพื่อหา "เสร็จแล้ว" - สำหรับการตรวจสอบหลายไฟล์ ให้แยกเป็น การตรวจสอบเฉพาะไฟล์ แล้วตามด้วยการตรวจสอบข้ามไฟล์แยกต่างหาก
- เอเจนต์ย่อยไม่สืบทอดประวัติ ต้องส่งบริบทอย่างชัดเจน ดำเนินเซสชันเดิมต่ออย่างระมัดระวัง เพราะเซสชันใหม่ที่มีสรุปแบบมีโครงสร้างอาจดีกว่าผลลัพธ์จากเครื่องมือของเซสชันเดิมที่ล้าสมัย
เรียนรู้ Python ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 26
- บทเรียน
- 104
คำถามที่พบบ่อย
บทเรียน “กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Claude Architect ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว”
เชื่อมพรอมต์สำหรับขั้นตอนที่ทราบแน่ชัด และใช้แบบปรับตัวสำหรับงานปลายเปิด คุณปฏิบัติ Claude Architect ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Claude Architect หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Claude Architect บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Claude Architect นี้ได้ไหม
ได้ บทเรียน Claude Architect ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- กระบวนการทำงานแบบตายตัวเทียบกับการแยกย่อยแบบปรับตัว
- การแยกย่อยหลายรอบ
- การจัดการเซสชัน
- บริบทเก่าและการเริ่มต้นใหม่