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

นอกจากนี้ ในชุดยังมีผู้ช่วยเฉพาะทางอย่างเอเจนต์อีก 71 ตัวและคำสั่งอีก 97 คำสั่ง โดยทั้งหมดนี้ออกแบบมาเพื่อติดตั้งลงใน Claude Code ที่เป็น AI สำหรับอ่านไฟล์ แก้โค้ด และรันคำสั่งในเทอร์มินัลโดยเฉพาะ รวมถึงยังนำไปใช้กับเครื่องมือกลุ่มเดียวกันอย่าง Codex และ Cursor ได้อีกด้วย

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

โปรเจกต์นี้เปิดให้ใช้งานฟรีภายใต้สัญญาอนุญาต MIT พัฒนาและดูแลหลักโดยวิศวกรเพียงคนเดียว และปล่อยอัปเดตทุกสัปดาห์เพื่อรองรับ AI ช่วยเขียนโค้ดถึง 7 ตัว

ECC เปลี่ยนคำสั่งในแชตให้เป็นขั้นตอนทำงานจริง

หัวใจของ ECC คือวงจรการทำงาน 7 ขั้นตอน ได้แก่ วางแผน, เขียนเทสต์, ลงมือเขียน, รีวิว, ตรวจผล, จดจำ และปรับปรุง

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

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

การเขียนเทสต์: เวลาเราบอกให้ AI เขียนโค้ดแบบ TDD คำสั่งแบบนี้ AI อาจลืมได้กลางคัน ECC จึงเปลี่ยนแนวทางนี้ให้เป็น 3 ขั้นตอนที่ต้องผ่านตามลำดับ ได้แก่ ขั้น RED ที่เขียนเทสต์และรันให้เห็นว่าพังก่อน, ขั้น GREEN ที่เขียนโค้ดจนเทสต์ผ่าน และขั้น REFACTOR ที่ปรับโค้ดให้สะอาดเรียบร้อย โดยในแต่ละขั้นตอนต้องมีผลรันจริงเป็นหลักฐานยืนยัน

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

เมื่อรวมทั้ง 3 จุดนี้เข้าด้วยกัน การเพิ่มฟีเจอร์ใหม่สักตัวด้วย ECC จะมีลำดับขั้นตอนดังนี้:

1. พิมพ์คำสั่ง /ecc:plan ตามด้วยรายละเอียดของฟีเจอร์ เพื่อให้ AI ร่างแผนงาน
2. ตรวจสอบแผน แล้วกดยืนยันหรือแก้ไขก่อนเริ่มทำงาน
3. เรียกใช้สกิล tdd-workflow
4. เก็บหลักฐานว่าเทสต์รันไม่ผ่านจริง (RED) ก่อนเริ่มเขียนโค้ด
5. เขียนโค้ดจนเทสต์รันผ่านทั้งหมด (GREEN)
6. ส่งโค้ดไปให้เอเจนต์ตัวใหม่ที่ใช้ Context ว่างเปล่าช่วยรีวิว
7. แก้ไขโค้ดตามผลรีวิว พร้อมเพิ่มเทสต์เพื่อป้องกันไม่ให้บั๊กเดิมย้อนกลับมา
8. ตรวจสอบความถูกต้องรอบสุดท้าย ทั้งการ build, รูปแบบโค้ด, ความถูกต้องของชนิดข้อมูล และการรันเทสต์ทั้งหมด

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

นอกจากนี้ ECC ยังมีแนวคิด "research-first" หรือการค้นคว้าก่อนเขียนโค้ด โดยมีสกิลชื่อ search-first ซึ่งเป็นขั้นตอนค้นคว้าก่อนลงมือเขียนโค้ด

5 ส่วนประกอบของ ECC ที่โหลดเข้า Context คนละจังหวะ

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

แนวคิดสำคัญของ ECC คือ "ประหยัด Context Window ให้มากที่สุด และแยกส่วนอื่นออกไปเก็บไว้ภายนอก" ECC จึงแบ่งเครื่องมือในคลังออกเป็น 5 ประเภท เพื่อเลือกดึงเข้า Context ในจังหวะที่เหมาะสม:

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

หากเราติดตั้ง Rules ไว้ครบทุกภาษา AI ก็จะต้องแบกมาตรฐานของภาษาที่ไม่ได้ใช้เลยไปด้วยทุกครั้ง หน้าโปรเจกต์จึงแนะนำให้เริ่มจาก Rules ชุดกลางที่ชื่อ common ควบคู่กับแพ็กภาษาที่เราใช้งานจริงเพียงภาษาเดียวก่อน เนื่องจากระบบปลั๊กอินของ Claude Code ยังไม่รองรับการคัดลอก Rules ให้อัตโนมัติ เราจึงต้องคัดลอกไฟล์ด้วยตัวเองดังนี้:

git clone https://github.com/affaan-m/ECC.git
cd ECC
mkdir -p ~/.claude/rules/ecc
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/

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

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

คำว่า Harness ที่ ECC ใช้เรียกตัวเองนั้นหมายถึงโปรแกรมที่ครอบตัวโมเดล AI เอาไว้ เพื่อให้ AI อ่านไฟล์ รันคำสั่งในระบบ และเรียกใช้เครื่องมือภายนอกได้ ซึ่ง Claude Code เองก็จัดเป็น Harness แบบหนึ่ง เช่นกัน ECC จึงนิยามตัวเองว่าเป็นระบบเพิ่มประสิทธิภาพให้แก่ Harness โดยมีทั้งเอเจนต์ harness-optimizer ที่คอยปรับแต่งการตั้งค่า และคำสั่ง /context-budget ที่ใช้ตรวจดูว่าพื้นที่ Context เริ่มแน่นเกินไปแล้วหรือยัง

ความจำของ ECC เก็บเฉพาะบทสรุป ไม่เก็บประวัติแชตทั้งหมด

วิธีที่ง่ายที่สุดในการทำให้ AI จำงานเก่าได้ คือการบันทึกประวัติแชตทั้งหมดแล้วส่งกลับเข้าไปใหม่ในรอบถัดไป แต่นั่นทำให้ข้อความยาวเหยียดเข้าไปแย่งพื้นที่ Context Window ตั้งแต่ยังไม่เริ่มงาน ECC จึงเลือกทำตรงกันข้าม โดยจะดึงเนื้อหาสำคัญในแต่ละเซสชันออกมาเป็นข้อสรุปสั้นๆ, Instincts และสกิลที่หยิบกลับมาใช้ซ้ำได้

ระบบจัดเก็บความจำของ ECC มีชื่อว่า Memory Vault เรียกใช้งานผ่านคำสั่ง ecc memory โดยจะบันทึกข้อมูลออกมาเป็นไฟล์ Markdown เก็บไว้ในเครื่องของเราเอง ความจำระดับโปรเจกต์จะเก็บไว้ในโฟลเดอร์ .ecc/memory/ ส่วนความจำส่วนตัวระดับผู้ใช้จะเก็บไว้ที่ ~/.ecc/memory/

และเนื่องจากบันทึกเป็นไฟล์ Markdown มาตรฐาน เครื่องมือ AI ตัวอื่นๆ เช่น Claude Code, Codex หรือ Kimi จึงอ่านและแชร์ข้อมูลชุดเดียวกันได้ ทำให้เราส่งต่องานที่ทำค้างไว้จากเครื่องมือหนึ่งไปให้อีกเครื่องมือหนึ่งทำต่อได้ทันที

ขั้นตอนสำคัญที่ไม่ควรมองข้ามคือ การติดตั้ง ECC แบบปลั๊กอินจะยังไม่มีคำสั่ง ecc memory ติดมาด้วย หากต้องการใช้ฟีเจอร์นี้ คุณต้องติดตั้งแพ็กเกจเสริมผ่านระบบจัดการแพ็กเกจอย่าง npm ด้วยคำสั่ง npm install -g [email protected] ก่อน จึงจะเรียกใช้คำสั่งนี้ได้

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

Instincts คือรูปแบบหรือแนวทางการทำงานที่ ECC สังเกตและเรียนรู้จากการใช้งานจริง โดยแต่ละข้อจะมีคะแนนความมั่นใจกำกับไว้ และเพื่อประหยัดพื้นที่ Context เมื่อเปิดเซสชันใหม่ ECC จะเลือกดึง Instincts มาใช้ไม่เกิน 6 ข้อ และต้องมีคะแนนความมั่นใจตั้งแต่ 0.7 ขึ้นไป (จากคะแนนเต็ม 1.0) ซึ่งทั้งสองค่านี้เราปรับแต่งเองได้

คำสั่งที่ใช้จัดการ Instincts ได้แก่:

• /instinct-status ใช้ตรวจสอบรายการที่ระบบเรียนรู้ พร้อมดูคะแนนความมั่นใจ
• /instinct-export และ /instinct-import ใช้ส่งออกหรือนำเข้า Instincts เพื่อแชร์ให้คนอื่นในทีม
• /evolve ใช้รวมกลุ่ม Instincts ที่เกี่ยวข้องกัน แล้วแปลงเป็นสกิลใหม่
• /prune ใช้ลบ Instincts ที่หมดอายุหรือไม่ใช้งานแล้วทิ้งไป

คำสั่ง /evolve จะช่วยให้วิธีทำงานที่ใช้ซ้ำแล้วได้ผลบ่อยๆ ค่อยๆ กลายเป็นสกิลที่เรียกใช้ได้ทุกเมื่อ ซึ่งตรงกับขั้นตอน "ปรับปรุง" ในวงจรการทำงาน 7 ขั้นของ ECC

หากไม่อยากรอสะสม Instincts จากการใช้งานจริง คำสั่ง /skill-create จะอ่านประวัติการแก้ไขโค้ดจาก Git ภายในเครื่อง แล้วสร้างไฟล์ SKILL.md ออกมาเป็นสกิลตามแนวทางการทำงานของโปรเจกต์นั้นได้ทันที ถ้าต้องการให้สร้าง Instincts ออกมาด้วย ก็แค่ใส่แฟล็ก --instincts ต่อท้ายคำสั่ง

AgentShield ตรวจความปลอดภัยของไฟล์ตั้งค่าที่มักถูกมองข้าม

ไฟล์ตั้งค่าของ AI ช่วยเขียนโค้ดมักดูเหมือนไฟล์ข้อความธรรมดา แต่เบื้องหลังหลายส่วนสามารถสั่งงานในระบบได้จริง เช่น Hooks สามารถรันคำสั่งในเครื่องได้, ตัวเชื่อมต่อระหว่าง AI กับบริการภายนอกอย่าง MCP Server อาจเก็บรหัสผ่านหรือกุญแจเข้าถึงระบบอย่าง API Key เอาไว้ และข้อความคำสั่งในไฟล์โปรเจกต์ก็โหลดเข้า Context ของ AI ได้โดยตรง หน้าโปรเจกต์จึงเตือนให้ปฏิบัติต่อไฟล์ตั้งค่าเหล่านี้เหมือนเป็นโค้ดที่รันได้จริง

AgentShield คือเครื่องมือสแกนความปลอดภัยที่มาพร้อมกับ ECC โดยมองว่าระบบ Harness ทั้งหมดอาจมีจุดที่ถูกโจมตีได้ ไม่ใช่สิ่งที่ปล่อยให้ทำงานไปได้โดยไม่ตรวจสอบ เครื่องมือนี้พัฒนาขึ้นในงาน Claude Code Hackathon ที่ Cerebral Valley จัดร่วมกับ Anthropic เมื่อเดือนกุมภาพันธ์ 2026 และมีกฎสำหรับตรวจสอบความปลอดภัยถึง 102 ข้อ

ไฟล์ที่ AgentShield จะเข้าไปสแกนประกอบด้วย CLAUDE.md ไฟล์คำสั่งประจำโปรเจกต์ที่ Claude Code อ่านทุกครั้ง, settings.json, ไฟล์ตั้งค่า MCP, Hooks, ไฟล์กำหนดค่าเอเจนต์ และสกิลต่างๆ โดยครอบคลุม 5 ด้านสำคัญ:

• สแกนหารหัสลับหรือ API Key ที่อาจเผลอทำหลุดไว้ ด้วยแพทเทิร์นตรวจจับ 14 รูปแบบ
• ตรวจสอบสิทธิ์การทำงานต่างๆ ที่อนุญาตให้ AI
• ตรวจหาช่องโหว่ที่อาจเปิดให้มีคำสั่งไม่พึงประสงค์แทรกเข้ามาใน Hooks
• ประเมินระดับความเสี่ยงของ MCP Server แต่ละตัว
• ตรวจสอบความถูกต้องและความปลอดภัยในการตั้งค่าเอเจนต์

ผลการตรวจสอบจะแสดงเป็นเกรด A ถึง F บนหน้าจอ หรือจะเลือกส่งออกเป็นรูปแบบ JSON, Markdown หรือ HTML ก็ได้ หากพบปัญหาในระดับวิกฤต โปรแกรมจะจบการทำงานด้วยรหัสข้อผิดพลาด Exit code 2 เมื่อนำไปเชื่อมกับระบบตรวจโค้ดอัตโนมัติอย่าง CI รหัสนี้จะหยุดกระบวนการทำงานทันทีเพื่อป้องกันปัญหา

agentshield scan --path .
agentshield scan --path . --fix
agentshield scan --path . --opus --stream
agentshield init

คำสั่งชุดนี้แยกตามการใช้งาน บรรทัดแรกคือการสแกนเฉพาะในโฟลเดอร์โปรเจกต์ปัจจุบัน หากใส่แฟล็ก --fix ระบบจะแก้ไขให้อัตโนมัติเฉพาะจุดที่แก้ได้อย่างปลอดภัย ส่วนแฟล็ก --opus จะเรียกเอเจนต์ Claude Opus 4.6 จำนวน 3 ตัวมาช่วยวิเคราะห์ โดยแบ่งหน้าที่เป็นตัวจำลองการโจมตี ตัวประเมินระบบป้องกัน และตัวสรุปลำดับความเสี่ยง คำสั่ง agentshield init ใช้สร้างไฟล์ตั้งค่าความปลอดภัยเริ่มต้น นอกจากนี้ หากใช้งานอยู่ในหน้าแชตของ Claude Code ก็พิมพ์ /security-scan เพื่อสั่งรันได้เช่นกัน

ข้อควรระวังคือ คำสั่งทั้งหมดข้างต้น รวมถึง /security-scan จะทำงานได้ก็ต่อเมื่อมีโปรแกรม AgentShield ติดตั้งและตรวจสอบเรียบร้อยแล้วในเครื่อง โดย ECC เตือนไว้ชัดเจนว่าไม่ได้ล็อกเวอร์ชันที่ผ่านการตรวจสอบมาให้ในตัว และไม่ควรดาวน์โหลดมารันแบบชั่วคราวโดยไม่เจาะจงเวอร์ชัน สำหรับแพ็กเกจทางการบน npm มีชื่อว่า ecc-agentshield

ติดตั้ง ECC บน Claude Code ด้วยคำสั่งเดียว

ECC ทำงานได้ครบที่สุดบน Claude Code จึงแนะนำให้เริ่มทดลองจากที่นี่ก่อน โดยเครื่องของคุณต้องติดตั้ง Node.js (เวอร์ชัน 18 ขึ้นไป), Git และ Claude Code (เวอร์ชัน 2.1 ขึ้นไป) หากยังไม่เคยติดตั้ง สามารถดูขั้นตอนได้จากคู่มือ Claude Code สำหรับมือใหม่

เมื่อเตรียมเครื่องมือพร้อมแล้ว ให้รันคำสั่งติดตั้งในเทอร์มินัล:

npx [email protected] setup

คำสั่งนี้จะดึงแพ็กเกจ ecc-universal เวอร์ชัน 2.2.3 (เวอร์ชันล่าสุดตามหน้าโปรเจกต์ ปล่อยเมื่อวันที่ 1 ตุลาคม 2026) โดยตัวช่วยติดตั้งจะถามการตั้งค่าทีละข้อ หากใช้งานคนเดียวบนเครื่องส่วนตัว หน้าโปรเจกต์แนะนำให้เลือก "Global user" และ "Standard hooks" แล้วกดยืนยัน

เมื่อติดตั้งเสร็จ ให้เปิดเซสชัน Claude Code ขึ้นมาใหม่ แล้วพิมพ์ /plugin list หากเห็น ecc@ecc ขึ้นสถานะเปิดใช้งานอยู่ ก็พร้อมเริ่มทำงานได้ทันที

อีกทางหนึ่งคือติดตั้งผ่านระบบปลั๊กอินของ Claude Code โดยตรง ด้วยการพิมพ์คำสั่งในหน้าแชต:

/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

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

npx [email protected] list-installed
npx [email protected] doctor
npx [email protected] repair
npx [email protected] uninstall --dry-run

อีกจุดที่มักสับสนคือ ECC มีชื่อเรียก 3 แบบที่ใช้แทนกันไม่ได้ ได้แก่ คลังโค้ด (Repository) บน GitHub ใช้ชื่อ affaan-m/ECC, ตัวปลั๊กอินใช้ชื่อ ecc@ecc และแพ็กเกจบน npm ใช้ชื่อ ecc-universal ส่วนชื่อ ecc-install ที่อาจพบนั้นไม่ใช่แพ็กเกจแยก แต่เป็นคำสั่งภายใน ecc-universal จึงต้องเรียกใช้งานผ่าน npx [email protected] เสมอ

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

npx [email protected] install --profile minimal --target claude

ข้อควรพิจารณาคือ การติดตั้งด้วยโปรไฟล์นี้จะไม่มี Hooks ใดๆ ทำงานเลย ซึ่งรวมถึงระบบช่วยดักจับคำสั่งอันตรายอย่าง GateGuard ด้วย

บริการแบบมีค่าใช้จ่ายของโปรเจกต์นี้คือ ECC Pro แอปเสริมบน GitHub ที่ช่วยดูแลระบบให้แบบเสร็จสรรพสำหรับคลังโค้ดส่วนตัว มีค่าบริการเริ่มต้นที่ 19 ดอลลาร์ต่อผู้ใช้ต่อเดือน

Codex และ Cursor ใช้งานได้ แต่ฟีเจอร์ยังไม่ครบเท่า Claude Code

สำหรับ Codex สามารถติดตั้ง ECC ผ่านระบบปลั๊กอินของ Codex เองได้โดยตรง:

codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc

ส่วน Cursor จะต้องโคลนคลังโค้ดลงมาที่เครื่องก่อน แล้วสั่งติดตั้งผ่านตัวแปลงหรือ Adapter ลงในโฟลเดอร์ .cursor/ ระดับโปรเจกต์:

git clone https://github.com/affaan-m/ECC.git
cd ECC
./install.sh --profile minimal --target cursor

หากคุณใช้งาน AI ช่วยเขียนโค้ดหลายตัวพร้อมกัน คำสั่ง npx [email protected] install --guided จะเปิดตัวช่วยติดตั้งที่ให้คุณเลือกติดตั้ง Claude Code, Codex และ Kimi Code ได้พร้อมกันในรอบเดียว โดยระบบจะตรวจสอบความพร้อมของแต่ละตัวก่อนเริ่มเขียนไฟล์ลงเครื่อง และให้เรายืนยันการตั้งค่าครั้งเดียวในตอนท้าย

อย่างไรก็ตาม ความสามารถในการทำงานยังแตกต่างกันตามระดับการรองรับ โดย Codex จะรองรับผ่านระบบปลั๊กอินของตัวเอง ส่วน Cursor, OpenCode, Gemini, Zed และ GitHub Copilot จะทำงานผ่าน Adapter ซึ่งอาจใช้ฟีเจอร์ได้ไม่ครบถ้วนเท่ากับบน Claude Code จึงแนะนำให้ตรวจสอบตารางความเข้ากันได้บนหน้าโปรเจกต์ก่อนเริ่มใช้งาน

เริ่มจากงานตรงหน้า ไม่จำเป็นต้องเปิดใช้ทั้ง 311 สกิล

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

หากคุณติดตั้งระบบด้วยตัวเอง คำสั่ง /ecc:plan อาจปรากฏเป็นชื่อสั้นๆ ว่า /plan

นอกจากนี้ คำสั่งบางตัวในคลังจำเป็นต้องติดตั้งเครื่องมือเสริมเพิ่มเติมก่อนใช้งาน เช่น คำสั่งกลุ่ม /multi-plan และคำสั่งที่ขึ้นต้นด้วย /multi- จะต้องติดตั้ง ccg-workflow แยกต่างหาก ส่วนคำสั่ง /astra-review จะต้องมีโปรแกรมสั่งการผ่านเทอร์มินัลอย่าง Codex CLI ติดตั้งอยู่ในเครื่อง และจะส่งโค้ดส่วนที่แก้ไขไปยัง OpenAI เพื่อช่วยรีวิว จึงควรตรวจสอบให้แน่ใจก่อนว่าโค้ดชุดนั้นสามารถส่งออกไปประมวลผลภายนอกได้

ยิ่ง AI มีของให้หยิบมากเท่าไร งานของคนใช้ก็ยิ่งเป็นการเลือกว่าชิ้นไหนยังไม่ต้องเปิด

ที่มา: โปรเจกต์ ECC บน GitHub