រង្វិលជុំ Inference៖ ហេតុអ្វីការសរសេរកូដកំពុងក្លាយជារង្វិលជុំ មិនមែនជាការគោះគ្រាប់ចុច

អស់រយៈពេលសាមសិបឆ្នាំ ការសរសេរសូហ្វវែរមានន័យថាការបង្កើតការគោះគ្រាប់ចុច។ អ្នកកាន់គំរូនៃកម្មវិធីនៅក្នុងគំនិតរបស់អ្នក ហើយបកប្រែវាជាអក្សរម្ដងមួយៗទៅក្នុងឯកសារ។ Autocomplete ធ្វើឱ្យការគោះគ្រាប់ចុចលឿនជាងមុន។ Copilot ធ្វើឱ្យវាឆ្លាតជាងមុន។ ប៉ុន្តែឯកតានៃការងារមិនដែលផ្លាស់ប្ដូរទេ៖ មនុស្សវាយកូដ ហើយម៉ាស៊ីនដំណើរការវា។

ឥឡូវនេះ ឯកតានោះកំពុងផ្លាស់ប្ដូរ។ បុព្វបទសូហ្វវែរសំខាន់បំផុតនៃទសវត្សរ៍នេះមិនមែនជាការគោះគ្រាប់ចុចទេ — វាជារង្វិលជុំ។ ហៅម៉ូដែល ឱ្យវាដំណើរការឧបករណ៍ បញ្ជូនលទ្ធផលត្រឡប់មកវិញ ហើយធ្វើម្ដងទៀតរហូតដល់ការងារបានសម្រេច។ វាសមនៅក្នុងប្រហែលដប់បន្ទាត់នៃកូដ ហើយវាកំពុងលេបយកការអភិវឌ្ឍសូហ្វវែរយ៉ាងស្ងាត់ៗ។ យើងបានដាក់ឈ្មោះក្រុមហ៊ុនរបស់យើងតាមវា៖ រង្វិលជុំ inference (the inference loop)។

អត្ថបទនេះនិយាយអំពីអ្វីដែលរង្វិលជុំនោះពិតជា ហេតុអ្វីបានជាវាល្អជាង prompt តែម្ដងដែលបានកំណត់រលកដំបូងនៃ AI coding កន្លែងណាដែលវានៅតែដួលរលំ និងទិសដៅដែលវាកំពុងឆ្ពោះទៅ។ ប្រសិនបើអ្នកដឹកនាំក្រុមវិស្វកម្ម ហើយអ្នកព្យាយាមបំបែកសញ្ញាចេញពីភាពអ៊ូអរ ចាប់ផ្ដើមនៅទីនេះ។

តើរង្វិលជុំសរសេរកូដ agentic ពិតជាអ្វី

ដកយីហោចេញ នោះ AI coding agent គឺសាមញ្ញគួរឱ្យអាម៉ាស់។ ដូចដែល Simon Willison បាននិយាយនៅក្នុងមគ្គុទេសក៍របស់គាត់អំពីរបៀបដែល coding agent ដំណើរការ LLM agent គឺជា “អ្វីមួយដែលដំណើរការឧបករណ៍នៅក្នុងរង្វិលជុំ ដើម្បីសម្រេចគោលដៅ”។ ឧបករណ៍ គឺគ្រាន់តែជាមុខងារដែលកម្មវិធីព័ទ្ធជុំវិញ — harness — បង្ហាញដល់ម៉ូដែល៖ អានឯកសារ ដំណើរការ command ស្វែងរកក្នុង codebase ប្រតិបត្តិ test។ ម៉ូដែលសម្រេចចិត្តថាត្រូវហៅឧបករណ៍ណា ហើយ harness ដំណើរការវា ហើយបញ្ជូនលទ្ធផលត្រឡប់មកវិញ។

នោះជាល្បិចទាំងមូល។ រង្វិលជុំមើលទៅដូចនេះ៖

1. ផ្ដល់គោលដៅ និងសំណុំឧបករណ៍ដល់ម៉ូដែល។
2. ម៉ូដែលឆ្លើយតបដោយផ្ដល់ចម្លើយ ឬសំណើដើម្បីហៅឧបករណ៍មួយ។
3. Harness ដំណើរការឧបករណ៍ ហើយបញ្ជូនលទ្ធផលត្រឡប់ទៅម៉ូដែលវិញ។
4. ត្រឡប់ទៅជំហានទី ២ រហូតដល់គោលដៅសម្រេច។

Thorsten Ball បានបង្ហាញយ៉ាងល្បីថា អ្នកអាចបង្កើត coding agent ដែលដំណើរការបាននៅក្នុងកូដប៉ុន្មានរយបន្ទាត់ — គ្មាន framework គ្មាន orchestration engine គ្មាន vector database ទេ។ Agent ដូចសម្ដីដែលគេនិយាយ គឺគ្រាន់តែជា “LLM ដែលមានឧបករណ៍ត្រឹមត្រូវនៅក្នុងរង្វិលជុំសន្ទនា”។ មូលហេតុដែលរឿងនេះសំខាន់ គឺវាបំបាត់អាថ៌កំបាំងនៃប្រភេទទាំងមូលនេះ។ វេទមន្តមិនមែនជាស្ថាបត្យកម្មសម្ងាត់ទេ។ វេទមន្តគឺថា ម៉ូដែលដ៏មានសមត្ថភាព ពេលដែលផ្ដល់ឱ្យនូវសមត្ថភាព ធ្វើសកម្មភាព ហើយបន្ទាប់មក សង្កេតមើលផលវិបាកនៃសកម្មភាពរបស់វា អាចដោះស្រាយបញ្ហាដែលវាមិនអាចដោះស្រាយបាននៅក្នុងជំហានតែមួយ។

Willison បន្ថែមទៀតនៅក្នុងការរចនារង្វិលជុំ agentic (Designing agentic loops) ដោយអះអាងថា ជំនាញពិតប្រាកដនៃប៉ុន្មានឆ្នាំខាងមុខ គឺការរចនារង្វិលជុំខ្លួនវាផ្ទាល់៖ ឧបករណ៍ណាដែលត្រូវបង្ហាញ ត្រូវផ្ដល់ស្វ័យភាពប៉ុន្មាន និងរបៀបដំណើរការរង្វិលជុំដោយសុវត្ថិភាព — សូម្បីតែនៅក្នុងអ្វីដែលគាត់ហៅលេងសើចថា “YOLO mode” ដែល agent ប្រតិបត្តិ command ដោយមិនសុំការអនុញ្ញាតនៅជំហានម្ដងៗ។ រង្វិលជុំគឺជាគំរូកម្មវិធីថ្មី។ ការរចនាវាឱ្យបានល្អគឺជាសិល្បៈថ្មី។

ទេសភាពឧបករណ៍ឆ្នាំ ២០២៥–២០២៦

រង្វិលជុំគឺជាបុព្វបទ ផលិតផលគឺជា harness ដែលសាងសង់ព័ទ្ធជុំវិញវា។ ត្រឹមឆ្នាំ ២០២៦ ទេសភាពនេះបានរៀបចំខ្លួនវាជារូបរាងច្បាស់លាស់មួយចំនួន។

Claude Code គឺ agent-first។ វារស់នៅក្នុង terminal មាន access ផ្ទាល់ទៅ filesystem និង git របស់អ្នក ហើយសន្មតថា AI ដឹកនាំខណៈអ្នកអភិវឌ្ឍពិនិត្យឡើងវិញ។ អ្នកផ្ដល់ភារកិច្ចមួយ វាអានឯកសារ កែប្រែវា ដំណើរការ test អានកំហុស ហើយព្យាយាមម្ដងទៀត — ធ្វើរង្វិលជុំរហូតដល់វាសម្រេច ឬជាប់គាំង។ ការងាររបស់មនុស្សផ្លាស់ប្ដូរពីអ្នកនិពន្ធទៅជាអ្នកពិនិត្យ។

Cursor បានយកចំណុចចូលផ្ទុយគ្នា៖ បង្កប់ agent នៅក្នុង IDE ជាដៃគូដែលធ្វើការនៅជាមួយអ្នកនៅក្នុង editor ដែលអ្នកប្រើរួចហើយ។ ទោះជាយ៉ាងណា ទស្សនវិជ្ជាទាំងពីរបានបញ្ចូលគ្នា — Cursor បានចេញCLI ជាមួយ agent modes នៅខែមករា ឆ្នាំ ២០២៦ ដែលនាំវាខិតទៅជិតគំរូ terminal-native, agent-driven។ Codex, Aider, និង Cline បំពេញវាលនេះ ដោយម្នាក់ៗភ្នាល់ខុសគ្នាបន្តិចបន្តួចអំពីកន្លែងដែលមនុស្សអង្គុយធៀបនឹងរង្វិលជុំ។

ការបញ្ចូលគ្នាគឺជារឿង។ ដូចដែលមគ្គុទេសក៍ឆ្នាំ ២០២៦ របស់ Sourcegraph អំពីការសរសេរកូដ agentic កត់ត្រា ព្រំដែនមិនមែនជា “តើ agent អាចកែឯកសារបានទេ” ទៀតទេ — វាជាការដំណើរការរង្វិលជុំទាំងនេះធៀបនឹង codebase ពិតប្រាកដ ធំៗ ដោយ agent ឈោងទៅ code search ការផ្ទេរទៅ cloud និងភារកិច្ចផ្ទៃខាងក្រោយដែលដំណើរការយូរ។ ឧបករណ៍កំពុងប្រណាំងឆ្ពោះទៅទិសដៅតែមួយ ពីទ្វារខុសៗគ្នា៖ agent native-CLU មួយដែលអាចត្រូវប្រគល់ ticket ពិតប្រាកដ ហើយទុកចិត្តឱ្យធ្វើវឌ្ឍនភាពលើ repository ពិតប្រាកដ។

ហេតុអ្វីរង្វិលជុំល្អជាង prompt

រលកដំបូងនៃ AI coding គឺការបង្កើតជំហានតែម្ដង៖ អ្នកសរសេរ prompt ដោយប្រុងប្រយ័ត្ន ម៉ូដែលបង្កើតប្លុកកូដ ហើយអ្នកបិទភ្ជាប់វា ហើយអធិស្ឋាន។ ពេលវាខុស — API ខុស method ដែលនឹកស្មាន off-by-one ដ៏ល្អិតល្អន់ — អ្នកចាប់ផ្ដើមឡើងវិញជាមួយ prompt ប្រសើរជាងមុន។ ម៉ូដែលមិនដែលឃើញថាកូដរបស់វាពិតជាដំណើរការឬអត់ទេ។

រង្វិលជុំផ្លាស់ប្ដូររឿងនេះទាំងស្រុង ហើយភាពខុសគ្នាមិនមែនជាការកើនបន្តិចម្ដងៗទេ។ រឿងបីយ៉ាងក្លាយទៅជាអាចធ្វើបាន នៅពេលដែលម៉ូដែលអាចធ្វើសកម្មភាព និងសង្កេត៖

ការកែខ្លួនឯង (Self-correction)។ Agent ដំណើរការកូដ ឃើញ stack trace ហើយកែកំហុសរបស់ខ្លួនឯង — ដូចគ្នានឹងអ្នកអភិវឌ្ឍជាមនុស្សដែរ។ ម៉ូដែលជំហានតែម្ដងងងឹតភ្នែកចំពោះកំហុសរបស់ខ្លួនវាផ្ទាល់។ Agent ដែលធ្វើរង្វិលជុំមាន feedback។ វាអាចសរសេរ test មើលវាបរាជ័យ ផ្លាស់ប្ដូរការអនុវត្ត ហើយមើលវាជោគជ័យ។

ការចាក់ឫសក្នុងការពិត។ ជំនួសឱ្យការបង្កើតពីការចងចាំរបស់វាអំពីរបៀបដែល library ប្រហែលជា ដំណើរការ agent អានប្រភពពិតប្រាកដ grep រក function signature ពិតប្រាកដ ហើយពិនិត្យ type ពិតប្រាកដនៅក្នុង codebase របស់អ្នក។ រង្វិលជុំជំនួសការស្មានដោយទំនុកចិត្តដោយការផ្ទៀងផ្ទាត់ដ៏ថោក។

ការបំបែកតាមពេលវេលា។ បញ្ហាពិបាកមិនចុះចាញ់ការលោតយ៉ាងធំតែម្ដងទេ វាចុះចាញ់ជំហានតូចៗ ដែលបានផ្ទៀងផ្ទាត់ជាច្រើន។ រង្វិលជុំគឺជាម៉ាស៊ីនសម្រាប់ការដើរជំហានតូចៗ។ Agent អាចស្វែងរក ប៉ះជញ្ជាំង ថយក្រោយ ហើយព្យាយាមវិធីផ្សេង — ប្រមូលផ្ដុំវឌ្ឍនភាពកាត់ across tool call ជាច្រើនដប់ ជំនួសឱ្យការភ្នាល់អ្វីៗគ្រប់យ៉ាងលើជំហានតែមួយ។

នេះជាមូលហេតុដែលម៉ូដែលកម្រិតមធ្យមនៅក្នុងរង្វិលជុំល្អ ច្រើនតែដំណើរការល្អជាងម៉ូដែលឆ្នើមដែលឆ្លើយក្នុងជំហានតែម្ដង។ ភាពឆ្លាតវៃមិនមែននៅត្រឹមតែ weights ទេ វានៅក្នុងរង្វិលជុំដែលរុំជុំវិញវា។

កន្លែងណាដែលវានៅតែដួលរលំសព្វថ្ងៃ

ភាពស្មោះត្រង់គឺជាចំណុចសំខាន់ទាំងស្រុងនៃអត្ថបទបែបនេះ ដូច្នេះនេះជាកន្លែងដែលរង្វិលជុំនៅតែដួលនៅឆ្នាំ ២០២៦។

ភារកិច្ចមាន horizon វែង។ Agent ខ្លាំងលើភារកិច្ចដែលវាស់ជានាទី និងជា tool call ច្រើនដប់។ ភារកិច្ចដែលវាស់ជាម៉ោង — refactor រាលដាលលើឯកសារសែសិប ការផ្ទេរ (migration) ដែលមានឧបសគ្គលំដាប់ដ៏ល្អិតល្អន់ — នៅតែមានទំនោរថយចេញ។ Agent បាត់បង់ខ្សែ ធ្វើការផ្លាស់ប្ដូរដែលសមហេតុផលក្នុងតំបន់ ប៉ុន្តែបំបែកអ្វីមួយនៅឯឯកសារបីផ្សេងទៀត ហើយមិនអាចស្ដារឡើងវិញបានជានិច្ច។

ការហៀរ context។ រាល់ការធ្វើរង្វិលជុំម្ដងៗ បន្ថែមទៅ context របស់ម៉ូដែល៖ ឯកសារដែលអាន លទ្ធផល command ការវែកញែកមុនៗ។ នៅលើ codebase ធំ ព័ត៌មានពាក់ព័ន្ធទីបំផុតលើសពីអ្វីដែលអាចដាក់ក្នុង window ហើយ agent ចាប់ផ្ដើមភ្លេចអ្វីដែលវាបានរៀនដប់ជំហានមុន។ ការគ្រប់គ្រងអ្វីដែល agent ចងចាំ — និងអ្វីដែលវាត្រូវបានអនុញ្ញាតឱ្យភ្លេច — គឺជាបញ្ហាមួយដែលមិនទាន់ដោះស្រាយ និងកំពុងធ្វើការយ៉ាងសកម្ម។

គម្លាតការផ្ទៀងផ្ទាត់។ រង្វិលជុំកែខ្លួនឯងបានល្អត្រឹមតែ test និងការត្រួតពិនិត្យរបស់វាអនុញ្ញាត។ ប្រសិនបើ codebase របស់អ្នកមាន test coverage ស្ដើង សញ្ញា feedback របស់ agent ខ្សោយ ហើយវានឹងប្រកាសជ័យជម្នះដោយទំនុកចិត្តលើកូដដែលពិតជាមិនដំណើរការ។ Feedback សំរាមចូល ទំនុកចិត្តសំរាមចេញ។

ដែនកំណត់ទាំងនេះច្បាស់ជាមូលហេតុដែលការសន្ទនាកំពុងផ្លាស់ប្ដូរទៅ harness — រចនាសម្ព័ន្ធនៃការគ្រប់គ្រង context ការផ្ទៀងផ្ទាត់ និងរបាំងការពារព័ទ្ធជុំវិញម៉ូដែល — និងទៅរក benchmark ស្មោះត្រង់ដែលវាស់ agent លើការងារ horizon វែងពិតប្រាកដ ជំនួសឱ្យបញ្ហាក្មេងលេង។ រង្វិលជុំចាំបាច់ ប៉ុន្តែមិនគ្រប់គ្រាន់ទេ។ អ្វីដែលអ្នកសាងសង់ព័ទ្ធជុំវិញវា កំណត់ថាតើវាជា demo ឬជាដៃគូដែលអាចទុកចិត្តបាន។

ទិសដៅដែលវាកំពុងឆ្ពោះទៅ

ចង្អុលគន្លងបច្ចុប្បន្នទៅមុខ ហើយរឿងបីយ៉ាងចូលមកក្នុងការផ្ដោត។

ការដំណើរការស្វយ័តយូរជាងមុន។ ខណៈដែលការគ្រប់គ្រង context ប្រសើរឡើង ហើយម៉ូដែលកាន់តែពូកែនៅជាប់នឹងភារកិច្ច horizon ដែលអាចទុកចិត្តបានលាតសន្ធឹងពីនាទីឆ្ពោះទៅម៉ោង។ Agent ដែលអ្នកប្រគល់ bug ឱ្យសព្វថ្ងៃ អ្នកនឹងប្រគល់ feature ឱ្យនៅថ្ងៃស្អែក។

Sub-agent ស្របគ្នា។ ជំនួសឱ្យ agent តែមួយដែលកិនកាត់ភារកិច្ចតាមលំដាប់ អ្នកសម្របសម្រួលបង្កើត sub-agent ច្រើន — មួយស្វែងរក codebase មួយសរសេរ test មួយអនុវត្ត — ដែលធ្វើការស្របគ្នា ហើយរាយការណ៍ត្រឡប់មកវិញ។ រង្វិលជុំក្លាយជាដើមឈើនៃរង្វិលជុំ។

អ្នកអភិវឌ្ឍជាអ្នកដឹកនាំវង់ភ្លេង។ នេះជាការផ្លាស់ប្ដូរជ្រៅជ្រះបំផុត ហើយ Addy Osmani ដាក់ឈ្មោះវាបានល្អនៅក្នុងCoding for the Future Agentic World៖ អ្នកអភិវឌ្ឍវិវឌ្ឍពី “អ្នកសរសេរកូដ” ទៅជា “អ្នកដឹកនាំវង់ភ្លេង”។ តម្លៃរបស់អ្នកផ្លាស់ឡើងលើជណ្ដើរ abstraction — ពីការសរសេរបន្ទាត់ ទៅការបញ្ជាក់គោលដៅ ការរចនារង្វិលជុំ ការពិនិត្យលទ្ធផល និងការកាន់កាប់ការវិនិច្ឆ័យថាតើលទ្ធផលពិតជាត្រឹមត្រូវ។ ការគោះគ្រាប់ចុចមិនដែលជាផ្នែកមានតម្លៃទេ។ ការគិតទេតើ។ ការសរសេរកូដ agentic ដកការវាយចេញ ហើយទុកការគិតឱ្យលេចចេញ។

នោះមិនមែនជាការគំរាមកំហែងដល់វិស្វករល្អទេ។ វាជាការតម្លើងឋានៈ។ ការងារដែលនៅសល់គឺការងារដែលតែងតែជាចំណុចសំខាន់៖ ការយល់បញ្ហាឱ្យបានជ្រៅគ្រប់គ្រាន់ ដើម្បីដឹងថា “រួចរាល់” មានន័យដូចម្ដេច និងមានរសជាតិ (taste) ដើម្បីទទួលស្គាល់វា នៅពេលអ្នកឃើញវា។

សេចក្ដីសន្និដ្ឋាន

ការគោះគ្រាប់ចុចមានដំណើររបស់វាអស់រយៈពេលសាមសិបឆ្នាំ។ វាកំពុងត្រូវបានជំនួសដោយរង្វិលជុំដែលសមនៅក្នុងដប់បន្ទាត់ — ហៅម៉ូដែល ដំណើរការឧបករណ៍ បញ្ជូនលទ្ធផលត្រឡប់មកវិញ ហើយធ្វើម្ដងទៀត។ រង្វិលជុំនោះសាមញ្ញគ្រប់គ្រាន់ដើម្បីសាងសង់ក្នុងពេលរសៀលមួយ ហើយខ្លាំងគ្រប់គ្រាន់ដើម្បីផ្លាស់ប្ដូររបៀបបង្កើតសូហ្វវែរ។ វាល្អជាង prompt ជំហានតែម្ដង ព្រោះវាអាចធ្វើសកម្មភាព សង្កេត និងកែ។ វានៅតែដួលលើការងារ horizon វែង និងការផ្ទៀងផ្ទាត់ខ្សោយ។ ហើយវាកំពុងឆ្ពោះទៅយ៉ាងលឿន រកការដំណើរការយូរជាងមុន agent ស្របគ្នា និងអ្នកអភិវឌ្ឍម្នាក់ដែលការងាររបស់គាត់គឺការដឹកនាំវង់ភ្លេង ជាជាងការវាយ។

នេះជារង្វិលជុំដែលយើងសាងសង់អាជីវកម្មជុំវិញ។ ប្រសិនបើក្រុមរបស់អ្នកកំពុងព្យាយាមរកមើលថា ការសរសេរកូដ agentic ពិតជាសមនៅកន្លែងណា — ភារកិច្ចណាដែលត្រូវប្រគល់ឱ្យរង្វិលជុំ របៀបសាងសង់ harness និងរបាំងការពារព័ទ្ធជុំវិញវា និងរបៀបរក្សាវិស្វករអ្នកនៅលើកៅអីអ្នកដឹកនាំវង់ភ្លេង — នោះច្បាស់ជាការងារដែលយើងធ្វើ។

សូមពិភាក្សាជាមួយយើងអំពីការដាក់រង្វិលជុំសរសេរកូដ agentic ឱ្យដំណើរការនៅក្នុងក្រុមរបស់អ្នក។