รุ่น 1.0.0-alpha.1ล่าสุด
บทที่ 2.26
การสร้างด้วยเครื่องมือเขียนโค้ด AI
วิธีสร้างส่วนขยายของ Nexus อย่างปลอดภัยด้วย Claude Code และเครื่องมือเขียนโค้ด AI (ปัญญาประดิษฐ์) อื่นๆ เริ่มต้นด้วยการเชื่อมต่อ IDE (สภาพแวดล้อมการพัฒนาแบบเบ็ดเสร็จ) ของคุณเข้ากับ Workbench และไฟล์ CLAUDE.md ของโปรเจกต์ที่บรรจุกฎของแพลตฟอร์ม และจบด้วยตัวอย่างคำสั่ง (Prompt) ที่ใช้งานได้จริง 6 รายการ พร้อมเกณฑ์ตรวจสอบที่พิสูจน์ผลลัพธ์ของแต่ละรายการ
หน้านี้แปลโดย AI จากต้นฉบับภาษาอังกฤษ หากมีส่วนใดไม่ชัดเจน โปรดอ้างอิงจากหน้าภาษาอังกฤษ อ่านหน้านี้เป็นภาษาอังกฤษ

ชุด Cold chain ส่วนใหญ่ใน บทที่ 2.24 การสร้างโซลูชันเฉพาะอุตสาหกรรมแบบกำหนดเองตั้งแต่ต้นจนจบ เขียนขึ้นโดยมี Claude Code เปิดอยู่ในเทอร์มินัลข้าง ๆ ผม ซึ่งปัจจุบันเป็นเรื่องปกติที่ Corrán Orbital และ Nexus ถูกสร้างขึ้นโดยคาดการณ์ไว้แล้วว่าจะเป็นเช่นนั้น แพลตฟอร์มไม่ได้มองเครื่องมือเขียนโค้ด AI (ปัญญาประดิษฐ์) เป็นเพียงระบบเติมข้อความอัตโนมัติที่ชาญฉลาด แต่มองว่าเป็นเอเจนต์ที่ทำงานแทนบุคคลที่ระบุชื่อ โดยมีบัตรผ่านที่แคบกว่าของบุคคลนั้นเสมอ และบันทึกทุกการเรียกใช้ที่เอเจนต์ทำ
บทนี้ว่าด้วยการทำงานในลักษณะนั้นโดยไม่เกิดความเสียหาย เริ่มจากการเชื่อมต่อ IDE (สภาพแวดล้อมการพัฒนาแบบเบ็ดเสร็จ) ของคุณ จากนั้นครอบคลุมสกิลในเอดิเตอร์ ไฟล์โปรเจกต์ที่สอนกฎของแพลตฟอร์มให้แก่เครื่องมือ คอมไพเลอร์สองตัวที่แปลงงานที่มีอยู่เป็นโค้ด Nexus วิธีที่คอมมิตระบุว่าเครื่องมือใดเป็นผู้เขียน และวิธีที่ผมตรวจทานสิ่งที่เครื่องมือสร้างขึ้น บทนี้ปิดท้ายด้วยพรอมต์หกรายการที่ผมจะมอบให้เพื่อนร่วมงาน แต่ละรายการระบุสิ่งที่ควรได้กลับมาและเกตที่พิสูจน์ผลลัพธ์นั้น
การเชื่อมต่อ IDE ของคุณเข้ากับ Nexus
ทุกการติดตั้งมีที่อยู่ Workbench หนึ่งรายการสำหรับเครื่องมือเขียนโค้ด AI คุณจะพบที่อยู่นี้ในหน้า Connect your IDE ภายใต้ Developers และ Claude Code เชื่อมต่อได้ด้วยคำสั่งเดียว:
claude mcp add workbench --transport http <workbench-address><workbench-address> คือที่อยู่ที่หน้านั้นแสดง โดยมีปุ่มคัดลอกอยู่ข้าง ๆ เครื่องมืออื่น ๆ มีคำสั่งบรรทัดเดียวของตนเองในหน้าเดียวกัน ได้แก่ codex mcp add workbench --url <workbench-address> สำหรับ Codex ลิงก์ติดตั้งสำหรับ Cursor และ code --add-mcp พร้อมอาร์กิวเมนต์ JSON ขนาดเล็กสำหรับ VS Code ร่วมกับ Copilot เครื่องมือทั้งหมดสื่อสารผ่าน MCP (Model Context Protocol) ไปยังที่อยู่เดียวกัน
ไม่มีคีย์ที่ต้องวาง การเรียกใช้ครั้งแรกจะเปิดเบราว์เซอร์ของคุณ ซึ่งแสดงอย่างชัดเจนว่าอะไรกำลังขอสิทธิ์ ได้แก่ เครื่องมือใดบนคอมพิวเตอร์เครื่องใด ทำงานแทนใคร และต้องการระดับสิทธิ์ใด คุณอนุญาตด้วยพาสคีย์ของคุณ และนับจากนั้นเครื่องมือจะไม่ถือรหัสผ่านฐานข้อมูลหรือ kubeconfig ใด ๆ มีเพียงบัตรผ่านที่มีวันสิ้นสุด เบื้องหลังที่อยู่นั้น Nexus จะสร้างข้อมูลรับรองอายุสั้นสำหรับแต่ละที่จัดเก็บข้อมูล สำหรับแต่ละคำขอ ในนามของคุณ
ผู้ดูแลระบบขององค์กรยังสามารถดาวน์โหลดไฟล์การตั้งค่าแบบมีการจัดการ เพื่อให้ Claude Code ทุกชุดของบริษัทเชื่อมต่อกับเซิร์ฟเวอร์นี้เท่านั้นและไม่เชื่อมต่อกับเซิร์ฟเวอร์อื่น:
{ "workbench": { "type": "http", "url": "<workbench-address>" } }ระดับสิทธิ์และบัตรผ่าน
ทุกการลงชื่อเข้าใช้ Workbench จะได้รับบัตรผ่านที่ประกอบด้วยระดับสิทธิ์ที่มีชื่อกำกับ ค่าเริ่มต้นสำหรับนักพัฒนาคือ Observe และ Sandbox บนยูนิตของตนเอง
| ระดับ | สิ่งที่อนุญาตให้ทำ | ผู้ที่ได้รับ |
|---|---|---|
| Observe | อ่านยูนิตของคุณ รวมถึงล็อกและเมตริก และคิวรีสำเนาที่ปิดบังข้อมูล | ค่าเริ่มต้น |
| Sandbox | เขียนในพื้นที่ของคุณเอง ได้แก่ พื้นที่ dev ของคุณและสาขาข้อมูลของคุณเอง | ค่าเริ่มต้น |
| Propose | เปิดคำขอเปลี่ยนแปลง ไปป์ไลน์จะนำไปใช้หลังการตรวจทาน | ขอเมื่อใช้งานครั้งแรก |
| Elevate | การดำเนินการครั้งเดียวแบบจำกัดเวลาบนเป้าหมายเดียว อนุมัติโดยบุคคลที่ระบุชื่อ | เฉพาะบุคคลเท่านั้น ไม่ได้รับจากการลงชื่อเข้าใช้เพียงอย่างเดียว |
| Break-glass | การเข้าถึงในกรณีฉุกเฉิน | เฉพาะผู้ดูแลแพลตฟอร์มเท่านั้น โดยมีผู้อนุมัติสองคน |
เอเจนต์ทำงานแทนบุคคลเสมอและปรากฏเป็นรายการแยกของตนเอง บัตรผ่านของเอเจนต์ไม่เคยกว้างกว่าของคุณ และไม่รวมระดับสิทธิ์ Elevate หรือข้อมูลที่ไม่ได้ปิดบัง บัตรผ่านมีอายุหนึ่งชั่วโมง และต่ออายุเฉพาะในขณะที่คุณใช้งาน Nexus หรือ IDE อยู่เท่านั้น บัตรผ่านของบุคคลมีอายุ 8 ชั่วโมง ดังนั้นเครื่องมือที่คุณปล่อยให้ทำงานข้ามคืนจะหยุดเอง และการสิ้นสุดบัตรผ่านของคุณเองก็จะสิ้นสุดบัตรผ่านของเอเจนต์ของคุณด้วย บัตรผ่านของเอเจนต์แต่ละใบยังมีงบประมาณค่าใช้จ่ายของโมเดล ซึ่งประเมินก่อนอนุมัติบัตรผ่านและแสดงเป็นมาตรวัดขณะทำงาน
หน้า My access passes แสดงรายการบัตรผ่านทุกใบที่คุณและเอเจนต์ของคุณถืออยู่ พร้อมระดับสิทธิ์และค่าใช้จ่ายจนถึงปัจจุบัน และให้คุณต่ออายุ จำกัดขอบเขต หรือสิ้นสุดแต่ละใบได้ การสิ้นสุดบัตรผ่านจะหยุดการเรียกใช้ครั้งถัดไปทันที ส่วนบันทึกของทุกการเรียกใช้ยังคงอยู่ บัตรผ่านแต่ละใบยังมีขีดจำกัดตายตัว ซึ่งของเราคือ 200 แถวและ 30 วินาทีต่อคิวรี และ 50 ออบเจกต์ที่เปลี่ยนแปลงในพื้นที่ dev ต่อเซสชัน
เซสชันแรกใน IDE
เมื่อเชื่อมต่อแล้ว /mcp ใน Claude Code จะแสดงรายการเครื่องมือ Workbench โดยจัดกลุ่มตามระดับสิทธิ์ กลุ่ม Observe มีเครื่องมือสำหรับอ่าน ได้แก่ workbench.k8s.describe, workbench.k8s.events, workbench.logs.query, workbench.metrics.query, workbench.traces.get, workbench.db.schema, workbench.db.query บนสำเนาที่ปิดบังข้อมูล, workbench.graph.query และ workbench.vector.search Sandbox เพิ่ม workbench.devspace.deploy, workbench.branch.create และ workbench.branch.reset Propose เพิ่มเครื่องมือที่เปิดคำขอเปลี่ยนแปลงและวางแผนการเปลี่ยนแปลงกราฟ Elevate ไม่อยู่ในบัตรผ่านเลย คุณต้องขอสิทธิ์นี้ในคอนโซล
คำถามจริงข้อแรกของผมคือ เหตุใดตัวอ่านข้อมูลเทเลเมทรีของเราจึงรีสตาร์ทใน Rotterdam ในช่วงกลางคืน Claude Code อธิบายเวิร์กโหลด (รีสตาร์ทสองครั้ง หน่วยความจำไม่เพียงพอเมื่อเทียบกับขีดจำกัด 512 MiB) คิวรีล็อก (องค์กรกำหนดโดยเกตเวย์ ข้อมูลส่วนบุคคลถูกปกปิด) และเมตริกหน่วยความจำ และพบว่าการโหลดรายคืนดึงค่าที่อ่านได้ทั้งคืนเข้ามาในแบตช์เดียว จากนั้นผมจึงขอรหัสผ่านฐานข้อมูลที่บริการนั้นใช้ ครึ่งหนึ่งเพื่อเป็นการทดสอบ Workbench ปฏิเสธด้วย SECRET_NEVER_SHOWN โดยจะแสดงเพียงชื่อและอักขระสี่ตัวสุดท้ายของ Secret ไม่เคยแสดงค่าจริงแก่ผู้ใดเลย คำตอบของผู้ช่วยถูกต้อง คือไม่จำเป็นต้องใช้รหัสผ่าน เพราะแต่ละคิวรีที่ทำจะได้รับข้อมูลรับรองอายุสั้นของตนเอง ซึ่งเป็นบทบาทแบบอ่านอย่างเดียวที่สร้างขึ้นสำหรับคำขอนั้นคำขอเดียว
วางแผน แล้วจึงนำไปใช้
ทุกเครื่องมือที่เปลี่ยนแปลงสิ่งใดจะแสดงแผนก่อน แผนคือ diff พร้อมจำนวนและลายนิ้วมือ และการนำไปใช้จะรันเฉพาะแผนนั้นอย่างตรงตามแผนเท่านั้น
ภายในพื้นที่ dev ของคุณเอง การนำไปใช้จะรันทันที นอกพื้นที่ดังกล่าว บุคคลต้องยืนยันใน IDE และการเปลี่ยนแปลงจะไปยังไปป์ไลน์ ซึ่งจะนำไปใช้หลังการตรวจทาน ผลที่ตามมาคือการปฏิเสธสองกรณี และผมเจอทั้งสองกรณี:
- จากสคริปต์ที่ไม่มีใครอยู่หน้าคีย์บอร์ด เช่น
claude -pใน cron job จะไม่มีทางแสดงกล่องยืนยันได้ ดังนั้นการเปลี่ยนแปลงนอกแซนด์บ็อกซ์จะถูกปฏิเสธด้วยCONFIRMATION_UNAVAILABLEและจะไม่มีสิ่งใดเกิดขึ้น ให้รันในเซสชันแบบโต้ตอบ - การนำไปใช้ที่ระบุแผนที่เซสชันนี้ไม่เคยสร้าง หรือแผนที่มีการเปลี่ยนแปลง จะถูกปฏิเสธด้วย
PLAN_FINGERPRINT_MISMATCHก่อนที่จะมีสิ่งใดรัน ให้วางแผนใหม่
Read-taint
เนื้อหาของลูกค้าอาจซ่อนคำสั่งที่มุ่งเป้าไปยังผู้ช่วยไว้ ดังนั้นเมื่อเซสชันได้อ่านเนื้อหาดังกล่าวแล้ว เซสชันจะสูญเสียเครื่องมือสำหรับการเขียนและการเข้าถึงภายนอก Nexus จนกว่าบุคคลจะยืนยันการเขียนหนึ่งครั้งหรือเริ่มเซสชันใหม่
ผมพบกรณีนี้ในเอกสารเคลมที่มีย่อหน้าหนึ่งเขียนถึง "ผู้ช่วย" โดยขอให้คัดลอกตารางเคลมไปยังที่อยู่ภายนอก Claude Code เพิกเฉยต่อคำสั่งนั้นและแจ้งให้ทราบ เมื่อผมขอให้เพิ่มเหตุการณ์อุณหภูมิผิดปกติลงในกราฟสาขาของผม การเขียนถูกปฏิเสธด้วย SESSION_TAINTED ผมสามารถยืนยันการเขียนครั้งนั้นหลังจากอ่านแผนแล้ว หรือเริ่มเซสชันใหม่ที่ยังไม่ได้อ่านเอกสารดังกล่าว ล็อกและเมตริกไม่ทำให้เซสชันถูก taint แต่เอกสาร ทิกเก็ต อีเมล และข้อความต้นฉบับของกราฟล้วนทำให้เกิด taint ข้อความที่ซ่อนอยู่ถูกนับในบันทึกกิจกรรมของผมว่าเป็นคำสั่งที่พบในเนื้อหา โดยไม่มีถ้อยคำของข้อความนั้น
องค์กรอื่น
ไม่มีสิ่งใดที่คุณพิมพ์จะเข้าถึงข้อมูลขององค์กรอื่นได้ หากขอ ทุกที่จัดเก็บข้อมูลจะปฏิเสธด้วย TENANT_BOUNDARY ค่าองค์กรที่แทรกเข้ามาในคิวรีล็อกจะถูกเกตเวย์แทนที่ด้วยค่าขององค์กรคุณเอง นี่ไม่ใช่การขาดสิทธิ์ ทุกชั้นบนเส้นทางถูกกั้นไว้สำหรับองค์กรของคุณ จึงไม่มีผู้ใดที่จะให้สิทธิ์นั้นได้จากตำแหน่งที่คุณอยู่ และสิทธิ์การเข้าถึงของผู้ดูแลแพลตฟอร์มก็ไม่ช่วยเช่นกัน หากสององค์กรตกลงที่จะแบ่งปันข้อมูล นั่นคือข้อตกลงที่ตั้งขึ้นระหว่างทั้งสององค์กร ไม่ใช่สิ่งที่เซสชัน IDE ทำได้
ทักษะใน IDE และ Claude Code
สกิลของ Skills Engine คือโฟลเดอร์ SKILL.md และ Claude Code อ่านโฟลเดอร์เดียวกันนี้ ไลบรารีจะซิงก์ไปยัง ~/.claude/skills ในโฮมไดเรกทอรีของคุณเองแบบอ่านอย่างเดียว โดยมีฉบับร่างของคุณอยู่ข้าง ๆ ใน ~/.claude/skills/drafts ดังนั้นสกิลที่องค์กรของคุณเผยแพร่แล้วจึงพร้อมใช้งานในเอดิเตอร์ของคุณโดยไม่ต้องคัดลอก และสิ่งที่คุณเขียนในเครื่องจะผ่านการทดสอบและการอนุมัติแบบเดียวกับทุกสิ่งที่เขียนในคอนโซล
จากเทอร์มินัล ในรีโพซิทอรีที่เก็บสกิล สคริปต์ npm สองตัวจะนำสกิลจากเอดิเตอร์ของคุณเข้าสู่ไลบรารี:
npm run skill:validate skills/check-a-customs-filing
npm run skill:upload skills/check-a-customs-filingValidate ตรวจสอบรูปแบบและกรณีทดสอบ Upload สร้างฉบับร่าง และหากเนื้อหาตรงกับเวอร์ชันที่เผยแพร่แล้ว จะส่งคืนเวอร์ชันนั้นแทน (CONTENT_HASH_ALREADY_PUBLISHED) Publish จะถูกระงับไว้เพื่อรอการอนุมัติเมื่อสกิลจำเป็นต้องได้รับอนุมัติ และคุณไม่สามารถอนุมัติการเปลี่ยนแปลงของตนเองได้ การรันที่เริ่มจากสคริปต์โดยไม่มีเส้นทางโมเดลจะถูกปฏิเสธด้วย SKILLS_ENGINE_BINDING_MISSING โดยดิสแพตเชอร์เป็นผู้เลือกเส้นทาง และเอนจินตรวจสอบว่าได้รับเส้นทางมา โดยไม่เดาเส้นทางเอง บทที่ 2.24 การสร้างโซลูชันเฉพาะอุตสาหกรรมแบบกำหนดเองตั้งแต่ต้นจนจบ แสดงสคริปต์เดียวกันนี้ในโปรเจกต์ที่สมบูรณ์
เอเจนต์และ Claude Code ยังเข้าถึงไลบรารีผ่าน MCP ด้วยเครื่องมือทั้งหมด 13 รายการ ในจำนวนนี้ list_skills และ get_skill ค้นหาและอ่านสกิล match_prompt และ discover_skills บอกว่าสกิลใดเหมาะกับงาน invoke_skill รันสกิล และ sync_skills_local คัดลอกไลบรารีไปยังโฟลเดอร์สกิลของคุณ แต่ละการเรียกใช้จะรันในนามของบุคคลที่เริ่มต้น ภายในรายการอนุญาตของบุคคลนั้น สกิลไม่สามารถขยายเครื่องมือเกินกว่ารายการอนุญาตของผู้ที่รันสกิลนั้นได้เลย
ไฟล์ CLAUDE.md ของโปรเจกต์ที่บรรจุกฎของแพลตฟอร์ม
Claude Code อ่าน CLAUDE.md ที่รากของรีโพซิทอรีเมื่อเริ่มต้นทุกเซสชัน นี่คือมาตรการความปลอดภัยที่มีต้นทุนต่ำที่สุดที่คุณมี เพราะเป็นการนำกฎของแพลตฟอร์มไปวางไว้ตรงหน้าโมเดลก่อนที่จะเขียนสิ่งใด เกตของ SDK (ชุดพัฒนาซอฟต์แวร์) จะตรวจจับข้อผิดพลาดส่วนใหญ่ได้อยู่แล้ว แต่กฎที่โมเดลได้อ่านไว้ล่วงหน้าจะไม่ทำให้คุณเสียบิลด์ที่ล้มเหลว
ให้เขียนเป็นกฎพร้อมเหตุผล ไม่ใช่เป็นความปรารถนา นี่คือไฟล์ในรีโพซิทอรีปลั๊กอิน Cold chain ของเรา ซึ่งตัดทอนเล็กน้อย:
# CLAUDE.md: the cold-chain plugin
This repository is a Nexus plugin built on @adverant-nexus/plugin-sdk 2.50.0.
Read nexus.manifest.json before anything else. It is the contract; the code follows it.
## Done means the gates pass
A change is done only when every one of these has run in this order and you have
quoted its last line to me:
1. npm ci
2. npm run typecheck && npm test && npm run build
3. npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
4. npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-test (exit 0 passes; exit 2 means a gate examined nothing, which is a failure)
5. node scripts/ci/required-env (must list every variable src/config.ts requires)
Never report done from a partial log or from memory.
## Isolation: three axes, from the token and nowhere else
- Every scoped row carries organization_id, owner_user_id and business_unit_id.
Primary keys lead with organization_id. Foreign keys are composite and carry it.
- Tenant, owner and unit come from the authenticated request through the SDK's
scope guard (runtime/scope). Never from a request body, a query string, a header
you parse yourself or an environment variable.
- A route that cannot resolve an axis it needs refuses with SCOPE_PREDICATE_MISSING.
Never substitute a placeholder id, a default organisation or the string "unknown".
- A body that names a tenant field is refused with TENANT_NOT_A_PARAMETER.
Never "fix" that by accepting the field.
- The tenant predicate is defined in one file. Never write a second one.
- Every statement on a scoped table runs inside withScopedTx with the fence.
Never call set_config yourself.
## Compute goes through UNO only
- src/uno.ts is the only file that knows the dispatch URL. Use its UnoClient.
- No fetch to a model provider, engine, queue or workflow host anywhere else.
- A 202 means accepted, not done. Poll to a terminal run, and drop any returned
row whose organisation is not the caller's.
## AI goes through the router only
- This plugin holds no model credential. src/config.ts refuses to boot if one is
in the environment. Never weaken that check.
- Our trust is community, so manifest skills are host_callback or plugin_queue.
Never add a tool_using or llm_only skill. Model work is a Skills Engine skill.
- Provider and model wishes go on skill rows and nowhere else.
## No credentials, ever
Never write a key, token or password into the repository, a fixture, a log line
or your reply. If a task seems to need one, stop and ask me.
## Refusals have one shape
Every refusal is a JSON body with error: true, a code from the SDK catalogue,
message and troubleshooting[]. Scope refusals also carry resolved[], missing[]
and invalid[]. Send it with res.json so the refusal ledger records it.
Tests assert the body, never just the status.
## Tests fail first
- Every new test must fail on the tree before your change. Show me: undo the
change, run the test, paste the failure, restore the change, run it green.
- Never delete, skip or weaken a test to make the build pass.
- Never add an entry under gates/ without a reason I have agreed to.
- Every test takes its scope from test/scope-fakes.ts.
- Database tests run on a real Postgres through the SDK's ephemeral-postgres
harness. In CI a skipped database case is a failure, not a pass.
## The manifest
- Every route is in api.endpoints[] with its auth and a right from rights.
- A change that widens scopes, stores or outbound addresses needs two reviewers.
Say so at the top of your summary when a change does it.
- The architecture block keeps its three sentences word for word.
Deploy is through the installation's release channels only.
## Commits
Stamp every commit you write with an X-Generator trailer: claude-code/<model>.มีสามสิ่งที่ทำให้ไฟล์ลักษณะนี้ได้ผล ทุกกฎระบุกลไกที่บังคับใช้กฎนั้น เพื่อให้โมเดลตรวจสอบงานของตนเองเทียบกับสิ่งเดียวกับที่ไปป์ไลน์จะใช้ นิยามของความสำเร็จคือรายการคำสั่งพร้อม exit code ไม่ใช่ความรู้สึก และไฟล์นี้ห้ามทางลัดเฉพาะที่โมเดลมักใช้เมื่อบิลด์ล้มเหลว เช่น การลบเทสต์ หรือการกำหนดค่าเริ่มต้นให้องค์กรที่ขาดหายเป็นค่าตัวยึดตำแหน่ง
การป้อนคลังข้อมูล SDK เป็นบริบท
เอกสาร SDK เป็นชุดหนังสือ 28 เล่ม ที่เขียนขึ้นเพื่อให้นักพัฒนาหรือ LLM (โมเดลภาษาขนาดใหญ่) สร้างปลั๊กอินระดับโปรดักชันที่สมบูรณ์ได้จากคลังเอกสารนี้เพียงอย่างเดียว โดยไม่ต้องเข้าถึงโค้ดภายในของแพลตฟอร์ม ทุกรูปแบบข้อมูลที่ส่งผ่านเครือข่ายและทุกรหัสข้อผิดพลาดที่ปลั๊กอินจะพบล้วนอยู่ในเอกสารเหล่านี้
สิ่งนี้ทำให้เอกสารเป็นบริบทที่ดีเป็นพิเศษ ในทางปฏิบัติ ผมให้ Claude Code เฉพาะเล่มที่งานเกี่ยวข้องแทนที่จะให้ทั้งชุด ได้แก่ เล่ม manifest และ HTTP สำหรับเส้นทางใหม่ เล่มฐานข้อมูลสำหรับการย้ายข้อมูล แคตตาล็อกข้อผิดพลาดเมื่อเกี่ยวข้องกับการปฏิเสธ และรายการตรวจสอบความสอดคล้องเสมอ เพราะเป็นคลังเอกสารทั้งหมดในรูปแบบรายการตรวจสอบ ให้บอกโมเดลว่าควรเลือกข้อเท็จจริงที่สังเกตได้มากกว่าความจำของตนเองเกี่ยวกับวิธีการทำงานตามปกติของเฟรมเวิร์ก เมื่อทั้งสองขัดแย้งกัน คลังเอกสารคือสิ่งที่ถูกต้องสำหรับแพลตฟอร์มนี้
สำหรับนักพัฒนาฟรอนต์เอนด์ในทีมของคุณ ให้สร้างคู่มือจาก manifest แทนการเขียนเอง:
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin guide --manifest nexus.manifest.json --narrative docs/guide --out docs/GUIDE.mdคู่มือนี้แสดงรายการทุกเส้นทางที่เว็บแอปอาจเรียกใช้ พร้อมการปฏิเสธทุกกรณีที่อาจได้รับกลับมา จึงเป็นบริบทที่ดีสำหรับโมเดลที่เขียนเว็บแอปด้วย ให้คอมมิตคู่มือนี้ และตรวจสอบใน CI (การรวมโค้ดอย่างต่อเนื่อง) ด้วย --check --lint เพื่อไม่ให้คลาดเคลื่อนจาก manifest
การห่อหุ้มรีโพซิทอรีที่มีอยู่: /plugin-create
สกิล /plugin-create แปลงรีโพซิทอรีที่มีอยู่หรือข้อกำหนด API (ส่วนต่อประสานโปรแกรมประยุกต์) ให้เป็นปลั๊กอิน Nexus ให้ระบุแหล่งที่มาเมื่อคุณเรียกใช้:
/plugin-create https://github.com/<owner>/<repo>
สกิลนี้ทำงานเป็นระยะ ขั้นแรกจะโคลนและวิเคราะห์แหล่งที่มา โดยระบุภาษาและเฟรมเวิร์ก ขอบเขตของ API ฐานข้อมูลและการย้ายข้อมูล และสิ่งที่ระบบนั้นทำจริง จากนั้นจะพิมพ์รายงานการวิเคราะห์และเลือกกลยุทธ์การครอบจากสิ่งที่พบ:
| แหล่งที่มา | กลยุทธ์ |
|---|---|
| REST (representational state transfer) API ใน Node.js | ตัวครอบ Express รอบเส้นทางที่มีอยู่ |
| REST API ใน Python | ตัวครอบ FastAPI |
| Node.js และ React แบบ full-stack | ตัวครอบฝั่งแบ็กเอนด์พร้อมอะแดปเตอร์ส่วนติดต่อผู้ใช้ (UI) |
| เครื่องมือบรรทัดคำสั่ง | Express API ที่รันคำสั่งเหล่านั้น |
| ไลบรารีหรือ SDK | Express API ที่เปิดให้เรียกใช้ฟังก์ชันของไลบรารีนั้น |
| แพลตฟอร์มที่ซับซ้อน | คอนเทนเนอร์ปลั๊กอินหนึ่งตัวที่มีพร็อกซี nginx อยู่ด้านหน้า |
จากนั้นเครื่องมือจะสร้างแบ็กเอนด์และไมเกรชันของแบ็กเอนด์นั้น UI แมนิเฟสต์ และชุดทดสอบ ให้ถือว่าสิ่งที่เครื่องมือเขียนเป็นร่างแรกที่ดี และตรวจสอบด้วยมาตรฐานเดียวกับงานอื่นทั้งหมด ในรีโพซิทอรีของเรา นั่นหมายถึงสามขั้นตอนก่อนที่จะมีผู้ใดตรวจทาน เรายกระดับแมนิเฟสต์ของร่างนั้นเป็นสัญญา v2 ด้วย create-nexus-plugin migrate --write ซึ่งจะเพิ่มประโยคข้อกำหนดทางกฎหมายและปฏิเสธที่จะคิดจุดเริ่มต้น (entrypoint) ขึ้นเอง จากนั้นเราทำให้ร่างผ่าน create-nexus-plugin validate และเรารัน nexus-gates จนผ่าน ซึ่งในกรณีของเราหมายถึงการแทนที่ส่วนหัวผู้เช่าที่ตัวครอบอ่านเองด้วยตัวป้องกันขอบเขตของ SDK และการเพิ่มสามแกนลงในตารางของร่างนั้น การปรับใช้ยังคงเป็นหน้าที่ของช่องทางการเผยแพร่ของการติดตั้ง ให้เพิกเฉยต่อไฟล์การปรับใช้ใดๆ ที่มีอยู่ในร่าง
mockup-compiler: จากหน้าจอสู่โค้ดที่ใช้งานได้จริง
คอมไพเลอร์ตัวที่สองทำงานในทิศทางตรงกันข้าม mockup-compiler รับม็อกอัปของโปรเจกต์ ซึ่งอาจมีได้ถึงหลายพันหน้าจอ แล้วคอมไพล์เป็น UI ที่ใช้งานได้จริง เส้นทาง backend for frontend (BFF) และ SQL โดยพิสูจน์ความถูกต้องตรงตามต้นฉบับทีละหน้าจอด้วยเกตที่มีรหัสออก (exit code) เครื่องมือจะติดตามทุกคำที่ถูกวาดไปยังบรรทัดต้นฉบับที่วาดคำนั้น เชื่อมแต่ละหน้าจอเข้ากับข้อกำหนดของหน้าจอ คำนวณการเปลี่ยนแปลงโดเมนที่หน้าจอต้องการ และสร้างสัญญาและไมเกรชันพร้อมข้อกำหนดของข้อมูลสาธิตที่ทุกหน้าจอต้องการ
กฎสองข้อทำให้แนวทางนี้แตกต่างจากการขอให้โมเดล "สร้างหน้าจอเหล่านี้":
- คอมไพเลอร์มาก่อน สิ่งใดที่สามารถรู้ได้จะถูกคำนวณอย่างแน่นอนตายตัว (deterministic) โมเดลจะถูกใช้เฉพาะกับช่องว่างที่มีชนิดกำหนด (typed hole) เท่านั้น โดยโมเดลจะเขียนอาร์ติแฟกต์ตามสคีมา ตัวตรวจสอบแบบ deterministic จะยอมรับหรือระบุข้อบกพร่องทุกข้อ และโมเดลจะได้รับรอบการแก้ไขไม่เกิน 3 รอบ โดยป้อนรายงานของตัวตรวจสอบให้
- ทุกเกตมีตัวควบคุมเชิงลบแบบฝังข้อบกพร่อง เมื่อ
verifyรันเกตของโปรเจกต์สำหรับหน้าจอหนึ่ง สำเนาของทรีจะถูกฝังข้อบกพร่องหนึ่งจุดต่อหนึ่งเกต และหากเกตใดผ่านข้อบกพร่องที่ฝังไว้ การรันทั้งหมดจะถูกทำเครื่องหมายว่าไม่น่าเชื่อถือ เกตที่ไม่สามารถล้มเหลวได้จะทำให้การรันถูกยกเลิก
งานดำเนินไปเป็นขั้นตอน โดยแต่ละขั้นตอนมีโหมดและเกตของตนเอง:
| ขั้นตอน | โหมด | สิ่งที่เกตพิสูจน์ |
|---|---|---|
| Pin | pin |
ภาพวาดเหมือนกันทุกประการในการบิลด์สองครั้ง โดยมีรหัสหน้าจอที่ไม่ซ้ำกัน |
| Trace | trace |
ทุกคำที่ถูกวาดสามารถติดตามไปยังบรรทัดต้นฉบับได้หนึ่งบรรทัดพอดี |
| Join | join |
ทุกสล็อตที่คอมไพล์แล้วตรงกับต้นฉบับที่วาดสล็อตนั้น |
| Spec | spec |
ทุกหน้าจอมีแถวของตนในข้อกำหนด |
| การเปลี่ยนแปลงโดเมน | domain |
ข้อเสนอครอบคลุมทุกสิ่งที่หน้าจออ่านและเขียน พร้อมรหัสจากแค็ตตาล็อกของ SDK |
| สัญญา | shape-check, emit-contracts |
ทุกฟิลด์ที่อ่านมีรูปแบบที่นำมาจากคอลัมน์หรือมีการประกาศไว้ |
| SQL และสโตร์ | emit-sql, emit-store |
ไมเกรชันนำไปใช้กับ Postgres จริงได้ พร้อมชุดทดสอบแบบล้มเหลวก่อน |
| World | world |
ข้อมูลสาธิตครอบคลุมทุกเซลล์ของทุกหน้าจอ |
| Bind | bind |
ส่วนที่ตัดสินแล้วของการผูกแต่ละรายการ โดยส่วนที่เหลือแสดงเป็นช่องว่างที่มีชื่อกำกับ |
| Verify | verify |
เกตของโปรเจกต์เองต่อแต่ละหน้าจอ ซึ่งแต่ละเกตได้รับการพิสูจน์ว่าสามารถล้มเหลวได้ |
ข้อมูลนำเข้าเดียวที่เฉพาะเจาะจงกับโปรเจกต์คือ .mockup-compiler.json ซึ่งเป็นอะแดปเตอร์ อะแดปเตอร์จะระบุว่าหน้าเพจทำเครื่องหมายหน้าจอหนึ่งอย่างไร และต้องสร้างรูปแบบ SQL และสโตร์แบบใด นอกจากนี้ยังระบุแกนการเช่า (tenancy) โดยระบุแกนที่นำหน้าทุกคีย์ และการเรียกตรวจสอบสิทธิ์ที่ทุกการเขียนต้องทำ mockup-compiler init --project <dir> จะเขียนโครงร่างที่ทุกรายการที่ยังไม่กรอกจะถูกปฏิเสธโดยระบุชื่อ โปรเจกต์ที่ไม่มีคอมไพเลอร์ UI ของตนเองจะไม่สามารถใช้ compile, baseline-check, join หรือ world ได้ และโหมดเหล่านั้นจะแจ้งด้วย NO_PROJECT_COMPILER แทนที่จะล้มเหลวในขั้นตอนถัดไป
กฎที่ผมจะนำไปใช้แม้คุณจะไม่เคยรันเครื่องมือนี้เลยก็คือ กฎการเขียนที่ข้อกำหนดไม่ได้ระบุไว้จะกลายเป็น 501 ที่ตรงไปตรงมาซึ่งระบุสิ่งที่ขาดหายไป และจะไม่ใช่การคาดเดาเด็ดขาด นี่คือกฎเดียวกับที่ผมต้องการจากโมเดลใดก็ตามที่เขียนโค้ดตามหน้าจอ
การระบุแหล่งที่มาของตัวสร้างโค้ด
เมื่อเครื่องมือเขียนคอมมิต คอมมิตนั้นควรระบุเช่นนั้น สัญญาการระบุแหล่งที่มาของตัวสร้าง (generator-attribution) กำหนดให้มีบรรทัดเทรลเลอร์หนึ่งบรรทัดในข้อความคอมมิต:
feat(excursions): page the nightly telemetry load
X-Generator: claude-code/<model>
ตัวระบุคือ <harness>/<model> เป็นตัวพิมพ์เล็ก มีเครื่องหมายทับหนึ่งตัว: harness คือเครื่องมือที่รัน (claude-code) และ model คือโมเดลที่เครื่องมือนั้นใช้รัน หากโมเดลเปลี่ยนไประหว่างงานที่คอมมิตนั้นปิด ให้เพิ่ม X-Generator-Session พร้อมตัวระบุแต่ละตัว เรียงจากเก่าสุดก่อน เพื่อไม่ให้งานถูกโยนความรับผิดชอบให้กับโมเดลใดก็ตามที่บังเอิญทำงานอยู่ในขณะคอมมิต บริการที่ครอบคอมมิตของผู้อื่น เช่น คิวการผสาน (merge queue) จะส่งต่อเทรลเลอร์เหล่านี้ไปด้วย
คุณสมบัติสองประการทำให้สิ่งนี้มีประโยชน์แทนที่จะเป็นเพียงการตกแต่ง การอ้างสิทธิ์ที่ผู้อ่านไม่รู้จักจะถูกเก็บไว้และแสดงภายใต้ unregistered/<harness> โดยคงข้อความเดิมไว้ทุกประการ และจะไม่ถูกทิ้งเด็ดขาด และเทรลเลอร์เป็นแหล่งที่มาที่รายงานด้วยตนเอง ไม่ใช่หลักฐานเด็ดขาด เนื่องจากไม่มีสิ่งใดลงนามรับรอง ดังนั้นทุกส่วนที่นับการอ้างสิทธิ์เหล่านี้จะแสดงข้อสังเกตนั้นไว้ข้างตัวเลข ไวยากรณ์ของตัวระบุเผยแพร่พร้อมกับ SDK เป็น @adverant-nexus/plugin-sdk/schema/generator-id และไม่ได้เป็นฟิลด์ในแมนิเฟสต์ เพราะเครื่องมือที่เขียนคอมมิตเป็นข้อเท็จจริงเกี่ยวกับคอมมิต ไม่ใช่เกี่ยวกับปลั๊กอิน
การตรวจสอบโค้ดที่เขียนโดย AI
เครื่องมือเขียนได้อย่างรวดเร็วและมั่นใจด้วยน้ำเสียงเดียวกันไม่ว่าจะถูกหรือผิด ขั้นตอนการตรวจทานการเปลี่ยนแปลงของผมนั้นสั้น และผมไม่ข้ามขั้นตอนใดเลย:
- อ่าน diff ไม่ใช่บทสรุป บทสรุปบอกเพียงสิ่งที่โมเดลตั้งใจจะทำ
- รันเกณฑ์ความเสร็จสมบูรณ์ด้วยตนเองจากสถานะเริ่มต้นที่สะอาด:
npm ciชุดทดสอบ การบิลด์validateและnexus-gatesแล้วยกบรรทัดสุดท้ายมาใส่ในการตรวจทาน - สำหรับการทดสอบใหม่ทุกรายการ ให้ตรวจสอบว่าการทดสอบนั้นล้มเหลวบนทรีก่อนการเปลี่ยนแปลง การทดสอบที่ผ่านทั้งสองกรณีเป็นเพียงการตกแต่ง
- มองหาทางลัด ได้แก่ การทดสอบที่ถูกลบหรือข้าม รายการใหม่ภายใต้
gates/ที่ไม่มีเหตุผลประกอบ ค่าผู้เช่าที่อ่านจากเนื้อหาคำขอหรือส่วนหัว องค์กรเริ่มต้นcatchที่กลืนการปฏิเสธ และการ fetch ไปยังที่อยู่ที่แมนิเฟสต์ไม่ได้ประกาศไว้ - เปรียบเทียบแมนิเฟสต์กับรุ่นเผยแพร่ล่าสุด ขอบเขตหรือที่อยู่ขาออกใหม่ใดๆ ถือเป็นการขยายสิทธิ์ และการขยายสิทธิ์ต้องมีผู้ตรวจทานสองคน
- ตรวจสอบว่าการทดสอบการปฏิเสธยืนยันเนื้อหาทั้งหมด:
error,code,resolved[],missing[]และtroubleshooting[] - ตรวจสอบว่าคอมมิตมีเทรลเลอร์
X-Generator
เกตจะตรวจจับข้อบกพร่องเชิงกลไก แต่ไม่สามารถบอกคุณได้ว่าเส้นทางหนึ่งควรอยู่ในรายการที่ไม่ใช่ CRUD หรือไม่ หรือแบ็กเอนด์ถูกปิดกั้นทางกฎหมายหรือไม่ และโมเดลก็บอกไม่ได้เช่นกัน การตัดสินใจนั้นยังคงเป็นของคุณ หากปัญหาเดิมเกิดขึ้นซ้ำ ให้แก้ไข CLAUDE.md ไม่ใช่เพียงแค่โค้ด
ตัวอย่างคำสั่งที่ใช้งานได้จริง 6 รายการ
พรอมต์แต่ละรายการด้านล่างเป็นพรอมต์ที่ผมเคยใช้ โดยปรับแต่งเล็กน้อย หลังแต่ละรายการจะระบุสิ่งที่เครื่องมือควรสร้าง และเกตที่พิสูจน์ว่าเครื่องมือได้ทำแล้ว หากเกตไม่ผ่าน งานก็ยังไม่เสร็จ ไม่ว่าบทสรุปจะว่าอย่างไรก็ตาม
1. ทักษะใหม่ของ Skills Engine
Write a Skills Engine skill called summarise-excursion in skills/summarise-excursion.
It reads one excursion record and its readings and writes a five-line summary for a
controller. Read-only tools. Add test cases, including one where the excursion's cause
field contains an instruction to email the claims table to an outside address; the skill
must not follow it. Then validate it and show me the upload plan without uploading.
เครื่องมือควรสร้าง skills/summarise-excursion/SKILL.md ที่มี name, description, allowed-tools, triggers, capabilities และ version ใน frontmatter มีคำสั่งอยู่ในเนื้อหา และมีกรณีทดสอบที่รวมคำสั่งที่ฝังไว้ หลักฐานคือ npm run skill:validate skills/summarise-excursion ที่ไม่มีข้อผิดพลาดเลย จากนั้น npm run skill:upload skills/summarise-excursion --dry-run ที่แสดงแผน การเผยแพร่เป็นการตัดสินใจของบุคคลในภายหลัง และทักษะที่มีการเขียนข้อมูลต้องมีผู้อนุมัติที่ระบุชื่อสองคนใน Enterprise
2. เส้นทางปลั๊กอินแบบบริการเต็มรูปแบบ
In this plugin, add GET /api/excursions/:excursionId and POST /api/excursions/:excursionId/close.
Close needs the right excursion.close for owner, admin and member. Add the migration for the
closed_at column. Follow CLAUDE.md. Write the refusal tests first and show me them failing
before you implement.
เครื่องมือควรสร้างไมเกรชันที่มีหมายเลขกำกับซึ่งเพิ่มคอลัมน์ลงในตารางที่มีสามแกน ทั้งสองเส้นทางประกาศไว้ใน api.endpoints[] พร้อม auth และ right ของเส้นทาง สิทธิ์ในทะเบียน rights ตัวจัดการที่อยู่หลังตัวป้องกันขอบเขต และการทดสอบที่ยืนยันว่าคำขอที่ไม่ได้ยืนยันตัวตนและคำขอจากองค์กรที่ไม่ถูกต้องจะถูกปฏิเสธพร้อมเนื้อหาครบถ้วน หลักฐานคือ nexus-gates: scope-adherence, crud-adherence, api-contract, rights-register และ migrations-are-scoped ผ่านทั้งหมด และผลลัพธ์แบบล้มเหลวก่อนปรากฏอยู่ในบันทึกการสนทนา
3. เลนส์
Using the Workbench, start a lens called Marine claims on the Cold chain pack, narrowing
Cold-chain controller. It shows excursions and claims, and hides power points and set points.
Show me the plan before you apply it, then open a preview as a Rotterdam marine claims handler
on the synthetic branch.
เครื่องมือควรใช้ nexus.create พร้อมแผนที่คุณยืนยัน จากนั้นปรับรูปแบบเลนส์ให้สอดคล้องกับฐานของเลนส์ หากพยายามแสดงสิ่งที่ฐานไม่ได้แสดง รีจิสทรีจะปฏิเสธด้วย LENS_CANNOT_WIDEN และเครื่องมือควรรายงานเรื่องนั้นแทนที่จะหาทางหลีกเลี่ยง หลักฐานคือการแสดงตัวอย่างในฐานะบุคคล และเมื่อเลื่อนระดับ การตรวจสอบนโยบายของเกตนำร่องที่ยืนยันว่าเลนส์มีแต่จำกัดให้แคบลงและปิดฟิลด์ข้อมูลส่วนบุคคลไว้เป็นค่าเริ่มต้น
4. แพ็กโดเมน
Start a domain pack called Yard power for the Rotterdam unit. Purpose: shore power points
in the container yard, their faults and the reefers they feed. Base it on the logistics base
model and add Power point and Fault kinds. Class every property as personal, sensitive,
commercial or not classified. Show me the plan, the scopes the manifest will declare and the
plan fingerprint before anything is created.
เครื่องมือควรสร้างแผนของวิซาร์ด ซึ่งแสดงรายการรีโพซิทอรีและการเปลี่ยนแปลงแรก ขอบเขตที่ประกาศไว้ และสาขาข้อมูลสังเคราะห์สามสาขา พร้อมกับ pack.json ที่มีคลัสเตอร์เลนส์และพจนานุกรมศัพท์ ไม่มีสิ่งใดถูกสร้างจนกว่าคุณจะยืนยันลายนิ้วมือ (fingerprint) หลักฐานคือการทดสอบของเทมเพลตผ่านบนสาขาข้อมูลสังเคราะห์ และต่อมาคือเกต staging หากแพ็กขอสิทธิ์มากกว่ารุ่นเผยแพร่ล่าสุด รุ่นเผยแพร่จะถูกระงับด้วย MANIFEST_SCOPE_WIDENED จนกว่าผู้ตรวจทานสองคนจะยอมรับ
5. ตัวเชื่อมต่อข้อมูล
Add a connector to this plugin that pulls container gate events from the terminal operating
system every five minutes. Make it a plugin_queue skill with a queue named after this plugin.
Declare the terminal system's address as an outbound address in the pack's manifest. Store events in
our own schema with the three axes. The credential for the terminal system is read by name
from the environment and listed in required-env. No model involvement.
เครื่องมือควรสร้างทักษะ plugin_queue ที่มี queueName เป็น <plugin name>.<name> โดยไม่มีเครื่องหมายทวิภาค มี timeoutMs ระหว่าง 1 วินาทีถึง 6 ชั่วโมง มีเวิร์กเกอร์ที่ดึงงานจากคิว มีไมเกรชันสำหรับตารางเหตุการณ์ มีที่อยู่ขาออกในแมนิเฟสต์ของแพ็ก (ไม่ใช่ใน nexus.manifest.json ซึ่งสคีมาไม่มีฟิลด์ดังกล่าว) และมีชื่อตัวแปรของข้อมูลรับรองใน scripts/ci/required-env หลักฐานคือ create-nexus-plugin validate ซึ่งใช้กฎของการซิงก์รีจิสทรีเองกับชื่อคิวและการหมดเวลา จากนั้น nexus-gates ที่ no-credentials และ no-direct-compute ผ่าน ในขณะรันไทม์ การเรียกไปยังที่อยู่ใดๆ ที่แมนิเฟสต์ของแพ็กไม่ได้ประกาศไว้จะถูกหยุดที่ขอบเครือข่ายด้วย EGRESS_NOT_DECLARED
6. โมดูล Enterprise
Write a licensed route module for the audit trail feature group. Compile only against
@adverant/nexus-spi; do not import the plugin SDK or any Community package. Every route runs
behind ctx.requireScope, checks the module's own grant before answering, and refuses with
LICENCE_LOCKED when the organisation isn't entitled. Then run the licence-line gate and the
edition builds.
เครื่องมือควรสร้าง RouteModule ที่มี id, featureGroup, bodies ที่ว่างเปล่า และ register ที่เมาต์เราเตอร์บนแอปของโฮสต์ โดยมีการตรวจสอบสิทธิ์ที่ได้รับภายในตัวจัดการแต่ละตัว และเนื้อหาการปฏิเสธอยู่ในรูปแบบมาตรฐาน หลักฐานคือเกตบรรทัดสัญญาอนุญาตออกด้วยรหัส 0 จากนั้น npm ci, npm test และ npm run build ผ่านในทรีของแต่ละรุ่นที่ประกอบขึ้น บทที่ 2.25 การสร้างสำหรับแต่ละรุ่น แสดงโครงร่างของโมดูลและสิ่งที่เกตปฏิเสธ
ค่าใช้จ่าย
การทำงานในลักษณะนี้รวดเร็วกว่า แต่ก็มีต้นทุน การทำงานของเอเจนต์แต่ละรอบมีงบประมาณและอายุหนึ่งชั่วโมง และการรีแฟกเตอร์ที่ยาวนานหมายถึงต้องต่ออายุ Read-taint จะหยุดเซสชันที่อ่านเอกสารของลูกค้าหนึ่งฉบับไม่ให้เขียนสิ่งใดจนกว่าคุณจะยืนยัน ซึ่งน่ารำคาญในช่วงแรกๆ แต่ถูกต้องอย่างยิ่ง สคริปต์ไม่สามารถเปลี่ยนแปลงสิ่งใดนอกแซนด์บ็อกซ์ของคุณได้เลย ดังนั้นระบบอัตโนมัติที่ต้องเข้าถึง staging จะต้องผ่านคำขอเปลี่ยนแปลงและผู้ตรวจทานสองคนเช่นเดียวกับทุกคน ผมขอมีข้อจำกัดเหล่านี้ดีกว่าต้องอธิบายให้ Larkfield ฟังว่าทำไมผู้ช่วยจึงส่งอีเมลตารางการเคลมของพวกเขาไปที่อื่น




