วิธีสร้าง AI agent ตัวแรกด้วย Claude: ตั้งแต่การเรียก API ครั้งแรกไปจนถึงระบบอัตโนมัติ

90% ของโค้ดที่ Anthropic ถูกเขียนโดย Claude agents ไม่ใช่โดยวิศวกรที่พิมพ์ในหน้าต่างแชท แต่โดย agents อัตโนมัติที่ทำงานเป็นลูป เรียกใช้เครื่องมือ และส่งโค้ดในขณะที่ทีมงานหลับ

ติดตาม Substack ของฉันเพื่อรับ AI alpha ใหม่ๆ:

movez.substack.com

นี่คือการตั้งค่าที่แน่นอน ทีละขั้นตอน ตั้งแต่การเรียก API ครั้งแรกจนถึง agent ที่ทำงานได้จริง ซึ่งคุณสามารถชี้ไปที่งานใดก็ได้

บทความนี้จะครอบคลุม:

1 - เหตุที่ "agents" ส่วนใหญ่ที่คนสร้างขึ้นไม่ใช่ agents จริง

2 - 5 ส่วนประกอบที่ agent ทุกตัวต้องมี

3 - วิธีสร้างแต่ละส่วนด้วย Claude พร้อมโค้ด

4 - ข้อผิดพลาดที่ทำให้ agents ตายก่อนที่จะถูกใช้งานจริง

บุ๊กมาร์กไว้เลย โค้ดบล็อกทุกอันด้านล่างใช้งานได้

01. "AI agents" ส่วนใหญ่ไม่ใช่ agents

ฉันสร้างและพัง agents มาหมดแล้วนับไม่ถ้วน เคยเห็นพวกมันเผาโทเคนทั้งคืนและไม่产出อะไรเลย เคยเห็นพวกมันเขียนไฟล์เดิมซ้ำ 30 ครั้ง เคยเห็นพวกมันผ่านการทดสอบของตัวเองด้วยการลบการทดสอบทิ้ง

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

นี่คือสิ่งที่คนส่วนใหญ่สร้างเมื่อพวกเขาพูดว่า "AI agent":

1while True:
2    user_input = input("> ")
3    response = call_claude(user_input)
4    print(response)

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

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

"Claude Code ไปจากศูนย์ถึงรายได้ 400 ล้านดอลลาร์ในเวลาไม่กี่เดือน มันเริ่มต้นจากโปรเจกต์แฮกกาธอน และยังคงใช้แค่ API สาธารณะเท่านั้น" -

Boris Cherny, หัวหน้า Claude Code

API เดียวกันกับที่คุณมีอยู่ในตอนนี้ โมเดลเดียวกัน ความแตกต่างอยู่ที่สถาปัตยกรรมรอบๆ โมเดล

02. 5 ส่วนประกอบของ agent ที่แท้จริง

ทุก agent ที่ทำงานได้จริง - Claude Code, Devin, Codex, หรืออะไรก็ตามที่คุณสร้างเอง - ประกอบขึ้นจากห้าส่วน ขาดหนึ่งส่วนก็พัง

03. ชั้น API

ทุกอย่างเริ่มต้นที่นี่ คุณเรียก Claude, Claude ตอบกลับ แต่วิธีที่คุณเรียกจะเป็นตัวกำหนดว่าคุณจะได้แชทบอทหรือ agent

สามสิ่งที่สำคัญ: system prompt, structured output, และ temperature

System prompt ไม่ใช่การทักทาย มันคือคู่มือการทำงานของ agent ของคุณ กฎ ข้อจำกัด และพฤติกรรมทุกอย่างต้องอยู่ที่นี่ หากไม่มีมัน Claude จะเดาว่าคุณต้องการอะไร หากมีมัน Claude จะทำตามข้อกำหนดของคุณ

1import anthropic
2
3client = anthropic.Anthropic()
4
5response = client.messages.create(
6    model="claude-sonnet-4-6",
7    max_tokens=4096,
8    system="""คุณคือ agent ที่ตรวจสอบโค้ด
9
10กฎ:
11- อ่าน diff ทั้งหมดก่อนแสดงความคิดเห็น
12- แจ้งเฉพาะบั๊กจริง ไม่ใช่ความชอบด้านสไตล์
13- หากไม่มีอะไรผิด ให้พูดว่า "LGTM" แล้วหยุด
14- อย่าเสนอการเปลี่ยนแปลงที่คุณยังไม่ได้ทดสอบในใจ
15- รูปแบบผลลัพธ์: JSON array ของ {file, line, issue, fix}""",
16    messages=[{"role": "user", "content": diff_content}]
17)

Structured output ทำให้การตอบกลับของ agent อ่านได้ด้วยเครื่อง ถ้า Claude ส่งข้อความอิสระ โค้ดของคุณต้องแยกวิเคราะห์มัน ถ้า Claude ส่ง JSON โค้ดของคุณสามารถใช้ได้โดยตรง

1# บังคับให้ส่ง JSON โดยบอก Claude ถึงรูปร่างที่แน่นอน
2system = """คืนค่าเฉพาะ JSON ที่ถูกต้องเท่านั้น ไม่มี markdown ไม่มีคำอธิบาย
3Schema:
4{
5  "status": "pass" | "fail",
6  "issues": [{"file": str, "line": int, "issue": str}],
7  "summary": str
8}"""

Temperature. ตั้งเป็น 0 สำหรับ agents ที่ต้องทำงานแน่นอน ตั้งเป็น 0.3-0.5 สำหรับงานสร้างสรรค์ ค่าเริ่มต้น (1.0) จะเพิ่มความสุ่มที่คุณแทบไม่ต้องการใน agent

04. เครื่องมือ

โมเดลที่ไม่มีเครื่องมือสามารถคิดได้แต่ไม่สามารถลงมือทำได้ มันสามารถบอกคุณได้ว่าควรแก้ไขไฟล์ไหน แต่ไม่สามารถแก้ไขได้ มันสามารถอธิบาย query ได้แต่ไม่สามารถรันได้

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

1tools = [{
2    "name": "run_sql",
3    "description": "รัน SQL query แบบอ่านอย่างเดียวกับฐานข้อมูล",
4    "input_schema": {
5        "type": "object",
6        "properties": {
7            "query": {
8                "type": "string",
9                "description": "SQL SELECT query ที่จะรัน"
10            }
11        },
12        "required": ["query"]
13    }
14},
15{
16    "name": "write_file",
17    "description": "เขียนเนื้อหาลงในไฟล์บนดิสก์",
18    "input_schema": {
19        "type": "object",
20        "properties": {
21            "path": {"type": "string"},
22            "content": {"type": "string"}
23        },
24        "required": ["path", "content"]
25    }
26}]

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

เริ่มต้นด้วยเครื่องมือ 3-5 อย่าง อ่านไฟล์ เขียนไฟล์ รันคำสั่ง ค้นหา และเครื่องมือเฉพาะโดเมนอีกหนึ่งอย่างสำหรับกรณีการใช้งานของคุณ นั่นครอบคลุม 90% ของงาน agent

05. ลูป

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

สามองค์ประกอบ:

• ตัวตรวจสอบ (Verifier) สิ่งที่ตรวจสอบว่าผลลัพธ์ดีหรือไม่ ชุดทดสอบ, ตัวตรวจสอบชนิด, linter, การเรียก Claude ครั้งที่สองพร้อมเกณฑ์ที่เข้มงวด หากไม่มีสิ่งนี้ agent จะเห็นด้วยกับตัวเองซ้ำไปซ้ำมา
• สถานะ (State) บันทึกสิ่งที่เกิดขึ้น อะไรใช้ได้ อะไรล้มเหลว อะไรควรลองต่อไป หากไม่มีสถานะ agent จะทำผิดพลาดซ้ำเดิมในทุกการวนซ้ำ
• เงื่อนไขหยุด (Stop condition) บรรลุเป้าหมาย หรือถึงขีดจำกัดที่กำหนดไว้ "หลังจาก N ครั้ง ให้หยุดและรายงาน" หากไม่มีเงื่อนไขนี้ ลูปจะทำงานตลอดไปและทำให้บัญชีของคุณหมด

1import json
2from pathlib import Path
3
4def run_agent(task: str, max_attempts: int = 5):
5    state = {"task": task, "attempts": [], "done": False}
6
7    for i in range(max_attempts):
8        # Build context from state
9        context = build_prompt(state)
10
11        # Call Claude with tools
12        result = call_claude(context, tools)
13
14        # Execute any tool calls
15        output = execute_tools(result)
16
17        # Verify the result
18        check = verify(output)
19
20        # Update state
21        state["attempts"].append({
22            "attempt": i + 1,
23            "action": result.summary,
24            "passed": check.passed,
25            "reason": check.reason
26        })
27
28        if check.passed:
29            state["done"] = True
30            break
31
32    # Save state for next run
33    Path("state.json").write_text(json.dumps(state, indent=2))
34    return state

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

06. หน่วยความจำ

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

Claude agents ใช้หน่วยความจำสามชั้น:

CLAUDE.md คือไฟล์ markdown ที่รากของโปรเจกต์ของคุณ Claude Code จะอ่านมันโดยอัตโนมัติเมื่อเริ่มต้นทุกเซสชัน กฎของคุณ สแต็คของคุณ ข้อตกลงของคุณ เขียนครั้งเดียว อ่านตลอดไป

1# CLAUDE.md
2
3## โปรเจกต์
4Task management API. Python 3.12, FastAPI, PostgreSQL.
5
6## กฎ
7- การตอบกลับทั้งหมด: รูปแบบ {data, error, meta}
8- ต้องมีการทดสอบสำหรับทุก endpoint ใหม่
9- ข้อความ commit: type(scope): description
10- ห้ามใช้ print() สำหรับการบันทึก ใช้ structlog
11
12## ปัญหาที่ทราบ
13- Auth middleware คาดหวัง x-auth-token, ไม่ใช่ Authorization
14- ชุดทดสอบใช้เวลา 45 วินาทีเต็ม ใช้ --filter สำหรับการวนซ้ำ

ทักษะ (Skills) จับภาพเวิร์กโฟลว์ทั้งหมด ไม่ใช่แค่ prompts - รูปร่างที่สมบูรณ์: รูปแบบอินพุต, ขั้นตอน, รูปแบบเอาต์พุต, กฎการตรวจสอบ ครั้งแรกใช้เวลา 20 นาที การเล่นซ้ำใช้เวลา 30 วินาที

ไฟล์เรียนรู้ (Learnings file) คือบันทึกข้อผิดพลาดที่เกิดขึ้นต่อเนื่อง agent เขียนลงไปหลังทุกเซสชัน เซสชันถัดไปอ่านมัน ข้อผิดพลาดจะเกิดขึ้นซ้ำจนกว่าจะถูกเขียนลงไป จากนั้นมันก็หยุด

1# learnings.md
2
3- Payment API คาดหวัง idempotency key ใน header, ไม่ใช่ body
4- PostgreSQL NOTIFY ต้องการ LISTEN ที่ชัดเจนใน connection pool
5- Rate limiter นับต่อ key, ไม่ใช่ต่อ IP การทดสอบต้องใช้ keys ที่ไม่ซ้ำ

07. ประตูตรวจสอบ (Verification gate)

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

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

สามรูปแบบที่ใช้ได้:

1. การทดสอบอัตโนมัติ agent เขียนโค้ด ชุดทดสอบรัน ถ้าการทดสอบล้มเหลว agent จะได้รับผลลัพธ์ข้อผิดพลาดและลองอีกครั้ง นี่คือวิธีการทำงานภายในของ Claude Code

1def verify(output):
2    # Run the test suite
3    result = subprocess.run(
4        ["pytest", "tests/", "-x", "--tb=short"],
5        capture_output=True, text=True
6    )
7    return {
8        "passed": result.returncode == 0,
9        "reason": result.stdout if result.returncode != 0 else "all tests pass"
10    }

2. ตัวตรวจสอบชนิด / linter รัน mypy, ruff, หรือ tsc --noEmit หลังทุกการเปลี่ยนแปลง จับบั๊กทั้งหมวดหมู่โดยไม่ต้องเขียนการทดสอบแม้แต่ตัวเดียว

3. โมเดลที่สองเป็นผู้ตรวจสอบ ใช้การเรียก Claude แยกต่างหากพร้อม system prompt ที่เข้มงวดซึ่งมองหาแต่ปัญหาเท่านั้น ผู้เขียนเร็วและถูก ผู้ตรวจสอบช้าและเข้มงวด การแยกนี้คือคุณภาพส่วนใหญ่

1# Reviewer prompt - separate from the builder
2reviewer_system = """คุณคือผู้ตรวจสอบโค้ดที่เข้มงวด
3งานเดียวของคุณคือค้นหาปัญหา
4
5ตรวจสอบ:
6- โค้ดตรงกับ spec หรือไม่?
7- มี edge cases ที่ไม่ถูกจับหรือไม่?
8- การทดสอบทั้งหมดทดสอบสิ่งที่ถูกต้องหรือไม่?
9
10หากทุกอย่างถูกต้อง ให้ตอบ: {"passed": true}
11หากมีอะไรผิด ให้ตอบ: {"passed": false, "issues": [...]}
12
13อย่าเสนอการปรับปรุง แค่แจ้งบั๊กจริงๆ"""

ผู้เขียนเร็วและถูก ผู้ตรวจสอบช้าและเข้มงวด การแยกนี้คือคุณภาพส่วนใหญ่

08. รวมทุกอย่างเข้าด้วยกัน

นี่คือ agent ที่สมบูรณ์ที่รับ URL issue ของ GitHub, อ่าน issue, เขียนโค้ด, รันการทดสอบ, และเปิด PR ห้าส่วนทำงานร่วมกัน

1import anthropic, subprocess, json
2from pathlib import Path
3
4client = anthropic.Anthropic()
5CLAUDE_MD = Path("CLAUDE.md").read_text()
6LEARNINGS = Path("learnings.md").read_text()
7
8SYSTEM = f"""คุณคือ agent ที่เขียนโค้ด
9อ่าน issue เขียนการแก้ไข รันการทดสอบ
10
11บริบทโปรเจกต์:
12{CLAUDE_MD}
13
14ปัญหาที่ทราบ:
15{LEARNINGS}
16
17กฎ:
18- อ่าน codebase ทั้งหมดก่อนเปลี่ยนแปลงอะไร
19- เขียนการทดสอบสำหรับทุกการเปลี่ยนแปลง
20- ถ้าการทดสอบล้มเหลว ให้แก้ไขโค้ด ไม่ใช่การทดสอบ
21- หยุดเมื่อการทดสอบทั้งหมดผ่าน"""
22
23TOOLS = [
24    read_file_tool,
25    write_file_tool,
26    run_command_tool,
27    search_codebase_tool,
28]
29
30def run(issue_text, max_attempts=5):
31    messages = [{"role": "user", "content": issue_text}]
32
33    for attempt in range(max_attempts):
34        # Call Claude
35        response = client.messages.create(
36            model="claude-sonnet-4-6",
37            max_tokens=8192,
38            system=SYSTEM,
39            tools=TOOLS,
40            messages=messages
41        )
42
43        # Execute tool calls
44        messages = handle_tool_use(response, messages)
45
46        # Verify: run tests
47        test_result = subprocess.run(
48            ["pytest", "-x", "--tb=short"],
49            capture_output=True, text=True
50        )
51
52        if test_result.returncode == 0:
53            print(f"เสร็จใน {attempt + 1} ครั้ง")
54            return True
55
56        # Feed failure back into the loop
57        messages.append({
58            "role": "user",
59            "content": f"การทดสอบล้มเหลว:\n{test_result.stdout}\nแก้ไขและลองใหม่"
60        })
61
62    return False

นั่นคือ agent ที่ทำงานได้จริง ชั้น API พร้อม system prompt และ CLAUDE.md เครื่องมือสำหรับดำเนินการกับไฟล์ ลูปพร้อมลองใหม่ หน่วยความจำจาก learnings.md ประตูตรวจสอบผ่าน pytest

ไม่ถึง 50 บรรทัด สถาปัตยกรรมเดียวกับที่ Claude Code ใช้ภายใน

**

09. 5 ข้อผิดพลาดที่ทำลาย agent ทุกตัว

1. ไม่มีประตูตรวจสอบ agent ให้คะแนนการบ้านตัวเอง มันเขียนโค้ด พูดว่า "ดูดี" แล้วเดินต่อไป ผลลัพธ์ดูถูกต้องแต่พังใน production
2. ไม่มีเงื่อนไขหยุด ลูปทำงานจนกว่าบิล API ของคุณจะเป็น $200 หากไม่มีขีดจำกัดตายตัว agent จะลองซ้ำไม่รู้จบ เขียนไฟล์เดิมซ้ำ 40 ครั้ง ตั้งค่า max_attempts เสมอ
3. ไม่มีไฟล์สถานะ ข้อผิดพลาดเดียวกันในครั้งที่ 1 และครั้งที่ 50 agent ไม่รู้ว่ามันลองอะไรไปแล้ว มันเสนอการแก้ไขที่พังเหมือนเดิมสามครั้งติดต่อกันเพราะไม่มีอะไรบันทึกความล้มเหลว
4. เครื่องมือมากเกินไป คุณให้ Claude 20 เครื่องมือและมันเลือกผิด โมเดลที่มีเครื่องมือชัดเจน 5 อย่างเลือกได้ดีกว่าโมเดลที่มี 20 อย่างที่ทับซ้อนกัน เริ่มเล็กๆ เพิ่มเครื่องมือเมื่อ agent ชนกำแพงเท่านั้น
5. System prompt คลุมเครือ "เป็นผู้ช่วยเขียนโค้ดที่ดี" ให้ผลลัพธ์ทั่วๆ ไป "การตอบกลับทั้งหมดต้องเป็น JSON ที่ถูกต้อง ต้องมีการทดสอบสำหรับทุกการเปลี่ยนแปลง ห้ามแก้ไขไฟล์นอก /src" ให้ agent ที่มีพฤติกรรมชัดเจน

สรุป:

agent ที่ทำงานได้จริงไม่ใช่ prompt ที่ดีกว่า แต่เป็นระบบ: API + เครื่องมือ + ลูป + หน่วยความจำ + ประตูตรวจสอบ ห้าส่วน ขาดหนึ่งส่วนก็พัง

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

คนที่สร้างลูปจะส่งงานในขณะที่พวกเขาหลับ โมเดลเดียวกัน API เดียวกัน ราคาเดียวกัน สถาปัตยกรรมต่างกัน

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

สร้าง agent หนึ่งตัวในสัปดาห์นี้ ชี้ไปที่งานที่คุณทำทุกวัน ปล่อยให้มันทำงาน