لنفرض أنك طلبت من وكيل البرمجة Coding Agent دالة صغيرة تحول المدة التي يكتبها المستخدم مثل 1h30m إلى ثوان، وطلبت منه أن يكتب لها اختبارات. بعد دقائق يرجع إليك بالدالة وبملف اختبارات، وكل الاختبارات خضراء. والسؤال الذي يجب أن تسأله هنا: من الذي قرر ما هو الصحيح؟ فالدالة كتبها الوكيل، والاختبارات كتبها الوكيل نفسه بعد أن كتب الدالة، أي أنها تختبر ما فعله الكود لا ما كان يجب أن يفعله. فإذا افترض الوكيل أن 5m1h مقبولة، أو أن الرقم دون وحدة يعني ثواني، فإن اختباره سوف يؤكد هذا الافتراض بثقة كاملة.
والتطوير بالاختبار أولاً Test-Driven Development واختصاراً TDD يقلب هذا الترتيب: أنت تكتب الاختبارات التي تقول ما هو الصحيح، وتتأكد أنها تفشل، ثم يكتب الوكيل الكود حتى تنجح. وبهذا يصبح للوكيل هدف واضح يرجع بنجاح أو فشل، ويصبح عندك حكم لم يكتبه الوكيل. وفي هذا المقال نرى كيف تعمل هذه الطريقة مع الوكلاء، وأين تنفع وأين تخدعك، ثم نجربها فعلاً على الدالة نفسها بأربع طرق مع نموذج محلي، ونحكم على النتيجة باختبارات قبول مخفية لم يرها الوكيل ولا كتبها.
في هذا المقال سوف نتناول:
- ما هو TDD باختصار، ولماذا يناسب الوكلاء أكثر مما يناسب كثيراً من البشر.
- مشكلة الحكم Test Oracle: من يقرر ما هو الصحيح عندما يكتب الوكيل الكود والاختبار معاً.
- كيف تكتب الاختبارات للوكيل: ماذا تغطي، وكيف تمنعه من تعديلها.
- الغش Cheating: حين يجعل الوكيل الاختبار ينجح دون أن يحل المشكلة.
- مختبر حقيقي: الكود أولاً ثم الاختبار، والاختبار أولاً للقراءة فقط، والاختبار أولاً قابلاً للتعديل، ثم الاختبار أولاً مع جملة من المطور.
- متى يستحق TDD الوقت مع الوكيل ومتى لا يستحق.
وإذا أردت أساسيات الاختبار قبل أن تبدأ، أو أردت أن تعرف كيف تقيس قوة الاختبارات نفسها، فقد شرحنا ذلك في مقالات مستقلة:
دليلاختبارات الوحدة Unit Tests عملياً: متى تستخدم Mocks؟كيف تكتب اختبارات وحدة تفشل حين يوجد خطأ وتنجح حين لا يوجد، ومتى يكون ال Mock مفيداً ومتى يخفي الأخطاء، مع تجربة على خدمة تجديد اشتراكات.
دليلاختبارات يكتبها الذكاء الاصطناعي: متى تثق بها؟أين يساعدك الذكاء الاصطناعي في كتابة الاختبارات وأين يخدعك، ولماذا يبقى قرار ما هو الصحيح بيد الإنسان.
دليلاختبار الطفرات Mutation Testing: هل تكشف اختباراتك الأخطاء؟لماذا تمر الأخطاء من اختبارات تغطيتها 100%، وكيف يقيس اختبار الطفرات قوتها فعلاً ويعمل في خط CI دون أن يبطئه.
دليلخطط ثم نفذ ثم تحقق: حلقة العمل مع وكيل البرمجةخطة قصيرة يراجعها إنسان، ثم خطوة واحدة في كل طلب، ثم دليل من أمر يرجع بنجاح أو فشل، مع مختبر يجرب الميزة نفسها بست طرق ويحكم عليها باختبارات لم يرها الوكيل.ما هو التطوير بالاختبار أولاً TDD؟
TDD طريقة في كتابة الكود جعلها Kent Beck معروفة، وتقوم على دورة قصيرة من ثلاث خطوات تتكرر، كما يلخصها تعريف Martin Fowler:
- الأحمر Red: اكتب اختباراً لسلوك صغير لم يكتب بعد، وشغله لترى أنه يفشل. والفشل هنا مهم، لأنه يثبت أن الاختبار يختبر شيئاً فعلاً، وأنه لا ينجح بالصدفة.
- الأخضر Green: اكتب أقل كود يجعل الاختبار ينجح، دون أن تضيف ما لم يطلبه أي اختبار.
- إعادة الهيكلة Refactor: حسن شكل الكود والاختبارات وأنت تشغل الاختبارات بعد كل تغيير، حتى تتأكد أنك لم تغير السلوك.
وقد يتساءل البعض: إذا كانت الطريقة قديمة ومعروفة، فلماذا لا يطبقها أغلب المطورين؟ والإجابة أن كتابة الاختبار قبل الكود تحتاج انضباطاً، وتبدو بطيئة في اللحظة، فالمطور يعرف في رأسه ما سوف يكتبه، فيكتبه مباشرة. أما مع الوكيل فالحساب مختلف، لأن الوكيل لا يعرف ما في رأسك، والاختبار هو أدق طريقة لتنقل له ما في رأسك: ليس وصفاً قد يفهمه بطريقتين، وإنما أمثلة بمدخلات ومخرجات لا تحتمل إلا معنى واحداً. ولأن الوكيل يستطيع أن يشغل الاختبار ويقرأ نتيجته ويحاول مرة أخرى، فإن الاختبار يصبح هو الفحص الذي يعرف به متى ينتهي، وهو ما يسميه توثيق أفضل الممارسات في Claude Code أن تعطي الوكيل شيئاً يشغله يرجع بنجاح أو فشل، ويضرب له مثلاً بطلب يقول للوكيل أن يكتب اختباراً يفشل ويعيد الخطأ ثم يصلحه.
ولاحظ أن الذي أعاد هذه الطريقة القديمة إلى النقاش في 2025 هو صاحبها نفسه، فقد كتب Kent Beck، الذي كتبنا قصته في مقال قصة Kent Beck في Facebook، أنه بنى مكتبة كاملة مع وكيل برمجة، وأنه كتب في تعليماته للوكيل أن يتبع دورة TDD في كل خطوة، كما سيأتي في قسم الغش. والسبب الذي يجمع بين الحالتين أن TDD في الأصل طريقة لتقليل الخوف من الكود الذي لا تعرف هل يعمل، والكود الذي يكتبه الوكيل هو بالضبط هذا النوع من الكود: سريع ويبدو صحيحاً، ولكنك لم تكتبه بيدك ولا تعرف ما افترضه.

من يقرر ما هو الصحيح؟ مشكلة الحكم Test Oracle
في مقال اختبارات الذكاء الاصطناعي شرحنا مشكلة المرجع أو الحكم Test Oracle، أي أن الاختبار يحتاج من يقرر ما هي النتيجة الصحيحة، وأن النموذج عندما يكتب الاختبار من الكود فإنه يأخذ النتيجة الصحيحة من الكود نفسه، فيثبت الخطأ بدل أن يكشفه. ومع الوكيل تصبح هذه المشكلة أوضح، لأن الوكيل يكتب الكود والاختبار في الجلسة نفسها، وبالافتراضات نفسها، فإذا أخطأ في فهم القاعدة فإن الخطأ يدخل في الاثنين معاً، والاختبارات تنجح.

والحل في TDD أن يأتي الحكم من خارج الوكيل، وهذا يعني ثلاثة أشياء عملية:
- الإنسان يكتب الاختبارات، أو يراجعها سطراً سطراً قبل التنفيذ: إذا طلبت من الوكيل أن يكتب الاختبارات أولاً من وصفك، فاقرأها قبل أن تسمح له بكتابة الكود، لأنها في هذه اللحظة هي المواصفة Specification.
- الاختبار يفشل قبل الكود: شغله وانظر إلى الفشل بعينك، فالاختبار الذي ينجح قبل أن يكتب أي كود لا يختبر شيئاً.
- الوكيل لا يعدل الاختبارات في خطوة الأخضر: يقرؤها ويشغلها ولكنه لا يغيرها، وإذا رأى أن اختباراً خاطئاً فيقول ذلك ويتوقف، ولا يصلحه بنفسه.
الغش Cheating: الاختبار ينجح والمشكلة باقية
عندما تعطي الوكيل هدفاً واحداً هو أن تنجح الاختبارات فإنه سوف يبحث عن أقصر طريق إليه، وأحياناً يكون أقصر طريق ليس حل المشكلة، وإنما تغيير الاختبار، أو حذفه، أو تعطيله، أو كتابة كود يعرف قيم الاختبار بالضبط ويرجعها Hardcoding. وهذا ليس افتراضاً نظرياً، ففي يونيو 2025 كتب Kent Beck نفسه، صاحب TDD، عن تجربته في بناء مكتبة مع وكيل برمجة في مقاله عن البرمجة المعززة Augmented Coding، وذكر ثلاث علامات كان يراقبها ليتدخل: الحلقات Loops، والوظائف التي لم يطلبها حتى لو كانت خطوة منطقية تالية، وأي علامة على أن الوكيل يغش، مثل تعطيل الاختبارات أو حذفها. وكانت تعليماته للوكيل في ملحق المقال صريحة: اتبع دورة الأحمر ثم الأخضر ثم إعادة الهيكلة دائماً، واكتب أبسط اختبار يفشل أولاً، واكتب من الكود ما يكفي لينجح الاختبار فقط، ولا تخلط تغيير الهيكل بتغيير السلوك في commit واحد.
ولذلك فإن الحماية من الغش ليست في أن تطلب من الوكيل ألا يغش، وإنما في بيئة التشغيل Harness:
- اجعل ملف الاختبارات للقراءة فقط: في Aider تضيفه بالخيار
--readبدل أن تضيفه للتعديل، فيراه النموذج ولا يستطيع Aider أن يطبق عليه أي تعديل. وفي الأدوات الأخرى تمنع الكتابة عليه بقواعد الصلاحيات Permissions، أو بخطاف يرفض أي تعديل عليه. - افحص الفرق في ملفات الاختبار قبل أن تقبل: أمر واحد مثل
git diff --stat main -- 'test_*'يخبرك هل لمس الوكيل الاختبارات. - احتفظ باختبارات قبول لا يراها الوكيل: مجموعة صغيرة بقيم أخرى للقواعد نفسها، تشغلها أنت أو خط CI بعد أن ينتهي، فإذا كان الوكيل قد كتب كوداً يعرف قيم اختباراتك فقط فإنها سوف تكشفه. وهذا ما فعلناه في المختبر.
المختبر: الدالة نفسها بأربع طرق
لنرى الفرق بالأرقام أعطينا وكيلاً حقيقياً الدالة نفسها بأربع طرق، وحكمنا على كل نتيجة بأحد عشر اختبار قبول مخفياً. والإعداد كما يلي:
- الوكيل: Aider 0.86.2 في Container، مع الخيارين
--test-cmd "python -m unittest -q"و--auto-testفي الطرق الأربع، أي أن الوكيل يشغل الاختبارات بعد كل تعديل ويحاول الإصلاح إذا فشلت. فالفرق بين الطرق ليس في وجود التحقق، وإنما في من كتب الاختبارات ومتى. - النموذج:
qwen2.5-coder:3bعلى Ollama 0.40.13 على معالج Intel Core i7-7700K دون بطاقة رسومية، بنافذة سياق 8192 توكن وحد 2048 توكن للرد، وبحرارة صفر. - المستودع: ملف
duration.pyفيه الدالة فارغة ترفعNotImplementedError.
والطرق الأربع كما يلي:
| الطريقة | ما في المستودع قبل الوكيل | الطلب | ملف الاختبارات |
|---|---|---|---|
| T1: الكود أولاً | الدالة الفارغة فقط | اكتب parse_duration التي تحول مدداً مثل 1h30m و90s و2h إلى ثوان، ثم اكتب لها اختبارات | يكتبه الوكيل |
| T2: الاختبار أولاً، للقراءة فقط | الدالة الفارغة واختبارات كتبناها في commit مستقل | اجعل الاختبارات في test_duration.py تنجح بكتابة parse_duration، ولا تغير الاختبارات | بالخيار --read، أي للقراءة فقط |
| T3: الاختبار أولاً، قابلاً للتعديل | مثل T2 | الطلب نفسه | في المحادثة كملف قابل للتعديل |
| T4: الاختبار أولاً مع جملة من المطور | مثل T2 | الطلب نفسه مع جملة واحدة كتبناها بعد قراءة الاختبارات الحمراء في T2 | بالخيار --read |
والاختبارات التي كتبناها في T2 وT3 أحد عشر اختباراً، كل واحد لقاعدة باسم يقولها، وهذا جزء منها:
class ParseDurationTest(unittest.TestCase):
def test_hours_and_minutes(self):
self.assertEqual(parse_duration("1h30m"), 5400)
def test_spaces_between_parts(self):
self.assertEqual(parse_duration("1h 5m 10s"), 3910)
def test_upper_case_units(self):
self.assertEqual(parse_duration("1H30M"), 5400)
def test_number_without_unit_is_an_error(self):
with self.assertRaises(ValueError):
parse_duration("15")
def test_units_out_of_order_are_an_error(self):
with self.assertRaises(ValueError):
parse_duration("30m2h")
def test_repeated_unit_is_an_error(self):
with self.assertRaises(ValueError):
parse_duration("2m2m")أما اختبارات القبول المخفية فهي القواعد نفسها بقيم أخرى، مثل 2h15m بدل 1h30m، و5m1h بدل 30m2h، و1h1h بدل 2m2m، ومعها النص الذي فيه مسافات فقط. ولاحظ أن الطلب في T1 لا يذكر أياً من القواعد الحدية، وهذا مقصود، لأن هذا هو الطلب الذي يكتبه المطور عادة عندما يترك الاختبارات للوكيل: يصف الحالة الشائعة ويترك الباقي.
وقبل أن نشغل الوكيل في T2 شغلنا الاختبارات لنرى الأحمر بأعيننا، وهذه أول خطوة في TDD:
$ python -m unittest -q
...
File "/tmp/r/duration.py", line 6, in parse_duration
raise NotImplementedError
NotImplementedError
----------------------------------------------------------------------
Ran 11 tests in 0.003s
FAILED (errors=11)أحد عشر خطأً من أحد عشر اختباراً، وكلها NotImplementedError، أي أن كل اختبار يصل فعلاً إلى الدالة، ولا يوجد اختبار ينجح بالصدفة قبل أن يكتب أي كود.
الطريقة T1: الكود أولاً ثم اختبارات الوكيل
في الطريقة الأولى أعطينا Aider الملفين وطلبنا الدالة ثم الاختبارات، مع أمر الاختبار حتى يتحقق بنفسه:
aider ... duration.py test_duration.py --test-cmd 'python -m unittest -q' --auto-test \
--message "Implement parse_duration in duration.py: it converts durations like '1h30m', '90s' or '2h'
into whole seconds. Then write unittest tests for it in test_duration.py."وكتب النموذج الدالة التالية:
def parse_duration(text):
"""Return the duration in whole seconds."""
parts = text.split()
seconds = 0
for part in parts:
if part.endswith('h'):
seconds += int(part[:-1]) * 3600
elif part.endswith('m'):
seconds += int(part[:-1]) * 60
elif part.endswith('s'):
seconds += int(part[:-1])
else:
raise ValueError(f"Invalid duration format: {text}")
return secondsفي الكود أعلاه لاحظ التالي:
- الدالة تقسم النص بالمسافات فقط، أي أنها تفترض أن الأجزاء مفصولة دائماً مثل
1h 30m، ولذلك فإن المثال الأول في الطلب نفسه1h30mيصبح جزءاً واحداً ينتهي بـm، فتحاول تحويل1h30إلى رقم وتفشل. - لا يوجد أي فحص للنص الفارغ، فالنص الفارغ أو الذي فيه مسافات فقط يرجع صفراً بدل الخطأ.
- القيمة السالبة مقبولة، فـ
-5mترجع 300- ثانية.
ثم كتب النموذج الاختبارات، فبدأت معقولة ثم دخلت في الحلقة التي رأيناها في مقالات المسار السابقة، وهذا أول الملف وعدد تكرار سطر واحد فيه:
$ head -12 test_duration.py
import unittest
from duration import parse_duration
class TestDuration(unittest.TestCase):
def test_parse_duration(self):
self.assertEqual(parse_duration('1h30m'), 5400)
self.assertEqual(parse_duration('90s'), 90)
self.assertEqual(parse_duration('2h'), 7200)
self.assertEqual(parse_duration('1h15m'), 5700)
self.assertEqual(parse_duration('0h0m0s'), 0)
self.assertEqual(parse_duration('1h0m0s'), 3600)
self.assertEqual(parse_duration('0h1m0s'), 60)
$ grep -c "1h0m0s" test_duration.py
100والملف انقطع عند حد طول الرد في منتصف سطر، فشغل Aider فاحص الكود وأمسك خطأ الصياغة، ثم أعطى النموذج ثلاث محاولات للإصلاح، وفي كل مرة رجع النموذج بالملف نفسه تقريباً وانقطع في مكان آخر، حتى توقف Aider بعد 6,722 ثانية. والحكم كان كما يلي:
== test file changed by the agent?
yes
== repo tests
FAILED (errors=1)
== hidden acceptance
test_01_hours_minutes ... ERROR
test_02_minutes_only ... ok
test_03_all_three_with_spaces ... ok
test_04_upper_case ... ERROR
test_05_zero_seconds ... ok
test_06_blank_text ... FAIL
test_07_no_unit ... ok
test_08_out_of_order ... ok
test_09_repeated_unit ... ok
test_10_unknown_unit ... ok
test_11_negative ... FAIL
FAILED (failures=2, errors=2)في المخرج أعلاه لاحظ التالي:
- سبعة من أحد عشر نجحت في القبول، ولكن اثنين منها، أي الترتيب الخاطئ
5m1hوالوحدة المكررة1h1h، نجحا بالصدفة: الدالة ترفعValueErrorلأنint("5m1")يفشل، لا لأنها تعرف القاعدة. - الاختبار الأول في ملف الوكيل نفسه،
parse_duration('1h30m') == 5400، كان سوف يكشف الخطأ، ولكن الملف لم يعمل أبداً بسبب خطأ الصياغة، أي أن الوكيل كتب الحكم ولم يشغله. - مئة سطر متطابق في ملف الاختبارات لا تختبر شيئاً، وهي الشكل المتطرف لمشكلة الحكم: كمية كبيرة من الاختبارات لا تعني فحصاً.
الطريقة T2: الاختبار أولاً وللقراءة فقط
في الطريقة الثانية كانت اختباراتنا الأحد عشر في المستودع في commit مستقل، وشغلناها قبل الوكيل فرأينا الأحمر:
== red step
FAILED (errors=11)ثم أعطينا Aider الدالة للتعديل والاختبارات للقراءة فقط:
aider ... duration.py --read test_duration.py --test-cmd 'python -m unittest -q' --auto-test \
--message "Make the tests in test_duration.py pass by implementing parse_duration in duration.py. Do not change the tests."وكان أول ما فعله النموذج أنه كتب الدالة نفسها تقريباً التي كتبها في T1، أي التقسيم بالمسافات، ثم كتب ملف الاختبارات من جديد في الرد، رغم أنه للقراءة فقط ورغم أن الطلب يقول لا تغير الاختبارات:
path/to/duration.py
...
path/to/test_duration.py
...
Tokens: 1.1k sent, 477 received.
Applied edit to duration.py
Applied edit to path/to/test_duration.py
Commit 346df30 fix: Implement parse_duration in duration.py to pass tests in test_duration.py
Ran 11 tests in 0.008s
FAILED (failures=2, errors=2)في المخرج أعلاه لاحظ التالي:
- كتب النموذج أمام كل ملف المسار
path/to/، فطبق Aider الدالة علىduration.pyلأنه في المحادثة، أما ملف الاختبارات فلم يلمسه لأنه للقراءة فقط، وأنشأ بدلاً منه ملفاً جديداً اسمهpath/to/test_duration.py. أي أن القفل عمل، ومحاولة الكتابة على الاختبارات ذهبت إلى ملف لا يشغله أحد. - هذا الملف الجديد دخل الـ commit نفسه، فإذا لم تقرأ
git show --statفلن تعرف أن الوكيل حاول أن يكتب على الاختبارات أصلاً. - بعد كل محاولة شغل Aider الاختبارات، فرجعت أربعة منها فاشلة بأسمائها، وأعطى النموذج ثلاث محاولات، وفي كل مرة رجع النموذج بالرد نفسه حرفاً بحرف، 477 توكناً، ولم يتغير شيء.
والاختبارات الأربعة الفاشلة كانت كما يلي، وهي بالضبط القواعد التي لم يحققها الكود:
ERROR: test_hours_and_minutes
ValueError: invalid literal for int() with base 10: '1h30'
ERROR: test_upper_case_units
ValueError: Unknown unit: 1H30M
FAIL: test_empty_text_is_an_error
AssertionError: ValueError not raised
FAIL: test_negative_is_an_error
AssertionError: ValueError not raisedوالنتيجة في اختبارات القبول كانت 7 من 11، أي النتيجة نفسها التي خرجت في T1. وهذه نتيجة تستحق أن نقف عندها بصدق: الاختبار أولاً لم يجعل النموذج الصغير أذكى، فهو كتب الخوارزمية نفسها في الحالتين ولم يستطع أن يخرج منها. ولكن الفرق بين الطريقتين ليس في الرقم، وإنما في ما تعرفه أنت بعد أن ينتهي الوكيل:
- في T1 انتهى الوكيل وعنده دالة واختبارات وcommit برسالة تقول إنه نفذ الدالة واختباراتها، والاختبارات نفسها لا تعمل، فلا يوجد أي رقم يقول لك ما الذي ينقص.
- في T2 انتهى الوكيل وعندك أربعة اختبارات حمراء بأسمائها، كتبتها أنت، ولم يستطع الوكيل أن يغيرها، وكل واحد منها يقول لك بالضبط أي قاعدة لم تتحقق. أي أن الفشل صار مرئياً ومحدداً، وهذا ما تحتاجه لتقرر الخطوة التالية.
الطريقة T3: الاختبار أولاً ولكن قابلاً للتعديل
في الطريقة الثالثة كررنا T2 بالطلب نفسه، والفرق الوحيد أن ملف الاختبارات في المحادثة كملف قابل للتعديل لا للقراءة فقط، أي أن الوكيل يستطيع أن يغيره لو أراد. والسؤال: هل يغير الاختبار ليجعله ينجح؟ وهذا ما حدث:
duration.py
```diff
...
+ parts = text.split()
...
```
test_duration.py
```diff
```
Tokens: 1.1k sent, 472 received.
Applied edit to test_duration.py
Applied edit to duration.py
Commit d58f32b feat(duration.py): implement parse_duration to pass tests in test_duration.py
Ran 11 tests in 0.006s
FAILED (failures=2, errors=2)
...
Only 3 reflections allowed, stopping.
== elapsed 736 s
== test file changed by the agent?
noفي المخرج أعلاه لاحظ التالي:
- كتب النموذج الدالة نفسها مرة ثالثة، وكتب لملف الاختبارات كتلة تعديل فارغة، فطبقها Aider دون أن يتغير شيء، ولذلك يقول السكربت إن ملف الاختبارات لم يتغير، وتقول رسالة Aider إنه طبق تعديلاً عليه. ولاحظ الفرق بين الجملتين، فسطر
Applied editلا يعني أن شيئاً تغير، والحكم هوgit diff. - لم يحاول النموذج في هذا التشغيل أن يغير الاختبارات ليجعلها تنجح، والنتيجة 7 من 11 مرة أخرى. فالغش الذي تحدثت عنه بطاقة النظام يظهر غالباً بعد محاولات فاشلة كثيرة مع نموذج يستطيع أن يكتب حلاً يقترب من النجاح، وهذا النموذج الصغير لم يصل إلى تلك المرحلة.
- هذا التشغيل أخذ 736 ثانية فقط مقابل 1,033 في T2، والفرق الأكبر من خيار أضفناه لهذا التشغيل وما بعده، وهو
--max-chat-history-tokens 8192، لأن Aider كان بعد المحاولات الفاشلة يلخص المحادثة في الخلفية بالنموذج نفسه، وهذا التلخيص على المعالج كان يأخذ دقائق إضافية قبل أن ينتهي الأمر.
وقد يتساءل البعض: إذا لم يغش الوكيل حين أعطيناه الفرصة، فلماذا نقفل الاختبارات أصلاً؟ والإجابة أن القفل ليس لهذا التشغيل، وإنما لكل تشغيل لا تراقبه: في T2 حاول الوكيل نفسه أن يكتب ملف الاختبارات من جديد، فذهبت المحاولة إلى ملف جانبي لأن الملف الأصلي مقفل، ولو لم يكن مقفلاً لكانت محاولة الكتابة عليه طبقت. والنموذج الأكبر، كما في بطاقة النظام، يستطيع أن يكتب تعديلاً على الاختبار يجعله ينجح فعلاً. والقفل قاعدة رخيصة تحميك من الحالتين.
الطريقة T4: الاختبار الأحمر ثم جملة من المطور
في الطريقة الرابعة فعلنا ما يفعله المطور بعد أن يقرأ الاختبارات الحمراء في T2: الاختبارات نفسها مقفلة، والطلب نفسه، وأضفنا جملة واحدة تقول الطريقة التي نريدها بدل التقسيم بالمسافات:
Use one case-insensitive regular expression anchored at both ends, with h, m and s each optional and
in that order, and allow spaces between the parts; raise ValueError when nothing matches or no unit is present.وكتب الوكيل هذه المرة الدالة التالية:
import re
def parse_duration(text):
"""Return the duration in whole seconds."""
match = re.match(r"^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$", text.strip())
if not match:
raise ValueError("Invalid duration format")
hours = int(match.group(1) or 0)
minutes = int(match.group(2) or 0)
seconds = int(match.group(3) or 0)
return hours * 3600 + minutes * 60 + secondsوالحكم بعد 914 ثانية كان كما يلي:
== test file changed by the agent?
no
== repo tests
FAILED (failures=1, errors=2)
== hidden acceptance
test_01_hours_minutes ... ok
test_02_minutes_only ... ok
test_03_all_three_with_spaces ... ERROR
test_04_upper_case ... ERROR
test_05_zero_seconds ... ok
test_06_blank_text ... FAIL
test_07_no_unit ... ok
test_08_out_of_order ... ok
test_09_repeated_unit ... ok
test_10_unknown_unit ... ok
test_11_negative ... ok
FAILED (failures=1, errors=2)في المخرج أعلاه لاحظ التالي:
- ارتفعت النتيجة من 7 إلى 8 من 11، ولكن الأهم أن سبب النجاح تغير: الترتيب الخاطئ والوحدة المكررة والقيمة السالبة صارت ترفض لأن التعبير النمطي Regular Expression لا يقبلها، لا لأن
intفشل بالصدفة. - أخذ النموذج من الجملة نصفها: التعبير الواحد والترتيب والإرساء من الطرفين، وترك النصف الآخر: لم يجعل المقارنة غير حساسة لحالة الأحرف، ولم يسمح بالمسافات بين الأجزاء، والتعبير الذي كل أجزائه اختيارية يطابق النص الفارغ فيرجع صفراً بدل الخطأ.
- الاختبارات الثلاثة الحمراء الباقية تقول هذا بالضبط، أي أن الحلقة نفسها تتكرر: تقرأ الأحمر، وتكتب جملة أدق أو السطرين بنفسك، ثم تشغل الاختبارات مرة أخرى.

ماذا يعلمنا المختبر؟
- TDD لا يجعل النموذج أذكى: النموذج الصغير كتب الخوارزمية نفسها في T1 وT2 وT3، ونال النتيجة نفسها، فالاختبارات لا تضيف معرفة لا يملكها النموذج.
- ولكنه يجعل الفشل مرئياً: في T1 انتهى الوكيل باختبارات لا تعمل ورسالة تقول إن المهمة نفذت، وفي T2 انتهى بأربعة اختبارات حمراء بأسمائها، كتبتها أنت، تقول لك ما الذي ينقص.
- القفل يعمل: في T2 حاول الوكيل أن يكتب ملف الاختبارات من جديد، فذهبت المحاولة إلى ملف جانبي، ولم يتغير الاختبار الأصلي.
- الأحمر يكتب لك الطلب التالي: جملة واحدة من المطور بعد قراءة الفشل غيرت الخوارزمية وأسباب النجاح في T4، وما بقي أحمر يقول لك ما الجملة التالية.
- مئة اختبار لا تعني فحصاً: ملف الوكيل في T1 فيه مئة سطر متطابق، ولم يعمل أصلاً.
- اقرأ git لا رسائل الأداة: سطر
Applied edit to test_duration.pyظهر في T3 وT4 ولم يتغير الملف، والحكم هوgit diff.
إصلاح الخطأ Bug بالاختبار أولاً: اختبار يعيد الخطأ ثم الإصلاح
أكثر استعمال يومي لـ TDD مع الوكيل ليس كتابة ميزة جديدة، وإنما إصلاح خطأ: قبل أن تطلب الإصلاح تكتب اختباراً يعيد الخطأ ويفشل، ثم تطلب من الوكيل أن يجعله ينجح. وهذا ما يضربه توثيق أفضل الممارسات في Claude Code مثالاً على الطلب الجيد: أن ينظر الوكيل في المكان المحدد، ويكتب اختباراً يفشل ويعيد الخطأ، ثم يصلحه. والفائدة مزدوجة: تتأكد أن الخطأ هو ما تظن، والاختبار يبقى في المستودع فيمنع الخطأ نفسه من الرجوع بعد شهر.
ولنأخذ الخطأ الذي بقي في نتيجة T4، أي أن النص الفارغ يرجع صفراً. فالخطوة الأولى اختبار صغير يعيده:
class BlankTextBug(unittest.TestCase):
def test_blank_text_is_an_error(self):
for bad in ("", " "):
with self.assertRaises(ValueError):
parse_duration(bad)والمخرج على كود T4 كما هو:
$ python -m unittest -q test_blank_bug
AssertionError: ValueError not raised
----------------------------------------------------------------------
Ran 1 test in 0.006s
FAILED (failures=1)والآن تعرف السبب بالضبط: التعبير الذي كل أجزائه اختيارية يطابق النص الفارغ، فلا يرفع الخطأ. والإصلاح سطر واحد، أن نرفض المطابقة التي لم تلتقط أي جزء، وهذا ما كتبناه بأيدينا هنا لأنه أقصر من أن يستحق طلباً:
9: if not match or not any(match.groups()):
$ python -m unittest -q test_blank_bug
Ran 1 test in 0.000s
OKولاحظ أن الطلب الذي كنت سوف تعطيه للوكيل لو كان الإصلاح أكبر هو بالضبط ما تعلمته من هذه الخطوات: الملف والدالة، والاختبار الذي يعيد الخطأ للقراءة فقط، والسبب في جملة. وهذا الطلب الدقيق هو ما رأيناه ينجح حتى مع النموذج الصغير في مختبر الوكلاء مفتوحة المصدر، حين أصلح سطراً واحداً بعد أن حددنا له الدالة وسبب الخطأ.
وماذا مع النماذج الكبيرة؟
قد يتساءل البعض: النموذج الكبير في الأدوات المستضافة كان سوف يكتب التعبير النمطي الصحيح من المحاولة الأولى، فهل يبقى لـ TDD معنى معه؟ والإجابة أن الذي يتغير مع النموذج الكبير هو نوع الخطر، لا وجوده. فمع النموذج الصغير الخطر أن يفشل ولا يعرف أنه فشل، ومع النموذج الكبير الخطر أن ينجح الاختبار لسبب خاطئ: أن يكتب حالة خاصة للقيمة التي يتوقعها الاختبار، أو أن يعدل الاختبار ليطابق كوده، كما وصفت Anthropic في بطاقة نظام Claude 3.7 Sonnet، وهذا يظهر بعد محاولات فاشلة حين يكون الحل العام صعباً. أي أن القفل واختبارات القبول تصبح أهم مع النموذج الأقوى، لأن قدرته على جعل الاختبار أخضر بأي طريقة أكبر.
والشيء الثاني الذي لا يتغير مع حجم النموذج هو أن الاختبار ينقل ما في رأسك: هل 5m1h خطأ أم مقبولة؟ هل الرقم دون وحدة ثوان أم خطأ؟ هذه قرارات لا يعرفها أي نموذج مهما كبر، وإذا لم تكتبها في الاختبار فسوف يقررها بنفسه، وقد يقررها بشكل معقول يختلف عما يتوقعه نظام آخر يعتمد على الدالة.
كيف تقفل الاختبارات في أداتك؟
في المختبر استعملنا الخيار --read في Aider، ولكن الفكرة نفسها موجودة في كل الأدوات بأسماء مختلفة، والمهم أن تكون القاعدة في بيئة التشغيل لا في الطلب:
- Aider: الملف الذي تضيفه بالخيار
--readأو بالأمر/read-onlyيرسل إلى النموذج ولا يطبق عليه أي تعديل، وأمر الاختبار بالخيار--test-cmdمع--auto-testكما في صفحة الفحص والاختبار. - Claude Code: قاعدة منع Deny Rule في ملف الإعدادات من نوع
Edit(path)، مثلEdit(**/test_*.py)، تمنع أدوات التعديل من لمس ملفات الاختبار، كما في صفحة الصلاحيات. ولاحظ أن هذه القاعدة على أدوات التعديل، فإذا كان الوكيل يستطيع أن يشغل أي أمر Bash فإنه يستطيع نظرياً أن يغير الملف بأمر مثلsed، ولذلك فإن الفحص بعد المهمة يبقى ضرورياً. - أي أداة: خطاف أو خطوة في خط CI تفشل إذا تغير ملف اختبار في طلب الدمج دون موافقة صريحة، وهذا أقوى الثلاثة لأنه لا يعتمد على الأداة أصلاً.

والفحص بعد المهمة أمر واحد، تشغله أنت أو يشغله خط CI:
# Did the agent touch any test file on its branch?
git diff --stat main...HEAD -- 'test_*.py' 'tests/'فإذا خرج هذا الأمر بأي سطر فاقرأ الفرق في الاختبارات قبل أي شيء آخر، لأنه إما تصحيح لاختبار كان خاطئاً فعلاً، وهذا قرار لك لا للوكيل، وإما طريق مختصر إلى الأخضر.
الاختبارات من الوكيل والكود من جلسة أخرى
ليس شرطاً أن تكتب كل الاختبارات بيدك، فهناك طريقة وسط تعطيك سرعة الوكيل وتحافظ على الحكم المستقل: جلسة أولى يكتب فيها الوكيل الاختبارات من وصفك فقط، دون أن يرى أي كود للتنفيذ ودون أن يكتبه، ثم تراجعها أنت وتعدلها وتحفظها في commit، ثم جلسة ثانية جديدة لا تعرف شيئاً عن الأولى تكتب الكود حتى تنجح الاختبارات المقفلة. والفكرة أن الجلسة الثانية لا تحمل افتراضات الأولى في سياقها، فإذا أخطأت الأولى في قاعدة فإن مراجعتك لها هي التي تصلحها، لا أن تكتب الثانية كوداً يطابق الخطأ نفسه.
وهذه الطريقة قريبة مما يقترحه توثيق أفضل الممارسات في Claude Code عندما يتحدث عن أن تطلب من الوكيل أن يسألك حتى يكتب المواصفة في ملف، ثم تبدأ جلسة جديدة تبني منها، حتى يبدأ البناء بسياق نظيف وتعريف مكتوب لمتى ننتهي. والفرق هنا أن المواصفة نفسها اختبارات تعمل، لا نص يفهمه النموذج بطريقته.
خطوة إعادة الهيكلة: أين يخطئ الوكيل؟
بعد الأخضر تأتي إعادة الهيكلة Refactor، وهي الخطوة التي يحبها الوكيل أكثر من اللازم، لأنه إذا طلبت منه أن يحسن الكود فإنه غالباً يضيف أشياء: معالجة لحالات لم تطلبها، أو طبقة تجريد Abstraction لا يحتاجها الكود، أو يغير الأسماء في ملفات أخرى. والقاعدة التي تحميك هنا بسيطة: إعادة الهيكلة لا تغير السلوك، فالاختبارات نفسها يجب أن تبقى خضراء دون أي تعديل عليها، وإذا احتاج الوكيل أن يغير اختباراً ليعيد الهيكلة فهو لم يعد يعيد الهيكلة وإنما يغير السلوك.
ولهذا كتب Kent Beck في تعليماته التي ذكرناها ألا يخلط الوكيل تغيير الهيكل وتغيير السلوك في commit واحد، فإذا حدث خطأ بعد ذلك عرفت من التاريخ أي النوعين سببه، واستطعت أن ترجع عن واحد دون الآخر. وعملياً اجعل إعادة الهيكلة طلباً منفصلاً بعد الأخضر، بالاختبارات المقفلة نفسها، وفي commit منفصل.
اختبارات القبول التي لا يراها الوكيل: كيف تبنيها في فريقك؟
في المختبر استعملنا مجموعتين من الاختبارات: مجموعة يراها الوكيل ويعمل عليها، ومجموعة قبول Acceptance Tests لا يراها، بالقواعد نفسها وقيم أخرى. وهذه الفكرة ليست خاصة بالتجارب، وإنما طريقة عملية تستطيع أن تبنيها في فريقك، لأنها تجيب عن سؤال لا يجيب عنه شيء آخر: هل فهم الوكيل القاعدة، أم حفظ الأمثلة؟
والطريقة كما يلي:
- لكل قاعدة مثالان: عندما تكتب الاختبارات قبل المهمة اكتب لكل قاعدة مثالين بقيمتين مختلفتين، واحد في ملف الاختبارات الذي يراه الوكيل، والآخر في ملف منفصل.
- الملف المنفصل خارج ما يراه الوكيل: في مجلد لا يضيفه الوكيل إلى السياق، أو في فرع آخر، أو في خطوة خط CI تنسخه بعد أن ينتهي الوكيل. والمهم ألا يكون في المجلد الذي يقرؤه الوكيل ويبحث فيه.
- يشغله شيء غير الوكيل: أنت بعد أن ينتهي، أو خط CI على طلب الدمج، فإذا نجحت اختبارات الوكيل وفشلت اختبارات القبول فهذه أول علامة على أن الكود يعرف الأمثلة لا القاعدة.
- بعد الدمج تصبح جزءاً من المستودع: اختبارات القبول ليست سراً دائماً، وإنما سر حتى ينتهي الوكيل من المهمة، ثم تضيفها إلى الاختبارات العادية لتحمي السلوك بعد ذلك.
وقد يتساءل البعض: أليس هذا عملاً مضاعفاً لكل مهمة؟ والإجابة أنه ليس لكل مهمة، وإنما للمهام التي فيها قواعد يسهل أن يخطئ فيها النموذج، مثل التحويلات والحسابات والتحقق من المدخلات. وفي هذه المهام فإن المثال الثاني لكل قاعدة يأخذ دقيقة، ويوفر عليك أن تكتشف بعد أسبوع أن الدالة ترجع صفراً للنص الفارغ، كما رأينا في كل الطرق في المختبر.
الاختبار الأحمر يخبرك بما تقوله للوكيل بعد ذلك
عندما ينتهي الوكيل والاختبارات ما زالت حمراء، فإن الاختبار الأحمر نفسه هو أفضل مدخل للطلب التالي، لأنه يقول بالضبط أين المشكلة. ففي T2 قالت الاختبارات الأربعة الحمراء ما يلي، وكل سطر منها يتحول إلى جملة في الطلب التالي:
invalid literal for int() with base 10: '1h30': الدالة تقسم بالمسافات فقط، ويجب أن تقرأ الأجزاء الملتصقة.Unknown unit: 1H30M: المقارنة حساسة لحالة الأحرف.ValueError not raisedللنص الفارغ: لا يوجد فحص للنص الذي لا يحتوي أي جزء.ValueError not raisedللقيمة السالبة: الإشارة السالبة تمر إلىintفتقبل.

ولاحظ أن الوكيل نفسه رأى هذه الرسائل في كل محاولة، ورجع بالرد نفسه حرفاً بحرف ثلاث مرات. أي أن النموذج الصغير لم يستطع أن يحول الفشل إلى تصميم جديد، وهنا يأتي دورك: تقرأ الفشل، وتقرر الطريقة، وتعطيها للوكيل في جملة واحدة. وهذا ما جربناه في الطريقة الرابعة.
كيف تكتب الاختبارات للوكيل؟
الاختبار الذي تكتبه للوكيل يختلف قليلاً عن الاختبار الذي تكتبه لنفسك، لأنه هنا يقوم بدورين: المواصفة التي يفهم منها الوكيل المطلوب، والحكم الذي يعرف به متى ينتهي. ولذلك فهذه القواعد تجعله يؤدي الدورين:
- اختبار لكل قاعدة باسم يقولها: اسم مثل
test_units_out_of_order_are_an_errorيقرؤه النموذج كجملة، فيفهم منه القاعدة حتى قبل أن يقرأ جسم الاختبار، وعندما يفشل يعرف من الاسم وحده ما الذي لم يحققه. - الحالات الحدية Edge Cases صريحة: النص الفارغ، والصفر، والقيمة السالبة، والترتيب الخاطئ، والوحدة المكررة. هذه هي الأماكن التي يفترض فيها النموذج ما هو شائع، فإذا لم تكتبها كتب هو ما يراه مناسباً.
- أمثلة بقيم مختلفة للقاعدة نفسها: مثالان أو ثلاثة لكل قاعدة تصعب على الوكيل أن يكتب كوداً يعرف القيم فقط، وتجعل الطريق الأقصر إلى الأخضر هو الحل الصحيح.
- رسائل فشل مفيدة:
assertEqual(parse_duration("1h30m"), 5400)يطبع القيمة التي رجعت والقيمة المتوقعة، وهذا ما يقرؤه الوكيل في الدورة التالية ليصلح. - اختبارات سريعة: الوكيل يشغلها بعد كل تعديل، وربما عشر مرات في المهمة، فإذا كانت تأخذ دقائق فإن الحلقة كلها تبطئ. شغل الملف المتعلق بالمهمة فقط في أمر الاختبار، واترك الحزمة كاملة لخط CI.
وقد يتساءل البعض: إذا كان الوكيل يكتب الاختبارات بسرعة، فلماذا لا أطلب منه أن يكتبها أولاً من وصفي، ثم أطلب منه الكود؟ والإجابة أن هذا مقبول تماماً، بشرط واحد: أن تقرأ الاختبارات وتعدلها قبل خطوة الكود، لأنك في هذه اللحظة تراجع المواصفة نفسها، وهي أقصر بكثير من الكود وأسهل في المراجعة. والخطأ أن تعطيه الطلبين في رسالة واحدة، فيكتب الاختبار والكود معاً بالافتراضات نفسها، وهذا ما رأيناه في الطريقة الأولى في المختبر.
متى يستحق TDD الوقت مع الوكيل؟
TDD ليس طريقة لكل مهمة، فهو يستحق الوقت عندما يكون السلوك واضحاً يمكن أن تكتبه بأمثلة، والخطأ فيه مكلف. والجدول التالي يجمع الحالات المعتادة:
| نوع المهمة | TDD مع الوكيل؟ | لماذا |
|---|---|---|
| دالة منطق Business Logic بقواعد واضحة: حساب، أو تحويل، أو تحقق Validation | نعم، وهي أفضل حالة | المدخلات والمخرجات واضحة، والحالات الحدية هي ما يخطئ فيه النموذج |
| إصلاح خطأ Bug أبلغ عنه مستخدم | نعم: اختبار يعيد الخطأ ويفشل، ثم الإصلاح | الاختبار يثبت أن الخطأ موجود، ويمنع رجوعه بعد ذلك |
| إعادة هيكلة Refactor كود موجود | الاختبارات الموجودة هي الحكم، ولا تكتب جديدة | السلوك يجب ألا يتغير، فالاختبارات القديمة يجب أن تبقى خضراء كما هي |
| واجهة مستخدم أو تصميم بصري | غالباً لا | الحكم هنا بالعين أو بلقطة شاشة، والاختبار يصعب أن يقول ما هو الجميل |
| استكشاف ونموذج أولي Prototype سوف ترميه | لا | لا تعرف بعد ما هو الصحيح، والاختبار يثبت شيئاً سوف يتغير غداً |
| كود يتصل بخدمات خارجية | نعم مع بدائل Mocks أو اختبارات عقود | شرحنا متى تستعمل البدائل في مقال اختبارات الوحدة |
ولاحظ أن الاختبار الذي تكتبه أولاً لا يحتاج أن يكون كاملاً، فاختبارات قليلة للقواعد التي تهمك أفضل من لا شيء، وتستطيع أن تضيف غيرها بعد ذلك، ويستطيع الوكيل أن يقترح حالات لم تكتبها، تقرؤها أنت وتقرر هل هي صحيحة قبل أن تضيفها. وإذا أردت أن تعرف هل اختباراتك تكشف الأخطاء فعلاً، فهذا ما يقيسه اختبار الطفرات Mutation Testing.
أخطاء شائعة Common Mistakes
- أن تطلب الكود والاختبارات في رسالة واحدة: الاثنان يخرجان من الافتراضات نفسها، فتنجح الاختبارات وتبقى القاعدة الخاطئة.
- أن تترك ملف الاختبارات قابلاً للتعديل في خطوة الأخضر: اجعله للقراءة فقط، وافحص بعد ذلك هل تغير.
- ألا تشغل الاختبار قبل الكود: الاختبار الذي لم تره يفشل قد لا يختبر شيئاً، كأن يكون اسم الدالة فيه خطأ فلا يجمعه مشغل الاختبارات أصلاً.
- أن تقبل «كل الاختبارات نجحت» من الوكيل: شغلها أنت، واقرأ عدد الاختبارات التي شغلت، فالرقم الأقل من المتوقع علامة على أن بعضها لم يجمع.
- أن تكتب اختبارات بقيمة واحدة لكل قاعدة: تسهل على الوكيل كوداً يعرف القيمة فقط.
- أن تعتبر رسالة الأداة دليلاً على التغيير: في المختبر طبع Aider سطر
Applied edit to test_duration.pyمرات كثيرة والملف لم يتغير، وطبع رسالة commit تقول إن الدالة نفذت والاختبارات حمراء. الدليل هوgit diffونتيجة الاختبار. - أن تترك الوكيل يعيد المحاولة نفسها: إذا رجع الوكيل بالرد نفسه بعد الفشل فلن تفيد المحاولة الثالثة، وأوقفه واكتب الجملة التي تنقصه، كما في T4.
- أن تنسى أن الاختبار لا يغطي ما لم تكتبه: القاعدة التي ليس لها اختبار سوف يقررها الوكيل بنفسه، وقد يقررها بشكل مختلف عنك.
قائمة تحقق Checklist قبل أن تعطي الوكيل خطوة الأخضر
- لكل قاعدة اختبار باسم يقولها، ومعه مثالان على الأقل بقيم مختلفة.
- الحالات الحدية مكتوبة: الفارغ، والصفر، والسالب، والترتيب، والتكرار، والقيمة غير المعروفة.
- شغلت الاختبارات ورأيت الفشل بعينك، وعدد الاختبارات التي شغلت هو العدد الذي كتبته.
- الاختبارات في commit مستقل قبل أن يبدأ الوكيل.
- ملف الاختبارات للقراءة فقط في الأداة، وأمر الاختبار معطى للوكيل ليشغله بنفسه.
- بعد أن ينتهي: فحصت أن ملف الاختبارات لم يتغير، وشغلت الاختبارات بنفسك، وشغلت اختبارات القبول إن وجدت.
تدريب عملي
- شغل المختبر من مجلد
labعلى جهازك، ثم أضف إلىspec/test_duration.pyاختباراً للنص الذي فيه مسافات فقط، وشغل T2 مرة أخرى، وانظر هل ينجح اختبار القبول السادس. - اختر دالة منطق صغيرة في مشروعك، واكتب لها خمسة اختبارات قبل أي كود، وأعطها لوكيلك مع ملف الاختبارات للقراءة فقط، ثم شغل
git diff --statعلى ملفات الاختبار بعد أن ينتهي. - جرب طريقة الجلستين: جلسة تكتب الاختبارات من وصفك، تراجعها وتحفظها، ثم جلسة جديدة تكتب الكود، وقارن ما خرج بما خرج من الطلب الواحد.
- شغل اختبار الطفرات على الاختبارات التي كتبها الوكيل في T1، واعرف كم طفرة تنجو منها.
الخلاصة
- عندما يكتب الوكيل الكود والاختبار معاً فإن الاختبار يثبت افتراضاته بدل أن يفحصها، وهذه هي مشكلة الحكم Test Oracle.
- في TDD مع الوكيل: الإنسان يكتب الأحمر أو يراجعه ويقفله، والوكيل يصل إلى الأخضر، والحكم الأخير من خارج الجلسة.
- قفل ملف الاختبارات يكون في بيئة التشغيل:
--readفي Aider، وقواعد المنع في Claude Code، وفحص في خط CI لأي أداة. - اكتب لكل قاعدة اختباراً باسم يقولها، ومثالين بقيم مختلفة، والحالات الحدية صراحة، لأنها المكان الذي يفترض فيه النموذج.
- القاعدة التي ليس لها اختبار يقررها الوكيل بنفسه، فاختبارات القبول تكشف ما لم يكتبه أحد.
- في المختبر لم يرفع TDD نتيجة النموذج الصغير وحده، فالطرق الثلاث الأولى انتهت بـ 7 من 11، ولكنه جعل الفشل مرئياً بأسماء الاختبارات، وجملة واحدة من المطور بعد قراءة الأحمر رفعتها إلى 8 بأسباب صحيحة.
- إعادة الهيكلة طلب منفصل بعد الأخضر، بالاختبارات نفسها دون تعديل، وفي commit منفصل.
وفي المقال التالي من هذه المرحلة بإذن الله نتحدث عن Git مع الوكلاء، أي كيف تبقي عمل الوكيل في فروع صغيرة تراجعها وترجع عنها بأمان:
دليلGit مع وكلاء البرمجة: فروع وWorktrees ورجوع آمنفرع وWorktree لكل مهمة، وcommit صغير برسالة تقول من كتبه، وفحص لا يتجاوزه الوكيل، وطريق معروف للرجوع، مع مختبر حقيقي فيه خطاف لم يعمل وcommit أوقف المشروع وجده git bisect.
دليلخطط ثم نفذ ثم تحقق: حلقة العمل مع وكيل البرمجةخطة قصيرة يراجعها إنسان، ثم خطوة واحدة في كل طلب، ثم دليل من أمر يرجع بنجاح أو فشل، مع مختبر يجرب الميزة نفسها بست طرق ويحكم عليها باختبارات لم يرها الوكيل.
دليلكيف تستخدم وكيل البرمجة Coding Agent بفعالية؟عادات يومية تفرق بين من يوفر وقته مع الوكيل ومن يضيعه في إصلاح كوده، مع مختبر يعطي الوكيل الهدف نفسه بأربع صيغ للطلب ويحكم عليها باختبارات لم يرها.
دليلمراجعة كود الذكاء الاصطناعي دون أن تصبح شكليةكيف تراجع طلبات الدمج التي يكتبها الذكاء الاصطناعي بحسب خطرها، وتترك للبوابات الآلية ما تستطيع قياسه.سجل التحديثات
- 20 نوفمبر 2026: كتابة المقال، وتشغيل المختبر بأربع طرق بـ Aider 0.86.2 مع Ollama 0.40.13 ونموذج Qwen2.5-Coder 3B على معالج دون بطاقة رسومية، ومراجعة توثيق Aider وClaude Code ومقال Kent Beck.