ویرگول
ورودثبت نام
Mohsen Farokhi - محسن فرخی
Mohsen Farokhi - محسن فرخیSenior .NET Developer
Mohsen Farokhi - محسن فرخی
Mohsen Farokhi - محسن فرخی
خواندن ۱۶ دقیقه·۳ ماه پیش

چرا آینده برنامه‌نویسی فقط به هوش Agentها وابسته نیست؟

تا همین چند وقت پیش، وقتی درباره استفاده از هوش مصنوعی در برنامه‌نویسی صحبت می‌کردیم، سؤال اصلی معمولاً این بود:

چطور Prompt بهتری بنویسیم؟

Prompt را دقیق‌تر می‌کردیم، Context بیشتری در اختیار مدل می‌گذاشتیم و تلاش می‌کردیم مسئله را با جزئیات بیشتری برای مدل توضیح دهیم.

اما با قدرتمندتر شدن مدل‌های زبانی، اتفاق مهمی افتاد.

AI دیگر فقط به سؤال ما جواب نمی‌دهد. Coding Agentها می‌توانند فایل‌ها را بخوانند، در کد جست‌وجو کنند، تغییر ایجاد کنند، تست اجرا کنند، خطاها را بررسی کنند و در چندین مرحله روی یک مسئله کار کنند.

در نتیجه، یک سؤال مهم‌تر از «چطور Prompt بهتری بنویسیم؟» مطرح می‌شود:

اگر قرار است Agent خودش کار کند، چه محیطی باید برایش بسازیم؟

این دقیقاً جایی است که مفهوم Harness Engineering اهمیت پیدا می‌کند.

مقاله‌ای با عنوان Harness engineering for coding agent users نوشته Birgitta Böckeler و منتشرشده در وب‌سایت Martin Fowler، تلاش می‌کند یک مدل ذهنی برای پاسخ به همین سؤال ارائه دهد: چگونه می‌توان محیطی ساخت که احتمال عملکرد درست Coding Agent را افزایش دهد و در عین حال، امکان کشف و اصلاح خطاها را قبل از رسیدن آن‌ها به انسان فراهم کند؟

ایده اصلی ساده است، اما پیامدهای آن عمیق‌اند:

برای اینکه Agentها بتوانند با استقلال بیشتری کار کنند، فقط به مدل‌های بهتر نیاز نداریم؛ به محیط‌های بهتر هم نیاز داریم.


Harness چیست؟

کلمه Harness را در این زمینه می‌توان چیزی شبیه «محیط هدایت و کنترل» در نظر گرفت.

اگر Agent را فقط یک مدل زبانی ببینیم، احتمالاً تمرکزمان روی مواردی مانند Model، Prompt و Context خواهد بود.

اما یک Coding Agent برای انجام درست یک کار واقعی، به چیزهای بسیار بیشتری نیاز دارد:

  • ابزارهای مناسب

  • مستندات

  • دستورالعمل‌ها

  • قوانین

  • محدودیت‌ها

  • تست‌ها

  • ابزارهای تحلیل

  • امکان مشاهده وضعیت سیستم

  • Feedback

  • امکان اصلاح اشتباهات

بنابراین Agent را نباید یک موجودیت مستقل در نظر گرفت.

Agent بخشی از یک سیستم بزرگ‌تر است.

در ادبیات Harness Engineering حتی می‌توان یک مدل ساده‌تر در نظر گرفت:

Agent = Model + Harness

البته Harness خودش یک مفهوم بسیار گسترده است و بسته به اینکه درباره کدام Agent صحبت می‌کنیم، مرز آن می‌تواند متفاوت باشد. در مورد Coding Agentها، بخشی از Harness از قبل توسط سازنده ابزار فراهم شده است؛ مثلاً System Prompt، مکانیزم بازیابی کد یا orchestration داخلی. بخش دیگری اما در اختیار تیم و توسعه‌دهنده‌ای است که از Agent استفاده می‌کند.

این بخش دوم همان چیزی است که می‌توانیم برای نیازهای خودمان طراحی و توسعه دهیم.


چرا Prompt Engineering به‌تنهایی کافی نیست؟

فرض کنید به یک Coding Agent می‌گوییم:

«این Bug را برطرف کن.»

این دستور به‌ظاهر ساده است، اما برای انجام درست آن سؤالات زیادی وجود دارد:

Bug دقیقاً کجاست؟

کدام قسمت سیستم به آن مربوط است؟

چه تست‌هایی برای این بخش وجود دارند؟

آیا قانون معماری خاصی باید رعایت شود؟

آیا تصمیم معماری قبلی مرتبطی وجود دارد؟

چه فایل‌هایی باید تغییر کنند؟

بعد از تغییر، چگونه مطمئن شویم که مشکل واقعاً برطرف شده است؟

یک Prompt، حتی اگر بسیار خوب نوشته شده باشد، نمی‌تواند به‌تنهایی تمام این مسائل را حل کند.

در یک مدل ساده ممکن است چرخه این‌گونه باشد:

Prompt ↓ Agent ↓ Code ↓ Done

اما توسعه نرم‌افزار واقعی بیشتر شبیه این است:

Understand ↓ Plan ↓ Change ↓ Build ↓ Test ↓ Observe ↓ Fix ↓ Test Again ↓ Review

تفاوت این دو مدل بسیار مهم است.

در مدل اول، فرض می‌کنیم Agent از همان ابتدا درست عمل می‌کند.

در مدل دوم، می‌پذیریم که Agent ممکن است اشتباه کند، اما باید بتواند نتیجه کار خودش را ببیند و در صورت نیاز آن را اصلاح کند.


Agent خوب لزوماً Agentی نیست که در اولین تلاش درست عمل کند

از یک توسعه‌دهنده انسانی هم انتظار نداریم اولین نسخه کدی که می‌نویسد بدون هیچ خطایی وارد Production شود.

توسعه‌دهنده کد می‌نویسد، Build می‌کند، تست اجرا می‌کند، خطا می‌بیند، کد را اصلاح می‌کند و دوباره تست می‌کند.

پس چرا باید از Agent انتظار داشته باشیم که در اولین تلاش همه‌چیز را درست انجام دهد؟

در واقع، یکی از اهداف Harness این است که هزینه اشتباه کردن و اصلاح کردن را پایین بیاورد.

چرخه می‌تواند چیزی شبیه این باشد:

Observe ↓ Decide ↓ Act ↓ Verify ↓ Feedback ↓ Correct ↓ Act Again

در چنین مدلی، اشتباه کردن پایان کار نیست.

اشتباه تبدیل به بخشی از فرایند حل مسئله می‌شود.

اما برای اینکه این چرخه واقعاً کار کند، Agent باید بتواند نتیجه اقدامات خودش را مشاهده کند.

اینجاست که مفهوم Feedback وارد می‌شود.


Feedforward و Feedback؛ دو طرف Harness

یکی از مفاهیم مهم در مقاله Böckeler، تفکیک Feedforward و Feedback است.

Feedforward یعنی قبل از اینکه Agent اقدامی انجام دهد، محیط تلاش کند رفتار مطلوب را به آن هدایت کند.

برای مثال:

  • Coding Guidelines

  • AGENTS.md

  • Skills

  • How-to Guides

  • Architecture Documentation

  • Coding Conventions

  • ابزارهای Bootstrap

  • Code Modification Tools

همگی می‌توانند قبل از تولید خروجی، مسیر Agent را هدایت کنند.

در مقابل، Feedback بعد از اقدام Agent وارد عمل می‌شود.

مثلاً:

  • Test

  • Linter

  • Type Checker

  • Static Analysis

  • Architecture Test

  • Logs

  • Browser Checks

  • Code Review

این ابزارها بررسی می‌کنند که Agent چه کاری انجام داده و آیا نتیجه با چیزی که انتظار داشتیم مطابقت دارد یا نه.

در نتیجه می‌توانیم Harness را به شکل زیر ببینیم:

FEEDFORWARD │ ▼ Agent │ ▼ Action │ ▼ FEEDBACK │ ▼ Self-Correction │ └──────→ Agent

اگر فقط Feedforward داشته باشیم، به Agent می‌گوییم چه کاری انجام دهد، اما نمی‌فهمیم آیا واقعاً درست انجام داده است.

اگر فقط Feedback داشته باشیم، ممکن است Agent بارها همان اشتباه را تکرار کند تا اینکه در نهایت توسط تست متوقف شود.

Harness مؤثر به هر دو نیاز دارد.


Feedback خوب فقط «Fail» نیست

فرض کنید تستی شکست خورده و فقط این پیام را داریم:

Test Failed

این پیام برای انسان و Agent چندان مفید نیست.

اما تصور کنید Feedback چنین باشد:

Test: BalanceRequest_ShouldDeduplicate Expected: Only one external request. Actual: Two external requests were sent. Reason: Deduplication rule was not applied.

در این حالت Agent اطلاعاتی دارد که می‌تواند بر اساس آن تصمیم بعدی را بگیرد.

پس مسئله فقط داشتن Feedback نیست.

کیفیت Feedback اهمیت دارد.

حتی می‌توان Feedback را به شکلی طراحی کرد که مستقیماً راه اصلاح را هم به Agent نشان دهد.

مثلاً یک Linter به جای:

Invalid dependency

بگوید:

Domain module must not depend on Infrastructure. Move the dependency behind an interface defined in the Domain layer.

در این حالت Feedback خودش به نوعی تبدیل به یک راهنمای قابل استفاده برای Agent شده است.


Computational در برابر Inferential

یکی دیگر از تفکیک‌های مهم در Harness Engineering، تفاوت بین کنترل‌های Computational و Inferential است.

Computational یعنی چیزی که می‌توان آن را به‌صورت deterministic توسط ماشین اجرا کرد.

مثل:

  • Compiler

  • Type Checker

  • Linter

  • Unit Test

  • Structural Analysis

  • Architecture Test

این ابزارها معمولاً سریع هستند و نتیجه آن‌ها قابل تکرار است.

برای مثال:

Architecture Rule ↓ Automated Check ↓ PASS / FAIL

اگر قانون مشخص باشد، ماشین می‌تواند آن را بررسی کند.

در مقابل، برخی مسائل ماهیت معنایی دارند و به قضاوت نیاز دارند.

برای مثال:

  • آیا این کد بیش از حد پیچیده است؟

  • آیا دو بخش مختلف واقعاً یک مفهوم را تکرار می‌کنند؟

  • آیا این طراحی بیش از حد مهندسی شده است؟

  • آیا نام‌گذاری‌ها از نظر معنایی مناسب‌اند؟

  • آیا این Implementation با Intent اصلی Feature سازگار است؟

اینجا می‌توان از کنترل‌های Inferential استفاده کرد؛ مثلاً یک LLM که نقش Code Reviewer را ایفا می‌کند.

اما این کنترل‌ها معمولاً کندتر، گران‌تر و غیرقطعی‌تر هستند.

پس یک Harness خوب الزاماً همه‌چیز را با LLM حل نمی‌کند.

برعکس، هر جا یک قانون را بتوانیم به شکل دقیق و deterministic تعریف کنیم، بهتر است آن را به ابزار Computational بسپاریم.

برای مثال اگر قانون این باشد:

«این ماژول نباید به آن ماژول وابستگی داشته باشد.»

بهتر است آن را با یک Architecture Test بررسی کنیم، نه اینکه هر بار از یک LLM بپرسیم آیا این Dependency مجاز است یا نه.

اما اگر سؤال این باشد:

«آیا این طراحی بیش از حد پیچیده است؟»

ممکن است بررسی Inferential ارزشمندتر باشد.


چرا این تفکیک مهم است؟

چون استفاده از LLM برای همه‌چیز هم گران است و هم غیرضروری.

فرض کنید یک قانون کاملاً مشخص داریم:

No dependency from Domain to Infrastructure.

اگر این قانون را بتوان با چند میلی‌ثانیه محاسبه کرد، منطقی نیست هر بار یک مدل زبانی را درگیر کنیم.

اما برای یک سؤال مبهم مانند:

«آیا این تغییر از نظر طراحی بیش از حد پیچیده است؟»

ممکن است تحلیل معنایی ارزشمند باشد.

بنابراین می‌توانیم یک اصل ساده داشته باشیم:

قوانین قطعی را تا حد امکان Computational کنیم و قضاوت‌های معنایی را در جایی که لازم است به Inferential Tools بسپاریم.


Steering Loop؛ نقش انسان تغییر می‌کند

اگر Agent اشتباه کند، یک واکنش طبیعی این است که همان لحظه به آن بگوییم:

«این کار را اشتباه انجام دادی. دفعه بعد این کار را بکن.»

اما اگر Agent در آینده دوباره همان اشتباه را تکرار کند چه؟

در اینجا Harness Engineering یک قدم جلوتر می‌رود.

اگر یک خطا چند بار تکرار می‌شود، شاید مشکل فقط همان خروجی خاص نباشد.

ممکن است Harness چیزی کم داشته باشد.

در اینجا مفهوم Steering Loop مطرح می‌شود.

چرخه به این شکل است:

Agent makes a mistake ↓ Human observes the problem ↓ Identify missing control ↓ Improve Guide / Sensor ↓ Agent works again ↓ Problem becomes less likely

در نتیجه، انسان فقط خروجی Agent را Review نمی‌کند.

انسان محیطی را که Agent در آن کار می‌کند نیز بهبود می‌دهد.

این یک تغییر بسیار مهم در نقش انسان است.


اگر یک اشتباه تکرار می‌شود، آن را به Harness اضافه کن

فرض کنید Agent مرتباً یک قانون معماری را نقض می‌کند.

می‌توانیم هر بار در Code Review این مشکل را پیدا کنیم.

اما یک راه بهتر وجود دارد:

  1. قانون را مشخص کنیم.

  2. آن را مستند کنیم.

  3. اگر ممکن است آن را به یک Rule تبدیل کنیم.

  4. در صورت امکان برایش Test بنویسیم.

  5. Feedback را به Agent برگردانیم.

در نتیجه:

Repeated Human Correction ↓ Rule ↓ Automated Sensor ↓ Agent Self-Correction

این یعنی دانشی که قبلاً فقط در ذهن توسعه‌دهنده وجود داشت، به بخشی از سیستم تبدیل شده است.


Keep Quality Left؛ هرچه زودتر، بهتر

یک اصل قدیمی در مهندسی نرم‌افزار می‌گوید:

هرچه یک مشکل زودتر پیدا شود، اصلاح آن ارزان‌تر است.

این اصل در Harness Engineering اهمیت بیشتری پیدا می‌کند.

اگر یک خطای ساده را بتوان قبل از Commit پیدا کرد، چرا باید آن را تا مرحله Integration Test یا حتی Human Review عقب بیندازیم؟

مثلاً:

Agent Change ↓ Fast Linter ↓ Unit Tests ↓ Architecture Checks ↓ Human Review ↓ Integration ↓ Expensive Tests

کنترل‌های سریع و ارزان باید تا حد امکان در ابتدای مسیر قرار بگیرند.

کنترل‌های گران‌تر می‌توانند دیرتر اجرا شوند.

برای مثال، یک Linter ساده می‌تواند تقریباً بلافاصله اجرا شود، در حالی که Mutation Testing یا یک بررسی معماری گسترده ممکن است برای مراحل بعدی مناسب‌تر باشد.

این همان ایده Keep Quality Left است:

کیفیت را تا حد امکان به سمت چپ چرخه توسعه منتقل کنیم.


Harness فقط برای یک تغییر نیست

یک نکته مهم دیگر این است که همه Feedbackها در چرخه یک تغییر اتفاق نمی‌افتند.

بعضی مشکلات به‌تدریج ایجاد می‌شوند.

مثلاً:

  • Dead Code

  • Dependency Drift

  • کاهش کیفیت Test Coverage

  • آسیب دیدن معماری

  • افزایش Complexity

  • قدیمی شدن Dependencies

ممکن است هیچ‌کدام در یک Commit مشخص به‌وضوح دیده نشوند.

بنابراین Harness می‌تواند Sensorهایی داشته باشد که به‌صورت مداوم وضعیت Codebase را بررسی کنند.

مثلاً:

Codebase │ ┌───────────┼───────────┐ ▼ ▼ ▼ Dead Code Coverage Dependencies │ │ │ └───────────┼───────────┘ ▼ Feedback │ ▼ Agent

حتی Runtime نیز می‌تواند منبع Feedback باشد.

Latency، Error Rate، Availability و سایر SLOها می‌توانند اطلاعاتی درباره سلامت سیستم در اختیار Agent قرار دهند.

در این حالت، Harness فقط کیفیت کدی را که Agent همین الان نوشته بررسی نمی‌کند؛ بلکه سلامت سیستم را در طول زمان نیز دنبال می‌کند.


سه نوع Harness

Böckeler برای دقیق‌تر شدن مفهوم Harness، سه حوزه متفاوت را از یکدیگر جدا می‌کند.

این تفکیک مهم است، چون «کیفیت» در نرم‌افزار فقط یک معنا ندارد.


۱. Maintainability Harness

اولین دسته، Harness مربوط به Maintainability یا قابلیت نگهداری کد است.

این بخش احتمالاً آشناترین قسمت برای تیم‌های نرم‌افزاری است.

Sensorهای این حوزه می‌توانند مواردی مانند این‌ها را بررسی کنند:

  • Duplicate Code

  • Cyclomatic Complexity

  • Test Coverage

  • Architectural Drift

  • Style Violations

  • Dependency Problems

بسیاری از این موارد را می‌توان با ابزارهای Computational به‌صورت سریع و deterministic بررسی کرد.

اما بعضی مشکلات معنایی‌تر هستند.

مثلاً ممکن است دو قطعه کد از نظر Syntax متفاوت باشند، اما در واقع یک مفهوم را دوباره پیاده‌سازی کرده باشند.

یا Agent ممکن است برای یک مسئله ساده راه‌حلی بیش از حد پیچیده ایجاد کند.

اینجا Sensorهای Inferential می‌توانند نقش مکمل داشته باشند.


۲. Architecture Fitness Harness

دسته دوم، Harness مربوط به Architecture Fitness است.

ایده اصلی این است که ویژگی‌های معماری موردنظر را به شکل قابل بررسی تعریف کنیم.

این مفهوم به Fitness Functionها در معماری نرم‌افزار نزدیک است.

مثلاً اگر سیستم یک الزام Performance دارد، می‌توانیم:

  • این الزام را به Agent اعلام کنیم.

  • Performance Test داشته باشیم.

  • نتیجه را اندازه‌گیری کنیم.

  • و در صورت Regression، Feedback را به Agent برگردانیم.

یا اگر Logging و Observability استاندارد خاصی دارند، می‌توانیم آن استاندارد را در Guide تعریف کنیم و ابزارهایی برای بررسی آن داشته باشیم.

در اینجا معماری دیگر فقط یک Diagram روی Whiteboard نیست.

بخشی از آن تبدیل به قوانین قابل مشاهده و قابل بررسی می‌شود.


۳. Behaviour Harness

اما سخت‌ترین بخش، Behaviour یا رفتار واقعی سیستم است.

سؤال این است:

چطور بفهمیم نرم‌افزاری که Agent ساخته، واقعاً همان رفتاری را دارد که می‌خواهیم؟

در اینجا معمولاً چنین چرخه‌ای داریم:

Functional Specification ↓ Agent ↓ Generated Code ↓ Generated Tests ↓ Tests Pass

اما یک مشکل اساسی وجود دارد:

اگر Agent خودش Specification را تفسیر کند و خودش Test بنویسد، سپس خودش هم همان Testها را اجرا کند، تا چه اندازه می‌توانیم به نتیجه اعتماد کنیم؟

ممکن است Testها سبز باشند، اما Specification به‌درستی پیاده نشده باشد.

این همان جایی است که Behaviour Harness هنوز یکی از چالش‌های جدی Harness Engineering محسوب می‌شود.

تست‌های خودکار بسیار ارزشمندند، اما سبز بودن Testها لزوماً اثبات نمی‌کند که نرم‌افزار دقیقاً همان چیزی را انجام می‌دهد که انسان می‌خواسته است.

بنابراین برای Behaviour هنوز به ترکیبی از Specification، Test، ابزارهای خودکار و در بسیاری از موارد Human Review نیاز داریم.


Harnessability؛ همه Codebaseها به یک اندازه قابل Harness شدن نیستند

یک ایده جالب دیگر، مفهوم Harnessability است.

همه Codebaseها به یک اندازه برای ساخت Harness مناسب نیستند.

فرض کنید یک سیستم:

  • زبان strongly typed داشته باشد.

  • Module Boundaryهای مشخصی داشته باشد.

  • Architecture قابل اندازه‌گیری داشته باشد.

  • Testهای قابل اعتماد داشته باشد.

  • ابزارهای Build سریع داشته باشد.

در چنین سیستمی، ساخت Sensor و Constraint نسبتاً ساده‌تر است.

مثلاً اگر Module Boundary مشخص باشد، می‌توانیم یک Architecture Test بنویسیم.

اگر Type System قوی باشد، بخشی از خطاها را Compiler پیدا می‌کند.

اگر Build سریع باشد، Feedback Loop کوتاه‌تر می‌شود.

اما در یک Codebase قدیمی و پر از Technical Debt، ممکن است بسیاری از این امکانات وجود نداشته باشند.

اینجاست که یک پارادوکس جالب شکل می‌گیرد:

بیشترین نیاز به Harness ممکن است دقیقاً در Codebaseهایی باشد که ساخت Harness برای آن‌ها سخت‌تر است.


Ambient Affordances؛ محیطی که خودش به Agent کمک می‌کند

در مقاله مفهوم جالب دیگری با عنوان Ambient Affordances مطرح می‌شود.

منظور ویژگی‌هایی از خود محیط است که باعث می‌شوند Codebase برای Agent قابل فهم‌تر، قابل پیمایش‌تر و قابل کنترل‌تر باشد.

مثلاً:

  • ساختار منظم پروژه

  • Module Boundaryهای واضح

  • Naming Conventionهای پایدار

  • Type System مناسب

  • ابزارهای استاندارد

  • تست‌های قابل اعتماد

  • Documentation در محل مناسب

این ویژگی‌ها حتی بدون اینکه مستقیماً به Agent بگوییم «این کار را انجام بده»، احتمال رفتار درست را افزایش می‌دهند.

در یک پروژه Greenfield می‌توان این ویژگی‌ها را از ابتدا در معماری لحاظ کرد.

اما در پروژه‌های Legacy، شرایط دشوارتر است.

ممکن است ابتدا مجبور شویم خود Codebase را به تدریج Harnessable کنیم.


Repository باید برای Agent قابل کشف باشد

در دنیای Agentها، Repository دیگر فقط محل نگهداری Source Code نیست.

می‌تواند شامل این موارد نیز باشد:

Source Code Tests Documentation Architecture Decisions Development Guidelines Build Commands Test Commands Automation Agent Guidance

بخش زیادی از دانش ضمنی تیم باید تا حد امکان به دانش قابل دسترسی تبدیل شود.

توسعه‌دهنده باتجربه ممکن است بداند:

«این قسمت را نباید تغییر بدهیم.»

یا:

«این طراحی به دلیل یک محدودیت قدیمی چنین شکلی دارد.»

یا:

«این تغییر روی چند بخش دیگر اثر می‌گذارد.»

Agent این دانش را به‌صورت طبیعی ندارد.

پس باید آن را در محیط قابل دسترس کنیم.

Documentation، ADR، Rule، Test و Automation همگی می‌توانند بخشی از این دانش باشند.


اما Documentation به‌تنهایی کافی نیست

مستندات قدیمی حتی می‌توانند خطرناک باشند.

اگر Documentation با Codebase هماهنگ نباشد، Agent ممکن است اطلاعات اشتباه را به‌عنوان حقیقت در نظر بگیرد.

به همین دلیل، هرجا ممکن است باید دانش مهم را از متن به Executable Knowledge تبدیل کنیم.

مثلاً:

Documentation: Module A should not depend on Module B.

و در کنار آن:

Architecture Test: Module A → Module B = FAIL

Documentation توضیح می‌دهد قانون چیست و چرا وجود دارد.

Test بررسی می‌کند آیا واقعاً رعایت شده است یا نه.

این ترکیب بسیار قدرتمندتر از هرکدام به‌تنهایی است.


Context Engineering چه نسبتی با Harness Engineering دارد؟

در سال‌های اخیر اصطلاح Context Engineering نیز بسیار مطرح شده است.

Context Engineering روی این مسئله تمرکز دارد که چه اطلاعاتی، با چه ساختاری و در چه زمانی در اختیار مدل قرار بگیرد.

Harness Engineering ارتباط نزدیکی با این مفهوم دارد.

در واقع می‌توان گفت ساخت یک User Harness برای Coding Agent، شکل خاصی از Context Engineering است.

اما Harness فقط Context نیست.

Harness می‌تواند شامل:

  • Guides

  • Sensors

  • Tools

  • Constraints

  • Verification

  • Documentation

  • Feedback

و سایر اجزای محیط باشد.

بنابراین سؤال از:

«چه Contextی به Agent بدهیم؟»

به سؤال بزرگ‌تری تبدیل می‌شود:

«چه محیطی بسازیم که Agent بتواند در آن به‌صورت قابل اعتماد کار کند؟»


هدف Harness حذف انسان نیست

یکی از برداشت‌های اشتباه ممکن است این باشد که Harness قرار است انسان را کاملاً از چرخه خارج کند.

هدف چنین چیزی نیست.

هدف اصلی این است که زمان و توجه انسان را به جایی منتقل کنیم که واقعاً ارزشمند است.

اگر یک خطای ساده را می‌توان با Linter پیدا کرد، چرا باید یک انسان آن را Review کند؟

اگر یک Dependency اشتباه را می‌توان با Architecture Test تشخیص داد، چرا باید در Code Review کشف شود؟

اگر یک مشکل را می‌توان در چند ثانیه با یک Sensor پیدا کرد، چرا باید چند روز بعد در Production دیده شود؟

در مقابل، برای تصمیم‌هایی که واقعاً به قضاوت انسانی نیاز دارند، انسان همچنان باید در حلقه باقی بماند.

پس Harness خوب الزاماً نمی‌گوید:

Human Out of the Loop

بلکه بیشتر می‌گوید:

Human Where It Matters


Harness Engineering در نهایت یک فرایند است، نه یک فایل تنظیمات

یک اشتباه دیگر این است که Harness را چیزی بدانیم که یک‌بار ساخته می‌شود و بعد تمام.

در واقع، Harness باید همراه با سیستم رشد کند.

اگر Agent مرتباً خطایی انجام می‌دهد، باید بپرسیم:

  • آیا Guide کافی نیست؟

  • آیا Sensor نداریم؟

  • آیا Feedback ضعیف است؟

  • آیا Rule مبهم است؟

  • آیا ابزار مناسبی وجود ندارد؟

و سپس Harness را اصلاح کنیم.

چرخه به این شکل درمی‌آید:

Agent ↓ Problem ↓ Human Observation ↓ Improve Harness ↓ Agent ↓ Fewer Problems

این همان Steering Loop است.

در این مدل، یکی از وظایف مهم مهندس نرم‌افزار دیگر فقط اصلاح خروجی Agent نیست.

بلکه بهبود سیستمی است که Agent در آن کار می‌کند.


شاید آینده مهندسی نرم‌افزار همین‌جا باشد

با قدرتمندتر شدن Coding Agentها، ممکن است بخش بیشتری از Implementation به Agent سپرده شود.

اما این به معنی بی‌اهمیت شدن مهندسی نرم‌افزار نیست.

برعکس.

ممکن است بخشی از کار مهندس نرم‌افزار از نوشتن مستقیم کد به سمت مواردی مانند این‌ها حرکت کند:

  • طراحی Architecture

  • تعریف Constraints

  • ساخت Testهای بهتر

  • طراحی Feedback Loop

  • ایجاد Sensor

  • تبدیل دانش ضمنی به Documentation

  • ساخت ابزارهای توسعه

  • تعریف استانداردها

  • طراحی محیط امن برای Agent

  • و مهم‌تر از همه، طراحی Harness

در چنین محیطی، ارزش مهندس فقط در این نیست که خودش بتواند کد خوبی بنویسد.

بلکه در این است که بتواند سیستمی بسازد که احتمال تولید کد خوب را افزایش دهد.


در نهایت، Agent فقط یک جزء از سیستم است

اگر Agent را فقط یک مدل زبانی ببینیم، طبیعی است که تمرکزمان روی Model، Prompt و Context باشد.

اما اگر Agent را بخشی از یک سیستم مهندسی بدانیم، تصویر کاملاً متفاوت می‌شود:

┌─────────────────────┐ │ HARNESS │ │ │ │ Guides │ │ Tools │ │ Constraints │ │ Documentation │ │ Sensors │ │ Verification │ │ Feedback │ └──────────┬──────────┘ │ ▼ AGENT │ ▼ Action │ ▼ Verification │ ┌────┴────┐ │ │ PASS FAIL │ │ ▼ ▼ Done Feedback │ └──────→ Agent

در این مدل، Agent دیگر یک «جادوگر» نیست که باید همه‌چیز را خودش درست انجام دهد.

Agent بخشی از یک سیستم است که اطراف آن ابزار، قانون، اطلاعات، Sensor و Feedback قرار گرفته است.

و شاید مهم‌ترین پیام Harness Engineering همین باشد:

به‌جای اینکه فقط تلاش کنیم Agent را باهوش‌تر کنیم، باید محیطی بسازیم که یک Agent حتی با وجود خطاها بتواند در آن به نتیجه‌ای قابل اعتماد برسد.

در چنین نگاهی، کیفیت نرم‌افزار دیگر فقط نتیجه هوش مدل نیست.

کیفیت حاصل تعامل چند عامل است:

Model + Context + Guides + Tools + Constraints + Sensors + Feedback + Human Judgment

و هرچه این سیستم بهتر طراحی شود، می‌توان بخش بیشتری از کار را با اعتماد بیشتری به Agent سپرد.

شاید در آینده سؤال اصلی دیگر این نباشد که:

«آیا AI می‌تواند این کد را بنویسد؟»

بلکه سؤال مهم‌تر این باشد:

«آیا محیطی ساخته‌ایم که AI بتواند این کار را به‌درستی انجام دهد؟»

این تغییر سؤال، شاید یکی از مهم‌ترین تغییرات ذهنی در مسیر حرکت از AI-Assisted Development به سمت Agentic Software Engineering باشد.


منبع

این مقاله بر اساس ایده‌ها و مدل ذهنی مطرح‌شده در مقاله Harness engineering for coding agent users نوشته Birgitta Böckeler و منتشرشده در وب‌سایت Martin Fowler تهیه شده است.

برای مطالعه مقاله اصلی، بخش‌های فنی و مثال‌های بیشتر، به منبع اصلی مراجعه کنید.

۲
۰
Mohsen Farokhi - محسن فرخی
Mohsen Farokhi - محسن فرخی
Senior .NET Developer
شاید از این پست‌ها خوشتان بیاید