Claude Code เป็นเครื่องมือเขียนโค้ดแบบ agentic ที่อ่านโค้ดเบสของคุณ แก้ไขไฟล์ รันคำสั่ง และทำงานร่วมกับ git ได้โดยตรง สำหรับนักพัฒนาคนเดียวในเทอร์มินัลเดียว มันไม่ต้องมีการจัดการใด ๆ เลย คุณแค่อธิบายงาน ดูมันทำงาน แล้วรีวิว diff ลูปนี้เร็วมาก และไม่มีส่วนไหนในคู่มือนี้ที่จะขอให้คุณเลิกใช้มัน
ช่องว่างจะเริ่มปรากฏเมื่อทีมต้องพึ่งพาเครื่องมือนี้ นักพัฒนาห้าคนที่รันเซสชัน Claude Code สร้างผลลัพธ์จริงได้ แต่ผลงานเหล่านั้นอยู่ในเทอร์มินัลส่วนตัว ไม่มีใครตอบคำถามที่ทีมต้องใช้ในการดำเนินงานได้เลย: ใครเป็นคนขอการเปลี่ยนแปลงนี้ ใครกำลังรันมันอยู่ตอนนี้ การรันนั้นทำอะไรไปบ้าง และใครอนุมัติผลลัพธ์ก่อนที่จะ merge การรันยอดเยี่ยมมาก แต่ไม่มีบันทึกของงานเหลืออยู่เลย
การจัดการโปรเจกต์ด้วย Claude Code คือแนวปฏิบัติในการทำงานนั้นให้เป็นงานโปรเจกต์ที่ถูกติดตามและรีวิวได้: issue หนึ่งกลายเป็น Task ที่มีขอบเขตชัดเจน Task ถูกมอบหมายให้ Agent ที่รันผ่าน Claude Code การรันเกิดขึ้นใน worktree ที่แยกออกมาบนเครื่องที่คุณควบคุม และผลลัพธ์ถูกส่งกลับมาให้มนุษย์รีวิว คู่มือนี้จะพาคุณเดินตามเส้นทางนั้นโดยใช้ Sharkly ซึ่งไม่ใช่ตัวแทนที่มาแทน Claude Code แต่เป็นตัวเพิ่มชั้นของ task ร่วม บริบท การควบคุม และการรีวิวให้กับเครื่องมือที่ทีมของคุณใช้อยู่แล้ว
สรุปสั้น ๆ (TL;DR)
ถ้าจะจัดการงาน Claude Code ให้เหมือนงานโปรเจกต์ ให้เขียน issue เป็น Task ที่มีขอบเขตชัดเจน พร้อมเป้าหมาย ขอบเขตงาน และเกณฑ์การยอมรับ จากนั้นมอบหมายให้ Agent ที่มี Runtime เป็น Claude Code ปล่อยให้การรันเกิดขึ้นบน Computer ที่เชื่อมต่ออยู่ ใน git worktree ที่แยกออกมา พร้อมสตรีมความคืบหน้ากลับมา แล้วรีวิวหลักฐานบน Task และตัดสินใจว่าจะยอมรับ ขอให้แก้ไข หรือมอบหมายใหม่ Claude Code ทำหน้าที่รัน ส่วน Sharkly จัดการการมอบหมาย บริบท ความคืบหน้า อุปสรรค ผลลัพธ์ และการรีวิวโดยมนุษย์รอบ ๆ มัน ทำให้การรันแบบขนานมองเห็นได้ทั้งทีม แทนที่จะหายไปในเทอร์มินัลส่วนตัว ส่วนเซสชันในเทอร์มินัลแบบเดี่ยวก็ยังเป็นเครื่องมือที่เหมาะกับงานเร็ว ๆ ในเครื่อง ที่มีความเสี่ยงต่ำ
Task ที่มีการจัดการเพิ่มอะไรให้กับเซสชัน Claude Code แบบดิบ
เซสชันแบบดิบและ Task ที่มีการจัดการรัน Claude Code ข้างใต้เหมือนกัน สิ่งที่ต่างคือทุกอย่างที่อยู่รอบการรัน และมันแบ่งออกเป็นสี่ความสามารถที่เทอร์มินัลให้ไม่ได้
การมองเห็นร่วมกัน Task เก็บความต้องการ สถานะงาน การสนทนา บันทึกการรัน และการรีวิวไว้ในที่เดียว แทนที่จะกระจายไปตาม prompt และเซสชันส่วนตัว เพื่อนร่วมทีมสามารถเปิด SH-214 แล้วดูได้ว่ามีการขออะไร อะไรกำลังรันอยู่ และอะไรส่งกลับมาแล้ว
ความเป็นเจ้าของ Task แยกความรับผิดชอบของมนุษย์ออกจากการรันของ Agent คนหนึ่งรับผิดชอบผลลัพธ์ ส่วน Agent หรือ Crew เป็นผู้รับผิดชอบการรัน ทั้งสองอย่างถูกบันทึกไว้ คำถามว่า "ใครเป็นเจ้าของงานนี้" จึงมีคำตอบเสมอ
หลักฐานสำหรับรีวิว ทุกการรันสร้าง execution trace: เริ่มเมื่อไหร่ เรียกใช้เครื่องมืออะไร ทำไมถึงถูกจัดคิว และจบลงอย่างไร รายงานของ Agent ถูกบันทึกเป็นคอมเมนต์ที่เชื่อมกับ trace นั้น การรีวิวจึงไม่ใช่ "เชื่อคนที่เฝ้าเทอร์มินัล" อีกต่อไป แต่กลายเป็น "อ่านบันทึก"
การรันแบบขนานที่ไม่ชนกัน แต่ละ Task ได้ไดเรกทอรีที่แยกออกมา และงานที่อิงกับ repository สามารถใช้ git worktree แยกต่างหากต่อการรันหนึ่งครั้ง ทำให้หลาย Task แก้ไขโค้ดเบสเดียวกันพร้อมกันได้ กลไกการทำงานแบบขนานมีคู่มือแยกของตัวเอง: วิธีรัน Claude Code agent หลายตัวพร้อมกัน
ขอพูดตรง ๆ ถึงขอบเขตก่อนจะเข้าเนื้อหา ไม่ใช่ทุกเซสชัน Claude Code ต้องใช้วิธีนี้ ใช้ Agent Chat แบบเดี่ยว หรือเซสชันเทอร์มินัลธรรมดา ในการสำรวจคำถาม ร่างแผน หรือแก้ไขเล็ก ๆ ในเครื่อง ใช้ Task เมื่องานต้องมีความเป็นเจ้าของ สถานะ ประวัติการรัน หรือการรีวิว
ขั้นตอนที่ 1: เปลี่ยน issue ให้เป็น Task ที่ Agent รันได้
เส้นทางนี้เริ่มก่อนที่ agent ตัวไหนจะรัน Claude Code วางแผนแนวทางจากสิ่งที่คุณให้ไป ดังนั้น Task ที่คลุมเครือจะทำให้ได้การรันที่มั่นใจมากแต่ไปผิดทาง
ชื่อ Task ที่ดีควรบอกผลลัพธ์ ไม่ใช่บอกหัวข้อ ส่วนคำอธิบายควรมีสิ่งที่คนใหม่ หรือ Agent ต้องรู้เพื่อเดินหน้าต่อ: งานนี้สำคัญเพราะอะไร อะไรอยู่ในและนอกขอบเขต ไฟล์ ลิงก์ หรือพฤติกรรมที่สังเกตได้ที่เกี่ยวข้อง ข้อจำกัดและการตัดสินใจที่มีอยู่แล้ว และจะรีวิวความสำเร็จอย่างไร
ข้อสุดท้ายคือสิ่งที่เวิร์กโฟลว์แบบทำคนเดียวมักข้ามไป การเขียนว่า "เสร็จหมายความว่า retry logic มีเทสต์ที่ fail กับพฤติกรรมเดิม" ลงในคำอธิบาย จะให้เช็กลิสต์กับคนรีวิว และให้เป้าหมายกับ Agent เก็บเป้าหมาย ขอบเขต และเกณฑ์การยอมรับที่ไม่ค่อยเปลี่ยนไว้ในคำอธิบาย ส่วนการสนทนาให้ใช้คอมเมนต์
หมวดหมู่สถานะก็สำคัญตรงนี้ด้วย Task ที่อยู่ใน Backlog คือถูกพักไว้ และการมอบหมาย Agent ให้มันจะไม่เริ่มการรัน นี่เป็นฟีเจอร์ที่มีประโยชน์ คุณสามารถร่าง Task เป็นชุด มอบหมายทั้งหมด แล้วปล่อยแต่ละอันอย่างตั้งใจด้วยการย้ายมันออกจาก Backlog เมื่อพร้อม
ถ้า issue ของคุณอยู่ที่อื่นอยู่แล้ว คุณไม่จำเป็นต้องสร้างกระบวนการใหม่ทั้งหมด การเชื่อมต่อของ Sharkly รองรับ Jira, Slack และ GitHub ทำให้ตัวติดตามงานที่มีอยู่ยังอยู่ที่เดิม ขณะที่การรันกลายเป็นสิ่งที่มอบหมายและติดตามได้ วินัยในการเขียนงานที่ agent รันได้เป็นส่วนหนึ่งของการเปลี่ยนแปลงครั้งใหญ่ที่เราครอบคลุมไว้ใน agentic coding คืออะไร
ขั้นตอนที่ 2: มอบหมายให้ Agent ที่มี Runtime เป็น Claude Code
ใน Sharkly คุณไม่ได้มอบหมายงานให้ Claude Code โดยตรง แต่คุณมอบหมายให้ Agent และ Runtime ของ Agent นั้นคือ Claude Code ความแตกต่างนี้คุ้มค่าที่จะทำความเข้าใจ
Agent คือชุดการตั้งค่าการทำงานที่บันทึกไว้ ไม่ใช่ prompt ที่ใช้ครั้งเดียว: คำสั่ง Runtime Skills repository ตัวแปรสภาพแวดล้อม และการตั้งค่าการรันของมันกำหนดวิธีที่มันจัดการงาน มีคนตั้งค่า Agent "Backend Fixer" ครั้งเดียว แชร์ไปที่ Space แล้วทั้งทีมก็มอบหมายงานให้การตั้งค่าที่ผ่านการทดสอบชุดเดียวกัน แทนที่นักพัฒนาแต่ละคนจะต้องคิด prompt เอง เราอธิบายแนวคิดนี้อย่างละเอียดใน Agent ใน Sharkly อธิบายให้เข้าใจ
Runtime คือเครื่องมือ agent จริงที่มีอยู่บน Computer เมื่อคุณเชื่อมต่อเครื่อง บริการภายในเครื่องตัวเล็ก ๆ จะตรวจหาเครื่องมือ agent ที่รองรับซึ่งติดตั้งอยู่ แล้วรายงานแต่ละตัวเป็น Runtime หนึ่งตัว การติดตั้ง Claude Code จะปรากฏเป็น Runtime ที่พร้อมใช้ทันทีที่บริการนี้มองเห็นมัน
มีสามข้อเกี่ยวกับโครงสร้างนี้ที่ช่วยให้ความคาดหวังตรงกับความจริง:
- Agent ใช้โมเดลเริ่มต้นของ Runtime Sharkly ไม่แสดงหรือให้สัญญาว่าจะใช้โมเดลชื่ออะไร และไม่มีตัวเลือกโมเดลหรือตัวควบคุมความลึกในการคิดบน Agent ถ้าต้องการเปลี่ยนโมเดล ให้เปลี่ยนการตั้งค่าใน Claude Code เอง
- การใช้โมเดลเป็นแบบ bring-your-own การรันใช้ Claude subscription หรือ API key ที่ตั้งค่าไว้แล้วใน Claude Code บน Computer เครื่องนั้น โควตาโมเดลขึ้นอยู่กับเครื่องมือเขียนโค้ดด้วย AI แพ็กเกจ และบัญชี API ที่ทีมของคุณเชื่อมต่อ
- การมอบหมายเป็นเรื่องชัดเจน คุณเปิดตัวควบคุม Assignee ของ Task แล้วเลือก Agent เหมือนกับที่คุณมอบหมายตั๋วให้เพื่อนร่วมงาน ส่วนคนที่รับผิดชอบจะถูกบันทึกแยกไว้ต่างหาก
สำหรับงานเล็ก ๆ ที่นิยามไว้ชัดเจน ให้มอบหมาย Task ให้ Agent ตัวเดียวโดยตรง ใช้ Crew ซึ่งเป็นกลุ่มของ People และ Agent ที่นำกลับมาใช้ซ้ำได้และประสานงานโดย Agent หัวหน้าเพียงตัวเดียว เฉพาะเมื่อหัวหน้าจำเป็นต้องตีความเป้าหมายจริง ๆ และนำผลลัพธ์ของสมาชิกคนอื่นกลับมารวมใน Task เดียว ขั้นตอนแบบทีละสเต็ปของการมอบหมายครั้งแรกอยู่ใน วิธีมอบหมายงานแรกให้ AI agent
ขั้นตอนที่ 3: การรันบน Computer ใน worktree ที่แยกออกมา
เมื่อ Task ออกจาก Backlog และ Agent พร้อมแล้ว Sharkly จะจัดคิวการรันและส่งไปยัง Computer ที่เลือกไว้: แล็ปท็อปของคุณ เซิร์ฟเวอร์ระยะไกล หรือคอนเทนเนอร์ บริการภายในเครื่องบนเครื่องนั้นจะรับการรัน เตรียมไดเรกทอรีงาน เริ่ม Claude Code และสตรีมความคืบหน้ากลับมา โค้ด ข้อมูลรับรอง และการติดตั้ง Claude Code ของคุณจะไม่มีวันออกจากฮาร์ดแวร์ที่คุณควบคุม
การแยกหน้าที่กันนี้ควรพูดให้ชัด: Agent นิยามว่างานควรถูกจัดการอย่างไร Computer จัดหาตัวโฮสต์และทรัพยากรภายในเครื่อง Runtime รันเซสชัน agent จริง ส่วน Task ยังคงเป็นบันทึกร่วม
สำหรับงานที่เกี่ยวกับ repository โหมดไดเรกทอรีทำงานที่แนะนำคือ Temporary: แต่ละ Task ได้ไดเรกทอรีที่แยกออกมา และบริการภายในเครื่องสามารถเตรียม git worktree ใหม่ต่อการรันหนึ่งครั้งจากข้อมูล repository ที่แคชไว้ สอง Task ที่แตะ repository เดียวกันจะเขียนลงไดเรกทอรีคนละอันบนดิสก์ จึงเป็นเหตุผลว่าทำไมการรันแบบขนานจึงไม่ทับกัน หลักการพื้นฐานนี้ถูกอธิบายไว้ใน วิธีใช้ git worktrees กับ AI coding agent ส่วนโหมด Specified ซึ่งเป็นไดเรกทอรีภายในเครื่องที่ตั้งค่าไว้หนึ่งอันและใช้ซ้ำในการรัน มีไว้สำหรับข้อยกเว้นที่สมเหตุสมผล: repository ที่ใหญ่โตมาก แคชภายในเครื่องที่มีราคาแพง หรือเครื่องมือที่ผูกกับเส้นทางใดเส้นทางหนึ่ง
ระหว่างที่ Claude Code ทำงาน การรันจะเคลื่อนผ่านสถานะที่มองเห็นได้: queued, dispatched, running แล้วก็ completed, failed หรือ canceled สถานะการรันแยกจากสถานะ Task และการแยกกันนี้มีประโยชน์: Task สามารถอยู่ในสถานะ In Progress ขณะที่ Agent กำลังทำงาน รอคำตอบจากมนุษย์ หรือรายงานข้อผิดพลาด และไม่มีใครต้องคอยเช็กเทอร์มินัลว่าตอนนี้เป็นสถานะไหน
ขั้นตอนที่ 4: ความคืบหน้าและอุปสรรคส่งกลับมาที่ Task
ทุกอย่างที่ทีมต้องเห็นจะกลับมาที่จุดเดียว รายงานของ Agent ถูกเก็บเป็นคอมเมนต์ที่เชื่อมกับ execution trace ของมัน Activity แสดงคอมเมนต์และการเปลี่ยนแปลงของ task ในไทม์ไลน์เดียว ส่วน Executions เก็บประวัติการรัน: แหล่งที่มาของการทริกเกอร์ เวลาเริ่มและสิ้นสุด การเรียกใช้เครื่องมือ และรายละเอียดความล้มเหลว
อุปสรรคจะถูกเปิดเผยออกมาแทนที่จะค้างอยู่เงียบ ๆ Agent สามารถทำให้ Task รอคำตอบหรือการรีวิวจากมนุษย์ได้ และงานที่ถูกบล็อกจะไหลเข้า Inbox ซึ่งเป็นคิวส่วนตัวที่แยก Task ที่ต้องการความสนใจของคุณออกจากการอัปเดตที่มีความสำคัญต่ำกว่า ความแตกต่างนี้เป็นเชิงโครงสร้าง: เซสชันที่ค้างอยู่จะรอจนกว่าคุณจะบังเอิญไปเช็กแท็บ ขณะที่ Task ที่ถูกบล็อกจะบอกคนที่รับผิดชอบว่ามันติดอยู่
การทำงานต่อคือการคอมเมนต์ ไม่ใช่การเปิดเซสชันใหม่ คอมเมนต์ที่เข้าเงื่อนไขบน Task ที่ยังมอบหมายให้ Agent อยู่จะเริ่มการรันต่อเนื่องด้วยบริบทสะสมของ Task และคอมเมนต์ที่ส่งรัว ๆ จะถูกรวมเข้าด้วยกันเพื่อไม่ให้เกิดการรันที่ค้างซ้ำซ้อน
ขั้นตอนที่ 5: การรีวิวและอนุมัติโดยมนุษย์
เส้นทางนี้จบลงตรงจุดที่ควรจบ: ที่ตัวคน Agents ค้นคว้า รัน ทดสอบ และรายงาน ส่วนคนกำหนดทิศทาง ให้อำนาจ และอนุมัติผลลัพธ์
การรีวิวบน Task ที่มีการจัดการคือการอ่านหลักฐาน ไม่ใช่การดูเซสชันซ้ำ คนรีวิวตรวจรายงานของ Agent เทียบกับเกณฑ์การยอมรับที่เขียนไว้ในขั้นตอนที่ 1: มันอยู่ในขอบเขตไหม รันการตรวจสอบที่เกี่ยวข้องหรือเปล่า ให้หลักฐานประกอบข้อสรุปไหม บันทึกความไม่แน่ใจแทนที่จะเดาไหม execution trace อยู่ตรงนั้นเผื่อสรุปไม่พอ
จากนั้นการอนุมัติจะเป็นหนึ่งในสามทางที่ตรงไปตรงมา อนุมัติงานแล้วย้าย Task ไปยังสถานะที่เสร็จสิ้น ขอให้แก้ไขด้วยคอมเมนต์ที่เจาะจง ซึ่งจะเริ่มการรันต่อเนื่องที่พาบริบทครบถ้วนไปด้วย หรือตัดสินว่าการรันครั้งนั้นผิดพลาด: ยกเลิก อ่านบันทึกการรัน แล้วลองใหม่หรือมอบหมายงานให้ Agent ตัวอื่น
ทั้งหมดนี้ไม่ได้แทนที่การรีวิวผ่าน git ของคุณ Claude Code สร้าง branch เขียน commit และเปิด pull request ผ่าน git hosting ปกติของคุณ และการรีวิวตอน merge ก็ยังอยู่ที่เดิม Task เพิ่มสิ่งที่หน้า PR มองไม่เห็น: คำขอตั้งต้น หลักฐานการรัน และการอนุมัติที่ถูกบันทึกไว้
เซสชันเดี่ยวเทียบกับ Task ที่มีการจัดการ
| คำถาม | เซสชัน Claude Code แบบเดี่ยว | Task ที่มีการจัดการใน Sharkly |
|---|---|---|
| ใครเป็นคนขอเรื่องนี้? | ความจำของคุณ | คำอธิบาย Task พร้อมขอบเขตและเกณฑ์การยอมรับ |
| ใครกำลังทำงานนี้อยู่? | ใครก็ตามที่เป็นเจ้าของเทอร์มินัล | คนที่รับผิดชอบบวกกับ Agent ในฐานะผู้รับผิดชอบการรัน |
| ตอนนี้เกิดอะไรขึ้นอยู่? | ดูที่เทอร์มินัล | สถานะการรันบน Task บอร์ด และ Inbox |
| การรันทำอะไรไปบ้าง? | เลื่อนดูย้อนหลัง จนกว่าแท็บจะปิด | Execution trace และคอมเมนต์ที่บันทึกไว้ |
| สองการรันใช้ repo เดียวกันได้ไหม? | ได้เฉพาะถ้าคุณตั้ง worktree เองด้วยมือ | Worktree แยกต่อ Task โดยค่าเริ่มต้น |
| ใครอนุมัติผลลัพธ์? | ไม่มีใครบันทึกไว้ | การรีวิวและการอนุมัติบน Task |
| ทีมนำการตั้งค่ากลับมาใช้ซ้ำได้ไหม? | Prompt อยู่กับคนคนเดียว | Agents และ Skills ที่แชร์ใน Space |
คอลัมน์ซ้ายไม่ใช่คอลัมน์ที่ผิด มันเป็นเครื่องมือที่เหมาะสำหรับการสำรวจและแก้ไขเร็ว ๆ ส่วนคอลัมน์ขวาคุ้มค่าเมื่องานต้องมองเห็นได้ รีวิวได้ และทำขนานกันได้
จาก Task เดียวสู่โปรเจกต์ที่มีการจัดการ
ทุกอย่างข้างต้นขยายจาก Task เดียวไปสู่แผนงานได้โดยไม่ต้องเปลี่ยนรูปแบบ Task จะรวมกลุ่มเป็น Projects เมื่อหลายอันรับใช้ผลลัพธ์เดียวกัน และรวมเป็น Sprints เมื่อคำถามคืออะไรจะส่งมอบได้ในกรอบเวลานี้ Views บันทึกคำถามที่ทีมถามซ้ำ ๆ เช่น Task ที่รอการรีวิว
นั่นคือแก่นทั้งหมดของเวิร์กโฟลว์นี้ จุดแข็งของทีมไม่ได้มาจากการเปิดแชต AI เพิ่มขึ้นเรื่อย ๆ แต่มาจากการแชร์บทบาท กฎ บริบท และเวิร์กโฟลว์ ตำแหน่งของวินัยนี้ในภาพรวมที่กว้างขึ้นเป็นหัวข้อของคู่มือหลักของเรา AI agent project management คืออะไร
เริ่มจากสิ่งที่เล็กกว่าที่รู้สึกว่าจำเป็นก็ได้ เชื่อมต่อ Computer หนึ่งเครื่อง ยืนยันว่า Claude Code ปรากฏเป็น Runtime ที่พร้อมใช้ สร้าง Agent หนึ่งตัวที่มีบทบาทแคบ ๆ แล้วมอบหมาย Task ความเสี่ยงต่ำหนึ่งอันที่มีเกณฑ์การยอมรับจริง ๆ ให้มัน รีวิวผลลัพธ์เหมือนที่คุณจะรีวิว pull request แรกของเพื่อนร่วมทีมใหม่ เอกสารของ Sharklyอธิบายแต่ละแนวคิดไว้ละเอียดกว่า
คำถามที่พบบ่อย
Sharkly มาแทน Claude Code หรือไม่?
ไม่ Sharkly ไม่ใช่ตัวแทนที่มาแทน Claude Code, Codex หรือเครื่องมือรันอื่น ๆ Claude Code ทำหน้าที่รัน: อ่านโค้ดเบส แก้ไขไฟล์ รันคำสั่ง และทำงานกับ git ส่วน Sharkly เพิ่มชั้นระดับทีมรอบ ๆ มัน จัดการการมอบหมาย บริบทของ task ความคืบหน้า อุปสรรค ผลลัพธ์ และการรีวิวโดยมนุษย์
ต้องมี subscription ของโมเดลแยกต่างหากเพื่อรัน Claude Code ผ่าน Sharkly ไหม?
ไม่ การใช้โมเดลยังคงใช้ subscription หรือ API key ที่ตั้งค่าไว้แล้วใน Claude Code บน Computer ที่คุณเชื่อมต่อ โควตาโมเดลขึ้นอยู่กับเครื่องมือเขียนโค้ดด้วย AI แพ็กเกจ และบัญชี API ที่ทีมของคุณเชื่อมต่อ
ยังใช้ Claude Code โดยตรงในเทอร์มินัลได้อยู่ไหม?
ได้ และควรทำด้วย เซสชันโดยตรงหรือ Agent Chat แบบเดี่ยวเป็นเครื่องมือที่เหมาะสำหรับการสำรวจคำถาม ร่างแผน หรือแก้ไขเล็ก ๆ ในเครื่อง ให้ย้ายไปใช้ Task เมื่องานต้องมีความเป็นเจ้าของ สถานะ ประวัติการรัน หรือการรีวิว
เกิดอะไรขึ้นเมื่อการรันล้มเหลว?
การรันจะถูกทำเครื่องหมายว่า failed บน Task และบันทึกการรันจะเก็บชื่อเรื่องพร้อมรายละเอียดทางเทคนิคดั้งเดิมจากบริการโมเดล คำแนะนำในการแก้ปัญหาของ Sharkly จะจับคู่กรณีที่พบบ่อย เช่น การจำกัดอัตราการเรียกใช้ โควตาหมด และข้อผิดพลาดด้านการยืนยันตัวตน เข้ากับขั้นตอนถัดไป พร้อมลิงก์ไปยังเอกสารอ้างอิงข้อผิดพลาดของ Claude Code เอง ลองรันใหม่หลังแก้สาเหตุ หรือมอบหมาย Task ให้ Agent ตัวอื่น
Task ของ Claude Code หลายตัวรันบน repository เดียวกันพร้อมกันได้ไหม?
ได้ ในโหมดไดเรกทอรีทำงานแบบ Temporary แต่ละ Task จะรันในไดเรกทอรีที่แยกออกมา และการรันที่อิงกับ repository จะได้ git worktree ใหม่แยกกัน ดังนั้น Task ที่รันพร้อมกันจะไม่เขียนลง checkout ที่ใช้ร่วมกัน โดยขีดจำกัดการทำงานพร้อมกันบน Agent และ Computer จะกำหนดว่ามีกี่อันที่รันได้ในเวลาเดียวกัน
