Skip to content

Harness engineering beginner tutorial, from 0 to 1

Add L13 + P07 translations for all 13 locales

sanbuphyfdffe241dac1
diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts
index 4e60a3b..7b2ec2a 100644
--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@@ -102,7 +102,9 @@ const viLectureItems = [
{ text: "Tại sao Agent tuyên bố thành công quá sớm", link: "/vi/lectures/lecture-09-why-agents-declare-victory-too-early/" },
{ text: "Tại sao kiểm thử End-to-End thay đổi kết quả", link: "/vi/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Tại sao tính quan sát thuộc về bên trong Harness", link: "/vi/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
- { text: "Tại sao mỗi phiên làm việc phải để lại trạng thái sạch", link: "/vi/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" }
+ { text: "Tại sao mỗi phiên làm việc phải để lại trạng thái sạch", link: "/vi/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Từ Nhắc lệnh Thủ công đến Vòng lặp Tự chủ", link: "/vi/lectures/lecture-13-loop-engineering/" },
];
const viProjectItems = [
@@ -113,6 +115,8 @@ const viProjectItems = [
{ text: "Phản hồi Runtime và Kiểm soát Phạm vi", link: "/vi/projects/project-04-incremental-indexing/" },
{ text: "Tự xác minh và Phân tách Vai trò", link: "/vi/projects/project-05-grounded-qa-verification/" },
{ text: "Harness Hoàn chỉnh", link: "/vi/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Xây dựng Vòng lặp Tự động Đầu tiên", link: "/vi/projects/project-07-loop-engineering-first-loop/" },
];
const viResourceItems = [
@@ -140,6 +144,8 @@ const ruLectureItems = [
{ text: "Только сквозной прогон — настоящая проверка", link: "/ru/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Наблюдаемость — часть harness", link: "/ru/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Каждая сессия должна оставлять чистое состояние", link: "/ru/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "От ручных запросов к автономным циклам", link: "/ru/lectures/lecture-13-loop-engineering/" },
];
const ruProjectItems = [
@@ -150,6 +156,8 @@ const ruProjectItems = [
{ text: "Обратная связь и контроль скоупа", link: "/ru/projects/project-04-incremental-indexing/" },
{ text: "Самопроверка и обоснованные ответы", link: "/ru/projects/project-05-grounded-qa-verification/" },
{ text: "Полный harness (капстоун)", link: "/ru/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Постройте свой первый автоматизированный цикл", link: "/ru/projects/project-07-loop-engineering-first-loop/" },
];
const ruResourceItems = [
@@ -177,6 +185,8 @@ const uzLectureItems = [
{ text: "End-to-end testlar nega natijani oʻzgartiradi", link: "/uz/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Kuzatuvchanlik nega harness ichida boʻlishi kerak", link: "/uz/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Har bir sessiya nega toza holat qoldirishi kerak", link: "/uz/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Qoʻlda prompt yozishdan avtonom loop'largacha", link: "/uz/lectures/lecture-13-loop-engineering/" },
];
const uzProjectItems = [
@@ -187,6 +197,8 @@ const uzProjectItems = [
{ text: "Runtime fikr-mulohaza va skoup nazorati", link: "/uz/projects/project-04-incremental-indexing/" },
{ text: "Oʻz-oʻzini tekshirish va rollarni ajratish", link: "/uz/projects/project-05-grounded-qa-verification/" },
{ text: "Toʻliq harness (yakuniy loyiha)", link: "/uz/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Birinchi avtomatlashtirilgan loop'ingizni qurish", link: "/uz/projects/project-07-loop-engineering-first-loop/" },
];
const uzResourceItems = [
@@ -214,6 +226,8 @@ const koLectureItems = [
{ text: "엔드투엔드 테스트가 결과를 바꾸는 이유", link: "/ko/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "관측 가능성이 하네스 안에 있어야 하는 이유", link: "/ko/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "모든 세션이 클린 상태로 끝나야 하는 이유", link: "/ko/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "수동 프롬프팅에서 자율 루프로", link: "/ko/lectures/lecture-13-loop-engineering/" },
];
const koProjectItems = [
@@ -224,6 +238,8 @@ const koProjectItems = [
{ text: "런타임 피드백과 범위 제어", link: "/ko/projects/project-04-incremental-indexing/" },
{ text: "자기 검증과 역할 분리", link: "/ko/projects/project-05-grounded-qa-verification/" },
{ text: "완성형 하네스(캡스톤)", link: "/ko/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "첫 번째 자동 루프 구축하기", link: "/ko/projects/project-07-loop-engineering-first-loop/" },
];
const koResourceItems = [
@@ -251,6 +267,8 @@ const jaLectureItems = [
{ text: "End-to-End テストだけが本当の検証である", link: "/ja/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "エージェントのランタイムを観測可能にする", link: "/ja/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "すべてのセッションをきれいな引き継ぎで終える", link: "/ja/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "手動プロンプトから自律ループへ", link: "/ja/lectures/lecture-13-loop-engineering/" },
];
const jaProjectItems = [
@@ -261,6 +279,8 @@ const jaProjectItems = [
{ text: "ランタイムフィードバックでエージェントの挙動を修正する", link: "/ja/projects/project-04-incremental-indexing/" },
{ text: "エージェントに自分の作業を検証させる", link: "/ja/projects/project-05-grounded-qa-verification/" },
{ text: "完全なエージェント harness を構築する(総合課題)", link: "/ja/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "初めての自動ループを構築する", link: "/ja/projects/project-07-loop-engineering-first-loop/" },
];
const jaResourceItems = [
@@ -288,6 +308,8 @@ const esLectureItems = [
{ text: "Solo las pruebas end-to-end son verificación real", link: "/es/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Haz observable el runtime del agente", link: "/es/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Deja un handoff limpio al final de cada sesión", link: "/es/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Del Prompting Manual a los Loops Autónomos", link: "/es/lectures/lecture-13-loop-engineering/" },
];
const esProjectItems = [
@@ -298,6 +320,8 @@ const esProjectItems = [
{ text: "Usa feedback de runtime para corregir el comportamiento", link: "/es/projects/project-04-incremental-indexing/" },
{ text: "Haz que el agente verifique su propio trabajo", link: "/es/projects/project-05-grounded-qa-verification/" },
{ text: "Construye un harness completo (capstone)", link: "/es/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Construye Tu Primer Loop Automatizado", link: "/es/projects/project-07-loop-engineering-first-loop/" },
];
const esResourceItems = [
@@ -325,6 +349,8 @@ const frLectureItems = [
{ text: "Seul le test end-to-end est une vraie vérification", link: "/fr/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Rendre le runtime de l'agent observable", link: "/fr/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Laisser un handoff propre à la fin de chaque session", link: "/fr/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Du prompting manuel aux boucles autonomes", link: "/fr/lectures/lecture-13-loop-engineering/" },
];
const frProjectItems = [
@@ -335,6 +361,8 @@ const frProjectItems = [
{ text: "Utiliser le feedback runtime pour corriger le comportement", link: "/fr/projects/project-04-incremental-indexing/" },
{ text: "Faire vérifier son propre travail par l'agent", link: "/fr/projects/project-05-grounded-qa-verification/" },
{ text: "Construire un harness complet (capstone)", link: "/fr/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Construisez votre première boucle automatisée", link: "/fr/projects/project-07-loop-engineering-first-loop/" },
];
const frResourceItems = [
@@ -362,6 +390,8 @@ const deLectureItems = [
{ text: "Nur End-to-End-Tests sind echte Verifikation", link: "/de/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Die Runtime des Agenten beobachtbar machen", link: "/de/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Sauberes Handoff am Ende jeder Session", link: "/de/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Von manuellen Prompts zu autonomen Loops", link: "/de/lectures/lecture-13-loop-engineering/" },
];
const deProjectItems = [
@@ -372,6 +402,8 @@ const deProjectItems = [
{ text: "Runtime-Feedback nutzen, um Agentenverhalten zu korrigieren", link: "/de/projects/project-04-incremental-indexing/" },
{ text: "Den Agenten seine eigene Arbeit verifizieren lassen", link: "/de/projects/project-05-grounded-qa-verification/" },
{ text: "Einen vollständigen Agenten-harness bauen (Capstone)", link: "/de/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Baue deinen ersten automatisierten Loop", link: "/de/projects/project-07-loop-engineering-first-loop/" },
];
const deResourceItems = [
@@ -399,6 +431,8 @@ const arLectureItems = [
{ text: "الاختبار end-to-end هو التحقق الحقيقي", link: "/ar/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "اجعل runtime الوكيل قابلًا للملاحظة", link: "/ar/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "اترك handoff نظيفًا في نهاية كل جلسة", link: "/ar/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "من المطالبة اليدوية إلى الحلقات المستقلة", link: "/ar/lectures/lecture-13-loop-engineering/" },
];
const arProjectItems = [
@@ -409,6 +443,8 @@ const arProjectItems = [
{ text: "استخدم feedback في runtime لتصحيح سلوك الوكيل", link: "/ar/projects/project-04-incremental-indexing/" },
{ text: "اجعل الوكيل يتحقق من عمله", link: "/ar/projects/project-05-grounded-qa-verification/" },
{ text: "ابنِ harness كاملًا للوكيل (Capstone)", link: "/ar/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "ابني أول حلقة آلية", link: "/ar/projects/project-07-loop-engineering-first-loop/" },
];
const arResourceItems = [
@@ -436,6 +472,8 @@ const trLectureItems = [
{ text: "Uçtan Uca Test Sonuçları Neden Değiştirir", link: "/tr/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Gözlemlenebilirlik Neden Harness’ın İçinde Olmalı", link: "/tr/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Her Oturum Neden Temiz Bir Durumla Bitmeli", link: "/tr/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Manuel Prompting'den Otonom Loop'lara", link: "/tr/lectures/lecture-13-loop-engineering/" },
];
const trProjectItems = [
@@ -446,6 +484,8 @@ const trProjectItems = [
{ text: "Çalışma Zamanı Geri Bildirimi ve Kapsam Kontrolü", link: "/tr/projects/project-04-incremental-indexing/" },
{ text: "Öz-Doğrulama ve Rol Ayrımı", link: "/tr/projects/project-05-grounded-qa-verification/" },
{ text: "Eksiksiz Harness (Bitirme Projesi)", link: "/tr/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "İlk Otomatik Loop'unuzu Oluşturun", link: "/tr/projects/project-07-loop-engineering-first-loop/" },
];
const trResourceItems = [
@@ -473,6 +513,8 @@ const zhTWLectureItems = [
{ text: "跑通完整流程才算真正驗證", link: "/zh-TW/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "讓 agent 的運行過程可觀測", link: "/zh-TW/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "每次會話結束前都做好交接", link: "/zh-TW/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "從手動驅動到自動循環", link: "/zh-TW/lectures/lecture-13-loop-engineering/" },
];
const zhTWProjectItems = [
@@ -483,6 +525,8 @@ const zhTWProjectItems = [
{ text: "用運行反饋修正 agent 的行為", link: "/zh-TW/projects/project-04-incremental-indexing/" },
{ text: "讓 agent 自己檢查自己做的對不對", link: "/zh-TW/projects/project-05-grounded-qa-verification/" },
{ text: "搭建一套完整的 agent 工作環境", link: "/zh-TW/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "搭建你的第一個自動循環", link: "/zh-TW/projects/project-07-loop-engineering-first-loop/" },
];
const zhTWResourceItems = [
@@ -510,6 +554,7 @@ const ptBRLectureItems = [
{ text: "Por que testes end-to-end mudam os resultados", link: "/pt-BR/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Por que observabilidade pertence ao Harness", link: "/pt-BR/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Por que toda sessão deve deixar um estado limpo", link: "/pt-BR/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+ { text: "Do Prompting Manual aos Loops Autônomos", link: "/pt-BR/lectures/lecture-13-loop-engineering/" },
];
const ptBRProjectItems = [
@@ -520,6 +565,7 @@ const ptBRProjectItems = [
{ text: "Feedback em Runtime e Controle de Escopo", link: "/pt-BR/projects/project-04-incremental-indexing/" },
{ text: "Autoverificação e Separação de Papéis", link: "/pt-BR/projects/project-05-grounded-qa-verification/" },
{ text: "Harness Completo (Projeto Final)", link: "/pt-BR/projects/project-06-runtime-observability-and-debugging/" },
+ { text: "Construa Seu Primeiro Loop Automatizado", link: "/pt-BR/projects/project-07-loop-engineering-first-loop/" },
];
const ptBRResourceItems = [
@@ -547,6 +593,8 @@ const ukLectureItems = [
{ text: "Чому наскрізне тестування змінює результати", link: "/uk/lectures/lecture-10-why-end-to-end-testing-changes-results/" },
{ text: "Чому спостережуваність має бути всередині harness", link: "/uk/lectures/lecture-11-why-observability-belongs-inside-the-harness/" },
{ text: "Чому кожна сесія має залишати чистий стан", link: "/uk/lectures/lecture-12-why-every-session-must-leave-a-clean-state/" },
+
+ { text: "Від ручного введення промптів до автономних циклів", link: "/uk/lectures/lecture-13-loop-engineering/" },
];
const ukProjectItems = [
@@ -557,6 +605,8 @@ const ukProjectItems = [
{ text: "Зворотний зв'язок у runtime і контроль обсягу", link: "/uk/projects/project-04-incremental-indexing/" },
{ text: "Самоверифікація та розподіл ролей", link: "/uk/projects/project-05-grounded-qa-verification/" },
{ text: "Повний harness (підсумковий проєкт)", link: "/uk/projects/project-06-runtime-observability-and-debugging/" },
+
+ { text: "Побудова вашого першого автоматизованого циклу", link: "/uk/projects/project-07-loop-engineering-first-loop/" },
];
const ukResourceItems = [
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/ar/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..d69bd20
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# مطالبة وكيل المدقق
+
+> لوكيل التحقق.
+> ركز على "إيجاد المشاكل" - كلما كان أكثر صرامة، كان أفضل.
+
+## دورك
+
+أنت المدقق. وظيفتك هي التحقق مما أنتجه الصانع. هدفك هو إيجاد المشاكل، وليس قول الأشياء اللطيفة.
+
+عندما تحصل على تنفيذ من الصانع، وظيفتك هي:
+
+1. اقرأ جميع التغييرات
+2. تحقق عنصرًا بعنصرًا مقابل قائمة التحقق
+3. شغّل أوامر التحقق الكاملة
+4. سجّل كل مشكلة تجدها - كل منها بأدلة
+
+**تذكر: أنت هنا ليس للمدح، بل هنا لإيجاد الأخطاء.** عدم إيجاد مشاكل هو فشلك.
+
+## قائمة التحقق
+
+### الصحة الوظيفية
+- [ ] هل يتطابق التنفيذ مع المتطلبات؟
+- [ ] هل هناك أي حالات حدية فاتت؟
+- [ ] هل معالجة الأخطاء في مكانها؟
+
+### جودة الكود
+- [ ] هل الكود واضح؟ هل الأسماء واضحة؟
+- [ ] هل هناك كود مكرر؟
+- [ ] هل يتبع معايير برمجة المشروع؟
+- [ ] هل هناك مشاكل أداء واضحة؟
+
+### الاختبار
+- [ ] هل تغطي الاختبارات السيناريوهات الرئيسية؟
+- [ ] هل يتم اختبار حالات الحد؟
+- [ ] هل الاختبارات تختبر شيئًا ذا معنى بالفعل، أم أنها فقط تمر بالحركات؟
+
+### أوامر التحقق
+- [ ] هل `npm test` يمر بالكامل؟
+- [ ] هل `npm run lint` ليس فيه أخطاء؟
+- [ ] هل فحص أنواع TypeScript يمر؟
+- [ ] هل التغطية تفي بالحد الأدنى؟
+
+### الأمان والتأثير
+- [ ] هل سيؤثر هذا التغيير على أي شيء آخر؟
+- [ ] هل تم تقديم أي تبعيات جديدة؟ هل لها مبرر؟
+- [ ] هل تغييرات ملف التكوين صحيحة؟
+
+## متطلبات المخرج
+
+يجب أن تتضمن كل مشكلة:
+1. **الوصف**
+2. **المكان** (الملف ورقم السطر)
+3. **الدليل** (ما هو الخطأ بالضبط، ولماذا هي مشكلة)
+4. **الشدة** (حرجة / متوسطة / ثانوية)
+
+انتهِ بحكم عام: ناجح / فاشل / مشاكل ثانوية، مقبول
+
+تنسيق المخرج:
+
+```
+## الحكم العام
+✅ ناجح / ❌ فاشل / ⚠️ مشاكل ثانوية، مقبول
+
+## المشاكل الموجودة
+
+### 1. [حرجة] عنوان المشكلة
+- المكان: الملف:السطر
+- الوصف: ...
+- الدليل: ...
+- الاقتراح: ...
+
+### 2. [متوسطة] عنوان المشكلة
+...
+
+## نتائج أمر التحقق
+- اختبارات الوحدة: X نجحت / Y إجمالي
+- Lint: ناجح / فاشل (X أخطاء)
+- فحص الأنواع: ناجح / فاشل
+- التغطية: XX٪
+```
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/ar/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..a8992d5
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# قالب حلقة الهدف
+
+> اكتب هدفك كمستند مثل هذا، ثم سلّمه إلى `/goal` أو وكيل صانع.
+> كلما كان أكثر تحديدًا وقابلًا للتحقق، زادت جودة الحلقة.
+
+## الهدف
+
+<!-- جملة واحدة تصف ماذا تفعل -->
+
+نفّذ ميزة XX بتغطية اختبار وحدة كاملة.
+
+## معايير القبول
+
+<!-- شروط الإكمال القابلة للتحقق آليًا - كل واحدة يمكن فحصها بأمر -->
+
+- [ ] `npm test` يمر بالكامل
+- [ ] تقرير التغطية يظهر تغطية الوحدة XX ≥ 80٪
+- [ ] `npm run lint` ليس فيه أخطاء
+- [ ] فحص أنواع TypeScript يمر (`npx tsc --noEmit`)
+- [ ] كل الكود الجديد يتبع معايير برمجة المشروع
+
+## النطاق
+
+<!-- كن صريحًا حول ما لا يجب لمسه -->
+
+### مسموح به
+
+- جميع الملفات ضمن `src/xx/`
+- ملفات الاختبار ضمن `tests/`
+- ملفات تعريف الأنواع ذات الصلة
+
+### ممنوع لمسه
+
+- ملف الإدخال `src/main.ts`
+- ترحيلات مخطط قاعدة البيانات
+- إصدارات التبعيات في `package.json` (إلا إذا كانت مطلوبة بشكل صريح)
+- ملفات تكوين CI/CD
+
+## طريقة التحقق
+
+<!-- كيف تتحقق بعد كل خطوة -->
+
+1. بعد التنفيذ، شغّل هذه الأوامر بالترتيب:
+ 1. `npx tsc --noEmit` — فحص الأنواع
+ 2. `npm run lint` — أسلوب الكود
+ 3. `npm test` — اختبارات الوحدة
+ 4. `npx vitest --coverage` — فحص التغطية
+
+2. أصلح أي إخفاقات قبل الانتقال إلى الخطوة التالية.
+3. عندما يمر كل شيء، شغّل مجموعة اختبار الشاملة الكاملة (إذا كانت متوفرة).
+
+## شروط التوقف
+
+- جميع معايير القبول تمر ✅
+- الوصول إلى الحد الأقصى من الدورات: 20
+- لا تقدم لمدة 3 جولات متتالية (يظل نفس الخطأ يظهر)
+- مشكلة حاجزة لا يمكن حلها بشكل مستقل (مثل تبعية مفقودة، مشكلة بيئة)
+
+## كيفية العمل
+
+1. اقرأ `AGENTS.md` و `feature_list.json` أولاً لفهم بنية المشروع والميزات الحالية.
+2. اكتب نهج التصميم قبل لمس الكود.
+3. تحقق بعد انتهاء كل مهمة فرعية.
+4. إذا تعثرت لأكثر من جولتين، غيّر النهج أو بسّط.
+5. حدّث التقدم في نهاية كل جولة.
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/code/index.md b/docs/ar/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..5b92f99
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# أمثلة كود المحاضرة 13
+
+استخدم هذا المجلد لأمثلة من:
+
+- قالب وصف هدف goal.md
+- قالب حالة الحلقة loop-state.md
+- قوالب مطالبة دور الصانع / المدقق
+- أمثلة نصوص التحكم في الحلقة
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/ar/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..df70d79
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# قالب حالة الحلقة
+
+> يجب أن يكون لكل حلقة ملف حالة يتتبع التقدم الحالي.
+> حدّثه في نهاية كل جولة؛ اقرأه في بداية الجولة التالية.
+
+## المعلومات الأساسية
+
+- **اسم الحلقة**: <!-- مثل "حلقة إكمال اختبار الوحدة" -->
+- **بدأت في**: 2026-07-09 10:00
+- **الجولة الحالية**: الجولة 1 / إجمالي N
+- **الحالة الحالية**: قيد التقدم <!-- قيد التقدم / مكتملة / محجوبة / فاشلة -->
+- **الوقت الإجمالي المنقضي**: 0 ساعة 0 دقيقة
+
+## الهدف
+
+<!-- ما تحاول هذه الحلقة تحقيقه -->
+
+## سجل الجولات
+
+### الجولة 1
+
+- **بدأت في**:
+- **ماذا فعل الصانع**:
+- **نتيجة التحقق**: ✅ ناجح / ❌ فاشل / ⚠️ جزئي
+- **المشاكل الموجودة**:
+ -
+- **خطة الجولة التالية**:
+- **تدخل بشري مطلوب**: نعم / لا
+
+### الجولة 2
+
+- **بدأت في**:
+- **ماذا فعل الصانع**:
+- **نتيجة التحقق**: ✅ ناجح / ❌ فاشل / ⚠️ جزئي
+- **المشاكل الموجودة**:
+ -
+- **خطة الجولة التالية**:
+- **تدخل بشري مطلوب**: نعم / لا
+
+<!-- انسخ التنسيق أعلاه واستمر في الإضافة -->
+
+## الإحصائيات التراكمية
+
+| المقياس | القيمة |
+|--------|-------|
+| الجولات المكتملة | 0 |
+| الجولات الناجحة | 0 |
+| الجولات الفاشلة | 0 |
+| إجمالي المشاكل الموجودة | 0 |
+| التدخلات البشرية | 0 |
+| الملفات المتغيرة | 0 |
+
+## قائمة الحواجز
+
+<!-- سجّل المشاكل المتكررة لتكون الجولة التالية على علم بها -->
+
+-
+
+## النتيجة النهائية
+
+<!-- املأ عندما تنتهي الحلقة -->
+
+- **الحالة النهائية**: مكتملة / فاشلة / متوقفة يدوياً
+- **انتهت في**:
+- **الملخص**:
+ - ماذا تم إنجازه
+ - كيف سارت الأمور
+ - ماذا تم تعلمه
+ - كيفية التحسين في المرة القادمة
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/ar/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..b65ce13
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# مطالبة وكيل الصانع
+
+> لوكيل التنفيذ.
+> ركز على "جعلها تعمل."
+
+## دورك
+
+أنت الصانع. وظيفتك هي تنفيذ الميزات وكتابة الكود.
+
+عندما تحصل على مهمة، وظيفتك هي:
+
+1. فهم المتطلبات
+2. تصميم النهج
+3. كتابة الكود
+4. تشغيل التحقق الأساسي (البناء، lint، اختبارات الوحدة)
+5. تسليم النتيجة إلى المدقق للمراجعة
+
+## قواعد العمل
+
+- اقرأ AGENTS.md والمستندات ذات الصلة أولاً لفهم بنية المشروع.
+- اشرح خطتك قبل إجراء التغييرات.
+- شغّل التحقق الأساسي بنفسك بعد الكتابة - تأكد من أنه يعمل على الأقل.
+- إذا كنت لا تعرف شيئًا، قل أنك لا تعرف. لا تختلق الأشياء.
+- سجّل التقدم في كل خطوة.
+
+## المخرجات
+
+- قائمة بالملفات المعدلة
+- ملخص تنفيذ موجز
+- نتائج التحقق الأساسي (البناء / lint / الاختبارات)
+- المجالات التي لست متأكدًا منها (ليركز عليها المدقق)
+
+## تنسيق المخرج
+
+```
+## ملخص التنفيذ
+...
+
+## الملفات المعدلة
+- ...
+
+## التحقق الأساسي
+- البناء: ناجح / فاشل
+- Lint: ناجح / فاشل
+- اختبارات الوحدة: X نجحت، Y فشلت
+
+## المشكلات والمخاطر المعروفة
+- ...
+```
diff --git a/docs/ar/lectures/lecture-13-loop-engineering/index.md b/docs/ar/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..a22c606
--- /dev/null
+++ b/docs/ar/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> أمثلة الكود: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/ar/lectures/lecture-13-loop-engineering/code/)
+> مشروع عملي: [المشروع 07. ابني أول حلقة آلية](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# المحاضرة 13. من المطالبة اليدوية إلى الحلقات المستقلة
+
+كل ما تعلمته في المحاضرات الاثنتي عشرة الأولى يستند إلى افتراض واحد: **أنت تجلس أمام لوحة المفاتيح، وتكتب التعليمات واحدة تلو الأخرى.**
+
+لقد كتبت `AGENTS.md` (المحاضرات 1-4)، وبنيت إدارة الحالة (المحاضرات 5-6)، وحددت النطاق بقوائم الميزات (المحاضرات 7-8)، وتركت تسليمات نظيفة في نهاية الجلسة (المحاضرات 9، 12)، وجعلت وقت التشغيل قابلًا للملاحظة (المحاضرات 10-11). لكن المحفز لكل ذلك كان دائمًا أنت. لم يقرر الوكيل من تلقاء نفسه متى يبدأ العمل - لأن لا أحد ضغط على زر "ابدأ".
+
+هذه المحاضرة تدور حول تسليم زر البدء إلى النظام. ليس التخلي عن السيطرة - بل رفعها إلى الطبقة التالية.
+
+## /goal: أبسط حلقة ممكنة
+
+أفضل مدخل لهندسة الحلقات ليس مخططًا معماريًا معقدًا - بل أمر واحد.
+
+في أوائل عام 2026، أطلق Claude Code و OpenAI Codex نفس الميزة بشكل مستقل: `/goal`. تكتب في الطرفية:
+
+```
+/goal "All tests pass, zero lint warnings, merge to main"
+```
+
+ثم تغلق جهاز الكمبيوتر وتذهب للنوم. بعد ثماني ساعات، يكون الوكيل قد تحليل وكتب واختبر وأصلح ودمج من تلقاء نفسه. يعيد المحاولة عند الفشل، ويغير الأساليب عندما يعثر على طريق مسدود، ويتوقف عند الانتهاء - دون أن تُنحني فوق كتفه قائلًا "حاول مرة أخرى".
+
+الفرق الوحيد بين `/goal` والمطالبة التقليدية هو شيء واحد. لكن هذا الشيء الواحد يغير كل شيء:
+
+| | المطالبة التقليدية | `/goal` |
+|---|---|---|
+| ما تقدمه | ماذا تفعل بعد ذلك | كيف تبدو الحالة النهائية |
+| ما يفعله الوكيل | ينفذ مرة واحدة | يكرر حتى يتحقق الهدف |
+| من يحكم على الانتهاء | أنت | شرط توقف قابل للتحقق |
+| متى يمكنك المغادرة | لا يمكنك ذلك | اللحظة التي تكتب فيها `/goal` |
+
+`/goal` هي في الأساس حلقة. لديها بالضبط ثلاثة أجزاء: **هدف، طريقة تحقق، وشرط توقف.** فقط هذه الأشياء الثلاثة تنقلك من داخل الحلقة إلى خارجها.
+
+### كيف نشأ `/goal` بشكل عضوي
+
+لم يقفز `/goal` من 0 إلى 1 من العدم. نما تدريجيًا من سير العمل اليومي، مرًا بأربع مراحل تقريبًا:
+
+**المرحلة 1: المطالبة اليدوية واحدة تلو الأخرى.** كانت أبسط طرق العمل هي ذهابًا وإيابًا: "اكتب دالة"، "أضف اختبارًا"، "أصلح هذا المنطق". كان الوكيل يتوقف بعد كل خطوة وينتظر أن تقول ما هو التالي. كنت أنت مجدول جدول الأنابيب بأكمله.
+
+**المرحلة 2: مطالبات طويلة بخطوات متعددة.** ثم بدأ الناس بكتابة مطالبات أطول تكدس الخطوات معًا: "أولاً تحليل الكود، ثم كتابة التنفيذ، ثم تشغيل الاختبارات، وإذا فشلت، أصلحها". كان الوكيل قادرًا على تشغيل عدة خطوات في مرة واحدة، لكنك لا تزال بحاجة إلى المراقبة - لأنه قد ينحرف في منتصف الطريق، أو ينتهي من خطوة ولا يعرف ماذا يفعل بعد ذلك.
+
+**المرحلة 3: التفكير الذاتي والتوجيه الذاتي للوكيل.** بعد ذلك، اكتسب الوكلاء "التفكير الداخلي" - بعد كل خطوة ينظرون إلى النتيجة ويقررون ماذا يفعلون بعد ذلك. أعطيت هدفًا، وقاموا بتفكيكه بأنفسهم وإعادة المحاولة من تلقاء أنفسهم. لكن مشكلة ظهرت: متى يتوقفون؟ هل "لقد انتهيت" الصادرة من الوكيل نفسه تعتبر؟ ظلت الممارسة تجيب - لا. الوكلاء يعلنون النصر بسهولة كبيرة.
+
+**المرحلة 4: حكم التوقف المستقل - `/goal`.** كانت الخطوة الأخيرة هي إخراج "الحكم على ما إذا كان قد انتهى" من يدي الوكيل الذي يقوم بالعمل، وتسليمه إلى قاضٍ مستقل. قد يكون نموذجًا مختلفًا، أو نصيبي، أو أمر اختبار - لكن القاعدة كانت نفسها: الشخص الذي يكتب الكود لا يمكنه تصحيح واجبه بنفسه. عند هذه النقطة، عمل `/goal` حقًا: أنت تعطي الهدف، وهو يكرر، ويقرر قاضٍ مستقل متى يتوقف، ويمكنك المغادرة.
+
+هذه المراحل الأربع لم تكن خريطة طريق خططتها أي شركة. كانت المسار الذي وصل إليه كل من يكتب الكود بالوكالة، بشكل مستقل، مدفوعًا بنفس نقاط الألم. لم يكن إطلاق Claude Code و Codex لـ `/goal` في نفس الوقت تقريبًا في أوائل عام 2026 مصادفة - لقد حان الوقت.
+
+### هناك أكثر من نوع واحد من الحلقات
+
+`/goal` هي أسهل حلقة يمكن فهمها، لكنها ليست النوع الوحيد. تنقسم الحلقات إلى فئات بناءً على كيفية تحفيزها وكيفية توقفها:
+
+| النوع | المحفز | شرط التوقف | Claude Code | Codex | الأفضل لـ |
+|------|---------|----------------|-------------|-------|----------|
+| **حلقة قائمة على الدور** | تكتب كل مطالبة يدويًا | يعتقد الوكيل أنه انتهى، أو تقاطعت أنت | الدردشة العادية | الدردشة العادية | المهام الصغيرة، العمل الاستكشافي |
+| **حلقة قائمة على الهدف** | تعطي هدفًا | يؤكد المقيّم المستقل الانتهاء، أو الوصول إلى الحد الأقصى من الدورات | `/goal` | `/goal` (يتطلب التمكين اليدوي) | المهام المعقدة ذات معايير الإكمال الواضحة |
+| **حلقة قائمة على الوقت** | فاصل مجدول (كل N دقائق/ساعات) | توقفها يدوياً، أو يخرج بعد إكمال العمل | `/loop` | أتمتة الموضوع | استطلاع الحالة، الفحوصات الدورية، العمل المتكرر |
+| **حلقة مدفوعة بالأحداث** | حدث خارجي (فتح PR، فشل CI، قضية جديدة) | يتوقف بعد معالجة الحدث، أو يصل إلى حد إعادة المحاولة | Routines (API / GitHub Webhook) | أتمتة مستقلة + المكونات الإضافية | سير العمل التفاعلي، تكامل CI/CD |
+
+هذه ليست متنافسة - بل هي أدوات مختلفة لوظائف مختلفة. الحلقة القائمة على الدور جيدة للأشياء الصغيرة. استخدم `/goal` عندما يكون هناك خط نهائي واضح. استخدم `/loop` عندما تحتاج إلى مراقبة شيء ما. استخدم المدفوعة بالأحداث عندما تتكامل مع أنظمة خارجية.
+
+### لا تخلط بين `/goal` و `/loop`
+
+كلاهما يحتوي على كلمة "حلقة" في الاسم، لكنهما يحلان مشكلتين مختلفتين تمامًا:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **ما هي** | مهمة كبيرة واحدة، تعمل حتى تنتهي | إجراء صغير واحد، يتكرر على فاصل زمني |
+| **شرط التوقف** | الوصول إلى الهدف، أو استنفاد الميزانية | توقفها يدوياً، أو تخرج المهمة من تلقاء نفسها |
+| **الملف الزمني** | تشغيل طويل واحد، قد يستغرق ساعات أو أيام | دفعات قصيرة دورية، كل تشغيل قد يستغرق بضع دقائق |
+| **التقدم** | يقترب من خط النهاية في كل تكرار | كل تشغيل مستقل، لا تقدم تراكمي |
+| **القياس** | جري ماراثون - يطلق بندقية البداية، وتتوقف عند خط النهاية | منبه - يرن على جدول زمني، وتطفئه |
+| **الاستخدام النموذجي** | "نفّذ نظام الدفع الكامل بتغطية اختبار" | "تحقق مما إذا كان CI معطلاً كل 15 دقيقة" |
+
+خطأ شائع: دفع شيء يجب أن يكون `/goal` إلى `/loop`. مثل كتابة `/loop 10m "استمر في تنفيذ نظام الدفع"` - هذا خطأ. `/loop` ينفذ نفس التعليم بشكل مستقل في كل مرة، ولا يتذكر أين توقف في المرة الأخيرة. ستحصل فقط على نفس نقطة البداية مرارًا وتكرارًا.
+
+**اختبار جملة واحدة لمعرفة أيهما تستخدم: هل لهذا الشيء نهاية؟**
+- له نهاية → `/goal`
+- لا نهاية له، أنت فقط بحاجة إلى الاستمرار في المراقبة → `/loop`
+
+هندسة الحلقات، موضوع هذه المحاضرة، لا تدور حول أي أمر واحد. إنها تدور حول **القدرة على تصميم أنظمة تشمل كل هذه الأنواع - بحيث يمكن لوكيلك الاستمرار في العمل حتى عندما لا تكون هناك.**
+
+ليس عليك كتابة `/goal` في كل مرة. لكن فهم من أين جاء ولماذا يبدو كما هو - ذلك هو فهم جوهر هندسة الحلقات. الحلقات الأكثر تعقيدًا تضيف فقط أجزاء مثل الجدولة، والتوازي، والعزل، والذاكرة فوق هذه الأساسيات الثلاثة نفسها: الهدف، والتحقق، وشرط التوقف.
+
+## يونيو 2026: ثلاثة أشخاص أشعلوا نفس الفتيلة في أسبوع واحد
+
+في الأسبوع الأول من يونيو 2026، قال ثلاثة ممارسين يبنون بنية تحتية لوكالة البرمجة - دون مقارنة ملاحظات - نفس الشيء بكلمات مختلفة.
+
+**بيتر شتاينبرغر** (مبتكر OpenClaw، [مقالته وصلت إلى 8 مليون مشاهدة](https://x.com/steipete/status/2063697162748260627)): "لا يجب أن تطالب وكلاء البرمجة بعد الآن. يجب أن تصمم حلقات تطلب من وكلائك."
+
+**بوريس تشيرني** (رئيس Claude Code في Anthropic، [على بودكاست Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): "أنا لا أطالب Claude بعد الآن. لدي حلقات تعمل تطالب Claude وتكتشف ماذا تفعل. وظيفتي هي كتابة الحلقات."
+
+**آدي عثماني** (قائد الهندسة في Google Chrome) [سمى المفهوم](https://addyosmani.com/blog/loop-engineering/) في 7 يونيو 2026، وأعطاه تعريفًا من جملة واحدة:
+
+> **هندسة الحلقات هي استبدال نفسك كشخص الذي يطالب الوكيل. أنت تصمم النظام الذي يفعل ذلك بدلاً منك.**
+
+كشف تشيرني عن أرقام: على مدار 30 يومًا متتالية، تم إجراء جميع مساهمات الكود في Claude Code بشكل مستقل بواسطة الذكاء الاصطناعي - 259 PR مدمجة، وأكثر من 80٪ من كود الإنتاج كتبه Claude، ومعدل نجاح 76٪ في مهام البرمجة مفتوحة النهاية.
+
+ثلاثة أشخاص. أسبوع واحد. نفس الاستنتاج. ليس لأنهم تناسقوا - بل لأن البنية التحتية عبرت بهدوء عتبة. أصبحت الوكلاء موثوقين بما يكفي لإنجاز المهام غير البسيطة دون إشراف. أصبحت بدائيات الجدولة (`/loop`، `/goal`، cron) مدمجة الآن في الأدوات. انخفضت تكلفة تشغيل وكيل واحد بما يكفي بحيث لم يعد تشغيله بشكل متكرر على مؤقت يبدو مُبذرًا. عندما تكون جميع الأجزاء موجودة، فإن الخطوة التي تجمعها تصبح واضحة للجميع في نفس الوقت.
+
+> المصدر: [آدي عثماني: هندسة الحلقات](https://addyosmani.com/blog/loop-engineering/)
+
+## داخل الحلقة مقابل خارج الحلقة
+
+لنقارن بين سيناريوهين ملموسين.
+
+**السيناريو أ: أنت داخل الحلقة (المحاضرات 1-12).**
+
+```mermaid
+flowchart TD
+ You["أنت"] -->|"اكتب التعليم يدويًا"| Agent["وكيل الذكاء الاصطناعي"]
+ Agent -->|"ينتج مخرجات"| Result["كود / اختبارات / توثيق"]
+ Result -->|"تفقد أنت"| You
+ You -->|"غير راضٍ، عدّل التعليم"| Agent
+ You -->|"راضٍ، انتقل إلى المهمة التالية"| You
+```
+
+لديك Harness كامل: `AGENTS.md` يخبر الوكيل بقواعد المشروع، `feature_list.json` يحد النطاق، `init.sh` يضمن بيئة متسقة، `claude-progress.md` يسجل التقدم. **لكن كل خطوة لا تزال تتطلب بدءك اليدوي.** أنهِ ميزة واحدة، اقرأ ملف التقدم، فكر في ما هو التالي، اكتب التعليم. أنت محرك سير العمل بأكمله.
+
+**السيناريو ب: أنت خارج الحلقة (هندسة الحلقات).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["نظام الحلقة الذي صممته"]
+ Trigger["محفز تلقائي<br/>جدول / حدث / اكتمال المهمة السابقة"] --> Discover["اكتشف العمل<br/>اقرأ ملف التقدم / متتبع القضايا"]
+ Discover --> Dispatch["وزع<br/>أنشئ وكيلًا فرعيًا"]
+ Dispatch --> Verify["تحقق<br/>اختبارات / lint / وكيل مراجع مستقل"]
+ Verify --> Persist["احفظ الحالة<br/>حدّث التقدم / التزام / افتح PR"]
+ Persist -->|"لا يزال هناك عمل"| Discover
+ Persist -->|"منتهٍ أو محجوب"| Inbox["ادفع إلى صندوق مراجعتك"]
+ end
+ Inbox -->|"أنت فقط بحاجة لاتخاذ القرارات"| You["أنت"]
+```
+
+أنت لم تعد تكتب التعليمات. النظام الذي صممته يكتشف العمل، ويوزعه، ويتحقق من النتائج، ويسجل الحالة، ويقرر الخطوة التالية. تتقلص وظيفتك إلى ثلاثة أشياء: **تحديد الهدف وشرط التوقف قبل البدء، ومراجعة المخرجات بعد الانتهاء، وضبط القواعد عندما ينحرف النظام عن المسار.** ينتقل النفوذ من "كتابة المطالبة الصحيحة" إلى "تصميم الحلقة الصحيحة".
+
+> عثماني: "قبل عام، إذا أردت حلقة كتبت كومة من bash وصرت تحافظ على تلك الكومة إلى الأبد وكانت لك وحدك. الآن الأجزاء تأتي مدمجة داخل المنتجات." ليس عليك البناء من الصفر. تحتاج إلى فهم كيف تتناسب الأجزاء مع بعضها البعض.
+
+## المفاهيم الأساسية
+
+- **هندسة الحلقات**: تصميم نظام يطالب وكيلك تلقائيًا، ليحل محل الإدخال البشري اليدوي خطوة بخطوة. ينتقل الإنسان من داخل الحلقة إلى خارجها، وينتقل النفوذ من "كتابة المطالبة الصحيحة" إلى "تصميم الحلقة الصحيحة".
+- **وضع `/goal`**: أبسط حلقة ممكنة - قدم هدفًا، وطريقة تحقق، وشرط توقف؛ يكرر الوكيل حتى يتحقق. الجسر من المطالبة اليدوية إلى الحلقات المستقلة.
+- **فصل المولد/المقيّم**: يجب فصل الوكيل الذي يكتب الكود والوكيل الذي يتحقق منه. النموذج الذي يصحح عمله نفسه غير موثوق؛ والمحقق المستقل - وأحيانًا باستخدام نموذج مختلف تمامًا - هو ضمان الموثوقية الأساسي لأي حلقة.
+- **عزل Worktree**: يعمل كل وكيل متوازي في worktree git مستقل، مما يمنع تصادم الملفات فعليًا. شرط البنية التحتية للتنفيذ المتوازي متعدد الوكلاء.
+- **الحالة الخارجية**: الذاكرة التي تعيش خارج محادثة واحدة - ملفات markdown، متتبعات القضايا، لوحات كانبان. النماذج تنسي كل شيء بين عمليتي التشغيل؛ يجب أن تعيش الذاكرة على القرص.
+- **التكاليف الصامتة الأربعة**: أربع تكاليف خفية تزداد حدة كلما طالت مدة تشغيل الحلقة - دين التحقق، تعفن الفهم، الاستسلام المعرفي، انفجار التوكنز. الحلقات لا تسرع المخرجات فحسب، بل المخاطر أيضًا.
+
+## البدائيات الست للحلقة
+
+قام عثماني بتفكيك الحلقة إلى خمس لبنات بناء أساسية، بالإضافة إلى طبقة ذاكرة تمر عبر كل منها - ستة أشياء في المجموع، لكن طبقة الذاكرة تحتل مكانة خاصة: إنها ليست مكونًا على نفس المستوى مثل الآخرين؛ بل هي العمود الفقري الذي يعتمد عليه كل شيء آخر.
+
+يرسم المخطط أدناه الستة كحلقة حتى تتمكن من رؤية الصورة الكاملة للوهلة الأولى. لكن تذكر: الحالة الخارجية ليست مجرد محطة أخرى على الحلقة - بل هي الأساس الذي تستند إليه الحلقة بأكملها.
+
+```mermaid
+flowchart LR
+ A["الأتمتة<br/>المحفزات المجدولة"] --> W["Worktrees<br/>العزل المتوازي"]
+ W --> S["المهارات<br/>معرفة المشروع المرمزة"]
+ S --> C["الموصلات<br/>الوصول إلى الأدوات الخارجية"]
+ C --> SA["الوكلاء الفرعيون<br/>تقسيم الصانع / المدقق"]
+ SA --> ES["الحالة الخارجية<br/>ذاكرة عبر التكرارات"]
+ ES --> A
+```
+
+### 1. الأتمتة — نبض القلب
+
+بدون أتمتة، الحلقة ليست حلقة - بل هي تشغيل لمرة واحدة قمت به يدويًا.
+
+يحتوي كل من Claude Code و Codex على أنظمة جدولة كاملة، لكنهما يستخدمان أسماء وطبقات مختلفة. الخريطة التقريبية من الأخف إلى الأثقل:
+
+| الطبقة | Claude Code | Codex | ملاحظات |
+|-------|-------------|-------|-------|
+| الاستطلاع داخل الجلسة | `/loop` | أتمتة الموضوع | مرتبطة بالجلسة الحالية، وتموت عند إغلاق الجلسة |
+| المهام المجدولة محليًا | مهام سطح المكتب المجدولة | أتمتة مستقلة (الوضع المحلي) | تعمل بينما الجهاز قيد التشغيل، ويمكنها الوصول إلى الملفات المحلية |
+| المهام المجدولة في السحابة | Cloud Routines | — (لا يوجد مجدول سحابي أصلي) | تعمل بينما الجهاز متوقف |
+| محفزات الأحداث | Routines (API / GitHub Webhook) | أتمتة مستقلة + المكونات الإضافية | تحفزها أحداث خارجية |
+| مستضافة ذاتية كاملة | GitHub Actions / cron مستضاف ذاتيًا | `codex exec` + cron | تحكم كامل |
+
+**علامة التبويب Automations في Codex** هي نقطة دخول الجدولة. اختر المشروع، والمطالبة، والإيقاع، وما إذا كان يعمل على النسخة المحلية الخاصة بك أو worktree في الخلفية. عمليات التشغيل التي تجد شيئًا تصل إلى صندوق Triage؛ عمليات التشغيل التي لا تجد شيئًا تؤرشف تلقائيًا. تستخدم OpenAIها داخليًا لتصنيف القضايا اليومي، وملخصات فشل CI، وإحاطات الالتزام، والبحث عن الأخطاء التي تم تقديمها الأسبوع الماضي.
+
+تأتي أتمتة Codex بنكهتين:
+- **أتمتة الموضوع** — مكالمات استيقاظ متكررة بنمط نبض القلب مرتبطة بموضوع، مع الحفاظ على السياق. جيدة للمتابعة المستمرة لشيء واحد، مثل مراقبة أمر طويل الأمد أو استطلاع حالة PR. المكافئ في Claude Code هو `/loop`.
+- **أتمتة مستقلة** — كل تشغيل يبدأ من جديد، والنتائج تذهب إلى Triage. جيدة للمهام المستقلة اليومية/الأسبوعية مثل الإحاطات أو فحوصات التبعيات. المكافئ في Claude Code هو مهام سطح المكتب المجدولة.
+
+نظام Claude Code طبقي بدقة أكبر:
+
+- **`/loop`** — تكرار مجدول خفيف الوزن داخل الجلسة. يعمل بينما طرفيتك مفتوحة، ويموت عند إغلاق الجلسة، وينتهي صلاحيته تلقائيًا بعد 7 أيام. جيدة للمراقبة المؤقتة أثناء جلسة العمل الحالية.
+- **مهام سطح المكتب المجدولة** — تعمل بينما جهازك قيد التشغيل، وتنجو من إعادة تشغيل الجلسة، بفواصل مستوى الدقيقة. جيدة للعمل المتكرر الذي يحتاج إلى الوصول إلى الملفات المحلية.
+- **Cloud Routines** — تعمل على بنية Anthropic السحابية، وتنجو من إيقاف جهازك، بحد أدنى للساعة واحدة. تدعم ثلاثة أنواع من المحفزات: مجدول، استدعاء API، خطاف ويب GitHub. جيدة للمهام اليومية التي لا تحتاج إلى بيئتك المحلية.
+- **GitHub Actions / cron مستضاف ذاتيًا** — تحت سيطرتك بالكامل، وتعمل كما تريد. جيدة للسيناريوهات ذات المتطلبات البيئية أو الأمنية الخاصة.
+
+```bash
+# Claude Code: شغّل الاختبارات كل 30 دقيقة، وأصلح الأخطاء (داخل الجلسة الحالية)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: تحقق من حالة النشر كل 15 دقيقة
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+الأتمتة هي نبض القلب. بدونها، الحلقة هي مخطط لا يستيقظ أبدًا.
+
+### 2. Worktrees — العزل على نطاق واسع
+
+بمجرد تشغيل أكثر من وكيل واحد، تصبح تصادمات الملفات هي طريقة الفشل الحتمية. وكيلان يكتبان في نفس الملف هو بالضبط صداع مهندسين يلتزمان بنفس الأسطر دون تشاور.
+
+`git worktree` يحل هذا: كل وكيل يعمل على فرعه الخاص في دليله الخاص. لا يمكنهم ماديًا لمس نسخة كل منهما.
+
+يأتي كل من Claude Code و Codex بدعم worktree. عندما تستخدم `--worktree` أو `isolation: worktree` على وكيل فرعي، يحصل كل مساعد على نسخة نظيفة مستقلة تنظف نفسها بعد الانتهاء. تزيل Worktrees مشكلة التصادم الميكانيكي - لكن تذكر: **نطاق مراجعتك لا يزال هو السقف.** عدد الوكلاء المتوازيين الذين يمكنك الإشراف عليهم يحدد عدد worktrees التي يمكنك تشغيلها فعليًا.
+
+### 3. المهارات — توقف عن إعادة شرح مشروعك
+
+المهارة هي كيف تتوقف عن إعادة شرح سياق المشروع نفسه في كل جلسة. إنها مجلد يحتوي على `SKILL.md` مع تعليمات وبيانات وصفية، بالإضافة إلى نصوص برمجية ومراجع وأصول اختيارية.
+
+يدعم كل من Codex و Claude Code نفس التنسيق. يتم استدعاء المهارات مباشرة بـ `/اسم-المهارة` (يدعم Codex أيضًا `$اسم-المهارة`)، أو يتم تشغيلها ضمنيًا عندما تتطابق المهمة مع وصف المهارة.
+
+المهارات تدور أساسًا حول سداد دين النية الخاص بك. يبدأ الوكيل كل جلسة باردًا - يملأ أي فجوة في نيتك بتخمين واثق. المهارة هي تلك النية المكتوبة على الخارج: الأعراف، خطوات البناء، و"نحن لا نفعل ذلك بهذه الطريقة بسبب تلك الحادثة" - مكتوبة مرة واحدة، وتُقرأ في كل تشغيل.
+
+### 4. الموصلات — حلقتك تلمس أدوات حقيقية
+
+الحلقة التي يمكنها فقط رؤية نظام الملفات هي حلقة صغيرة. الموصلات (المبنية على بروتوكول MCP) تتيح للوكيل قراءة متتبع قضايك، والاستعلام عن قاعدة بيانات، واستدعاء API تجريبي، وإسقاط رسالة في Slack.
+
+يتحدث كل من Codex و Claude Code لغة MCP، لذا فإن الموصل الذي كتبته لأحدهما عادة ما يعمل في الآخر. الموصلات هي الفرق بين "إليك الإصلاح" وحلقة تفتح PR، وتربط تذكرة Linear، وتنبّه القناة بمجرد أن يصبح CI أخضر - من تلقاء نفسها، داخل بيئتك الفعلية، وليس فقط في طرفية.
+
+### 5. الوكلاء الفرعيون — ابقِ الصانع بعيدًا عن المدقق
+
+الخيار التصميمي الأكثر قيمة هيكليًا في الحلقة هو فصل من يكتب عن من يتحقق. النموذج الذي كتب الكود يكون سخيًا جدًا في تصحيح واجبه بنفسه. وكيل ثانٍ، بتعليمات مختلفة وأحيانًا بنموذج مختلف، يلتقط ما أقنع به الوكيل الأول نفسه.
+
+التقسيم الكلاسيكي بثلاثة أدوار:
+
+```mermaid
+flowchart LR
+ Explorer["وكيل المستكشف<br/>اقرأ قاعدة الكود، حدد المشكلات"] --> Implementer["وكيل المنفذ<br/>اكتب الإصلاح، اكتب الاختبارات"]
+ Implementer --> Verifier["وكيل المدقق<br/>مراجعة مستقلة، شغّل التحقق"]
+ Verifier -->|"يفشل"| Implementer
+ Verifier -->|"ينجح"| Output["المخرج"]
+```
+
+يشغّل `/goal` في Claude Code هذا تحت الغطاء - جلسة مستقلة جديدة تحكم على ما إذا كانت الحلقة يجب أن تتوقف، وليس الجلسة التي قامت بالعمل. هذا يسمى **فصل المولد/المقيّم**، وهو أهم ضمان موثوقية واحد في تصميم الحلقة.
+
+### 6. الحالة الخارجية — ذاكرة الحلقة
+
+النماذج تنسي كل شيء بين عمليتي التشغيل. يجب أن تعيش الذاكرة على القرص، وليس في نافذة السياق.
+
+هذا يبدو بسيطًا جدًا ليكون مهمًا، لكنه هي نفس الخدعة التي تعتمد عليها كل وكيل طويل الأمد. ملف markdown، لوحة Linear - أي شيء يعيش خارج محادثة واحدة ويحتفظ بما تم إنجازه، وما قيد التقدم، وما هو التالي. الوكيل ينسى. المستودع لا ينسى.
+
+هذه البدائيات الست هي مجموعة أدوات تصميم الحلقة الخاصة بك. لا تحتاج إلى كل منها لكل حلقة. لكنك تحتاج إلى معرفة متى تصل إلى أي منها.
+
+## حلقة كاملة، مُحلَّلة
+
+اربط الستة معًا وإليك ما تبدو عليه حلقة تصنيف صباحية حقيقية:
+
+```mermaid
+flowchart TD
+ Trigger["كل صباح عند الساعة 9:00 صباحًا<br/>تشتغل الأتمتة"] --> Read["اقرأ الحالة الخارجية<br/>claude-progress.md بالأمس<br/>قضايا GitHub المفتوحة"]
+ Read --> Triage["تنشط مهارة التصنيف<br/>صنف النتائج ورتبها حسب الأولوية"]
+ Triage --> Fork["لكل عنصر قابل للتنفيذ<br/>فرّع Worktree معزول"]
+ Fork --> Implement["وكيل فرعي منفذ<br/>اكتب الإصلاح + الاختبارات"]
+ Implement --> Verify["وكيل فرعي مدقق<br/>شغّل الاختبارات + lint + المراجعة بشكل مستقل"]
+ Verify -->|"يفشل"| Retry["صف إعادة المحاولة<br/>جرب أسلوبًا مختلفًا"]
+ Retry --> Implement
+ Verify -->|"ينجح"| PR["موصل: افتح PR<br/>اربط القضية، حدّث ملف التقدم"]
+ PR --> Memory["اكتب في الحالة الخارجية<br/>حدّث claude-progress.md<br/>سجّل نتائج هذه الجولة"]
+ Memory -->|"لا يزال هناك عمل"| Fork
+ Memory -->|"كل شيء منتهٍ أو محجوب"| Inbox["النتائج تصل إلى صندوق Triage<br/>بانتظار مراجعتك"]
+```
+
+هذه لم تعد تشغيل وكيل واحد. إنها نظام يعمل باستمرار يستيقظ كل صباح، وينظف الأرضية من تلقاء نفسه، ويضع الأشياء التي تحتاج إلى اهتمامك أمامك. يصبح دورك: **راجع محتويات الصندوق، واتخذ القرارات، وعندما تكتشف نمطًا لا يستطيع النظام التعامل معه، صقل المهارات والقواعد.**
+
+استخدم تشيرني هذا النمط لدمج 259 PR في 30 يومًا دون فتح IDE مرة واحدة. استخدم مهندسو OpenAI نفس النمط لبناء منتج بيتا يبلغ حوالي مليون سطر كود يدويًا - دون كتابة سطر كود واحد بأنفسهم.
+
+## فصل المولد/المقيّم: لماذا لا يمكنك السماح للنموذج بتصحيح عمله بنفسه
+
+هذا هو الدرس الأصعب في هندسة الحلقات.
+
+يكتب أذكى وكلائك قطعة كود جميلة. المنطق واضح، والتعليقات شاملة، وكل دالة لها اختبار. أنت راضٍ.
+
+لكن إليك السؤال: **إذا سمحت للوكيل الذي كتب هذا الكود بأن يحكم على ما إذا كان قد قام بعمل جيد، ماذا سيقول؟**
+
+لقد تم تأكيد الإجابة بالتجربة مرارًا وتكرارًا: سيعطي نفسه درجة عالية. ليس لأنه غير صادق، بل لأنه هو المؤلف - لقد أقنع نفسه بأن هذا المسار صحيح أثناء التوليد. عندما ينظر إلى الوراء، لا يرى الأخطاء؛ بل يرى عملية تفكيره الخاصة.
+
+هذه ليست مشكلة Claude. هذه ليست مشكلة GPT. هذه خاصية جميع النماذج التوليدية. **النموذج هو أفضل محامٍ دفاع عن مخرجاته.**
+
+الحل: لا تدع نفس الكيان (نفس النموذج، نفس المطالبة) يقوم بالعمل والمراجعة معًا.
+
+- يستخدم `/goal` في Claude Code جلسة مشرف مستقلة لحكم على ما إذا كان الهدف قد تحقق - وليس الجلسة التي حاولت تحقيقه.
+- يتيح لك نظام الوكلاء الفرعيين في Codex تحديد وكيل مدقق باستخدام نموذج مختلف بجهد تفكير مختلف.
+- ممارسة المجتمع لـ "التحقق العدائي" تولد N مشككين مستقلين لكل نتيجة، كل مُطالب بالدحض - الرفض بالأغلبية يقتل النتيجة.
+
+جملة واحدة لتتذكرها: **يجب ألا يصدقك شخص ما في فريقك.**
+
+## autoresearch لكارباثي: النموذج المثالي للحلقة
+
+إذا كنت تريد أن ترى كيف تبدو حلقة مصممة جيدًا وتعمل بالفعل، فإن [autoresearch لكارباثي](https://github.com/karpathy/autoresearch) هي المثال النموذجي.
+
+في مارس 2026، أصدر كارباثي مشروع Python مكونًا من 630 سطرًا. أعطِه GPU واحدًا واتجاه بحثي، ويعمل طوال الليل - مكتملًا بمئات تجارب تدريب ML، ويحتفظ فقط بتلك التي تحسن حقًا. وصل المشروع إلى أكثر من 66,000 نجمة في غضون أيام من الإصدار.
+
+### ثلاثة ملفات، ثلاثة أدوار
+
+النظام بأكمله له فقط ثلاثة ملفات أساسية، لكن تقسيم العمل حاد للغاية:
+
+| الملف | من يقوم بتحريره | ماذا يفعل |
+|------|-------------|-------------|
+| `prepare.py` | لا أحد (للقراءة فقط) | تحضير البيانات، المُميّز، حزام التقييم. بنية تحتية ثابتة. |
+| `train.py` (~630 سطر) | **وكيل الذكاء الاصطناعي** | تعريف النموذج، المحسن، حلقة التدريب. ملعب الوكيل - غيّر أي شيء. |
+| `program.md` | **أنت** | منهجية البحث مكتوبة باللغة الطبيعية. أنت فقط تقوم بتحرير هذا. أخبر الوكيل كيف يستكشف، وكيف يقيم، وما لا يلمسه. |
+
+هذا التقسيم ثلاثي الاتجاه هو روح التصميم: **البشر لا يلمسون الكود، بل يلمسون الاتجاه؛ الوكلاء لا يلمسون الاتجاه، بل يلمسون الكود.** تتحول وظيفتك من كتابة Python إلى "كتابة ثقافة منظمة البحث."
+
+### الإدخال: كيف يبدو program.md
+
+`program.md` هو دماغ الحلقة. إنه ليس كودًا - بل دليل تعليمات بحثي مكتوب بـ Markdown. يحتوي تقريبًا على:
+
+- **الهدف**: تحسين `val_bpb` (بتات التحقق لكل بايت، كلما انخفض كان أفضل)
+- **القيود**: لا تلمس `prepare.py`، ابقَ ضمن ميزانية VRAM، تدريب ثابت مدته 5 دقائق
+- **اتجاهات الاستكشاف**: جرب بنى مختلفة، ومحسنين، وجداول LR
+- **قواعد التقييم**: ما يعتبر تحسنًا، كيف تسجل النتائج، ماذا تفعل عند الفشل
+- **القاعدة الحديدية**: لا تتوقف أبدًا. بمجرد بدء الحلقة، استمر إلى الأبد
+
+يمكن أن تكون مطالبة البدء الخاصة بك للوكيل قصيرة مثل جملة واحدة:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+الباقي متروك للوكيل الذي يقرأ المستند ويتخذ قراراته الخاصة.
+
+### حلقة الساتب ذات التسع خطوات
+
+في قلب autoresearch يوجد **ساتب** - يتقدم فقط إلى الأمام، ولا يتراجع أبدًا. يتبع كل تكرار تسع خطوات بدقة:
+
+```mermaid
+flowchart TD
+ 1["1. اقرأ الاتجاه<br/>حمّل program.md"] --> 2["2. استطلع الحالة الحالية<br/>اقرأ train.py + النتائج السابقة"]
+ 2 --> 3["3. اقترح فرضية<br/>فكر في تغيير لتجربته"]
+ 3 --> 4["4. عدّل الكود<br/>حرّر train.py"]
+ 4 --> 5["5. لقطة<br/>git commit"]
+ 5 --> 6["6. شغّل التدريب<br/>ساعة حائط ثابتة 5 دقائق"]
+ 6 --> 7{"7. قيّم<br/>هل تحسن val_bpb؟"}
+ 7 -->|نعم| 8a["8a. احتفظ<br/>يبقى الالتزام<br/>اكتب في results.tsv"]
+ 7 -->|لا| 8b["8b. ارجع للخلف<br/>git reset HEAD~1<br/>سجّل الفشل"]
+ 8a --> 9["9. الجولة التالية<br/>ارجع إلى الخطوة 1"]
+ 8b --> 9
+```
+
+تعمل بـ 12 تجربة تقريبًا في الساعة. تشغيل ليلة واحدة (8 ساعات) حوالي 100 تجربة. قام كارباثي نفسه بتشغيلها لمدة يومين - ~700 تجربة.
+
+ميزانية الساعة الحائط الثابتة البالغة 5 دقائق هي خيار تصميمي رئيسي - بغض النظر عما يغيره الوكيل، تستغرق كل تجربة نفس الوقت بالضبط. هذا يعني أن جميع النتائج قابلة للمقارنة مباشرة ضمن نفس الميزانية الزمنية - لا جدال حول "هذه شغلت لفترة أطول لذا فهي أفضل."
+
+### المخرج: ما تراه عند الاستيقاظ
+
+بعد ليلة من الحلقات، تجلس في الصباح وتجد ثلاثة أشياء:
+
+**1. سجل Git (الساتب المتقدم للأمام)**
+
+فقط الالتزامات التي تحسنت بالفعل تبقى على الفرع الرئيسي. كل ما فشل تم تراجعه. `git log` هو سجل بحثي موثق.
+
+**2. results.tsv (سجل التجربة الكامل)**
+
+كل تجربة واحدة - نجاح أو فشل - مسجلة:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. سجل بحثي (ملخص الوكيل الخاص)**
+
+يكتب الوكيل رسائل التزام واضحة حول ما جربه، وما نجح، وما لم ينجح، وما يخطط لتجربته بعد ذلك. أنت تقرأ تلك - لا يجب عليك قراءة فروق الكود.
+
+### ما وجده بالفعل
+
+النتائج من تشغيل كارباثي الأولي لمدة يومين، ~700 تجربة:
+
+- من بين ~700 محاولة، تم العثور على حوالي **20 تحسنًا حقيقيًا قابلًا للتكديس**
+- خفض وقت تدريب مستوى GPT-2 لـ nanochat على 8×H100 من **2.02 ساعة → 1.80 ساعة**، حوالي **أسرع بنسبة 11٪**
+- شملت النتائج: تعديلات معدل التعلم، وضبط المحسن، وتبديلات التنشيط، وتحسينات نمط الانتباه، إلخ.
+
+هل كانت جميع التحسينات اكتشافات مذهلة؟ لا. كانت معظمها تحسينات صغيرة تكدست. لكن تلك التحسينات الصالحة البالغ عددها 20 كانت ستستغرق باحثًا بشريًا أسابيع من العمل اليدوي - وفعلها الوكيل في 48 ساعة.
+
+### التفاصيل الأكثر دلالة: الحلقة مكتوبة باللغة الإنجليزية، وليس بالكود.
+
+`program.md` هو مستند Markdown، وليس نصيبي Python. يصف منهجية بحثية - ماذا تعدل، وماذا تترك شأنه، وكيف تقيم، وكيف تتعامل مع حالات الفشل، وقاعدة حديدية واحدة: **لا تطلب أبدًا مساعدة بشرية، فقط استمر.** وكيل برمجة يقرأ هذا المستند وينفذه إلى أجل غير مسمى.
+
+هذا هو قالب هندسة الحلقات: لا تعطِ الوكيل مهمة. أعطِه **منهجية**. دع المنهجية هي الحلقة. ملف `program.md` واحد، و630 سطرًا من كود الغراء، وكل شيء آخر هو الوكيل يدير نفسه.
+
+## أربعة تكاليف صامتة
+
+عندما تبدأ الحلقة في العمل، لن ترى المشاكل فورًا. تتراكم التكاليف الأربع التالية بصمت، وبحلول الوقت الذي تلاحظه فيه، ربما تكون قد دفعت ثمنًا باهظًا بالفعل.
+
+### 1. دين التحقق
+
+الحلقات السريعة تميلك لتخطي التحقق. "يبدو جيدًا" ليس نفس الشيء مثل "مؤكد صحيح." كلما زاد الكود الذي تولده الحلقة دون إشراف، زادت سرعة تراكم دين التحقق. الحل: **شروط التوقف يجب أن تكون قابلة للفحص آليًا، أبدًا "يشعر أنها صحيحة تقريبًا."**
+
+### 2. تعفن الفهم
+
+كلما زادت سرعة شحن الحلقة للكود، زاد تباعد فهمك لقاعدة الكود الخاصة بك عن الواقع. كان لدى فريق تشيرني 80٪ من الكود مكتوبًا بواسطة الوكلاء - مما يعني أن معظم كود الفريق لم يكتبه شخص. إذا لم تقرأ وتستخدم ما تنتجه الحلقة، فإن فهمك يتحلل باستمرار. **الحلقات السريعة تتطلب قراءة سريعة.**
+
+### 3. الاستسلام المعرفي
+
+عندما تعمل الحلقة بسلاسة، تكون الوضع الأكثر راحة هو التوقف عن وجود آراء. خذ ما يعيدونه، لا تفكر في المخرجات. لكن هذا هو بالضبط حيث يبدأ الخطر - أنت تستخدم الحلقة لتجنب التفكير، بدلاً من تضخيم التفكير. تحذير عثماني: "يمكن لشخصين بناء نفس الحلقة بالضبط والحصول على نتائج عكسية. أحدهما يستخدمها للذهاب بشكل أسرع في العمل الذي يفهمه؛ والآخر يستخدمها لتجنب فهم العمل. الحلقة لا تعرف الفرق. أنت تعرف."
+
+### 4. انفجار التوكنز
+
+يتراكم كل تكرار للحلقة المزيد من السياق: الكود المكتوب، والأخطاء التي تمت مواجهتها، والقرارات المتخذة. بدون إدارة السياق، ينمو حجم المطالبة تقريبًا تربعيًا مع عدد الدورات. يعالج Codex ذلك من خلال الضغط التلقائي للسياق - API مخصص يضغط أدوار المحادثة القديمة إلى ملخصات محتوى مشفرة، مع الاحتفاظ بالمعرفة الأساسية مع التخلص من التفاصيل الزائدة. هذا هو اهتمام هندسي يجب معالجته من الحلقة الأولى، وليس إضافة لاحقة.
+
+## بناء أول حلقة لك
+
+ليس عليك البدء بخط أنابيب بمقياس Stripe يدمج 1,300 PR في الأسبوع. ابدأ بأصغر شيء يعمل.
+
+### الخطوة 1: اختر مهمة متكررة واحدة
+
+ابحث عن شيء تفعله يدويًا مرتين على الأقل في الأسبوع. أمثلة:
+- افتح GitHub في الصباح، وتحقق من القضايا الجديدة، وصنفها ورد عليها
+- شغّل lint والاختبارات قبل كل مراجعة PR
+- حدّث مستندات التقدم في نهاية كل يوم
+
+### الخطوة 2: اكتب هدفًا وشرط توقف
+
+حوّل المهمة إلى شيء يمكن لـ `/goal` فهمه:
+
+```markdown
+Goal: Check the 10 most recent issues in the repo.
+For each issue:
+ - If it already has clear labels and an assignee, skip
+ - If untagged, add appropriate labels based on content
+ - If fixable in under 10 minutes, create a branch and attempt a fix
+Stop when: All qualifying issues have been processed, or an issue requires human decision.
+```
+
+### الخطوة 3: افصل الصانع والمدقق
+
+لا تدع نفس الوكيل يكتب الكود ويحكم عليه. اقسم حلقتك إلى دورين:
+- المنفذ: يقرأ القضية، يكتب الإصلاح، يكتب الاختبارات
+- المدقق: يشغّل الاختبارات بشكل مستقل، يراجع الفرق، يحكم على ما إذا كان الإصلاح يحل المشكلة بالفعل
+
+### الخطوة 4: أضف ذاكرة
+
+استخدم ملف markdown لتسجيل ما حدث في كل تشغيل للحلقة. يبدأ التشغيل التالي بقراءة هذا الملف - فيعرف ما تم إنجازه، وما هو معلق، وما كان محجوبًا. هذا يتفوق على أي قاعدة بيانات معقدة.
+
+### الخطوة 5: اضبط مؤقتًا
+
+استخدم `/loop` أو cron نظام التشغيل الخاص بك لتسمح للحلقة بالبدء بدونك. ابدأ بمرة واحدة في اليوم. راقب لمدة أسبوع.
+
+### سلم النضج
+
+ليس عليك الوصول إلى القمة في قفزة واحدة. تبني الحلقات هو سلم:
+
+1. **المستوى 1: مشغل الهدف** — يمكنك استخدام `/goal` لإعطاء مهمة بشرط توقف؛ يكرر الوكيل حتى يتحقق.
+2. **المستوى 2: مهمة واحدة مجدولة** — تقوم أتمتة واحدة بتشغيل مهمة واحدة على مؤقت (مثل فحص CI الصباحي).
+3. **المستوى 3: حلقة متعددة الوكلاء** — فصل الصانع والمدقق؛ كل نتيجة تفرع worktree معزول.
+4. **المستوى 4: حلقة ذاتية التغذية** — تكتشف الحلقة تلقائيًا مهمتها التالية من الحالة الخارجية؛ تقرر ماذا تفعل بعد ذلك.
+5. **المستوى 5: تنظيم الأسطول** — تعمل حلقات متعددة بشكل متوازي، مستقلة لكن تشارك طبقة ذاكرة.
+
+معظم الفرق حاليًا بين المستوى 2 والمستوى 3. المستوى 1 هو أسرع طريقة لرؤية العوائد.
+
+## الخلاصات الرئيسية
+
+- **هندسة الحلقات لا تحل محل هندسة الـ Harness — بل تبني طابقًا فوقها.** الـ Harness يجعل التشغيلات الفردية موثوقة. الحلقة تجعل التشغيلات المستمرة مستقلة.
+- **`/goal` هي أبسط حلقة ممكنة:** هدف + تحقق + شرط توقف. هذه الأشياء الثلاثة تنقلك من داخل الحلقة إلى خارجها.
+- **البدائيات الست (الأتمتة / Worktrees / المهارات / الموصلات / الوكلاء الفرعيون / الحالة الخارجية) هي لبنات بناء الحلقة.** ليست كلها في كل مرة، لكنك تحتاج إلى معرفة متى تصل إلى أي منها.
+- **يجب فصل الصانع والمدقق.** النموذج الذي يصحح عمله نفسه غير موثوق. المدقق المستقل - وأحيانًا نموذج مختلف تمامًا - هو ضمان الموثوقية الأساسي لأي حلقة.
+- **الحلقات تجعل التوليد مجانيًا تقريبًا وتترك الحكم كمورد نادر.** الوقت الذي توفره ليس للراحة. بل لاتخاذ المزيد من الأحكام.
+- **أربعة تكاليف صامتة تزداد حدة كلما طالت مدة تشغيل الحلقات:** دين التحقق، تعفن الفهم، الاستسلام المعرفي، انفجار التوكنز. الحلقات تسرع المخرجات - والمخاطر.
+- **ابدأ صغيرًا.** `/goal` واحد، و cron واحد، وملف ذاكرة markdown واحد. انظر للعائد، ثم تكدس لأعلى.
+
+## قراءات إضافية
+
+- [آدي عثماني: هندسة الحلقات](https://addyosmani.com/blog/loop-engineering/)
+- [آدي عثماني: هندسة حزام الوكيل](https://addyosmani.com/blog/agent-harness-engineering/)
+- [سايمون ويليسون: تصميم الحلقات الوكيلية (سبتمبر 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [كارباثي: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: سير العمل الديناميكي والتنظيم](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [مكتبة الحلقات (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — مجموعة عامة من 50 حلقة حقيقية
+- [The Neuron: مبتكري Claude Code حول حلقات الوكيل](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- المحاضرة 12: [اترك تسليمًا نظيفًا في نهاية كل جلسة](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — الشرط الأساسي للحلقات: كل جلسة تترك حالة نظيفة حتى تتمكن الجولة التالية من البدء تلقائيًا
+- المحاضرة 5: [احافظ على استمرارية المهام طويلة الأمد عبر الجلسات](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — المعرفة الأساسية للحالة الخارجية والذاكرة
+- المحاضرة 11: [لماذا تنتمي إمكانية الملاحظة داخل الـ Harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — كلما زادت سرعة تشغيل الحلقة، زدت حاجتك إلى إمكانية الملاحظة لاكتشاف المشاكل
+- المحاضرة 8: [لماذا قوائم الميزات هي بدائيات الـ Harness](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — قوائم الميزات هي مصدر البيانات الطبيعي لحلقة ذاتية التغذية لاكتشاف مهمتها التالية
+
+## التدريبات
+
+1. **حوّل مهمة متكررة إلى `/goal`:** ابحث عن شيء تفعله يدويًا مرتين على الأقل في الأسبوع. اكتب هدفه، وطريقة التحقق، وشرط التوقف. شغّله مرة واحدة بـ `/goal` وقارن الوقت والجودة مقابل القيام بذلك يدويًا. هذه هي خطوتك الأولى من Harness إلى Loop.
+
+2. **افصل الصانع والمدقق:** اختر مهمة سبق أن طلبت من وكيل تنفيذها. هذه المرة، اكتب مطالبتين مختلفتين: واحدة لوكيل المنفذ وواحدة لوكيل المدقق (استخدم نماذج مختلفة - مثل Claude للتنفيذ، و GPT للتحقق، أو العكس). يجب أن يشير المدقق إلى مشكلات محددة بأدلة مستشهد بها. سجل عدد ونوع المشكلات التي تم العثور عليها في كل وضع.
+
+3. **أعطِ حلقتك ذاكرة:** أنشئ ملف حالة markdown لحلقتك. في كل تكرار، اكتب: ما تم إنجازه في هذه الجولة، ونتائج التحقق، والحالة (نجاح/فشل/محجوب)، وماذا تفعل بعد ذلك. شغّل ثلاث جولات ولاحظ الفرق السلوكي بين وجود ملف ذاكرة وعدمه.
+
+4. **تدقق في تكاليف حلقتك الصامتة:** بعد أن تعمل الحلقة لمدة ساعة، قيّم هذه المقاييس الأربعة:
+ - كم كان التحقق "يشعر بأنه صحيح" بدلاً من "مؤكد آليًا"؟ (دين التحقق)
+ - ما مدى قدرتك على شرح الكود الذي أنتجته حلقتك مؤخرًا؟ (تعفن الفهم)
+ - كم مرة فكرت "سأنظر لاحقًا" ولم أنظر أبدًا؟ (الاستسلام المعرفي)
+ - كيف يتجه حجم سياق الحلقة؟ هل يكرر معلومات زائدة؟ (انفجار التوكنز)
diff --git a/docs/ar/projects/project-07-loop-engineering-first-loop/index.md b/docs/ar/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..38512a5
--- /dev/null
+++ b/docs/ar/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# المشروع 07. ابني أول حلقة آلية
+
+> المحاضرة ذات الصلة: [المحاضرة 13. لماذا تحتاج إلى التوقف عن مطالبة وكيلك](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## ماذا ستفعل
+
+هذا هو المشروع الانتقالي من "Harness" إلى "Loop". أنت تعرف بالفعل كيفية إعداد وكيل ببيئة مناسبة وتعليمات وتغذية راجعة - الآن ستحول هذا الإعداد إلى حلقة تعمل من تلقاء نفسها.
+
+ستقوم بثلاثة تجارب متتالية: أولاً تحول مهمة من يدوية إلى `/goal`، ثم تحول مهمة مراقبة إلى مؤقت `/loop`، وأخيراً بناء حلقة كاملة من نوع صانع-مدقق لتجربة شعور **عندما تخرج من الحلقة.**
+
+## ملفات المشروع
+
+مسار المستودع: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| الدليل | ما بداخله | ماذا تفعل |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | مشروع قاعدة معرفة صغير بـ Harness كامل (الحالة النهائية لـ P06)، بما في ذلك AGENTS.md، و feature_list.json، و init.sh، و session-handoff.md، و clean-state-checklist.md. | حوّل هذا الـ Harness إلى واحد يمكنه الحلقة تلقائيًا. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | تنفيذات كاملة لثلاث حلقات: حلقة هدف، وحلقة مؤقت، وحلقة صانع-مدقق، بالإضافة إلى ملفات حالة الحلقة ونصوص التحقق. | مرجع لأنماط تصميم الحلقة وإدارة الحالة. |
+
+## الأدوات التي ستستخدمها
+
+- Claude Code أو Codex
+- Git
+- الـ Harness الكامل الخاص بك من P06
+- مُضاعِف طرفية (tmux أو screen، لمراقبة الحلقات طويلة الأمد)
+- اختياري: GitHub Actions أو cron (للتجارب المتقدمة المدفوعة بالأحداث / المجدولة)
+
+## الخطوات
+
+### التحضير
+
+1. ابدأ من نفس الالتزام الذي أنهيت فيه P06.
+2. أنشئ ثلاثة فروع: `p07-goal-loop`، `p07-timer-loop`، `p07-maker-checker`.
+3. أكد أن الـ Harness الخاص بك يعمل: شغّل init.sh، وتحقق من ملف الحالة، وقائمة الميزات، ومستندات التسليم كلها في مكانها.
+4. اختر **مهمة مستهدفة** تريد أن تعمل الحلقة عليها بشكل متكرر. اختر شيئًا متوسط الحجم بمعايير إكمال واضحة - مثل "أضف اختبارات وحدة إلى جميع الوحدات، مع الوصول إلى تغطية 80٪" أو "أضف التحقق من صحة الإدخال إلى جميع نقاط نهاية API."
+
+### التجربة 1: حلقة الهدف — من التشغيل اليدوي إلى التشغيل التلقائي
+
+انتقل إلى الفرع `p07-goal-loop`.
+
+1. **اكتب وصف الهدف**: حوّل المهمة التي اخترتها إلى ملف `goal.md` يحتوي على:
+ - هدف واضح ("ما يعتبر منتهيًا")
+ - طريقة التحقق ("كيفية تأكيد انتهائه" - تشغيل الاختبارات؟ تشغيل lint؟ التحقق من التغطية؟)
+ - شرط التوقف ("متى يجب أن يتوقف" - الحد الأقصى من الدورات؟ الحد الزمني؟ حد الميزانية؟)
+ - القيود ("ما لا يجب لمسه" - تكوين الإنتاج، مخطط قاعدة البيانات، إلخ.)
+
+2. **أول تشغيل يدوي**: أعطِ المهمة للوكيل يدويًا بنفسك. سجل عدد الدورات التي استغرقتها، وعدد المرات التي تدخلت فيها، وجودة النتيجة. هذا هو خط الأساس الخاص بك.
+
+3. **شغّل بـ `/goal`**: استخدم نفس `goal.md` كمدخل وشغّله في وضع `/goal`. يكرر الوكيل من تلقاء نفسه حتى يتم الوصول إلى الهدف أو ينشط شرط التوقف.
+
+4. **قارن النتائج**:
+ - الفرق في عدد الدورات
+ - الفرق في عدد تدخلاتك
+ - الفرق في جودة النتيجة (باستخدام نفس معيار التحقق)
+ - الفرق في الوقت الذي قضيته
+
+5. **كرر على goal.md**: إذا كانت النتائج ضعيفة، راجع وصف الهدف وشغّل مرة أخرى. استمر حتى تكون راضيًا عن النتائج، أو حتى تؤكد الحد الأقصى لما يمكن أن تفعله حلقة الهدف في هذه المهمة.
+
+### التجربة 2: حلقة المؤقت — حوّل المراقبة إلى نبض قلب
+
+انتقل إلى الفرع `p07-timer-loop`.
+
+1. **اختر مهمة مراقبة**: ابحث عن فحص متكرر تقوم به عادةً يدويًا. على سبيل المثال:
+ - شغّل مجموعة الاختبارات كل ساعة، وأصلح الأخطاء
+ - تحقق من تحديثات أمان التبعيات كل صباح
+ - تحقق من انتهاكات أسلوب الكود بعد كل التزام
+ - افحص تعليقات TODO بشكل دوري لمعرفة أيها قديم
+
+2. **اكتب مطالبة/نص المراقبة**: ضع خطوات المراقبة بوضوح - ماذا تتحقق، وماذا تفعل عند العثور على مشاكل، ومتى تستدعي إنسانًا.
+
+3. **شغّل بـ `/loop` (أو أتمتة موضوع Codex)**:
+ - اضبط فاصلًا زمنيًا معقولًا (10-30 دقيقة موصى به - قصير جدًا وستشعر بالازعاج، وطويل جدًا ولن ترى التأثير)
+ - دعها تعمل لمدة ساعتين على الأقل (أو اذهب لتفعل شيئًا آخر وعد لاحقًا)
+
+4. **سجّل النتائج**:
+ - كم مشكلة وجدت؟
+ - كم أصلحت من تلقاء نفسها؟
+ - كم كانت إيجابيات كاذبة؟
+ - كم جعلتها أسوأ؟
+ - كم وقت قضيته في متابعة نتائجها؟
+
+5. **تأمل**: هل مهمة المراقبة هذه تستحق الأتمتة؟ قارن الوقت الذي وفرته مقابل الوقت الذي قضيته في المتابعة. إذا لم تكن تستحق ذلك، هل اخترت المهمة الخطأ، أم أن الحلقة مصممة بشكل سيئ؟
+
+### التجربة 3: حلقة الصانع-المدقق — أخرج نفسك من الحلقة
+
+انتقل إلى الفرع `p07-maker-checker`.
+
+هذه هي الأهم من التجارب الثلاث. ستبني **حلقة كاملة لا تحتاج إلى وجودك هناك:**
+
+1. **صمم بنية الحلقة**:
+ - **وكيل صانع**: ينفذ، يكتب الكود، يعدل الملفات
+ - **وكيل مدقق**: يتحقق، يشغّل الاختبارات، يقوم بمراجعة الكود، يمر / يفشل
+ - **ملف الحالة** (`loop-state.md`): يسجل الجولة الحالية، وما تم إنجازه، ونتائج التحقق، وما هو التالي
+ - **شرط التوقف**: N مرات نجاح متتالية، أو الوصول إلى الحد الأقصى من الجولات
+
+2. **اكتب ثلاث مطالبات**:
+ - تعليمات الصانع (ماذا يفعل، كيف يفعله، ما لا يلمسه)
+ - تعليمات المدقق (ماذا يتحقق، كيف يتحقق، ما يعتبر نجاحًا، كيف يقدم الملاحظات)
+ - منطق التحكم في الحلقة (من يبدأ أولاً، كيف يعمل التسليم، كيف تبدأ الجولة التالية)
+
+3. **شغّل 5 جولات على الأقل**:
+ - الجولة 1: ينفذ الصانع → يتحقق المدقق → يفشل → ملاحظات للصانع
+ - الجولة 2: يعدل الصانع بناءً على الملاحظات → يتحقق المدقق → ...
+ - ...
+ - حتى النجاح المتتالي، أو تقرر ذلك أنت
+
+4. **سجّل حالة كل جولة**:
+ - رقم الجولة
+ - ماذا فعل الصانع
+ - ما المشاكل التي وجدها المدقق
+ - نجاح / فشل
+ - هل تدخلت؟ (إذا كان نعم، لماذا؟)
+
+5. **الاستعراض النهائي**:
+ - كم مرة تدخلت؟ لماذا؟
+ - ماذا كان سيحدث لو لم تتدخل؟
+ - هل فات المدقق أي مشاكل؟
+ - هل استمر الصانع في ارتكاب نفس الخطأ؟
+ - أين هو سقف الجودة لهذه الحلقة؟ قدرة الصانع، أم قدرة المدقق؟
+
+## كيف تقيس النتائج
+
+| المقياس | التجربة 1 (الهدف) | التجربة 2 (المؤقت) | التجربة 3 (الصانع-المدقق) |
+|--------|-------------|--------------|----------------------|
+| معدل إكمال المهمة | هل تم الوصول إلى الهدف؟ | كم دورة مراقبة شغّلت؟ | كم جولة حتى النجاح؟ |
+| التدخلات البشرية | كم مرة تدخلت؟ | كم وقت قضيته في المتابعة؟ | كم مرة تدخلت؟ |
+| جودة النتيجة | كيف تقارن باليدوية؟ | معدل الإيجابيات الكاذبة؟ المشاكل التي فاتت؟ | كم مشكلة وجدها المدقق ولما وجدتها أنت؟ |
+| الوقت الموفّر | كم وقت وفرت؟ | هل تستحق الأتمتة؟ | الوقت المستغرق في تصميم الحلقة مقابل الوقت الموفّر |
+| الموثوقية | هل كان شرط التوقف موثوقًا؟ | هل هربت؟ | هل يمكن للحلقة أن تتعثر في نفس المكان؟ |
+
+## ما يجب تقديمه
+
+- `goal.md` (وصف هدف التجربة 1، جولتان على الأقل)
+- ملاحظات مقارنة التجربة 1: يدوي مقابل حلقة الهدف
+- مطالبة مراقبة التجربة 2 + سجل تشغيل لمدة ساعتين
+- المطالبات الثلاث للتجربة 3 (الصانع / المدقق / التحكم في الحلقة)
+- `loop-state.md` للتجربة 3 (مسجلة 5 جولات على الأقل)
+- الاستعراض النهائي: الدروس المستفادة من التجارب الثلاث جميعها، وكيف تغير فهمك لهندسة الحلقات، وما هي الأشياء مرشحة جيدة للتحويل إلى حلقة وما ليست كذلك.
+
+## المحاضرات ذات الصلة
+
+- [المحاضرة 13 — لماذا تحتاج إلى التوقف عن مطالبة وكيلك](../../lectures/lecture-13-loop-engineering/index.md)
+- [المحاضرة 12 — لماذا يجب أن تترك كل جلسة حالة نظيفة](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (كل جولة من الحلقة تحتاج إلى حالة نظيفة)
+- [المحاضرة 11 — لماذا تنتمي إمكانية الملاحظة داخل الـ Harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (تحتاج إلى رؤية ما يحدث داخل الحلقة)
+- [المحاضرة 05 — لماذا تعد ملفات الحالة هي عمود الفقار للاستمرارية](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (ملفات حالة الحلقة هي امتداد لملفات الحالة)
diff --git a/docs/de/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/de/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/de/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/de/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/de/lectures/lecture-13-loop-engineering/code/index.md b/docs/de/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/de/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/de/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/de/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/de/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/de/lectures/lecture-13-loop-engineering/index.md b/docs/de/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..a9425c4
--- /dev/null
+++ b/docs/de/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Codebeispiele: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Praxisprojekt: [Projekt 07. Baue deinen ersten automatisierten Loop](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Lektion 13. Von manuellen Prompts zu autonomen Loops
+
+Alles, was du in den ersten zwölf Lektionen gelernt hast, beruht auf einer Annahme: **du sitzt an der Tastatur und tippst Anweisungen nacheinander ein.**
+
+Du hast `AGENTS.md` geschrieben (Lektionen 1–4), State-Management aufgebaut (Lektionen 5–6), den Scope mit Feature-Listen begrenzt (Lektionen 7–8), saubere Übergaben am Sitzungsende hinterlassen (Lektionen 9, 12) und die Runtime beobachtbar gemacht (Lektionen 10–11). Aber der Auslöser für alles warst immer du. Der Agent hat nie selbst entschieden, wann er mit der Arbeit beginnt — weil niemand auf „Start“ gedrückt hat.
+
+In dieser Lektion geht es darum, den Startknopf dem System zu übergeben. Nicht die Kontrolle abgeben — sie auf die nächste Ebene heben.
+
+## /goal: Der einfachste mögliche Loop
+
+Der beste Einstieg in Loop Engineering ist kein komplexes Architekturdiagramm — es ist ein einziger Befehl.
+
+Anfang 2026 haben Claude Code und OpenAI Codex unabhängig voneinander dasselbe Feature veröffentlicht: `/goal`. Du tippst im Terminal:
+
+```
+/goal "All tests pass, zero lint warnings, merge to main"
+```
+
+Dann schließt du deinen Laptop und gehst schlafen. Acht Stunden später hat der Agent selbstständig analysiert, programmiert, getestet, behoben und gemergt. Er wiederholt bei Fehlern, wechselt den Ansatz bei Stockungen und hört auf, wenn er fertig ist — ohne dass du ihm über die Schulter schaust und „nochmal versuchen“ sagst.
+
+Der einzige Unterschied zwischen `/goal` und einem traditionellen Prompt ist eine Sache. Aber diese eine Sache verändert alles:
+
+| | Traditioneller Prompt | `/goal` |
+|---|---|---|
+| Was du angibst | Was als Nächstes zu tun ist | Wie der Endzustand aussieht |
+| Was der Agent tut | Einmal ausführen | Loopen, bis erreicht |
+| Wer beurteilt, ob es fertig ist | Du | Eine überprüfbare Stoppbedingung |
+| Wann du weggehen kannst | Nie | In dem Moment, in dem du `/goal` eingibst |
+
+`/goal` ist im Grunde ein Loop. Er hat genau drei Teile: **ein Ziel, eine Verifikationsmethode und eine Stoppbedingung.** Nur diese drei Dinge bringen dich von innerhalb des Loops nach draußen.
+
+### Wie `/goal` organisch gewachsen ist
+
+`/goal` ist nicht aus dem Nichts von 0 auf 1 gesprungen. Es ist allmählich aus alltäglichen Arbeitsabläufen hervorgegangen und hat grob vier Stadien durchlaufen:
+
+**Stadium 1: Manuelle Einzel-Prompts.** Die früheste Arbeitsweise war Hin und Her: „schreibe eine Funktion“, „füge einen Test hinzu“, „repariere diese Logik“. Der Agent hielt nach jedem Schritt an und wartete darauf, dass du sagst, was als Nächstes kommt. Du warst der Scheduler der gesamten Pipeline.
+
+**Stadium 2: Lange Prompts mit mehreren Schritten.** Dann fingen die Leute an, längere Prompts zu schreiben, die Schritte stapelten: „zuerst analysiere den Code, dann schreibe die Implementierung, dann führe Tests aus, und wenn sie fehlschlagen, repariere sie“. Der Agent konnte mehrere Schritte auf einmal ausführen, aber du musstest trotzdem zuschauen — weil er mittendrin abdriften oder einen Schritt beenden und nicht wissen könnte, was als Nächstes zu tun ist.
+
+**Stadium 3: Agent-Selbstreflexion und Selbststeuerung.** Danach bekamen Agenten „Introspektion“ — nach jedem Schritt betrachteten sie das Ergebnis und entschieden, was als Nächstes zu tun ist. Du gabst ein Ziel, und sie zerlegten es selbst und wiederholten auf eigene Faust. Aber ein Problem tauchte auf: Wann hören sie auf? Zählt „Ich bin fertig“, das vom Agenten selbst kommt? Die Praxis hat immer wieder geantwortet — nein. Agenten erklären den Sieg viel zu leichtfertig.
+
+**Stadium 4: Unabhängige Stoppbeurteilung — `/goal`.** Der letzte Schritt war, das „Beurteilen, ob es fertig ist“ aus den Händen des arbeitenden Agenten zu nehmen und einem unabhängigen Richter zu übergeben. Es könnte ein anderes Modell, ein Skript oder ein Testbefehl sein — aber die Regel war dieselbe: Die Person, die den Code schreibt, darf ihre eigenen Hausaufgaben nicht benoten. An diesem Punkt funktionierte `/goal` wirklich: Du gibst das Ziel, es loopt, ein unabhängiger Richter entscheidet, wann aufgehört wird, und du kannst weggehen.
+
+Diese vier Stadien waren keine Roadmap, die irgendein Unternehmen geplant hat. Sie waren der Weg, auf den jeder, der mit Agenten programmiert, unabhängig voneinander gestoßen ist — getrieben von denselben Schmerzpunkten. Dass Claude Code und Codex `/goal` fast gleichzeitig Anfang 2026 veröffentlicht haben, war kein Zufall — die Zeit war reif.
+
+### Es gibt mehr als eine Art von Loop
+
+`/goal` ist der am einfachsten zu verstehende Loop, aber er ist nicht die einzige Art. Loops fallen in Kategorien, je nachdem, wie sie ausgelöst werden und wie sie stoppen:
+
+| Typ | Auslöser | Stoppbedingung | Claude Code | Codex | Am besten für |
+|------|---------|----------------|-------------|-------|----------|
+| **Zugbasierter Loop** | Du tippst jeden Prompt manuell | Agent meint, er ist fertig, oder du unterbrichst | Normaler Chat | Normaler Chat | Kleine Aufgaben, explorative Arbeit |
+| **Zielbasierter Loop** | Du gibst ein Ziel | Unabhängiger Evaluator bestätigt Fertigstellung, oder maximale Züge erreicht | `/goal` | `/goal` (manuelle Aktivierung erforderlich) | Komplexe Aufgaben mit klaren Abschlusskriterien |
+| **Zeitbasierter Loop** | Geplantes Intervall (alle N Minuten/Stunden) | Du stoppst ihn manuell, oder er beendet sich nach abgeschlossener Arbeit | `/loop` | Thread-Automatisierung | Statusabfrage, periodische Prüfungen, wiederkehrende Arbeit |
+| **Ereignisgesteuerter Loop** | Externes Ereignis (PR eröffnet, CI fehlgeschlagen, neues Issue) | Hört nach Bearbeitung des Ereignisses auf oder erreicht Retry-Limit | Routines (API / GitHub Webhook) | Standalone-Automatisierung + Plugins | Reaktive Workflows, CI/CD-Integration |
+
+Diese konkurrieren nicht — sie sind verschiedene Werkzeuge für verschiedene Aufgaben. Zugbasiert ist für kleine Dinge in Ordnung. Nutze `/goal`, wenn es eine klare Ziellinie gibt. Nutze `/loop`, wenn du etwas beobachten musst. Nutze ereignisgesteuert, wenn du mit externen Systemen integrierst.
+
+### Verwechsle `/goal` und `/loop` nicht
+
+Beide haben „Loop“ im Namen, aber sie lösen völlig verschiedene Probleme:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Was es ist** | Eine große Aufgabe, läuft bis sie fertig ist | Eine kleine Aktion, wiederholt sich in einem Intervall |
+| **Stoppbedingung** | Ziel erreicht, oder Budget erschöpft | Du stoppst es manuell, oder die Aufgabe beendet sich von selbst |
+| **Zeitprofil** | Ein langer Lauf, kann Stunden oder Tage dauern | Periodische kurze Schübe, jeder Lauf kann ein paar Minuten dauern |
+| **Fortschritt** | Kommt jeder Iteration näher an die Ziellinie | Jeder Lauf ist unabhängig, kein kumulativer Fortschritt |
+| **Analogie** | Einen Marathon laufen — Startschuss fällt, du stoppst an der Ziellinie | Ein Wecker — klingelt nach Plan, du schaltest ihn aus |
+| **Typischer Einsatz** | „Implementiere das vollständige Zahlungssystem mit Testabdeckung“ | „Prüfe alle 15 Minuten, ob die CI kaputt ist“ |
+
+Ein häufiger Fehler: Etwas, das ein `/goal` sein sollte, in einen `/loop` zu stopfen. Wie zum Beispiel `/loop 10m "implementiere weiter das Zahlungssystem"` — das ist falsch. `/loop` führt jedes Mal dieselbe Anweisung unabhängig aus, es erinnert sich nicht, wo es beim letzten Mal aufgehört hat. Du wirst immer wieder denselben Startpunkt bekommen.
+
+**Ein-Satz-Test für die richtige Wahl: Hat dieses Ding ein Ende?**
+- Hat ein Ende → `/goal`
+- Kein Ende, du musst nur weiter zuschauen → `/loop`
+
+Loop Engineering, das Thema dieser Lektion, geht es nicht um irgendeinen einzelnen Befehl. Es geht darum, **Systeme designen zu können, die all diese Typen umfassen — damit dein Agent weiterarbeiten kann, auch wenn du nicht da bist.**
+
+Du musst nicht jedes Mal `/goal` eingeben. Aber zu verstehen, woher es kommt und warum es so aussieht, wie es aussieht — das ist das Verständnis des Kerns von Loop Engineering. Komplexere Loops fügen nur Teile wie Scheduling, Parallelismus, Isolation und Speicher auf diesen selben drei Grundlagen hinzu: Ziel, Verifikation, Stoppbedingung.
+
+## Juni 2026: Drei Leute haben in einer Woche dieselbe Zündung ausgelöst
+
+In der ersten Juniwoche 2026 haben drei Praktiker, die Infrastruktur für Coding-Agenten aufbauen — ohne sich abzusprechen — dasselbe in verschiedenen Worten gesagt.
+
+**Peter Steinberger** (Erfinder von OpenClaw, [sein Beitrag erreichte 8 Millionen Aufrufe](https://x.com/steipete/status/2063697162748260627)): „Du solltest Coding-Agenten nicht mehr prompten. Du solltest Loops designen, die deine Agenten prompten.“
+
+**Boris Cherny** (Leiter von Claude Code bei Anthropic, [im Acquired-Podcast](https://x.com/rohanpaul_ai/status/2063289804708835412)): „Ich prompt Claude nicht mehr. Ich habe Loops laufen, die Claude prompten und herausfinden, was zu tun ist. Mein Job ist es, Loops zu schreiben.“
+
+**Addy Osmani** (Engineering-Lead bei Google Chrome) [hat das Konzept benannt](https://addyosmani.com/blog/loop-engineering/) am 7. Juni 2026 und ihm eine Einzeildefinition gegeben:
+
+> **Loop Engineering bedeutet, dich selbst als die Person zu ersetzen, die den Agenten promptet. Du designst stattdessen das System, das es tut.**
+
+Cherny hat Zahlen genannt: Über 30 aufeinanderfolgende Tage wurden alle Code-Beiträge zu Claude Code autonom von KI erstellt — 259 gemergte PRs, über 80 % des Produktionscodes von Claude verfasst, und eine Erfolgsrate von 76 % bei offenen Softwareaufgaben.
+
+Drei Leute. Eine Woche. Dieselbe Schlussfolgerung. Nicht weil sie koordiniert haben — sondern weil die Infrastruktur leise eine Schwelle überschritten hat. Agenten waren zuverlässig genug geworden, um nicht-triviale Aufgaben unbeaufsichtigt abzuschließen. Scheduling-Primitive (`/loop`, `/goal`, cron) waren jetzt in die Werkzeuge eingebaut. Die Kosten eines einzelnen Agenten-Laufs waren so niedrig geworden, dass das wiederholte Ausführen auf einem Timer nicht mehr verschwenderisch wirkte. Wenn alle Teile vorhanden sind, wird der Schritt, sie zu kombinieren, für alle gleichzeitig offensichtlich.
+
+> Quelle: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Innerhalb des Loops vs. außerhalb des Loops
+
+Lassen Sie uns zwei konkrete Szenarien gegenüberstellen.
+
+**Szenario A: Du bist innerhalb des Loops (Lektionen 1–12).**
+
+```mermaid
+flowchart TD
+ You["Du"] -->|"Manuell Anweisung eingeben"| Agent["KI-Agent"]
+ Agent -->|"Erzeugt Ausgabe"| Result["Code / Tests / Docs"]
+ Result -->|"Du prüfst"| You
+ You -->|"Unzufrieden, Anweisung anpassen"| Agent
+ You -->|"Zufrieden, zur nächsten Aufgabe"| You
+```
+
+Du hast ein vollständiges Harness: `AGENTS.md` sagt dem Agenten die Projektregeln, `feature_list.json` begrenzt den Scope, `init.sh` sorgt für eine konsistente Umgebung, `claude-progress.md` protokolliert den Fortschritt. **Aber jeder Schritt erfordert noch deine manuelle Initiierung.** Ein Feature fertigstellen, die Fortschrittsdatei lesen, darüber nachdenken, was als Nächstes kommt, die Anweisung eingeben. Du bist der Motor des gesamten Workflows.
+
+**Szenario B: Du bist außerhalb des Loops (Loop Engineering).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Das Loop-System, das du designed hast"]
+ Trigger["Auto-Trigger<br/>Zeitplan / Ereignis / Vorherige Aufgabe abgeschlossen"] --> Discover["Arbeit entdecken<br/>Fortschrittsdatei lesen / Issue-Tracker"]
+ Discover --> Dispatch["Verteilen<br/>Sub-Agent erzeugen"]
+ Dispatch --> Verify["Verifizieren<br/>Tests / Lint / Unabhängiger Reviewer-Agent"]
+ Verify --> Persist["State persistieren<br/>Fortschritt aktualisieren / Committen / PR eröffnen"]
+ Persist -->|"Arbeit übrig"| Discover
+ Persist -->|"Fertig oder blockiert"| Inbox["In deinen Review-Eingang schieben"]
+ end
+ Inbox -->|"Du musst nur Entscheidungen treffen"| You["Du"]
+```
+
+Du gibst keine Anweisungen mehr ein. Das von dir designte System entdeckt die Arbeit, verteilt sie, verifiziert die Ergebnisse, protokolliert den State und entscheidet über den nächsten Schritt. Dein Job schrumpft auf drei Dinge: **definiere das Ziel und die Stoppbedingung, bevor es losgeht, überprüfe die Ausgabe, nachdem es fertig ist, und passe die Regeln an, wenn das System vom Kurs abweicht.** Die Hebelwirkung verschiebt sich von „den richtigen Prompt schreiben“ zu „den richtigen Loop designen“.
+
+> Osmani: „Vor einem Jahr, wenn du einen Loop wolltest, hast du einen Haufen Bash geschrieben und diesen Haufen für immer gewartet, und er war deiner und nur deiner. Jetzt sind die Teile einfach in den Produkten enthalten.“ Du musst nicht von Grund auf neu bauen. Du musst verstehen, wie die Teile zusammenpassen.
+
+## Kernkonzepte
+
+- **Loop Engineering**: Designen eines Systems, das deinen Agenten automatisch promptet und manuelle schrittweise menschliche Eingabe ersetzt. Der Mensch bewegt sich von innerhalb des Loops nach draußen, und die Hebelwirkung verschiebt sich von „den richtigen Prompt schreiben“ zu „den richtigen Loop designen“.
+- **`/goal`-Modus**: Der einfachste mögliche Loop — gib ein Ziel, eine Verifikationsmethode und eine Stoppbedingung an; der Agent loopt, bis sie erfüllt sind. Die Brücke von manuellen Prompts zu autonomen Loops.
+- **Generator/Evaluator-Trennung**: Der Agent, der den Code schreibt, und der Agent, der ihn prüft, müssen getrennt sein. Ein Modell, das seine eigene Arbeit benotet, ist unvertrauenswürdig; ein unabhängiger Verifikator — manchmal mit einem völlig anderen Modell — ist die grundlegende Zuverlässigkeitsgarantie jedes Loops.
+- **Worktree-Isolation**: Jeder parallele Agent arbeitet in einem unabhängigen Git-Worktree und verhindert so physisch Dateikollisionen. Die Infrastrukturvoraussetzung für parallele Ausführung mit mehreren Agenten.
+- **External State**: Speicher, der außerhalb einer einzelnen Konversation lebt — Markdown-Dateien, Issue-Tracker, Kanban-Boards. Modelle vergessen alles zwischen Läufen; Speicher muss auf der Festplatte leben.
+- **Vier stille Kosten**: Vier versteckte Kosten, die umso schärfer werden, je länger ein Loop läuft — Verifikationsschulden, Verständnisverfall, kognitive Kapitulation, Token-Explosion. Loops beschleunigen nicht nur die Ausgabe, sondern auch das Risiko.
+
+## Die sechs Primitiven eines Loops
+
+Osmani hat einen Loop in fünf Kernbausteine zerlegt, plus eine Speicherschicht, die sich durch alle zieht — insgesamt sechs Dinge, aber die Speicherschicht nimmt einen besonderen Status ein: sie ist keine Komponente auf derselben Ebene wie die anderen; sie ist das Rückgrat, von dem alles andere abhängt.
+
+Das Diagramm unten zeichnet alle sechs als Ring, damit du das Gesamtbild auf einen Blick siehst. Aber denk dran: External State ist nicht nur eine weitere Station im Loop — es ist das Fundament, auf dem der gesamte Loop ruht.
+
+```mermaid
+flowchart LR
+ A["Automationen<br/>Geplante Trigger"] --> W["Worktrees<br/>Parallele Isolation"]
+ W --> S["Skills<br/>Kodifiziertes Projektwissen"]
+ S --> C["Connectors<br/>Zugriff auf externe Tools"]
+ C --> SA["Sub-Agenten<br/>Maker / Checker-Aufteilung"]
+ SA --> ES["External State<br/>Iterationsübergreifender Speicher"]
+ ES --> A
+```
+
+### 1. Automationen — Der Herzschlag
+
+Ohne Automatisierung ist ein Loop kein Loop — es ist ein einmaliger Lauf, den du manuell durchgeführt hast.
+
+Sowohl Claude Code als auch Codex haben vollständige Scheduling-Systeme, aber sie verwenden unterschiedliche Namen und Ebenen. Grob von leicht bis schwer zugeordnet:
+
+| Ebene | Claude Code | Codex | Hinweise |
+|-------|-------------|-------|-------|
+| In-Session-Polling | `/loop` | Thread-Automatisierung | Gebunden an aktuelle Session, stirbt wenn Session schließt |
+| Lokale geplante Aufgaben | Desktop geplante Aufgaben | Standalone-Automatisierung (lokaler Modus) | Läuft solange Maschine an ist, kann auf lokale Dateien zugreifen |
+| Cloud-geplante Aufgaben | Cloud Routines | — (kein nativer Cloud-Scheduler) | Läuft auch wenn Maschine aus ist |
+| Ereignis-Trigger | Routines (API / GitHub Webhook) | Standalone-Automatisierung + Plugins | Durch externe Ereignisse ausgelöst |
+| Vollständig selbst gehostet | GitHub Actions / selbst gehosteter Cron | `codex exec` + Cron | Volle Kontrolle |
+
+**Codex's Automations-Tab** ist der Einstiegspunkt für das Scheduling. Wähle das Projekt, den Prompt, die Kadenz und ob es auf deinem lokalen Checkout oder einem Hintergrund-Worktree läuft. Läufe, die etwas finden, landen in einem Triage-Eingang; Läufe, die nichts finden, werden automatisch archiviert. OpenAI nutzt sie intern für tägliches Issue-Triage, CI-Fehlerzusammenfassungen, Commit-Briefings und die Suche nach Bugs, die letzte Woche eingeführt wurden.
+
+Codex-Automationen gibt es in zwei Varianten:
+- **Thread-Automatisierung** — Herzschlag-artige wiederkehrende Weckrufe, die an einen Thread gebunden sind und Kontext bewahren. Gut für kontinuierliche Nachverfolgung einer einzelnen Sache, wie die Überwachung eines lang andauernden Befehls oder das Abfragen des PR-Status. Das Äquivalent in Claude Code ist `/loop`.
+- **Standalone-Automatisierung** — Jeder Lauf beginnt frisch, Ergebnisse gehen an Triage. Gut für tägliche/wöchentliche unabhängige Aufgaben wie Briefings oder Abhängigkeitsscans. Das Äquivalent in Claude Code sind Desktop geplante Aufgaben.
+
+Claude Code's System ist granularer geschichtet:
+
+- **`/loop`** — Leichtgewichtige in-Session geplante Wiederholung. Funktioniert solange dein Terminal offen ist, stirbt wenn die Session schließt, läuft nach 7 Tagen automatisch ab. Gut für temporäre Überwachung während deiner aktuellen Arbeitssession.
+- **Desktop geplante Aufgaben** — Läuft solange deine Maschine an ist, überlebt Session-Neustarts, Minuten-Intervalle. Gut für wiederkehrende Arbeit, die lokalen Dateizugriff benötigt.
+- **Cloud Routines** — Läuft auf Anthropic's Cloud-Infrastruktur, überlebt wenn deine Maschine aus ist, Mindestintervall von 1 Stunde. Unterstützt drei Trigger-Typen: geplant, API-Aufruf, GitHub-Webhook. Gut für tägliche Aufgaben, die deine lokale Umgebung nicht brauchen.
+- **GitHub Actions / selbst gehosteter Cron** — Vollständig unter deiner Kontrolle, läuft wie du willst. Gut für Szenarien mit besonderen Umgebungs- oder Sicherheitsanforderungen.
+
+```bash
+# Claude Code: Tests alle 30 Min ausführen, Fehler beheben (innerhalb der aktuellen Session)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: Deploy-Status alle 15 Minuten prüfen
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Automationen sind der Herzschlag. Ohne sie ist der Loop ein Bauplan, der nie aufwacht.
+
+### 2. Worktrees — Isolation im Maßstab
+
+Sobald du mehr als einen Agenten ausführst, werden Dateikollisionen zum unvermeidlichen Fehlermodus. Zwei Agenten, die in dieselbe Datei schreiben, sind genau der Kopfschmerz von zwei Ingenieuren, die in dieselben Zeilen committen, ohne sich abzusprechen.
+
+`git worktree` löst das: Jeder Agent arbeitet auf seinem eigenen Branch in seinem eigenen Verzeichnis. Sie können sich physisch nicht gegenseitig in ihren Checkout fassen.
+
+Sowohl Claude Code als auch Codex werden mit Worktree-Unterstützung ausgeliefert. Wenn du `--worktree` oder `isolation: worktree` bei einem Sub-Agenten verwendest, bekommt jeder Helfer einen sauberen, unabhängigen Checkout, der sich selbst aufräumt. Worktrees beseitigen das mechanische Kollisionsproblem — aber denk dran: **deine Review-Bandbreite ist immer noch die Obergrenze.** Wie viele parallele Agenten du überwachen kannst, bestimmt, wie viele Worktrees du tatsächlich ausführen kannst.
+
+### 3. Skills — Hör auf, dein Projekt immer wieder zu erklären
+
+Ein Skill ist die Art und Weise, wie du aufhörst, jeden Session denselben Projektkontext neu zu erklären. Es ist ein Ordner mit einer `SKILL.md` mit Anweisungen und Metadaten, plus optionalen Skripten, Referenzen und Assets.
+
+Codex und Claude Code unterstützen dasselbe Format. Skills werden direkt mit `/skill-name` aufgerufen (Codex unterstützt auch `$skill-name`), oder implizit ausgelöst, wenn die Aufgabe zur Skill-Beschreibung passt.
+
+Bei Skills geht es grundsätzlich darum, deine Intent-Schulden zu begleichen. Ein Agent startet jede Session kalt — er füllt jede Lücke in deiner Absicht mit einer zuversichtlichen Vermutung. Ein Skill ist diese Absicht, die außen aufgeschrieben steht: die Konventionen, die Build-Schritte, das „wir machen es nicht so wegen diesem einen Vorfall“ — einmal geschrieben, bei jedem Lauf gelesen.
+
+### 4. Connectors — Dein Loop berührt echte Werkzeuge
+
+Ein Loop, der nur das Dateisystem sehen kann, ist ein kleiner Loop. Connectors (aufgebaut auf dem MCP-Protokoll) lassen den Agenten deinen Issue-Tracker lesen, eine Datenbank abfragen, eine Staging-API aufrufen, eine Nachricht in Slack hinterlassen.
+
+Sowohl Codex als auch Claude Code sprechen MCP, also funktioniert der Connector, den du für das eine geschrieben hast, normalerweise auch im anderen. Connectors sind der Unterschied zwischen „hier ist der Fix“ und einem Loop, der den PR eröffnet, das Linear-Ticket verlinkt und den Channel anpingt, sobald die CI grün ist — von selbst, in deiner tatsächlichen Umgebung, nicht nur in einem Terminal.
+
+### 5. Sub-Agenten — Halte den Maker vom Checker fern
+
+Die strukturell wertvollste Designentscheidung in einem Loop ist die Trennung desjenigen, der schreibt, von demjenigen, der prüft. Das Modell, das den Code geschrieben hat, ist viel zu großzügig bei der Benotung seiner eigenen Hausaufgaben. Ein zweiter Agent mit anderen Anweisungen und manchmal einem anderen Modell fängt das, was der erste Agent sich selbst eingeredet hat.
+
+Die klassische Drei-Rollen-Aufteilung:
+
+```mermaid
+flowchart LR
+ Explorer["Explorer-Agent<br/>Codebase lesen, Probleme lokalisieren"] --> Implementer["Implementer-Agent<br/>Fix schreiben, Tests schreiben"]
+ Implementer --> Verifier["Verifier-Agent<br/>Unabhängiges Review, Verifikation ausführen"]
+ Verifier -->|"Fehlgeschlagen"| Implementer
+ Verifier -->|"Bestanden"| Output["Ausgabe"]
+```
+
+Claude Code's `/goal` führt das unter der Haube aus — eine frische, unabhängige Session beurteilt, ob der Loop stoppen soll, nicht die Session, die die Arbeit gemacht hat. Das wird **Generator/Evaluator-Trennung** genannt, und sie ist die wichtigste Zuverlässigkeitsgarantie im Loop-Design.
+
+### 6. External State — Der Speicher des Loops
+
+Modelle vergessen alles zwischen Läufen. Speicher muss auf der Festplatte leben, nicht im Context Window.
+
+Das klingt zu einfach, um wichtig zu sein, aber es ist derselbe Trick, auf den jeder lang andauernde Agent angewiesen ist. Eine Markdown-Datei, ein Linear-Board — alles, was außerhalb einer einzelnen Konversation lebt und festhält, was erledigt ist, was in Arbeit ist und was als Nächstes kommt. Der Agent vergisst. Das Repository nicht.
+
+Diese sechs Primitiven sind dein Loop-Design-Werkzeugkasten. Du brauchst nicht alle für jeden Loop. Aber du musst wissen, wann du welches greifst.
+
+## Ein vollständiger Loop, seziert
+
+Verdrahte alle sechs zusammen und so sieht ein echter Morning-Triage-Loop aus:
+
+```mermaid
+flowchart TD
+ Trigger["Jeden Morgen um 9:00 Uhr<br/>Automatisierung feuert"] --> Read["External State lesen<br/>Gesternes claude-progress.md<br/>Offene GitHub-Issues"]
+ Read --> Triage["Triage-Skill tritt ein<br/>Befunde klassifizieren und priorisieren"]
+ Triage --> Fork["Für jedes handhabbare Item<br/>Isolierten Worktree erzeugen"]
+ Fork --> Implement["Implementer Sub-Agent<br/>Fix + Tests schreiben"]
+ Implement --> Verify["Verifier Sub-Agent<br/>Unabhängig Tests + Lint + Review ausführen"]
+ Verify -->|"Fehlgeschlagen"| Retry["Retry-Warteschlange<br/>Anderen Ansatz versuchen"]
+ Retry --> Implement
+ Verify -->|"Bestanden"| PR["Connector: PR eröffnen<br/>Issue verlinken, Fortschrittsdatei aktualisieren"]
+ PR --> Memory["In External State schreiben<br/>claude-progress.md aktualisieren<br/>Ergebnisse dieser Runde protokollieren"]
+ Memory -->|"Arbeit übrig"| Fork
+ Memory -->|"Alles fertig oder blockiert"| Inbox["Ergebnisse landen im Triage-Eingang<br/>Warten auf dein Review"]
+```
+
+Das ist nicht mehr ein einzelner Agent-Lauf. Es ist ein kontinuierlich arbeitendes System, das jeden Morgen aufwacht, den Boden selbst fegt und die Dinge, die deine Aufmerksamkeit brauchen, vor dich legt. Deine Rolle wird: **Überprüfe den Eingangsinhalt, triff Entscheidungen, und wenn du ein Muster erkennst, das das System nicht handhaben kann, verfeinere die Skills und Regeln.**
+
+Cherny hat dieses Muster verwendet, um 259 PRs in 30 Tagen zu mergen, ohne jemals eine IDE zu öffnen. OpenAI-Ingenieure haben dasselbe Muster verwendet, um ein etwa eine Million Zeilen großes Beta-Produkt von Hand zu bauen — ohne selbst eine einzige Codezeile zu schreiben.
+
+## Generator/Evaluator-Trennung: Warum du das Modell nicht seine eigene Arbeit benoten lassen kannst
+
+Das ist die härteste Lektion im Loop Engineering.
+
+Dein klügster Agent schreibt ein wunderschönes Stück Code. Die Logik ist klar, die Kommentare sind gründlich, und jede Funktion hat einen Test. Du bist zufrieden.
+
+Aber hier ist die Frage: **Wenn du den Agenten, der diesen Code geschrieben hat, beurteilen lässt, ob er gute Arbeit geleistet hat — was wird er sagen?**
+
+Die Antwort wurde immer wieder durch die Erfahrung bestätigt: Er wird sich selbst eine gute Note geben. Nicht weil er unehrlich ist, sondern weil er der Autor ist — er hat sich selbst während der Generierung davon überzeugt, dass dieser Weg richtig ist. Wenn er zurückschaut, sieht er keine Fehler; er sieht seinen eigenen Denkprozess.
+
+Das ist kein Claude-Problem. Das ist kein GPT-Problem. Das ist eine Eigenschaft aller generativen Modelle. **Ein Modell ist der beste Verteidiger seiner eigenen Ausgabe.**
+
+Die Lösung: Lass niemals dieselbe Entität (dasselbe Modell, derselbe Prompt) sowohl die Arbeit als auch das Review machen.
+
+- Claude Code's `/goal` verwendet eine unabhängige Supervisor-Session, um zu beurteilen, ob das Ziel erreicht ist — nicht die Session, die es versucht hat.
+- Codex's Sub-Agent-System lässt dich einen Verifier-Agent mit einem anderen Modell und anderem Reasoning-Aufwand definieren.
+- Die Community-Praxis des „adversarial verify“ erzeugt N unabhängige Skeptiker pro Befund, die jeweils zum Widerlegen aufgefordert werden — Mehrheitsablehnung tötet den Befund.
+
+Ein Satz zum Merken: **Jemand in deiner Crew muss dir nicht glauben.**
+
+## Karpathy's autoresearch: Das Loop-Vorbild
+
+Wenn du sehen willst, wie ein gut designter, tatsächlich laufender Loop aussieht, ist [Karpathy's autoresearch](https://github.com/karpathy/autoresearch) das Lehrbuchbeispiel.
+
+Im März 2026 veröffentlichte Karpathy ein 630-Zeilen-Python-Projekt. Gib ihm eine GPU und eine Forschungsrichtung, und es läuft die ganze Nacht — es führt Hunderte von ML-Trainingsexperimenten durch und behält nur die, die wirklich verbessern. Das Projekt erreichte innerhalb weniger Tage nach der Veröffentlichung 66.000+ Stars.
+
+### Drei Dateien, drei Rollen
+
+Das gesamte System hat nur drei Kern-Dateien, aber die Arbeitsteilung ist messerscharf:
+
+| Datei | Wer sie bearbeitet | Was sie tut |
+|------|-------------|-------------|
+| `prepare.py` | Niemand (nur lesen) | Datenaufbereitung, Tokenizer, Eval-Harness. Feste Infrastruktur. |
+| `train.py` (~630 Zeilen) | **KI-Agent** | Modelldefinition, Optimierer, Trainingsschleife. Der Spielplatz des Agenten — ändere alles. |
+| `program.md` | **Du** | Forschungsmethodik in natürlicher Sprache geschrieben. Du bearbeitest nur das. Sag dem Agenten, wie er erkunden soll, wie er evaluieren soll, was er nicht anfassen soll. |
+
+Diese dreiteilige Aufteilung ist die Seele des Designs: **Menschen fassen keinen Code an, sie fassen Richtung an; Agenten fassen keine Richtung an, sie fassen Code an.** Dein Job wechselt davon, Python zu schreiben, dazu, „die Kultur der Forschungsorganisation zu schreiben“.
+
+### Eingabe: Wie program.md aussieht
+
+`program.md` ist das Gehirn des Loops. Es ist kein Code — es ist eine Forschungsanleitung, geschrieben in Markdown. Es enthält grob:
+
+- **Ziel**: optimiere `val_bpb` (Validation Bits per Byte, niedriger ist besser)
+- **Einschränkungen**: `prepare.py` nicht anfassen, innerhalb des VRAM-Budgets bleiben, festes 5-minütiges Training
+- **Erkundungsrichtungen**: verschiedene Architekturen, Optimierer, LR-Pläne ausprobieren
+- **Evaluationsregeln**: was als Verbesserung zählt, wie Ergebnisse zu protokollieren sind, was bei Fehlern zu tun ist
+- **Eiserne Regel**: nie aufhören. Sobald der Loop startet, immer weiterlaufen
+
+Dein Start-Prompt an den Agenten kann so kurz wie ein Satz sein:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Der Rest liegt beim Agenten, der das Dokument liest und seine eigenen Entscheidungen trifft.
+
+### Die Neun-Schritte-Ratsche-Loop
+
+Im Herzen von autoresearch steckt eine **Ratsche** — sie bewegt sich nur vorwärts, nie rückwärts. Jede Iteration folgt streng neun Schritten:
+
+```mermaid
+flowchart TD
+ 1["1. Richtung lesen<br/>program.md laden"] --> 2["2. Aktuellen Zustand untersuchen<br/>train.py + vergangene Ergebnisse lesen"]
+ 2 --> 3["3. Hypothese vorschlagen<br/>Eine Änderung zum Ausprobieren überlegen"]
+ 3 --> 4["4. Code ändern<br/>train.py bearbeiten"]
+ 4 --> 5["5. Snapshot<br/>git commit"]
+ 5 --> 6["6. Training ausführen<br/>Feste 5-Minuten-Wall-Clock"]
+ 6 --> 7{"7. Evaluieren<br/>Hat sich val_bpb verbessert?"}
+ 7 -->|Ja| 8a["8a. Behalten<br/>Commit bleibt<br/>In results.tsv schreiben"]
+ 7 -->|Nein| 8b["8b. Zurücksetzen<br/>git reset HEAD~1<br/>Fehler protokollieren"]
+ 8a --> 9["9. Nächste Runde<br/>Zurück zu Schritt 1"]
+ 8b --> 9
+```
+
+Es laufen etwa 12 Experimente pro Stunde. Ein Übernacht-Lauf (8 Stunden) ergibt etwa 100 Experimente. Karpathy selbst hat es 2 Tage laufen lassen — ~700 Experimente.
+
+Das feste 5-Minuten-Wall-Clock-Budget ist eine wichtige Designentscheidung — egal was der Agent ändert, jedes Experiment dauert genau gleich lange. Das bedeutet, alle Ergebnisse sind unter demselben Zeitbudget direkt vergleichbar — keine Diskussion darüber, dass „dieses länger gelaufen ist, also ist es besser“.
+
+### Ausgabe: Was du siehst, wenn du aufwachst
+
+Nach einer Nacht mit Looping setzt du dich morgens hin und findest drei Dinge:
+
+**1. Git-Historie (die vorwärts laufende Ratsche)**
+
+Nur Commits, die tatsächlich verbessert haben, bleiben auf dem Main-Branch. Alles, was fehlgeschlagen ist, wurde zurückgerollt. `git log` ist ein validiertes Forschungsprotokoll.
+
+**2. results.tsv (der vollständige Experimentierdatensatz)**
+
+Jedes einzelne Experiment — Erfolg oder Misserfolg — wird protokolliert:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Ein Forschungsprotokoll (eigene Zusammenfassung des Agenten)**
+
+Der Agent schreibt klare Commit-Nachrichten darüber, was er ausprobiert hat, was funktioniert hat, was nicht, und was er als Nächstes ausprobieren will. Du liest die — du musst nicht die Code-Diffs lesen.
+
+### Was er tatsächlich gefunden hat
+
+Ergebnisse von Karpathy's anfänglichem 2-tägigen, ~700-Experimente-Lauf:
+
+- Von ~700 Versuchen wurden etwa **20 stapelbare echte Verbesserungen** gefunden
+- Reduzierte nanochat's GPT-2-level Trainingszeit auf 8×H100 von **2,02 Stunden → 1,80 Stunden**, etwa **11 % schneller**
+- Funde umfassten: Lernratenanpassungen, Optimierer-Tuning, Aktivierungswechsel, Attention-Muster-Optimierungen usw.
+
+Waren alle Verbesserungen bahnbrechende Entdeckungen? Nein. Die meisten waren kleine Optimierungen, die sich gestapelt haben. Aber diese 20 gültigen Verbesserungen hätten einem menschlichen Forscher Wochen manueller Arbeit gedauert — der Agent hat es in 48 Stunden geschafft.
+
+### Das aussagekräftigste Detail: Der Loop ist in Englisch geschrieben, nicht in Code.
+
+`program.md` ist ein Markdown-Dokument, kein Python-Skript. Es beschreibt eine Forschungsmethodik — was zu ändern ist, was in Ruhe zu lassen ist, wie zu evaluieren ist, wie mit Fehlfällen umzugehen ist, und eine eiserne Regel: **nie menschliche Hilfe anfordern, einfach weiterlaufen.** Ein Coding-Agent liest dieses Dokument und führt es auf unbestimmte Zeit aus.
+
+Das ist die Vorlage für Loop Engineering: Gib dem Agenten keine Aufgabe. Gib ihm eine **Methodik**. Lass die Methodik der Loop sein. Eine `program.md`, 630 Zeilen Kleber-Code, und alles andere ist der Agent, der sich selbst ausführt.
+
+## Vier stille Kosten
+
+Wenn ein Loop anfängt zu laufen, wirst du die Probleme nicht sofort sehen. Die folgenden vier Kosten sammeln sich still an, und wenn du es merkst, hast du vielleicht schon schwer gezahlt.
+
+### 1. Verifikationsschulden
+
+Schnelle Loops verführen dich dazu, Verifikation zu überspringen. „Sieht gut aus“ ist nicht dasselbe wie „bestätigt korrekt“. Je mehr Code ein Loop unbeaufsichtigt erzeugt, desto schneller stapeln sich Verifikationsschulden. Die Lösung: **Stoppbedingungen müssen maschinenprüfbar sein, nie „fühlt sich ungefähr richtig an“.**
+
+### 2. Verständnisverfall
+
+Je schneller ein Loop Code ausliefert, desto weiter driftet dein Verständnis deiner eigenen Codebase von der Realität ab. Cherny's Team hatte 80 % des Codes von Agenten verfasst — das bedeutet, der meiste Code eines Teams wurde nicht von einer Person geschrieben. Wenn du nicht liest und nutzt, was der Loop erzeugt, verfällt dein Verständnis kontinuierlich. **Schnelle Loops erfordern schnelles Lesen.**
+
+### 3. Kognitive Kapitulation
+
+Wenn der Loop reibungslos läuft, ist die bequemste Haltung, aufzuhören, Meinungen zu haben. Nimm, was er zurückgibt, denk nicht über die Ausgabe nach. Aber genau da fängt die Gefahr an — du benutzt den Loop, um nicht nachzudenken, anstatt das Denken zu verstärken. Osmani's Warnung: „Zwei Leute können genau denselben Loop bauen und entgegengesetzte Ergebnisse bekommen. Der eine benutzt ihn, um bei Arbeit, die er versteht, schneller voranzukommen; der andere benutzt ihn, um zu vermeiden, die Arbeit zu verstehen. Der Loop weiß den Unterschied nicht. Du schon.“
+
+### 4. Token-Explosion
+
+Jede Iteration eines Loops sammelt mehr Kontext an: geschriebener Code, aufgetretene Fehler, getroffene Entscheidungen. Ohne Kontextmanagement wächst die Prompt-Größe grob quadratisch mit der Anzahl der Züge. Codex adressiert das mit automatischer Kontextkompaktierung — eine dedizierte API komprimiert ältere Konversationszüge in verschlüsselte Inhaltszusammenfassungen, behält wesentliches Wissen und verwirft redundante Details. Das ist eine Engineering-Angelegenheit, die du ab dem ersten Loop adressieren musst, nicht ein späterer Nachrüstding.
+
+## Deinen ersten Loop bauen
+
+Du musst nicht mit einer Pipeline im Stripe-Maßstab anfangen, die 1.300 PRs pro Woche merged. Fang mit dem Kleinsten an, das funktioniert.
+
+### Schritt 1: Wähle eine wiederkehrende Aufgabe
+
+Finde etwas, das du mindestens zweimal pro Woche manuell machst. Beispiele:
+- Morgens GitHub öffnen, neue Issues prüfen, triagen und antworten
+- Vor jedem PR-Review Lint und Tests ausführen
+- Fortschrittsdokumente am Ende jedes Tages aktualisieren
+
+### Schritt 2: Schreibe ein Ziel und eine Stoppbedingung
+
+Wandle die Aufgabe in etwas um, das ein `/goal` verstehen kann:
+
+```markdown
+Ziel: Prüfe die 10 aktuellsten Issues im Repo.
+Für jedes Issue:
+ - Wenn es bereits klare Labels und einen Assignee hat, überspringe
+ - Wenn unmarkiert, füge passende Labels basierend auf dem Inhalt hinzu
+ - Wenn in unter 10 Minuten behebbar, erstelle einen Branch und versuche einen Fix
+Stopp wenn: Alle qualifizierenden Issues bearbeitet wurden, oder ein Issue eine menschliche Entscheidung erfordert.
+```
+
+### Schritt 3: Trenne Maker und Checker
+
+Lass nicht denselben Agenten sowohl den Code schreiben als auch ihn beurteilen. Teile deinen Loop in zwei Rollen auf:
+- Implementer: liest das Issue, schreibt den Fix, schreibt die Tests
+- Verifier: führt unabhängig Tests aus, reviewed den Diff, beurteilt, ob der Fix das Problem tatsächlich löst
+
+### Schritt 4: Füge Speicher hinzu
+
+Benutze eine Markdown-Datei, um zu protokollieren, was in jedem Loop-Lauf passiert ist. Der nächste Lauf beginnt damit, diese Datei zu lesen — er weiß, was erledigt war, was ansteht, was blockiert war. Das schlägt jede komplexe Datenbank.
+
+### Schritt 5: Setze einen Timer
+
+Benutze `/loop` oder deinen OS-Cron, damit der Loop ohne dich startet. Fang mit einmal pro Tag an. Beobachte eine Woche lang.
+
+### Die Reifegradleiter
+
+Du musst nicht in einem Sprung die Spitze erreichen. Loop-Adoption ist eine Leiter:
+
+1. **Level 1: Goal Runner** — Du kannst `/goal` verwenden, um eine Aufgabe mit Stoppbedingung zu geben; der Agent loopt, bis sie erfüllt ist.
+2. **Level 2: Geplante Einzelaufgabe** — Eine Automatisierung führt eine Aufgabe auf einem Timer aus (z. B. morgendliche CI-Prüfung).
+3. **Level 3: Multi-Agent-Loop** — Maker und Checker aufgeteilt; jeder Befund erzeugt einen isolierten Worktree.
+4. **Level 4: Selbst ernährender Loop** — Der Loop entdeckt seine nächste Aufgabe automatisch aus dem External State; er entscheidet, was als Nächstes zu tun ist.
+5. **Level 5: Flottenorchestrierung** — Mehrere Loops laufen parallel, unabhängig aber teilen sich eine Speicherschicht.
+
+Die meisten Teams befinden sich derzeit zwischen Level 2 und Level 3. Level 1 ist der schnellste Weg, Rendite zu sehen.
+
+## Kernaussagen
+
+- **Loop Engineering ersetzt nicht Harness Engineering — es baut ein Stockwerk darüber.** Das Harness macht einzelne Läufe zuverlässig. Der Loop macht kontinuierliche Läufe autonom.
+- **`/goal` ist der einfachste mögliche Loop:** Ziel + Verifikation + Stoppbedingung. Diese drei Dinge bringen dich von innerhalb des Loops nach draußen.
+- **Sechs Primitiven (Automationen / Worktrees / Skills / Connectors / Sub-Agenten / External State) sind die Bausteine des Loops.** Nicht alle jedes Mal, aber du musst wissen, wann du welches greifst.
+- **Der Maker und der Checker müssen getrennt sein.** Ein Modell, das seine eigene Arbeit benotet, ist unvertrauenswürdig. Ein unabhängiger Verifikator — manchmal ein völlig anderes Modell — ist die grundlegende Zuverlässigkeitsgarantie jedes Loops.
+- **Loops machen die Generierung fast kostenlos und lassen das Urteilsvermögen zur knappen Ressource werden.** Die Zeit, die du sparst, ist nicht zum Ausruhen. Sie ist dafür, mehr Urteile zu fällen.
+- **Vier stille Kosten werden schärfer, je länger Loops laufen:** Verifikationsschulden, Verständnisverfall, kognitive Kapitulation, Token-Explosion. Loops beschleunigen die Ausgabe — und das Risiko.
+- **Fang klein an.** Ein `/goal`, ein Cron, eine Markdown-Speicherdatei. Sieh die Rendite, dann stapel weiter nach oben.
+
+## Weiterführende Lektüre
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Öffentlicher Korpus von 50 echten Loops
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Lektion 12: [Hinterlasse eine saubere Übergabe am Ende jeder Session](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Die Voraussetzung für Loops: Jede Session hinterlässt sauberen State, damit die nächste Runde automatisch starten kann
+- Lektion 5: [Halte lang andauernde Aufgaben über Sessions hinweg kontinuierlich](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Voraussetzungswissen für External State und Speicher
+- Lektion 11: [Warum Beobachtbarkeit ins Harness gehört](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Je schneller ein Loop läuft, desto mehr brauchst du Beobachtbarkeit, um Probleme zu fangen
+- Lektion 8: [Warum Feature-Listen Harness-Primitive sind](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Feature-Listen sind die natürliche Datenquelle für einen selbst ernährenden Loop, um seine nächste Aufgabe zu entdecken
+
+## Übungen
+
+1. **Wandle eine wiederkehrende Aufgabe in ein `/goal` um:** Finde etwas, das du mindestens zweimal pro Woche manuell machst. Schreibe sein Ziel, seine Verifikationsmethode und seine Stoppbedingung auf. Führe es einmal mit `/goal` aus und vergleiche Zeit und Qualität mit der manuellen Ausführung. Das ist dein erster Schritt von Harness zu Loop.
+
+2. **Trenne Maker und Checker:** Wähle eine Aufgabe, die du bereits von einem Agenten ausführen lassen hast. Diesmal schreibe zwei verschiedene Prompts: einen für den Implementer-Agenten und einen für den Verifier-Agenten (verwende verschiedene Modelle — z. B. Claude für die Implementierung, GPT für die Verifikation, oder umgekehrt). Der Verifier muss spezifische Probleme mit zitierten Belegen aufzeigen. Protokolliere Anzahl und Art der in jedem Modus gefundenen Probleme.
+
+3. **Gib deinem Loop einen Speicher:** Erstelle eine Markdown-State-Datei für deinen Loop. Schreibe in jeder Iteration: was in dieser Runde gemacht wurde, Verifikationsergebnisse, Status (bestanden/fehlgeschlagen/blockiert) und was als Nächstes zu tun ist. Führe drei Runden aus und beobachte den Verhaltensunterschied zwischen mit und ohne Speicherdatei.
+
+4. **Auditiere die stillen Kosten deines Loops:** Nachdem dein Loop eine Stunde gelaufen ist, bewerte diese vier Metriken:
+ - Wie viel Verifikation war „fühlt sich richtig an“ statt „maschinenbestätigt“? (Verifikationsschulden)
+ - Wie gut kannst du den Code erklären, den dein Loop zuletzt erzeugt hat? (Verständnisverfall)
+ - Wie oft hast du gedacht „Ich schau später“ und nie hingeschaut? (Kognitive Kapitulation)
+ - Wie entwickelt sich die Kontextgröße des Loops? Wiederholt er redundante Informationen? (Token-Explosion)
diff --git a/docs/de/projects/project-07-loop-engineering-first-loop/index.md b/docs/de/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..0acfc8a
--- /dev/null
+++ b/docs/de/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Projekt 07. Baue deinen ersten automatisierten Loop
+
+> Zugehörige Lektion: [L13. Warum du aufhören solltest, deinen Agenten zu prompten](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Was du tust
+
+Das ist das Übergangsprojekt von „Harness“ zu „Loop“. Du weißt bereits, wie man einen Agenten mit einer ordentlichen Umgebung, Anweisungen und Feedback einrichtet — jetzt verwandelst du dieses Setup in einen Loop, der von selbst läuft.
+
+Du machst drei fortschreitende Experimente: zuerst wandelst du eine Aufgabe von manuell zu `/goal`, dann verwandelst du eine Überwachungsaufgabe in einen `/loop`-Timer, und schließlich baust du einen vollständigen Maker-Checker-Loop, um zu erleben, wie es sich anfühlt, wenn **du aus dem Loop heraustrittst.**
+
+## Projektdateien
+
+Repo-Pfad: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Verzeichnis | Was drin ist | Was du machst |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Ein kleines Wissensdatenbank-Projekt mit einem vollständigen Harness (P06 Endzustand), inklusive AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Verwandle dieses Harness in eines, das automatisch loopen kann. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Vollständige Implementierungen von drei Loops: Goal-Loop, Timer-Loop, Maker-Checker-Loop, plus Loop-State-Dateien und Verifikationsskripte. | Referenz für Loop-Designmuster und State-Management. |
+
+## Werkzeuge, die du nutzt
+
+- Claude Code oder Codex
+- Git
+- Dein vollständiges Harness aus P06
+- Ein Terminal-Multiplexer (tmux oder screen, zur Beobachtung lang andauernder Loops)
+- Optional: GitHub Actions oder Cron (für fortgeschrittene ereignisgesteuerte / geplante Experimente)
+
+## Schritte
+
+### Vorbereitung
+
+1. Starte von demselben Commit, an dem du P06 beendet hast.
+2. Erstelle drei Branches: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Bestätige, dass dein Harness funktioniert: führe init.sh aus, überprüfe, ob State-Datei, Feature-Liste und Handoff-Dokumente alle vorhanden sind.
+4. Wähle eine **Zielaufgabe**, an der der Loop wiederholt arbeiten soll. Wähle etwas Mittelgroßes mit klaren Abschlusskriterien — z. B. „füge allen Modulen Unit-Tests hinzu und erreiche 80 % Abdeckung“ oder „füge allen API-Endpunkten Eingabevalidierung hinzu“.
+
+### Experiment 1: Goal-Loop — Von manuellem Lauf zu automatischem Lauf
+
+Wechsle zum Branch `p07-goal-loop`.
+
+1. **Schreibe die Zielbeschreibung**: Wandle deine gewählte Aufgabe in eine `goal.md`-Datei um, die enthält:
+ - Klares Ziel („was zählt als fertig“)
+ - Verifikationsmethode („wie bestätigt man, dass es fertig ist“ — Tests ausführen? Lint ausführen? Abdeckung prüfen?)
+ - Stoppbedingung („wann soll es aufhören“ — maximale Züge? Zeitlimit? Budgetlimit?)
+ - Einschränkungen („was nicht anfassen“ — Produktionskonfiguration, Datenbankschema usw.)
+
+2. **Erster manueller Lauf**: Gib die Aufgabe dem Agenten manuell, selbst. Protokolliere, wie viele Züge es gebraucht hat, wie oft du eingegriffen hast, und die Ergebnisqualität. Das ist dein Basiswert.
+
+3. **Führe mit `/goal` aus**: Verwende dieselbe `goal.md` als Eingabe und führe sie im `/goal`-Modus aus. Der Agent loopt von selbst, bis das Ziel erreicht ist oder die Stoppbedingung auslöst.
+
+4. **Vergleiche die Ergebnisse**:
+ - Unterschied in der Zuganzahl
+ - Unterschied in deiner Eingriffsanzahl
+ - Unterschied in der Ergebnisqualität (mit demselben Verifikationsstandard)
+ - Unterschied in der von dir aufgewendeten Zeit
+
+5. **Iteriere an goal.md**: Wenn die Ergebnisse schlecht sind, überarbeite die Zielbeschreibung und führe sie erneut aus. Mach so lange weiter, bis du mit den Ergebnissen zufrieden bist, oder bis du die Grenze bestätigt hast, was ein Goal-Loop bei dieser Aufgabe leisten kann.
+
+### Experiment 2: Timer-Loop — Verwandle Überwachung in einen Herzschlag
+
+Wechsle zum Branch `p07-timer-loop`.
+
+1. **Wähle eine Überwachungsaufgabe**: Finde eine wiederkehrende Prüfung, die du normalerweise manuell machst. Zum Beispiel:
+ - Führe die Test-Suite jede Stunde aus, behebe Fehler
+ - Prüfe jeden Morgen auf Sicherheitsupdates von Abhängigkeiten
+ - Prüfe nach jedem Commit auf Verletzungen des Coding-Stils
+ - Scanne periodisch TODO-Kommentare, um zu sehen, welche veraltet sind
+
+2. **Schreibe den Überwachungs-Prompt / das Skript**: Stelle die Überwachungsschritte klar dar — was zu prüfen ist, was zu tun ist, wenn Probleme gefunden werden, und wann ein Mensch gerufen werden soll.
+
+3. **Führe mit `/loop` aus (oder Codex Thread-Automatisierung)**:
+ - Setze ein vernünftiges Intervall (10-30 Minuten empfohlen — zu kurz und du wirst genervt sein, zu lang und du wirst den Effekt nicht sehen)
+ - Lass es mindestens 2 Stunden laufen (oder geh etwas anderes machen und komm später zurück)
+
+4. **Protokolliere die Ergebnisse**:
+ - Wie viele Probleme hat es gefunden?
+ - Wie viele hat es selbst behoben?
+ - Wie viele waren Fehlalarme?
+ - Wie viele hat es verschlimmert?
+ - Wie viel Zeit hast du damit verbracht, den Ergebnissen nachzugehen?
+
+5. **Reflektiere**: Lohnt sich diese Überwachungsaufgabe zu automatisieren? Vergleiche die gesparte Zeit mit der Zeit, die du mit der Nachverfolgung verbracht hast. Wenn es sich nicht lohnt — hast du die falsche Aufgabe gewählt, oder ist der Loop schlecht designed?
+
+### Experiment 3: Maker-Checker-Loop — Nimm dich selbst aus dem Loop
+
+Wechsle zum Branch `p07-maker-checker`.
+
+Das ist das wichtigste der drei Experimente. Du baust **einen vollständigen Loop, der dich nicht braucht, um da zu sein:**
+
+1. **Designe die Loop-Struktur**:
+ - **Maker-Agent**: implementiert, schreibt Code, ändert Dateien
+ - **Checker-Agent**: verifiziert, führt Tests aus, macht Code-Review, besteht / fällt durch
+ - **State-Datei** (`loop-state.md`): protokolliert aktuelle Runde, was gemacht wurde, Verifikationsergebnisse, was als Nächstes kommt
+ - **Stoppbedingung**: N aufeinanderfolgende Bestehen, oder maximale Runden erreicht
+
+2. **Schreibe drei Prompts**:
+ - Maker-Anweisungen (was zu tun ist, wie es zu tun ist, was nicht anzufassen ist)
+ - Checker-Anweisungen (was zu verifizieren ist, wie zu verifizieren ist, was als Bestehen zählt, wie Feedback zu geben ist)
+ - Loop-Steuerlogik (wer anfängt, wie die Übergabe funktioniert, wie die nächste Runde gestartet wird)
+
+3. **Führe mindestens 5 Runden aus**:
+ - Runde 1: Maker implementiert → Checker verifiziert → Fehlschlag → Feedback an Maker
+ - Runde 2: Maker überarbeitet basierend auf Feedback → Checker verifiziert → ...
+ - ...
+ - Bis aufeinanderfolgendes Bestehen, oder du brichst es ab
+
+4. **Protokolliere den Status jeder Runde**:
+ - Rundennummer
+ - Was der Maker gemacht hat
+ - Welche Probleme der Checker gefunden hat
+ - Bestanden / durchgefallen
+ - Hast du eingegriffen? (wenn ja, warum?)
+
+5. **Abschließendes Retro**:
+ - Wie oft hast du eingegriffen? Warum?
+ - Was wäre passiert, wenn du nicht eingegriffen hättest?
+ - Hat der Checker Probleme übersehen?
+ - Hat der Maker immer wieder denselben Fehler gemacht?
+ - Wo liegt die Qualitätsdecke dieses Loops? Maker-Fähigkeit oder Checker-Fähigkeit?
+
+## Wie man Ergebnisse misst
+
+| Metrik | Exp 1 (Goal) | Exp 2 (Timer) | Exp 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Aufgabenabschlussrate | Wurde das Ziel erreicht? | Wie viele Überwachungszyklen sind gelaufen? | Wie viele Runden bis zum Bestehen? |
+| Menschliche Eingriffe | Wie oft hast du eingegriffen? | Wie viel Zeit hast du mit der Nachverfolgung verbracht? | Wie oft hast du eingegriffen? |
+| Ergebnisqualität | Wie schneidet es im Vergleich zu manuell ab? | Fehlalarmrate? Übersehene Probleme? | Wie viele Probleme hat der Checker gefunden, die du nicht gefunden hättest? |
+| Gesparte Zeit | Wie viel Zeit hast du gespart? | Lohnt sich die Automatisierung? | Zeit für das Design des Loops vs. gesparte Zeit |
+| Zuverlässigkeit | War die Stoppbedingung vertrauenswürdig? | Ist es durchgedreht? | Kann der Loop an derselben Stelle steckenbleiben? |
+
+## Was einzureichen ist
+
+- `goal.md` (Zielbeschreibung von Experiment 1, mindestens zwei Iterationen)
+- Experiment 1 Vergleichsnotizen: manuell vs. Goal-Loop
+- Experiment 2 Überwachungs-Prompt + 2-Stunden-Laufprotokoll
+- Experiment 3's drei Prompts (Maker / Checker / Loop-Steuerung)
+- Experiment 3's `loop-state.md` (mindestens 5 protokollierte Runden)
+- Abschließendes Retro: Erkenntnisse aus allen drei Experimenten, wie sich dein Verständnis von Loop Engineering verändert hat, welche Dinge gute Kandidaten für Loop-ifizierung sind und welche nicht
+
+## Zugehörige Lektionen
+
+- [Lektion 13 — Warum du aufhören solltest, deinen Agenten zu prompten](../../lectures/lecture-13-loop-engineering/index.md)
+- [Lektion 12 — Warum jede Session einen sauberen Zustand hinterlassen muss](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (jede Runde eines Loops braucht sauberen State)
+- [Lektion 11 — Warum Beobachtbarkeit ins Harness gehört](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (du musst sehen, was im Inneren des Loops passiert)
+- [Lektion 05 — Warum State-Dateien das Rückgrat der Kontinuität sind](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (Loop-State-Dateien sind eine Erweiterung von State-Dateien)
diff --git a/docs/es/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/es/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/es/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/es/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/es/lectures/lecture-13-loop-engineering/code/index.md b/docs/es/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/es/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/es/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/es/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/es/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/es/lectures/lecture-13-loop-engineering/index.md b/docs/es/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..dbe12f7
--- /dev/null
+++ b/docs/es/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Ejemplos de código: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Proyecto práctico: [Proyecto 07. Construye Tu Primer Loop Automatizado](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Lección 13. Del Prompting Manual a los Loops Autónomos
+
+Todo lo que aprendiste en las primeras doce lecciones se basa en un supuesto: **estás sentado frente al teclado, escribiendo instrucciones una a una.**
+
+Escribiste `AGENTS.md` (Lecciones 1–4), construiste gestión del estado (Lecciones 5–6), limitaste el alcance con listas de características (Lecciones 7–8), dejaste handoffs limpios al final de la sesión (Lecciones 9, 12), e hiciste el runtime observable (Lecciones 10–11). Pero el disparador de todo siempre eras tú. El agente nunca decidía por sí mismo cuándo empezar a trabajar — porque nadie presionaba "inicio".
+
+Esta lección trata sobre entregar el botón de inicio al sistema. No se trata de renunciar al control — se trata de elevarlo al siguiente nivel.
+
+## /goal: El Loop Más Simple Posible
+
+La mejor entrada al loop engineering no es un diagrama de arquitectura complejo — es un solo comando.
+
+A principios de 2026, Claude Code y OpenAI Codex lanzaron independientemente la misma característica: `/goal`. Escribes en la terminal:
+
+```
+/goal "All tests pass, zero lint warnings, merge to main"
+```
+
+Luego cierras tu laptop y te vas a dormir. Ocho horas después, el agente ha analizado, codificado, probado, corregido y fusionado por sí solo. Reintenta ante fallos, cambia de enfoque cuando se atasca, y se detiene cuando termina — sin que tú estés encima diciéndole "inténtalo de nuevo".
+
+La única diferencia entre `/goal` y un prompt tradicional es una cosa. Pero esa cosa lo cambia todo:
+
+| | Prompt Tradicional | `/goal` |
+|---|---|---|
+| Lo que proporcionas | Qué hacer a continuación | Cómo se ve el estado final |
+| Lo que hace el agente | Ejecuta una vez | Itera hasta lograrlo |
+| Quién juzga si está terminado | Tú | Una condición de parada verificable |
+| Cuándo puedes irte | No puedes | En el momento en que escribes `/goal` |
+
+`/goal` es esencialmente un loop. Tiene exactamente tres partes: **un objetivo, un método de verificación y una condición de parada.** Solo esas tres cosas te mueven de estar dentro del loop a estar fuera.
+
+### Cómo Creció `/goal` Orgánicamente
+
+`/goal` no saltó de 0 a 1 de la nada. Creció gradualmente a partir de flujos de trabajo cotidianos, pasando por aproximadamente cuatro etapas:
+
+**Etapa 1: Prompting manual uno por uno.** La forma más temprana de trabajar era de ida y vuelta: "escribe una función", "añade un test", "arregla esta lógica". El agente se detenía después de cada paso y esperaba a que dijeras qué sigue. Tú eras el planificador de todo el pipeline.
+
+**Etapa 2: Prompts largos con múltiples pasos.** Luego la gente empezó a escribir prompts más largos que apilaban pasos juntos: "primero analiza el código, luego escribe la implementación, luego ejecuta los tests, y si fallan, arréglalos". El agente podía ejecutar varios pasos de una vez, pero aún tenías que vigilar — porque podría desviarse a mitad de camino, o terminar un paso y no saber qué hacer después.
+
+**Etapa 3: Auto-reflexión y autodirección del agente.** Después de eso, los agentes ganaron "introspección" — después de cada paso miraban el resultado y decidían qué hacer a continuación. Tú dabas un objetivo, y ellos lo desglosaban por sí mismos y reintentaban por su cuenta. Pero surgió un problema: ¿cuándo se detienen? ¿Cuenta "ya terminé" viniendo del propio agente? La práctica seguía respondiendo — no. Los agentes declaran victoria con demasiada facilidad.
+
+**Etapa 4: Juicio de parada independiente — `/goal`.** El paso final fue sacar "juzgar si está terminado" de las manos del agente que hace el trabajo, y entregarlo a un juez independiente. Podría ser un modelo diferente, un script, o un comando de test — pero la regla era la misma: la persona que escribe el código no puede calificar su propia tarea. En este punto, `/goal` realmente funcionó: das el objetivo, itera, un juez independiente decide cuándo detenerse, y puedes irte.
+
+Estas cuatro etapas no fueron una hoja de ruta planificada por ninguna empresa. Fueron el camino al que llegó todo el mundo que codifica con agentes, independientemente, impulsado por los mismos puntos de dolor. Que Claude Code y Codex lanzaran `/goal` casi simultáneamente a principios de 2026 no fue una coincidencia — había llegado el momento.
+
+### Hay Más de Un Tipo de Loop
+
+`/goal` es el loop más fácil de entender, pero no es el único tipo. Los loops se clasifican según cómo se activan y cómo se detienen:
+
+| Tipo | Disparador | Condición de Parada | Claude Code | Codex | Mejor Para |
+|------|---------|----------------|-------------|-------|----------|
+| **Loop basado en turnos** | Escribes cada prompt manualmente | El agente cree que está terminado, o tú lo interrumpes | Chat normal | Chat normal | Tareas pequeñas, trabajo exploratorio |
+| **Loop basado en objetivo** | Das un objetivo | Evaluador independiente confirma terminado, o se alcanzan los turnos máximos | `/goal` | `/goal` (requiere activación manual) | Tareas complejas con criterios de finalización claros |
+| **Loop basado en tiempo** | Intervalo programado (cada N minutos/horas) | Lo detienes manualmente, o sale después de completar el trabajo | `/loop` | Thread automation | Consultar estado, verificaciones periódicas, trabajo recurrente |
+| **Loop impulsado por eventos** | Evento externo (PR abierto, CI fallido, nueva issue) | Se detiene después de manejar el evento, o alcanza el límite de reintentos | Routines (API / GitHub Webhook) | Standalone automation + plugins | Flujos de trabajo reactivos, integración CI/CD |
+
+Estos no compiten — son herramientas diferentes para trabajos diferentes. El basado en turnos está bien para cosas pequeñas. Usa `/goal` cuando hay una línea de meta clara. Usa `/loop` cuando necesitas vigilar algo. Usa el impulsado por eventos cuando te integras con sistemas externos.
+
+### No Confundas `/goal` y `/loop`
+
+Ambos tienen "loop" en el nombre, pero resuelven problemas completamente diferentes:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Qué es** | Una tarea grande, se ejecuta hasta que termina | Una acción pequeña, se repite en un intervalo |
+| **Condición de parada** | Objetivo alcanzado, o presupuesto agotado | Lo detienes manualmente, o la tarea sale por sí sola |
+| **Perfil temporal** | Una ejecución larga, puede tomar horas o días | Ráfagas cortas periódicas, cada ejecución puede ser de unos minutos |
+| **Progreso** | Se acerca más a la línea de meta en cada iteración | Cada ejecución es independiente, no hay progreso acumulativo |
+| **Analogía** | Correr un maratón — suena el pistolazo de salida, te detienes en la línea de meta | Un despertador — suena en un horario, lo apagas |
+| **Uso típico** | "Implementar el sistema de pagos completo con cobertura de tests" | "Comprobar si la CI está rota cada 15 minutos" |
+
+Un error común: meter algo que debería ser un `/goal` en un `/loop`. Como escribir `/loop 10m "sigue implementando el sistema de pagos"` — eso está mal. `/loop` ejecuta la misma instrucción independientemente cada vez, no recuerda dónde se quedó la última vez. Solo obtendrás el mismo punto de partida una y otra vez.
+
+**Prueba de una frase para saber cuál usar: ¿esta cosa tiene un final?**
+- Tiene final → `/goal`
+- No tiene final, solo necesitas seguir vigilando → `/loop`
+
+Loop Engineering, el tema de esta lección, no trata sobre ningún comando en particular. Trata sobre **ser capaz de diseñar sistemas que incluyen todos estos tipos — para que tu agente pueda seguir trabajando incluso cuando tú no estás.**
+
+No tienes que escribir `/goal` cada vez. Pero entender de dónde vino y por qué se ve como se ve — eso es entender el núcleo del loop engineering. Los loops más complejos solo añaden partes como planificación, paralelismo, aislamiento y memoria sobre estos mismos tres fundamentos: objetivo, verificación, condición de parada.
+
+## Junio 2026: Tres Personas Encendieron la Mecha en Una Semana
+
+En la primera semana de junio de 2026, tres profesionales que construían infraestructura de agentes de codificación — sin comparar notas — dijeron lo mismo con palabras diferentes.
+
+**Peter Steinberger** (creador de OpenClaw, [su publicación alcanzó 8 millones de vistas](https://x.com/steipete/status/2063697162748260627)): "Ya no deberías estar haciendo prompting a agentes de codificación. Deberías estar diseñando loops que hacen prompting a tus agentes."
+
+**Boris Cherny** (jefe de Claude Code en Anthropic, [en el podcast Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): "Ya no le hago prompting a Claude. Tengo loops ejecutándose que le hacen prompting a Claude y descubren qué hacer. Mi trabajo es escribir loops."
+
+**Addy Osmani** (líder de ingeniería en Google Chrome) [nombró el concepto](https://addyosmani.com/blog/loop-engineering/) el 7 de junio de 2026, y le dio una definición de una línea:
+
+> **Loop engineering es reemplazarte a ti mismo como la persona que hace prompting al agente. Diseñas el sistema que lo hace en su lugar.**
+
+Cherny reveló cifras: durante más de 30 días consecutivos, todas las contribuciones de código a Claude Code fueron realizadas autónomamente por IA — 259 PRs fusionados, más del 80% del código de producción autorado por Claude, y una tasa de éxito del 76% en tareas de software de final abierto.
+
+Tres personas. Una semana. La misma conclusión. No porque se coordinaran — sino porque la infraestructura había cruzado silenciosamente un umbral. Los agentes se habían vuelto lo suficientemente confiables como para terminar tareas no triviales sin supervisión. Las primitivas de planificación (`/loop`, `/goal`, cron) ahora estaban integradas en las herramientas. El costo de una sola ejecución de agente había bajado lo suficiente como para que ejecutar uno repetidamente en un temporizador dejara de parecer un desperdicio. Cuando todas las piezas están presentes, el movimiento que las combina se vuelve obvio para todos al mismo tiempo.
+
+> Fuente: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Dentro del Loop vs. Fuera del Loop
+
+Comparemos dos escenarios concretos.
+
+**Escenario A: Estás dentro del loop (Lecciones 1–12).**
+
+```mermaid
+flowchart TD
+ You["Tú"] -->|"Escribe instrucción manualmente"| Agent["Agente IA"]
+ Agent -->|"Produce salida"| Result["Código / tests / docs"]
+ Result -->|"Tú inspeccionas"| You
+ You -->|"Insatisfecho, modificas instrucción"| Agent
+ You -->|"Satisfecho, pasas a la siguiente tarea"| You
+```
+
+Tienes un harness completo: `AGENTS.md` le dice al agente las reglas del proyecto, `feature_list.json` limita el alcance, `init.sh` asegura un entorno consistente, `claude-progress.md` registra el progreso. **Pero cada paso aún requiere tu iniciación manual.** Termina una característica, lee el archivo de progreso, piensa en qué sigue, escribe la instrucción. Tú eres el motor de todo el flujo de trabajo.
+
+**Escenario B: Estás fuera del loop (Loop Engineering).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["El sistema de loop que diseñaste"]
+ Trigger["Disparador automático<br/>Horario / Evento / Tarea anterior completada"] --> Discover["Descubrir trabajo<br/>Leer archivo de progreso / tracker de issues"]
+ Discover --> Dispatch["Despachar<br/>Crear sub-agente"]
+ Dispatch --> Verify["Verificar<br/>Tests / lint / Agente revisor independiente"]
+ Verify --> Persist["Persistir estado<br/>Actualizar progreso / Commit / Abrir PR"]
+ Persist -->|"Queda trabajo"| Discover
+ Persist -->|"Terminado o bloqueado"| Inbox["Enviar a tu bandeja de revisión"]
+ end
+ Inbox -->|"Solo necesitas tomar decisiones"| You["Tú"]
+```
+
+Ya no escribes instrucciones. El sistema que diseñaste descubre el trabajo, lo despacha, verifica los resultados, registra el estado y decide el siguiente paso. Tu trabajo se reduce a tres cosas: **definir el objetivo y la condición de parada antes de que empiece, revisar la salida después de que termine, y ajustar las reglas cuando el sistema se desvíe del camino.** El apalancamiento pasa de "escribir el prompt correcto" a "diseñar el loop correcto".
+
+> Osmani: "Hace un año, si querías un loop escribías un montón de bash y mantenías ese montón para siempre y era tuyo y solo tuyo. Ahora las piezas simplemente vienen dentro de los productos." No necesitas construir desde cero. Necesitas entender cómo encajan las piezas.
+
+## Conceptos Clave
+
+- **Loop Engineering**: Diseñar un sistema que automáticamente hace prompting a tu agente, reemplazando la entrada humana manual paso a paso. El humano pasa de estar dentro del loop a estar fuera de él, y el apalancamiento cambia de "escribir el prompt correcto" a "diseñar el loop correcto".
+- **Modo `/goal`**: El loop más simple posible — proporciona un objetivo, método de verificación y condición de parada; el agente itera hasta cumplirlos. El puente del prompting manual a los loops autónomos.
+- **Separación Generador/Evaluador**: El agente que escribe el código y el agente que lo verifica deben estar separados. Un modelo calificando su propio trabajo no es confiable; un verificador independiente — a veces usando un modelo completamente diferente — es la garantía de confiabilidad básica de cualquier loop.
+- **Aislamiento de Worktree**: Cada agente paralelo trabaja en un git worktree independiente, previniendo físicamente colisiones de archivos. El prerrequisito de infraestructura para la ejecución paralela de múltiples agentes.
+- **Estado Externo**: Memoria que vive fuera de una sola conversación — archivos markdown, trackers de issues, tableros kanban. Los modelos olvidan todo entre ejecuciones; la memoria debe vivir en el disco.
+- **Cuatro Costes Silenciosos**: Cuatro costes ocultos que se vuelven más agudos cuanto más tiempo corre un loop — deuda de verificación, deterioro de la comprensión, rendición cognitiva, explosión de tokens. Los loops aceleran no solo la producción, sino también el riesgo.
+
+## Las Seis Primitivas de un Loop
+
+Osmani descompuso un loop en cinco bloques de construcción centrales, más una capa de memoria que atraviesa todos ellos — seis cosas en total, pero la capa de memoria ocupa un estatus especial: no es un componente al mismo nivel que los demás; es la columna vertebral de la que depende todo lo demás.
+
+El diagrama siguiente dibuja las seis como un anillo para que puedas ver el panorama completo de un vistazo. Pero recuerda: el Estado Externo no es solo otra parada en el loop — es la base sobre la que descansa todo el loop.
+
+```mermaid
+flowchart LR
+ A["Automations<br/>Disparadores programados"] --> W["Worktrees<br/>Aislamiento paralelo"]
+ W --> S["Skills<br/>Conocimiento del proyecto codificado"]
+ S --> C["Connectors<br/>Acceso a herramientas externas"]
+ C --> SA["Sub-agentes<br/>Separación maker / checker"]
+ SA --> ES["Estado Externo<br/>Memoria entre iteraciones"]
+ ES --> A
+```
+
+### 1. Automations — El Latido
+
+Sin automatización, un loop no es un loop — es una ejecución única que hiciste manualmente.
+
+Tanto Claude Code como Codex tienen sistemas de planificación completos, pero usan nombres y capas diferentes. Mapeando aproximadamente de más ligero a más pesado:
+
+| Capa | Claude Code | Codex | Notas |
+|-------|-------------|-------|-------|
+| Sondeo en sesión | `/loop` | Thread automation | Vinculado a la sesión actual, muere cuando la sesión se cierra |
+| Tareas programadas locales | Desktop scheduled tasks | Standalone automation (modo local) | Se ejecuta mientras la máquina está encendida, puede acceder a archivos locales |
+| Tareas programadas en la nube | Cloud Routines | — (sin planificador nativo en nube) | Se ejecuta mientras la máquina está apagada |
+| Disparadores de eventos | Routines (API / GitHub Webhook) | Standalone automation + plugins | Activados por eventos externos |
+| Totalmente auto-hospedado | GitHub Actions / cron auto-hospedado | `codex exec` + cron | Control total |
+
+**La pestaña Automations de Codex** es el punto de entrada de la planificación. Elige el proyecto, el prompt, la cadencia, y si se ejecuta en tu checkout local o en un worktree en segundo plano. Las ejecuciones que encuentran algo llegan a una bandeja de Triage; las que no encuentran nada se archivan automáticamente. OpenAI los usa internamente para el triaje diario de issues, resúmenes de fallos de CI, informes de commits, y búsqueda de bugs introducidos la semana pasada.
+
+Las automations de Codex vienen en dos sabores:
+- **Thread automation** — Llamadas de atención recurrentes estilo latido adjuntas a un hilo, preservando el contexto. Bueno para el seguimiento continuo de una sola cosa, como monitorear un comando de larga ejecución o consultar el estado de un PR. El equivalente en Claude Code es `/loop`.
+- **Standalone automation** — Cada ejecución empieza de cero, los resultados van a Triage. Bueno para tareas independientes diarias/semanales como informes o escaneos de dependencias. El equivalente en Claude Code es Desktop scheduled tasks.
+
+El sistema de Claude Code está estratificado más granularmente:
+
+- **`/loop`** — Repetición programada ligera en sesión. Funciona mientras tu terminal está abierta, muere cuando la sesión se cierra, expira automáticamente después de 7 días. Bueno para monitoreo temporal durante tu sesión de trabajo actual.
+- **Desktop scheduled tasks** — Se ejecuta mientras tu máquina está encendida, sobrevive a reinicios de sesión, intervalos a nivel de minuto. Bueno para trabajo recurrente que necesita acceso a archivos locales.
+- **Cloud Routines** — Se ejecuta en la infraestructura en la nube de Anthropic, sobrevive a que tu máquina esté apagada, intervalo mínimo de 1 hora. Soporta tres tipos de disparadores: programado, llamada API, webhook de GitHub. Bueno para tareas diarias que no necesitan tu entorno local.
+- **GitHub Actions / cron auto-hospedado** — Totalmente bajo tu control, se ejecuta como quieras. Bueno para escenarios con requisitos especiales de entorno o seguridad.
+
+```bash
+# Claude Code: ejecutar tests cada 30 min, arreglar fallos (dentro de la sesión actual)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: comprobar estado del deploy cada 15 minutos
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Las automations son el latido. Sin ellas, el loop es un plano que nunca despierta.
+
+### 2. Worktrees — Aislamiento a Escala
+
+En cuanto ejecutas más de un agente, las colisiones de archivos se convierten en el modo de fallo inevitable. Dos agentes escribiendo en el mismo archivo es exactamente el dolor de cabeza de dos ingenieros haciendo commit en las mismas líneas sin consultarse.
+
+`git worktree` resuelve esto: cada agente trabaja en su propia rama en su propio directorio. Físicamente no pueden tocar el checkout del otro.
+
+Tanto Claude Code como Codex incluyen soporte para worktree. Cuando usas `--worktree` o `isolation: worktree` en un sub-agente, cada ayudante obtiene un checkout limpio e independiente que se limpia solo después. Los worktrees eliminan el problema mecánico de colisión — pero recuerda: **tu ancho de banda de revisión sigue siendo el techo.** Cuántos agentes paralelos puedes supervisar determina cuántos worktrees puedes realmente ejecutar.
+
+### 3. Skills — Deja de Re-Explicar Tu Proyecto
+
+Un skill es cómo dejas de re-explicar el mismo contexto del proyecto cada sesión. Es una carpeta que contiene un `SKILL.md` con instrucciones y metadatos, además de scripts opcionales, referencias y activos.
+
+Codex y Claude Code soportan el mismo formato. Los skills se invocan directamente con `/skill-name` (Codex también soporta `$skill-name`), o se activan implícitamente cuando la tarea coincide con la descripción del skill.
+
+Los skills son fundamentalmente sobre pagar tu deuda de intención. Un agente empieza cada sesión en frío — llena cualquier hueco en tu intención con una suposición segura. Un skill es esa intención escrita por fuera: las convenciones, los pasos de compilación, el "no lo hacemos así por aquel incidente" — escritos una vez, leídos en cada ejecución.
+
+### 4. Connectors — Tu Loop Toca Herramientas Reales
+
+Un loop que solo puede ver el sistema de archivos es un loop pequeño. Los connectors (construidos sobre el protocolo MCP) permiten al agente leer tu tracker de issues, consultar una base de datos, llamar a una API de staging, dejar un mensaje en Slack.
+
+Tanto Codex como Claude Code hablan MCP, así que el connector que escribiste para uno usualmente funciona en el otro. Los connectors son la diferencia entre "aquí está la solución" y un loop que abre el PR, enlaza el ticket de Linear, y avisa al canal una vez que la CI está en verde — por sí solo, dentro de tu entorno real, no solo en una terminal.
+
+### 5. Sub-agentes — Mantén al Maker Lejos del Checker
+
+La elección de diseño con mayor valor estructural en un loop es separar a quien escribe de quien verifica. El modelo que escribió el código es demasiado generoso calificando su propia tarea. Un segundo agente, con instrucciones diferentes y a veces un modelo diferente, atrapa lo que el primer agente se convenció a sí mismo.
+
+La clásica división de tres roles:
+
+```mermaid
+flowchart LR
+ Explorer["Agente Explorador<br/>Leer codebase, localizar issues"] --> Implementer["Agente Implementador<br/>Escribir fix, escribir tests"]
+ Implementer --> Verifier["Agente Verificador<br/>Revisión independiente, ejecutar verificación"]
+ Verifier -->|"Falla"| Implementer
+ Verifier -->|"Pasa"| Output["Salida"]
+```
+
+El `/goal` de Claude Code ejecuta esto por debajo — una sesión nueva e independiente juzga si el loop debe detenerse, no la sesión que hizo el trabajo. Esto se llama **separación generador/evaluador**, y es la garantía de confiabilidad más importante en el diseño de loops.
+
+### 6. Estado Externo — La Memoria del Loop
+
+Los modelos olvidan todo entre ejecuciones. La memoria debe vivir en el disco, no en la ventana de contexto.
+
+Esto suena demasiado simple para importar, pero es el mismo truco del que depende todo agente de larga ejecución. Un archivo markdown, un tablero de Linear — cualquier cosa que viva fuera de una sola conversación y mantenga lo que está hecho, lo que está en progreso y lo que sigue. El agente olvida. El repositorio no.
+
+Estas seis primitivas son tu kit de herramientas de diseño de loops. No las necesitas todas para cada loop. Pero necesitas saber cuándo usar cuál.
+
+## Un Loop Completo, Anatomizado
+
+Conecta las seis y así es como se ve un loop real de triaje matutino:
+
+```mermaid
+flowchart TD
+ Trigger["Todas las mañanas a las 9:00 AM<br/>Se dispara la Automation"] --> Read["Leer estado externo<br/>claude-progress.md de ayer<br/>Issues de GitHub abiertas"]
+ Read --> Triage["Entra en acción el Skill de Triage<br/>Clasificar y priorizar hallazgos"]
+ Triage --> Fork["Para cada item accionable<br/>Crear un Worktree aislado"]
+ Fork --> Implement["Sub-agente Implementador<br/>Escribir fix + tests"]
+ Implement --> Verify["Sub-agente Verificador<br/>Ejecutar independientemente tests + lint + revisión"]
+ Verify -->|"Falla"| Retry["Cola de reintentos<br/>Probar enfoque diferente"]
+ Retry --> Implement
+ Verify -->|"Pasa"| PR["Connector: Abrir PR<br/>Enlazar issue, actualizar archivo de progreso"]
+ PR --> Memory["Escribir en Estado Externo<br/>Actualizar claude-progress.md<br/>Registrar resultados de esta ronda"]
+ Memory -->|"Queda trabajo"| Fork
+ Memory -->|"Todo terminado o bloqueado"| Inbox["Resultados llegan a bandeja de Triage<br/>Esperando tu revisión"]
+```
+
+Esto ya no es una sola ejecución de agente. Es un sistema que opera continuamente que se despierta cada mañana, barre el piso por sí solo, y pone las cosas que necesitan tu atención frente a ti. Tu rol se convierte en: **revisar el contenido de la bandeja, tomar decisiones, y cuando detectes un patrón que el sistema no puede manejar, refinar los skills y las reglas.**
+
+Cherny usó este patrón para fusionar 259 PRs en 30 días sin abrir un IDE ni una vez. Los ingenieros de OpenAI usaron el mismo patrón para construir un producto beta de aproximadamente un millón de líneas a mano — sin escribir una sola línea de código ellos mismos.
+
+## Separación Generador/Evaluador: Por Qué No Puedes Dejar que el Modelo Califique Su Propio Trabajo
+
+Esta es la lección más difícil en loop engineering.
+
+Tu agente más inteligente escribe un pedazo de código hermoso. La lógica es clara, los comentarios son exhaustivos, y cada función tiene un test. Estás satisfecho.
+
+Pero aquí está la pregunta: **si dejas que el agente que escribió ese código juzgue si hizo un buen trabajo, ¿qué dirá?**
+
+La respuesta ha sido confirmada por la experiencia una y otra vez: se dará a sí mismo una puntuación alta. No porque sea deshonesto, sino porque es el autor — se convenció a sí mismo de que este camino era correcto durante la generación. Cuando mira atrás, no ve errores; ve su propio proceso de razonamiento.
+
+Esto no es un problema de Claude. Esto no es un problema de GPT. Esto es una propiedad de todos los modelos generativos. **Un modelo es el mejor abogado defensor de su propia salida.**
+
+La solución: nunca dejes que la misma entidad (mismo modelo, mismo prompt) haga tanto el trabajo como la revisión.
+
+- El `/goal` de Claude Code usa una sesión supervisora independiente para juzgar si se cumple el objetivo — no la sesión que lo intentó.
+- El sistema de sub-agentes de Codex te permite definir un agente verificador usando un modelo diferente con diferente esfuerzo de razonamiento.
+- La práctica comunitaria de "adversarial verify" genera N escépticos independientes por hallazgo, cada uno con el prompt de refutar — el rechazo por mayoría mata el hallazgo.
+
+Una frase para recordar: **alguien en tu equipo no debe creerte.**
+
+## El autoresearch de Karpathy: El Ejemplo de Loop
+
+Si quieres ver cómo se ve un loop bien diseñado y realmente en ejecución, [el autoresearch de Karpathy](https://github.com/karpathy/autoresearch) es el ejemplo de libro de texto.
+
+En marzo de 2026, Karpathy lanzó un proyecto Python de 630 líneas. Dale una GPU y una dirección de investigación, y corre toda la noche — completando cientos de experimentos de entrenamiento de ML, quedándose solo con los que realmente mejoran. El proyecto alcanzó 66,000+ estrellas en pocos días después del lanzamiento.
+
+### Tres Archivos, Tres Roles
+
+Todo el sistema tiene solo tres archivos centrales, pero la división del trabajo es nítida:
+
+| Archivo | Quién lo Edita | Qué Hace |
+|------|-------------|-------------|
+| `prepare.py` | Nadie (solo lectura) | Preparación de datos, tokenizador, harness de evaluación. Infraestructura fija. |
+| `train.py` (~630 líneas) | **Agente IA** | Definición del modelo, optimizador, loop de entrenamiento. El patio de juegos del agente — cambia cualquier cosa. |
+| `program.md` | **Tú** | Metodología de investigación escrita en lenguaje natural. Tú solo editas esto. Dile al agente cómo explorar, cómo evaluar, qué no tocar. |
+
+Esta división de tres vías es el alma del diseño: **los humanos no tocan el código, tocan la dirección; los agentes no tocan la dirección, tocan el código.** Tu trabajo pasa de escribir Python a "escribir la cultura de la organización de investigación".
+
+### Entrada: Cómo se Ve program.md
+
+`program.md` es el cerebro del loop. No es código — es un manual de instrucciones de investigación escrito en Markdown. Contiene aproximadamente:
+
+- **Objetivo**: optimizar `val_bpb` (bits por byte de validación, menor es mejor)
+- **Restricciones**: no tocar `prepare.py`, mantenerse dentro del presupuesto de VRAM, entrenamiento fijo de 5 minutos
+- **Direcciones de exploración**: probar diferentes arquitecturas, optimizadores, horarios de LR
+- **Reglas de evaluación**: qué cuenta como mejora, cómo registrar resultados, qué hacer ante fallos
+- **Regla de hierro**: nunca te detengas. Una vez que el loop empieza, sigue para siempre
+
+Tu prompt de inicio al agente puede ser tan corto como una oración:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Lo demás depende del agente leyendo el documento y tomando sus propias decisiones.
+
+### El Loop de Ratchet de Nueve Pasos
+
+En el corazón de autoresearch hay un **ratchet** — solo se mueve hacia adelante, nunca hacia atrás. Cada iteración sigue estrictamente nueve pasos:
+
+```mermaid
+flowchart TD
+ 1["1. Leer dirección<br/>Cargar program.md"] --> 2["2. Estudiar estado actual<br/>Leer train.py + resultados pasados"]
+ 2 --> 3["3. Proponer hipótesis<br/>Pensar en un cambio para probar"]
+ 3 --> 4["4. Modificar código<br/>Editar train.py"]
+ 4 --> 5["5. Instantánea<br/>git commit"]
+ 5 --> 6["6. Ejecutar entrenamiento<br/>Reloj fijo de 5 minutos"]
+ 6 --> 7{"7. Evaluar<br/>¿Mejoró val_bpb?"}
+ 7 -->|Sí| 8a["8a. Mantener<br/>El commit se queda<br/>Escribir en results.tsv"]
+ 7 -->|No| 8b["8b. Revertir<br/>git reset HEAD~1<br/>Registrar el fallo"]
+ 8a --> 9["9. Siguiente ronda<br/>Volver al paso 1"]
+ 8b --> 9
+```
+
+Ejecuta aproximadamente 12 experimentos por hora. Una ejecución nocturna (8 horas) son unos 100 experimentos. El propio Karpathy lo ejecutó durante 2 días — ~700 experimentos.
+
+El presupuesto fijo de 5 minutos de reloj es una elección de diseño clave — sin importar lo que cambie el agente, cada experimento toma exactamente el mismo tiempo. Esto significa que todos los resultados son directamente comparables bajo el mismo presupuesto de tiempo — sin discusiones sobre "este corrió más tiempo así que es mejor".
+
+### Salida: Lo Que Ves Cuando Te Despiertas
+
+Después de una noche de iteraciones, te sientas por la mañana y encuentras tres cosas:
+
+**1. Historial de Git (el ratchet que avanza)**
+
+Solo los commits que realmente mejoraron se quedan en la rama principal. Todo lo que falló fue revertido. `git log` es un registro de investigación validado.
+
+**2. results.tsv (el registro completo de experimentos)**
+
+Cada solo experimento — éxito o fracaso — está registrado:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Un registro de investigación (resumen del propio agente)**
+
+El agente escribe mensajes de commit claros sobre lo que probó, lo que funcionó, lo que no, y lo que planea probar a continuación. Tú lees esos — no tienes que leer los diffs de código.
+
+### Lo Que Realmente Encontró
+
+Resultados de la ejecución inicial de 2 días y ~700 experimentos de Karpathy:
+
+- De ~700 intentos, se encontraron aproximadamente **20 mejoras reales acumulables**
+- Redujo el tiempo de entrenamiento a nivel GPT-2 de nanochat en 8×H100 de **2.02 horas → 1.80 horas**, aproximadamente **11% más rápido**
+- Los hallazgos incluyeron: ajustes de tasa de aprendizaje, afinación de optimizador, cambios de activación, optimizaciones de patrón de atención, etc.
+
+¿Fueron todas las mejoras descubrimientos trascendentales? No. La mayoría fueron pequeñas optimizaciones que se acumularon. Pero esas 20 mejoras válidas le habrían tomado a un investigador humano semanas de trabajo manual — el agente lo hizo en 48 horas.
+
+### El Detalle Más Revelador: El Loop Está Escrito en Inglés, No en Código.
+
+`program.md` es un documento Markdown, no un script de Python. Describe una metodología de investigación — qué modificar, qué dejar en paz, cómo evaluar, cómo manejar casos de fallo, y una regla de hierro: **nunca pidas ayuda humana, solo sigue adelante.** Un agente de codificación lee este documento y lo ejecuta indefinidamente.
+
+Esta es la plantilla para el loop engineering: no le des al agente una tarea. Dale una **metodología**. Deja que la metodología sea el loop. Un `program.md`, 630 líneas de código de pegamento, y todo lo demás es el agente ejecutándose a sí mismo.
+
+## Cuatro Costes Silenciosos
+
+Cuando un loop empieza a ejecutarse, no verás los problemas inmediatamente. Los siguientes cuatro costes se acumulan silenciosamente, y para cuando te des cuenta, puede que ya hayas pagado caro.
+
+### 1. Deuda de Verificación
+
+Los loops rápidos te tientan a saltarte la verificación. "Se ve bien" no es lo mismo que "confirmado correcto". Cuanto más código genera un loop sin supervisión, más rápido se acumula la deuda de verificación. La solución: **las condiciones de parada deben ser comprobables por máquina, nunca "se siente más o menos bien".**
+
+### 2. Deterioro de la Comprensión
+
+Cuanto más rápido envía código un loop, más se aleja tu comprensión de tu propia base de código de la realidad. El equipo de Cherny tenía el 80% del código autorado por agentes — lo que significa que la mayor parte del código de un equipo no fue escrito por una persona. Si no lees y usas lo que produce el loop, tu comprensión decae continuamente. **Los loops rápidos requieren lectura rápida.**
+
+### 3. Rendición Cognitiva
+
+Cuando el loop corre sin problemas, la postura más cómoda es dejar de tener opiniones. Toma lo que sea que devuelva, no pienses en la salida. Pero ahí es exactamente donde empieza el peligro — estás usando el loop para evitar pensar, en lugar de amplificar el pensamiento. La advertencia de Osmani: "Dos personas pueden construir exactamente el mismo loop y obtener resultados opuestos. Uno lo usa para ir más rápido en trabajo que entiende; el otro lo usa para evitar entender el trabajo. El loop no sabe la diferencia. Tú sí."
+
+### 4. Explosión de Tokens
+
+Cada iteración de un loop acumula más contexto: código escrito, errores encontrados, decisiones tomadas. Sin gestión del contexto, el tamaño del prompt crece aproximadamente cuadráticamente con el número de turnos. Codex aborda esto con la compactación automática de contexto — una API dedicada comprime los turnos de conversación antiguos en resúmenes de contenido cifrados, reteniendo el conocimiento esencial mientras descarta el detalle redundante. Esto es una preocupación de ingeniería que debes abordar desde el primer loop, no un añadido posterior.
+
+## Construyendo Tu Primer Loop
+
+No necesitas empezar con un pipeline a escala de Stripe fusionando 1,300 PRs a la semana. Empieza con lo más pequeño que funcione.
+
+### Paso 1: Elige Una Tarea Recurrente
+
+Encuentra algo que hagas manualmente al menos dos veces por semana. Ejemplos:
+- Abrir GitHub por la mañana, comprobar nuevas issues, triar y responder
+- Ejecutar lint y tests antes de cada revisión de PR
+- Actualizar docs de progreso al final de cada día
+
+### Paso 2: Escribe un Objetivo y una Condición de Parada
+
+Convierte la tarea en algo que un `/goal` pueda entender:
+
+```markdown
+Goal: Check the 10 most recent issues in the repo.
+For each issue:
+ - If it already has clear labels and an assignee, skip
+ - If untagged, add appropriate labels based on content
+ - If fixable in under 10 minutes, create a branch and attempt a fix
+Stop when: All qualifying issues have been processed, or an issue requires human decision.
+```
+
+### Paso 3: Separa Maker y Checker
+
+No dejes que el mismo agente escriba el código y lo juzgue. Divide tu loop en dos roles:
+- Implementador: lee la issue, escribe el fix, escribe los tests
+- Verificador: ejecuta tests independientemente, revisa el diff, juzga si el fix realmente resuelve el problema
+
+### Paso 4: Añade Memoria
+
+Usa un archivo markdown para registrar lo que pasó en cada ejecución del loop. La siguiente ejecución empieza leyendo este archivo — sabe lo que se hizo, lo que está pendiente, lo que estaba bloqueado. Esto supera a cualquier base de datos compleja.
+
+### Paso 5: Pon un Temporizador
+
+Usa `/loop` o el cron de tu SO para dejar que el loop empiece sin ti. Empieza con una vez al día. Observa durante una semana.
+
+### La Escalera de Madurez
+
+No necesitas llegar a la cima de un salto. La adopción de loops es una escalera:
+
+1. **Nivel 1: Ejecutor de Objetivos** — Puedes usar `/goal` para dar una tarea con una condición de parada; el agente itera hasta cumplirla.
+2. **Nivel 2: Tarea Única Programada** — Una automatización ejecuta una tarea en un temporizador (ej., comprobación matutina de CI).
+3. **Nivel 3: Loop de Múltiples Agentes** — Separación de maker y checker; cada hallazgo crea un worktree aislado.
+4. **Nivel 4: Loop Auto-Alimentado** — El loop descubre automáticamente su siguiente tarea a partir del estado externo; decide qué hacer a continuación.
+5. **Nivel 5: Orquestación de Flota** — Múltiples loops se ejecutan en paralelo, independientes pero compartiendo una capa de memoria.
+
+La mayoría de los equipos están actualmente entre el Nivel 2 y el Nivel 3. El Nivel 1 es el camino más rápido para ver retornos.
+
+## Puntos Clave
+
+- **Loop Engineering no reemplaza a Harness Engineering — construye un piso encima.** El harness hace que las ejecuciones individuales sean confiables. El loop hace que las ejecuciones continuas sean autónomas.
+- **`/goal` es el loop más simple posible:** objetivo + verificación + condición de parada. Esas tres cosas te mueven de estar dentro del loop a estar fuera de él.
+- **Seis primitivas (Automations / Worktrees / Skills / Connectors / Sub-agentes / Estado Externo) son los bloques de construcción del loop.** No todas cada vez, pero necesitas saber cuándo usar cuál.
+- **El maker y el checker deben estar separados.** Un modelo calificando su propio trabajo no es confiable. Un verificador independiente — a veces un modelo completamente diferente — es la garantía de confiabilidad básica de cualquier loop.
+- **Los loops hacen que la generación sea casi gratuita y dejan el juicio como el recurso escaso.** El tiempo que ahorras no es para descansar. Es para tomar más juicios.
+- **Cuatro costes silenciosos se vuelven más agudos cuanto más tiempo corren los loops:** deuda de verificación, deterioro de la comprensión, rendición cognitiva, explosión de tokens. Los loops aceleran la producción — y el riesgo.
+- **Empieza pequeño.** Un `/goal`, un cron, un archivo markdown de memoria. Ve el retorno, luego acumula hacia arriba.
+
+## Lectura Adicional
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Corpus público de 50 loops reales
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Lección 12: [Deja un Handoff Limpio al Final de Cada Sesión](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — El prerrequisito para los loops: cada sesión deja un estado limpio para que la siguiente ronda pueda auto-iniciarse
+- Lección 5: [Mantén las Tareas de Larga Ejecución Continuas Entre Sesiones](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Conocimiento previo para estado externo y memoria
+- Lección 11: [Por Qué la Observabilidad Pertenece Dentro del Harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Cuanto más rápido corre un loop, más necesitas observabilidad para detectar problemas
+- Lección 8: [Por Qué las Listas de Características Son Primitivas del Harness](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Las listas de características son la fuente de datos natural para que un loop auto-alimentado descubra su siguiente tarea
+
+## Ejercicios
+
+1. **Convierte una tarea recurrente en un `/goal`:** Encuentra algo que hagas manualmente al menos dos veces por semana. Escribe su objetivo, método de verificación y condición de parada. Ejecútalo una vez con `/goal` y compara el tiempo y la calidad contra hacerlo manualmente. Este es tu primer paso de Harness a Loop.
+
+2. **Separa maker y checker:** Elige una tarea que hayas tenido previamente un agente ejecutando. Esta vez, escribe dos prompts diferentes: uno para el agente implementador y otro para el agente verificador (usa modelos diferentes — ej., Claude para implementación, GPT para verificación, o viceversa). El verificador debe señalar problemas específicos con evidencia citada. Registra el número y tipo de problemas encontrados en cada modo.
+
+3. **Dale a tu loop una memoria:** Crea un archivo de estado markdown para tu loop. En cada iteración, escribe: lo que se hizo esta ronda, resultados de verificación, estado (pass/fail/bloqueado), y qué hacer a continuación. Ejecuta tres rondas y observa la diferencia de comportamiento entre tener y no tener un archivo de memoria.
+
+4. **Audita los costes silenciosos de tu loop:** Después de que tu loop haya estado corriendo durante una hora, evalúa estas cuatro métricas:
+ - ¿Cuánta verificación fue "se siente bien" en lugar de "confirmada por máquina"? (Deuda de verificación)
+ - ¿Qué tan bien puedes explicar el código que tu loop produjo más recientemente? (Deterioro de la comprensión)
+ - ¿Cuántas veces pensaste "lo veré más tarde" y nunca lo viste? (Rendición cognitiva)
+ - ¿Cómo está tendiendo el tamaño del contexto del loop? ¿Está repitiendo información redundante? (Explosión de tokens)
diff --git a/docs/es/projects/project-07-loop-engineering-first-loop/index.md b/docs/es/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..6e6edc3
--- /dev/null
+++ b/docs/es/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Proyecto 07. Construye Tu Primer Loop Automatizado
+
+> Lección relacionada: [L13. Por Qué Necesitas Dejar de Hacerle Prompting a Tu Agente](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Qué Harás
+
+Este es el proyecto de transición de "Harness" a "Loop". Ya sabes cómo configurar un agente con un entorno adecuado, instrucciones y retroalimentación — ahora convertirás esa configuración en un loop que corre por sí solo.
+
+Harás tres experimentos progresivos: primero convertirás una tarea de manual a `/goal`, luego convertirás una tarea de monitoreo en un temporizador `/loop`, y finalmente construirás un loop completo de maker-checker para experimentar cómo se siente cuando **tú sales del loop.**
+
+## Archivos del Proyecto
+
+Ruta en el repo: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Directorio | Qué Hay Dentro | Qué Haces Tú |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Un pequeño proyecto de base de conocimientos con un harness completo (estado final de P06), incluyendo AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Convierte este harness en uno que pueda iterar automáticamente. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Implementaciones completas de tres loops: loop de objetivo, loop de temporizador, loop de maker-checker, además de archivos de estado de loop y scripts de verificación. | Referencia para patrones de diseño de loops y gestión del estado. |
+
+## Herramientas Que Usarás
+
+- Claude Code o Codex
+- Git
+- Tu harness completo de P06
+- Un multiplexor de terminal (tmux o screen, para observar loops de larga ejecución)
+- Opcional: GitHub Actions o cron (para experimentos avanzados impulsados por eventos / programados)
+
+## Pasos
+
+### Preparación
+
+1. Empieza desde el mismo commit donde terminaste P06.
+2. Crea tres ramas: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Confirma que tu harness funciona: ejecuta init.sh, verifica que el archivo de estado, la lista de características y los docs de handoff están todos en su lugar.
+4. Elige una **tarea objetivo** en la que quieras que el loop trabaje repetidamente. Elige algo de tamaño mediano con criterios de finalización claros — ej., "añadir tests unitarios a todos los módulos, alcanzando 80% de cobertura" o "añadir validación de entrada a todos los endpoints de API."
+
+### Experimento 1: Loop de Objetivo — De Ejecución Manual a Ejecución Automática
+
+Cambia a la rama `p07-goal-loop`.
+
+1. **Escribe la descripción del objetivo**: Convierte tu tarea elegida en un archivo `goal.md` que contenga:
+ - Objetivo claro ("qué cuenta como terminado")
+ - Método de verificación ("cómo confirmar que está terminado" — ¿ejecutar tests? ¿ejecutar lint? ¿comprobar cobertura?)
+ - Condición de parada ("cuándo debe detenerse" — ¿turnos máximos? ¿límite de tiempo? ¿límite de presupuesto?)
+ - Restricciones ("qué no tocar" — configuración de producción, esquema de base de datos, etc.)
+
+2. **Primera ejecución manual**: Dale la tarea al agente manualmente, tú mismo. Registra cuántos turnos tomó, cuántas veces interviniste, y la calidad del resultado. Esta es tu línea base.
+
+3. **Ejecuta con `/goal`**: Usa el mismo `goal.md` como entrada y ejecútalo en modo `/goal`. El agente itera por sí solo hasta que se alcanza el objetivo o se activa la condición de parada.
+
+4. **Compara resultados**:
+ - Diferencia en el recuento de turnos
+ - Diferencia en tu recuento de intervenciones
+ - Diferencia en la calidad del resultado (usando el mismo estándar de verificación)
+ - Diferencia en el tiempo que invertiste
+
+5. **Itera sobre goal.md**: Si los resultados son pobres, revisa la descripción del objetivo y vuelve a ejecutar. Sigue hasta que estés satisfecho con los resultados, o hasta que hayas confirmado el límite de lo que un loop de objetivo puede hacer en esta tarea.
+
+### Experimento 2: Loop de Temporizador — Convierte el Monitoreo en un Latido
+
+Cambia a la rama `p07-timer-loop`.
+
+1. **Elige una tarea de monitoreo**: Encuentra una comprobación repetitiva que normalmente haces manualmente. Por ejemplo:
+ - Ejecutar la suite de tests cada hora, arreglar fallos
+ - Comprobar actualizaciones de seguridad de dependencias cada mañana
+ - Comprobar violaciones de estilo de codificación después de cada commit
+ - Escanear periódicamente comentarios TODO para ver cuáles están obsoletos
+
+2. **Escribe el prompt/script de monitoreo**: Expón los pasos de monitoreo claramente — qué comprobar, qué hacer cuando se encuentren problemas, y cuándo llamar a un humano.
+
+3. **Ejecuta con `/loop` (o Codex Thread automation)**:
+ - Establece un intervalo razonable (10-30 minutos recomendados — demasiado corto y te molestará, demasiado largo y no verás el efecto)
+ - Déjalo correr durante al menos 2 horas (o ve a hacer otra cosa y vuelve más tarde)
+
+4. **Registra los resultados**:
+ - ¿Cuántos problemas encontró?
+ - ¿Cuántos arregló por sí solo?
+ - ¿Cuántos fueron falsos positivos?
+ - ¿Cuántos empeoró?
+ - ¿Cuánto tiempo invertiste haciendo seguimiento de sus resultados?
+
+5. **Reflexiona**: ¿Vale la pena automatizar esta tarea de monitoreo? Compara el tiempo que ahorraste vs. el tiempo que invertiste haciendo seguimiento. Si no vale la pena, ¿elegiste la tarea equivocada, o el loop está mal diseñado?
+
+### Experimento 3: Loop de Maker-Checker — Sácate del Loop
+
+Cambia a la rama `p07-maker-checker`.
+
+Este es el más importante de los tres experimentos. Construirás un **loop completo que no necesita que estés ahí:**
+
+1. **Diseña la estructura del loop**:
+ - **Agente Maker**: implementa, escribe código, modifica archivos
+ - **Agente Checker**: verifica, ejecuta tests, hace revisión de código, aprueba / reprueba
+ - **Archivo de estado** (`loop-state.md`): registra la ronda actual, lo que se hizo, resultados de verificación, qué sigue
+ - **Condición de parada**: N aprobaciones consecutivas, o se alcanzan las rondas máximas
+
+2. **Escribe tres prompts**:
+ - Instrucciones del Maker (qué hacer, cómo hacerlo, qué no tocar)
+ - Instrucciones del Checker (qué verificar, cómo verificar, qué cuenta como aprobación, cómo dar retroalimentación)
+ - Lógica de control del loop (quién va primero, cómo funciona el handoff, cómo empezar la siguiente ronda)
+
+3. **Ejecuta al menos 5 rondas**:
+ - Ronda 1: Maker implementa → Checker verifica → Fallo → Retroalimentación al Maker
+ - Ronda 2: Maker revisa basado en retroalimentación → Checker verifica → ...
+ - ...
+ - Hasta aprobación consecutiva, o lo llamas tú
+
+4. **Registra el estado de cada ronda**:
+ - Número de ronda
+ - Qué hizo el Maker
+ - Qué problemas encontró el Checker
+ - Aprobado / reprobado
+ - ¿Interviniste? (si sí, ¿por qué?)
+
+5. **Retrospectiva final**:
+ - ¿Cuántas veces interviniste? ¿Por qué?
+ - ¿Qué habría pasado si no hubieras intervenido?
+ - ¿El Checker se perdió algún problema?
+ - ¿El Maker seguía cometiendo el mismo error?
+ - ¿Dónde está el techo de calidad de este loop? ¿Capacidad del Maker, o capacidad del Checker?
+
+## Cómo Medir los Resultados
+
+| Métrica | Exp 1 (Objetivo) | Exp 2 (Temporizador) | Exp 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Tasa de finalización de tarea | ¿Se alcanzó el objetivo? | ¿Cuántos ciclos de monitoreo corrieron? | ¿Cuántas rondas hasta aprobar? |
+| Intervenciones humanas | ¿Cuántas veces interviniste? | ¿Cuánto tiempo invertiste haciendo seguimiento? | ¿Cuántas veces interviniste? |
+| Calidad del resultado | ¿Cómo se compara con lo manual? | ¿Tasa de falsos positivos? ¿Problemas perdidos? | ¿Cuántos problemas encontró Checker que tú no habrías encontrado? |
+| Tiempo ahorrado | ¿Cuánto tiempo ahorraste? | ¿Vale la pena automatizarlo? | Tiempo invertido diseñando el loop vs. tiempo ahorrado |
+| Confiabilidad | ¿Fue confiable la condición de parada? | ¿Se descontroló? | ¿Puede el loop atascarse en el mismo lugar? |
+
+## Qué Entregar
+
+- `goal.md` (descripción del objetivo del Experimento 1, al menos dos iteraciones)
+- Notas de comparación del Experimento 1: manual vs loop de objetivo
+- Prompt de monitoreo del Experimento 2 + registro de ejecución de 2 horas
+- Los tres prompts del Experimento 3 (Maker / Checker / Control de loop)
+- `loop-state.md` del Experimento 3 (al menos 5 rondas registradas)
+- Retrospectiva final: aprendizajes de los tres experimentos, cómo cambió tu comprensión del loop engineering, qué cosas son buenas candidatas para loop-ificación y cuáles no
+
+## Lecciones Relacionadas
+
+- [Lección 13 — Por Qué Necesitas Dejar de Hacerle Prompting a Tu Agente](../../lectures/lecture-13-loop-engineering/index.md)
+- [Lección 12 — Por Qué Cada Sesión Debe Dejar un Estado Limpio](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (cada ronda de un loop necesita estado limpio)
+- [Lección 11 — Por Qué la Observabilidad Pertenece Dentro del Harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (necesitas ver qué está pasando dentro del loop)
+- [Lección 05 — Por Qué los Archivos de Estado Son la Columna Vertebral de la Continuidad](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (los archivos de estado de loop son una extensión de los archivos de estado)
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/fr/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/fr/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/code/index.md b/docs/fr/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/fr/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/fr/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/fr/lectures/lecture-13-loop-engineering/index.md b/docs/fr/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..5ca1683
--- /dev/null
+++ b/docs/fr/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Exemples de code : [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Projet pratique : [Projet 07. Construisez votre première boucle automatisée](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Cours 13. Du prompting manuel aux boucles autonomes
+
+Tout ce que vous avez appris dans les douze premiers cours repose sur une hypothèse : **vous êtes assis devant le clavier, en tapant des instructions une par une.**
+
+Vous avez écrit `AGENTS.md` (Cours 1–4), construit la gestion d'état (Cours 5–6), contraint le périmètre avec des listes de fonctionnalités (Cours 7–8), laissé des transferts propres à la fin de chaque session (Cours 9, 12), et rendu l'exécution observable (Cours 10–11). Mais le déclencheur de tout cela, c'était toujours vous. L'agent ne décidait jamais seul de commencer à travailler — car personne n'avait appuyé sur « démarrer ».
+
+Ce cours porte sur la remise du bouton de démarrage au système. Pas abandonner le contrôle — l'élever au niveau suivant.
+
+## /goal : La boucle la plus simple possible
+
+La meilleure entrée en matière d'ingénierie des boucles n'est pas un diagramme d'architecture complexe — c'est une seule commande.
+
+Au début de 2026, Claude Code et OpenAI Codex ont lancé indépendamment la même fonctionnalité : `/goal`. Vous tapez dans le terminal :
+
+```
+/goal "Tous les tests passent, zéro avertissement lint, fusionner dans main"
+```
+
+Puis vous fermez votre ordinateur portable et allez dormir. Huit heures plus tard, l'agent a analysé, codé, testé, corrigé et fusionné de lui-même. Il réessaie en cas d'échec, change d'approche quand il est bloqué, et s'arrête quand c'est terminé — sans que vous ne le surveilliez en lui disant « réessaie ».
+
+La seule différence entre `/goal` et un prompt traditionnel, c'est une chose. Mais cette chose change tout :
+
+| | Prompt traditionnel | `/goal` |
+|---|---|---|
+| Ce que vous fournissez | Quoi faire ensuite | À quoi ressemble l'état final |
+| Ce que fait l'agent | Exécuter une fois | Boucler jusqu'à l'atteinte du but |
+| Qui juge la fin | Vous | Une condition d'arrêt vérifiable |
+| Quand vous pouvez vous en aller | Vous ne pouvez pas | Au moment où vous tapez `/goal` |
+
+`/goal` est essentiellement une boucle. Elle comporte exactement trois parties : **un but, une méthode de vérification et une condition d'arrêt.** Rien que ces trois choses vous font passer de l'intérieur à l'extérieur de la boucle.
+
+### Comment `/goal` a grandi organiquement
+
+`/goal` n'est pas apparu de nulle part. Il a grandi progressivement à partir des flux de travail quotidiens, passant par environ quatre étapes :
+
+**Étape 1 : Prompting manuel un par un.** La première façon de travailler était l'aller-retour : « écris une fonction », « ajoute un test », « corrige cette logique ». L'agent s'arrêtait après chaque étape et attendait que vous disiez ce qu'il faut faire ensuite. Vous étiez l'ordonnanceur de tout le pipeline.
+
+**Étape 2 : Longs prompts avec plusieurs étapes.** Puis les gens ont commencé à écrire des prompts plus longs qui empilaient les étapes : « d'abord analyser le code, puis écrire l'implémentation, puis lancer les tests, et s'ils échouent, les corriger ». L'agent pouvait exécuter plusieurs étapes d'un coup, mais vous deviez toujours surveiller — car il pouvait dévier en cours de route, ou terminer une étape sans savoir quoi faire ensuite.
+
+**Étape 3 : Auto-réflexion et auto-direction de l'agent.** Après cela, les agents ont acquis l'« introspection » — après chaque étape, ils regardaient le résultat et décidaient de la suite. Vous donniez un but, et ils le décomposaient eux-mêmes et réessayaient seuls. Mais un problème a émergé : quand s'arrêtent-ils ? Est-ce que « j'ai terminé » venant de l'agent lui-même compte ? La pratique a toujours répondu — non. Les agents déclarent la victoire beaucoup trop facilement.
+
+**Étape 4 : Jugement d'arrêt indépendant — `/goal`.** L'étape finale a été de retirer « juger si c'est terminé » des mains de l'agent qui fait le travail, et de le remettre à un juge indépendant. Ça pouvait être un modèle différent, un script, ou une commande de test — mais la règle était la même : la personne qui écrit le code ne peut pas noter ses propres devoirs. À ce stade, `/goal` a vraiment fonctionné : vous donnez le but, il boucle, un juge indépendant décide quand s'arrêter, et vous pouvez vous en aller.
+
+Ces quatre étapes n'étaient pas une feuille de route planifiée par une entreprise. C'était le chemin que tous ceux qui codaient avec des agents ont emprunté, indépendamment, poussés par les mêmes points de douleur. Ce que Claude Code et Codex aient lancé `/goal` presque simultanément au début de 2026 n'était pas une coïncidence — le temps était venu.
+
+### Il n'y a pas qu'un seul type de boucle
+
+`/goal` est la boucle la plus facile à comprendre, mais ce n'est pas la seule. Les boucles se classent en catégories selon la façon dont elles sont déclenchées et dont elles s'arrêtent :
+
+| Type | Déclencheur | Condition d'arrêt | Claude Code | Codex | Idéal pour |
+|------|---------|----------------|-------------|-------|----------|
+| **Boucle par tour** | Vous tapez chaque prompt manuellement | L'agent pense avoir terminé, ou vous l'interrompez | Chat normal | Chat normal | Petites tâches, travail exploratoire |
+| **Boucle par but** | Vous donnez un but | Un évaluateur indépendant confirme la fin, ou le nombre maximum de tours est atteint | `/goal` | `/goal` (activation manuelle requise) | Tâches complexes avec critères d'achèvement clairs |
+| **Boucle temporelle** | Intervalle programmé (toutes les N minutes/heures) | Vous l'arrêtez manuellement, ou elle se termine après avoir fini le travail | `/loop` | Thread automation | Sondage d'état, vérifications périodiques, travail récurrent |
+| **Boucle pilotée par événement** | Événement externe (PR ouverte, CI échouée, nouveau ticket) | S'arrête après avoir traité l'événement, ou atteint la limite de tentatives | Routines (API / GitHub Webhook) | Standalone automation + plugins | Flux de travail réactifs, intégration CI/CD |
+
+Ce ne sont pas des concurrents — ce sont des outils différents pour des travaux différents. La boucle par tour convient pour les petites choses. Utilisez `/goal` quand il y a une ligne d'arrivée claire. Utilisez `/loop` quand vous devez surveiller quelque chose. Utilisez la boucle pilotée par événement quand vous intégrez des systèmes externes.
+
+### Ne confondez pas `/goal` et `/loop`
+
+Les deux ont « boucle » dans le nom, mais elles résolvent des problèmes complètement différents :
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Ce que c'est** | Une grande tâche, s'exécute jusqu'à ce qu'elle soit terminée | Une petite action, se répète à intervalle régulier |
+| **Condition d'arrêt** | But atteint, ou budget épuisé | Vous l'arrêtez manuellement, ou la tâche se termine d'elle-même |
+| **Profil temporel** | Une longue exécution, peut prendre des heures ou des jours | Courtes rafales périodiques, chaque exécution peut durer quelques minutes |
+| **Progression** | Se rapproche de la ligne d'arrivée à chaque itération | Chaque exécution est indépendante, pas de progression cumulative |
+| **Analogie** | Courir un marathon — le coup de feu de départ retentit, vous vous arrêtez à la ligne d'arrivée | Un réveil — sonne selon un horaire, vous l'éteignez |
+| **Utilisation typique** | « Implémenter le système de paiement complet avec une couverture de test » | « Vérifier si la CI est cassée toutes les 15 minutes » |
+
+Une erreur courante : fourrer quelque chose qui devrait être un `/goal` dans un `/loop`. Comme écrire `/loop 10m "continuez à implémenter le système de paiement"` — c'est faux. `/loop` exécute la même instruction indépendamment à chaque fois, il ne se souvient pas de là où il s'était arrêté la dernière fois. Vous obtiendrez juste le même point de départ encore et encore.
+
+**Test en une phrase pour savoir lequel utiliser : est-ce que cette chose a une fin ?**
+- A une fin → `/goal`
+- Pas de fin, vous avez juste besoin de continuer à surveiller → `/loop`
+
+L'ingénierie des boucles, sujet de ce cours, ne concerne pas une commande en particulier. Il s'agit de **pouvoir concevoir des systèmes qui incluent tous ces types — afin que votre agent puisse continuer à travailler même quand vous n'êtes pas là.**
+
+Vous n'avez pas à taper `/goal` à chaque fois. Mais comprendre d'où il vient et pourquoi il a cette apparence — c'est comprendre le cœur de l'ingénierie des boucles. Les boucles plus complexes ajoutent simplement des éléments comme la planification, le parallélisme, l'isolation et la mémoire sur ces mêmes trois fondamentaux : but, vérification, condition d'arrêt.
+
+## Juin 2026 : Trois personnes ont allumé la même mèche en une semaine
+
+La première semaine de juin 2026, trois praticiens construisant une infrastructure d'agents de codage — sans se consulter — ont dit la même chose avec des mots différents.
+
+**Peter Steinberger** (créateur d'OpenClaw, [son post a atteint 8 millions de vues](https://x.com/steipete/status/2063697162748260627)) : « Vous ne devriez plus faire de prompting à des agents de codage. Vous devriez concevoir des boucles qui font du prompting à vos agents. »
+
+**Boris Cherny** (responsable de Claude Code chez Anthropic, [sur le podcast Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)) : « Je ne fais plus de prompting à Claude. J'ai des boucles qui tournent et qui font du prompting à Claude et trouvent quoi faire. Mon travail, c'est écrire des boucles. »
+
+**Addy Osmani** (responsable ingénierie chez Google Chrome) [a nommé le concept](https://addyosmani.com/blog/loop-engineering/) le 7 juin 2026, et lui a donné une définition en une ligne :
+
+> **L'ingénierie des boucles, c'est vous remplacer vous-même comme la personne qui fait du prompting à l'agent. Vous concevez le système qui le fait à votre place.**
+
+Cherny a divulgué des chiffres : pendant plus de 30 jours consécutifs, toutes les contributions de code à Claude Code ont été faites de manière autonome par l'IA — 259 PR fusionnées, plus de 80 % du code de production écrit par Claude, et un taux de réussite de 76 % sur les tâches logicielles ouvertes.
+
+Trois personnes. Une semaine. La même conclusion. Pas parce qu'ils se sont coordonnés — mais parce que l'infrastructure avait discrètement franchi un seuil. Les agents étaient devenus suffisamment fiables pour terminer des tâches non triviales sans surveillance. Les primitives de planification (`/loop`, `/goal`, cron) étaient désormais intégrées aux outils. Le coût d'une seule exécution d'agent avait suffisamment baissé pour que l'exécuter répétitivement sur une minuterie ne paraisse plus gaspillé. Quand toutes les pièces sont présentes, le mouvement qui les combine devient évident pour tout le monde en même temps.
+
+> Source : [Addy Osmani : Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## À l'intérieur de la boucle vs. à l'extérieur de la boucle
+
+Opposons deux scénarios concrets.
+
+**Scénario A : Vous êtes à l'intérieur de la boucle (Cours 1–12).**
+
+```mermaid
+flowchart TD
+ You["Vous"] -->|"Tapez manuellement l'instruction"| Agent["Agent IA"]
+ Agent -->|"Produit une sortie"| Result["Code / tests / docs"]
+ Result -->|"Vous inspectez"| You
+ You -->|"Insatisfait, modifiez l'instruction"| Agent
+ You -->|"Satisfait, passez à la tâche suivante"| You
+```
+
+Vous avez un harness complet : `AGENTS.md` indique à l'agent les règles du projet, `feature_list.json` contraint le périmètre, `init.sh` assure un environnement cohérent, `claude-progress.md` enregistre la progression. **Mais chaque étape nécessite toujours votre initiation manuelle.** Terminer une fonctionnalité, lire le fichier de progression, réfléchir à la suite, taper l'instruction. Vous êtes le moteur de tout le flux de travail.
+
+**Scénario B : Vous êtes à l'extérieur de la boucle (Ingénierie des boucles).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Le système de boucle que vous avez conçu"]
+ Trigger["Déclenchement auto<br/>Programmation / Événement / Tâche précédente terminée"] --> Discover["Découvrir le travail<br/>Lire le fichier de progression / suivi de tickets"]
+ Discover --> Dispatch["Répartir<br/>Générer un sous-agent"]
+ Dispatch --> Verify["Vérifier<br/>Tests / lint / Agent relecteur indépendant"]
+ Verify --> Persist["Persister l'état<br/>Mettre à jour la progression / Commit / Ouvrir une PR"]
+ Persist -->|"Il reste du travail"| Discover
+ Persist -->|"Terminé ou bloqué"| Inbox["Pousser dans votre boîte de révision"]
+ end
+ Inbox -->|"Vous n'avez qu'à prendre des décisions"| You["Vous"]
+```
+
+Vous ne tapez plus d'instructions. Le système que vous avez conçu découvre le travail, le répartit, vérifie les résultats, enregistre l'état et décide de la prochaine étape. Votre travail se réduit à trois choses : **définir le but et la condition d'arrêt avant qu'il ne commence, revoir la sortie après qu'il a terminé, et ajuster les règles quand le système dévie.** L'effet de levier passe de « écrire le bon prompt » à « concevoir la bonne boucle ».
+
+> Osmani : « Il y a un an, si vous vouliez une boucle, vous écriviez un tas de bash et vous mainteniez ce tas pour toujours et c'était à vous et seulement à vous. Maintenant, les pièces sont simplement livrées dans les produits. » Vous n'avez pas besoin de construire à partir de zéro. Vous avez besoin de comprendre comment les pièces s'emboîtent.
+
+## Concepts clés
+
+- **Ingénierie des boucles** : Concevoir un système qui fait automatiquement du prompting à votre agent, remplaçant l'entrée humaine étape par étape. L'humain passe de l'intérieur à l'extérieur de la boucle, et l'effet de levier passe de « écrire le bon prompt » à « concevoir la bonne boucle ».
+- **Mode `/goal`** : La boucle la plus simple possible — fournir un but, une méthode de vérification et une condition d'arrêt ; l'agent boucle jusqu'à ce que ce soit atteint. Le pont entre le prompting manuel et les boucles autonomes.
+- **Séparation générateur/évaluateur** : L'agent qui écrit le code et l'agent qui le vérifie doivent être séparés. Un modèle qui note son propre travail n'est pas fiable ; un vérificateur indépendant — utilisant parfois un modèle complètement différent — est la garantie de fiabilité de base de toute boucle.
+- **Isolation des worktrees** : Chaque agent parallèle travaille dans un worktree git indépendant, empêchant physiquement les collisions de fichiers. Le prérequis d'infrastructure pour l'exécution parallèle multi-agents.
+- **État externe** : Mémoire qui vit en dehors d'une seule conversation — fichiers markdown, suivis de tickets, tableaux kanban. Les modèles oublient tout entre les exécutions ; la mémoire doit vivre sur le disque.
+- **Quatre coûts silencieux** : Quatre coûts cachés qui s'accentuent plus la boucle tourne longtemps — dette de vérification, pourriture de compréhension, abandon cognitif, explosion de tokens. Les boucles accélèrent non seulement la production, mais aussi le risque.
+
+## Les six primitives d'une boucle
+
+Osmani a décomposé une boucle en cinq blocs de construction de base, plus une couche mémoire qui traverse toutes les autres — six choses au total, mais la couche mémoire occupe un statut spécial : ce n'est pas un composant au même niveau que les autres ; c'est l'épine dorsale dont tout le reste dépend.
+
+Le diagramme ci-dessous dessine les six comme un anneau pour que vous puissiez voir l'ensemble d'un coup d'œil. Mais rappelez-vous : l'État externe n'est pas juste une autre étape de la boucle — c'est le fondement sur lequel toute la boucle repose.
+
+```mermaid
+flowchart LR
+ A["Automations<br/>Déclenchements programmés"] --> W["Worktrees<br/>Isolation parallèle"]
+ W --> S["Skills<br/>Connaissance du projet codifiée"]
+ S --> C["Connecteurs<br/>Accès aux outils externes"]
+ C --> SA["Sous-agents<br/>Séparation maker / checker"]
+ SA --> ES["État externe<br/>Mémoire inter-itérations"]
+ ES --> A
+```
+
+### 1. Automations — Le battement de cœur
+
+Sans automation, une boucle n'est pas une boucle — c'est une exécution ponctuelle que vous avez faite manuellement.
+
+Claude Code et Codex ont tous deux des systèmes de planification complets, mais ils utilisent des noms et des couches différents. Mapping approximatif du plus léger au plus lourd :
+
+| Couche | Claude Code | Codex | Notes |
+|-------|-------------|-------|-------|
+| Sondage en session | `/loop` | Thread automation | Lié à la session en cours, meurt quand la session se ferme |
+| Tâches programmées locales | Tâches programmées du bureau | Standalone automation (mode local) | S'exécute quand la machine est allumée, peut accéder aux fichiers locaux |
+| Tâches programmées cloud | Cloud Routines | — (pas de planificateur cloud natif) | S'exécute quand la machine est éteinte |
+| Déclencheurs d'événement | Routines (API / GitHub Webhook) | Standalone automation + plugins | Déclenchés par des événements externes |
+| Entièrement auto-hébergé | GitHub Actions / cron auto-hébergé | `codex exec` + cron | Contrôle total |
+
+**L'onglet Automations de Codex** est le point d'entrée de la planification. Choisissez le projet, le prompt, la cadence, et si ça s'exécute sur votre checkout local ou un worktree d'arrière-plan. Les exécutions qui trouvent quelque chose aboutissent dans une boîte de réception Triage ; celles qui ne trouvent rien s'archivent automatiquement. OpenAI les utilise en interne pour le tri quotidien des tickets, les résumés d'échec de CI, les briefings de commit, et la chasse aux bugs introduits la semaine dernière.
+
+Les automations Codex se présentent sous deux formes :
+- **Thread automation** — Appels de réveil récurrents de type battement de cœur attachés à un fil de discussion, préservant le contexte. Bon pour le suivi continu sur une seule chose, comme surveiller une commande de longue durée ou sonder l'état d'une PR. L'équivalent dans Claude Code est `/loop`.
+- **Standalone automation** — Chaque exécution repart de zéro, les résultats vont dans Triage. Bon pour les tâches indépendantes quotidiennes/hebdomadaires comme les briefings ou les analyses de dépendances. L'équivalent dans Claude Code est les tâches programmées du bureau.
+
+Le système de Claude Code est couplé plus finement :
+
+- **`/loop`** — Répétition programmée légère en session. Fonctionne tant que votre terminal est ouvert, meurt quand la session se ferme, expire automatiquement après 7 jours. Bon pour la surveillance temporaire pendant votre session de travail actuelle.
+- **Tâches programmées du bureau** — S'exécutent quand votre machine est allumée, survivent aux redémarrages de session, intervalles au niveau de la minute. Bon pour le travail récurrent qui nécessite un accès aux fichiers locaux.
+- **Cloud Routines** — S'exécutent sur l'infrastructure cloud d'Anthropic, survivent à l'arrêt de votre machine, intervalle minimum d'1 heure. Prend en charge trois types de déclenchement : programmé, appel API, webhook GitHub. Bon pour les tâches quotidiennes qui n'ont pas besoin de votre environnement local.
+- **GitHub Actions / cron auto-hébergé** — Entièrement sous votre contrôle, s'exécute comme vous voulez. Bon pour les scénarios avec des exigences d'environnement ou de sécurité spéciales.
+
+```bash
+# Claude Code : lancer les tests toutes les 30 min, corriger les échecs (dans la session en cours)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code : vérifier le statut du déploiement toutes les 15 minutes
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Les automations sont le battement de cœur. Sans elles, la boucle est un plan qui ne se réveille jamais.
+
+### 2. Worktrees — L'isolation à l'échelle
+
+Dès que vous exécutez plus d'un agent, les collisions de fichiers deviennent le mode d'échec inévitable. Deux agents écrivant dans le même fichier, c'est exactement le casse-tête de deux ingénieurs qui committent sur les mêmes lignes sans se consulter.
+
+`git worktree` résout ça : chaque agent travaille sur sa propre branche dans son propre répertoire. Ils ne peuvent physiquement pas toucher au checkout de l'autre.
+
+Claude Code et Codex sont tous deux livrés avec la prise en charge des worktrees. Quand vous utilisez `--worktree` ou `isolation: worktree` sur un sous-agent, chaque assistant obtient un checkout propre et indépendant qui se nettoie après lui-même. Les worktrees éliminent le problème mécanique de collision — mais rappelez-vous : **votre bande passante de revue reste le plafond.** Le nombre d'agents parallèles que vous pouvez superviser détermine le nombre de worktrees que vous pouvez réellement exécuter.
+
+### 3. Skills — Arrêtez de réexpliquer votre projet
+
+Un skill, c'est comment vous arrêtez de réexpliquer le même contexte de projet à chaque session. C'est un dossier contenant un `SKILL.md` avec des instructions et des métadonnées, plus des scripts, références et actifs optionnels.
+
+Codex et Claude Code prennent en charge le même format. Les skills sont invoqués directement avec `/skill-name` (Codex prend également en charge `$skill-name`), ou déclenchés implicitement quand la tâche correspond à la description du skill.
+
+Les skills sont fondamentalement une question de remboursement de votre dette d'intention. Un agent démarre chaque session à froid — il comble tout écart dans votre intention par une supposition confiante. Un skill, c'est cette intention écrite à l'extérieur : les conventions, les étapes de build, le « nous ne faisons pas comme ça à cause de cet incident-là » — écrits une fois, lus à chaque exécution.
+
+### 4. Connecteurs — Votre boucle touche de vrais outils
+
+Une boucle qui ne peut voir que le système de fichiers est une petite boucle. Les connecteurs (construits sur le protocole MCP) laissent l'agent lire votre suivi de tickets, interroger une base de données, appeler une API de staging, déposer un message dans Slack.
+
+Codex et Claude Code parlent tous deux MCP, donc le connecteur que vous avez écrit pour l'un fonctionne généralement dans l'autre. Les connecteurs font la différence entre « voici la correction » et une boucle qui ouvre la PR, lie le ticket Linear, et ping le canal une fois que la CI est au vert — toute seule, dans votre environnement réel, pas juste dans un terminal.
+
+### 5. Sous-agents — Gardez le maker loin du checker
+
+Le choix de conception structurellement le plus précieux dans une boucle, c'est de séparer celui qui écrit de celui qui vérifie. Le modèle qui a écrit le code est beaucoup trop généreux pour noter ses propres devoirs. Un second agent, avec des instructions différentes et parfois un modèle différent, attrape ce dont le premier agent s'est convaincu.
+
+Le classique découpage en trois rôles :
+
+```mermaid
+flowchart LR
+ Explorer["Agent Explorer<br/>Lire la base de code, localiser les problèmes"] --> Implementer["Agent Implémenteur<br/>Écrire la correction, écrire les tests"]
+ Implementer --> Verifier["Agent Vérificateur<br/>Revue indépendante, exécuter la vérification"]
+ Verifier -->|"Échoue"| Implementer
+ Verifier -->|"Passe"| Output["Sortie"]
+```
+
+`/goal` de Claude Code exécute ça sous le capot — une session indépendante et fraîche juge si la boucle doit s'arrêter, pas la session qui a fait le travail. C'est ce qu'on appelle la **séparation générateur/évaluateur**, et c'est la garantie de fiabilité la plus importante dans la conception de boucles.
+
+### 6. État externe — La mémoire de la boucle
+
+Les modèles oublient tout entre les exécutions. La mémoire doit vivre sur le disque, pas dans la fenêtre de contexte.
+
+Ça sonne trop simple pour avoir de l'importance, mais c'est le même truc dont dépend tout agent de longue durée. Un fichier markdown, un tableau Linear — n'importe quoi qui vit en dehors d'une seule conversation et conserve ce qui est fait, ce qui est en cours, et ce qui vient ensuite. L'agent oublie. Le dépôt, non.
+
+Ces six primitives sont votre boîte à outils de conception de boucles. Vous n'avez pas besoin de toutes pour chaque boucle. Mais vous avez besoin de savoir quand utiliser laquelle.
+
+## Une boucle complète, anatomisée
+
+Branchez les six ensemble et voici à quoi ressemble une vraie boucle de triage matinale :
+
+```mermaid
+flowchart TD
+ Trigger["Tous les matins à 9h00<br/>L'automation se déclenche"] --> Read["Lire l'état externe<br/>claude-progress.md d'hier<br/>Tickets GitHub ouverts"]
+ Read --> Triage["Le skill Triage entre en jeu<br/>Classer et prioriser les découvertes"]
+ Triage --> Fork["Pour chaque élément actionnable<br/>Forker un Worktree isolé"]
+ Fork --> Implement["Sous-agent Implémenteur<br/>Écrire la correction + les tests"]
+ Implement --> Verify["Sous-agent Vérificateur<br/>Exécuter indépendamment tests + lint + revue"]
+ Verify -->|"Échoue"| Retry["File d'attente de nouvelle tentative<br/>Essayer une approche différente"]
+ Retry --> Implement
+ Verify -->|"Passe"| PR["Connecteur : Ouvrir une PR<br/>Lier le ticket, mettre à jour le fichier de progression"]
+ PR --> Memory["Écrire dans l'État externe<br/>Mettre à jour claude-progress.md<br/>Enregistrer les résultats de ce tour"]
+ Memory -->|"Il reste du travail"| Fork
+ Memory -->|"Tout terminé ou bloqué"| Inbox["Les résultats aboutissent dans la boîte Triage<br/>En attente de votre revue"]
+```
+
+Ce n'est plus une simple exécution d'agent. C'est un système en fonctionnement continu qui se réveille chaque matin, balaye le sol de lui-même, et met les choses qui nécessitent votre attention devant vous. Votre rôle devient : **revoir le contenu de la boîte de réception, prendre des décisions, et quand vous repérez un schéma que le système ne peut pas gérer, affiner les skills et les règles.**
+
+Cherny a utilisé ce schéma pour fusionner 259 PR en 30 jours sans ouvrir un IDE une seule fois. Les ingénieurs d'OpenAI ont utilisé le même schéma pour construire un produit bêta d'environ un million de lignes à la main — sans écrire une seule ligne de code eux-mêmes.
+
+## Séparation générateur/évaluateur : Pourquoi vous ne pouvez pas laisser le modèle noter son propre travail
+
+C'est la leçon la plus difficile en ingénierie des boucles.
+
+Votre agent le plus intelligent écrit un beau morceau de code. La logique est claire, les commentaires sont complets, et chaque fonction a un test. Vous êtes satisfait.
+
+Mais voici la question : **si vous laissez l'agent qui a écrit ce code juger s'il a fait du bon travail, que dira-t-il ?**
+
+La réponse a été confirmée par l'expérience encore et encore : il s'attribuera une note élevée. Pas parce qu'il est malhonnête, mais parce qu'il est l'auteur — il s'est convaincu que ce chemin était correct pendant la génération. Quand il regarde en arrière, il ne voit pas d'erreurs ; il voit son propre processus de raisonnement.
+
+Ce n'est pas un problème de Claude. Ce n'est pas un problème de GPT. C'est une propriété de tous les modèles génératifs. **Un modèle est le meilleur avocat de sa propre sortie.**
+
+La solution : ne jamais laisser la même entité (même modèle, même prompt) faire à la fois le travail et la revue.
+
+- `/goal` de Claude Code utilise une session de supervision indépendante pour juger si le but est atteint — pas la session qui l'a tenté.
+- Le système de sous-agents de Codex vous permet de définir un agent vérificateur utilisant un modèle différent avec un effort de raisonnement différent.
+- La pratique communautaire de « vérification adversariale » génère N sceptiques indépendants par découverte, chacun incité à réfuter — un rejet à la majorité tue la découverte.
+
+Une phrase à retenir : **quelqu'un dans votre équipe ne doit pas vous croire.**
+
+## L'autoresearch de Karpathy : L'exemple de boucle
+
+Si vous voulez voir à quoi ressemble une boucle bien conçue et qui tourne réellement, [l'autoresearch de Karpathy](https://github.com/karpathy/autoresearch) est l'exemple de manuel.
+
+En mars 2026, Karpathy a publié un projet Python de 630 lignes. Donnez-lui un GPU et une direction de recherche, et il tourne toute la nuit — complétant des centaines d'expériences d'entraînement ML, ne gardant que celles qui s'améliorent réellement. Le projet a atteint 66 000+ étoiles en quelques jours après sa sortie.
+
+### Trois fichiers, trois rôles
+
+Tout le système n'a que trois fichiers principaux, mais la division du travail est d'une précision chirurgicale :
+
+| Fichier | Qui l'édite | Ce qu'il fait |
+|------|-------------|-------------|
+| `prepare.py` | Personne (lecture seule) | Préparation des données, tokenizer, harness d'évaluation. Infrastructure fixe. |
+| `train.py` (~630 lignes) | **Agent IA** | Définition du modèle, optimiseur, boucle d'entraînement. Le terrain de jeu de l'agent — changez n'importe quoi. |
+| `program.md` | **Vous** | Méthodologie de recherche écrite en langage naturel. Vous n'éditez que ça. Dites à l'agent comment explorer, comment évaluer, quoi ne pas toucher. |
+
+Ce découpage en trois parties est l'âme de la conception : **les humains ne touchent pas au code, ils touchent à la direction ; les agents ne touchent pas à la direction, ils touchent au code.** Votre travail passe de l'écriture de Python à « écrire la culture de l'organisation de recherche ».
+
+### Entrée : À quoi ressemble program.md
+
+`program.md` est le cerveau de la boucle. Ce n'est pas du code — c'est un manuel d'instructions de recherche écrit en Markdown. Il contient approximativement :
+
+- **But** : optimiser `val_bpb` (validation bits per byte, plus bas est mieux)
+- **Contraintes** : ne pas toucher à `prepare.py`, rester dans le budget VRAM, entraînement fixe de 5 minutes
+- **Directions d'exploration** : essayer différentes architectures, optimiseurs, plannings LR
+- **Règles d'évaluation** : ce qui compte comme amélioration, comment enregistrer les résultats, quoi faire en cas d'échec
+- **Règle de fer** : ne jamais s'arrêter. Une fois que la boucle démarre, continuer pour toujours
+
+Votre prompt de lancement à l'agent peut être aussi court qu'une phrase :
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Le reste revient à l'agent qui lit le document et prend ses propres décisions.
+
+### La boucle à cliquet de neuf étapes
+
+Au cœur d'autoresearch se trouve un **cliquet** — il n'avance que vers l'avant, jamais vers l'arrière. Chaque itération suit strictement neuf étapes :
+
+```mermaid
+flowchart TD
+ 1["1. Lire la direction<br/>Charger program.md"] --> 2["2. Étudier l'état actuel<br/>Lire train.py + résultats passés"]
+ 2 --> 3["3. Proposer une hypothèse<br/>Penser à une modification à essayer"]
+ 3 --> 4["4. Modifier le code<br/>Éditer train.py"]
+ 4 --> 5["5. Instantané<br/>git commit"]
+ 5 --> 6["6. Lancer l'entraînement<br/>5 minutes de temps réel fixes"]
+ 6 --> 7{"7. Évaluer<br/>val_bpb s'est-il amélioré ?"}
+ 7 -->|Oui| 8a["8a. Garder<br/>Le commit reste<br/>Écrire dans results.tsv"]
+ 7 -->|Non| 8b["8b. Revenir en arrière<br/>git reset HEAD~1<br/>Journaliser l'échec"]
+ 8a --> 9["9. Tour suivant<br/>Retour à l'étape 1"]
+ 8b --> 9
+```
+
+Il exécute environ 12 expériences par heure. Une exécution de nuit (8 heures) représente environ 100 expériences. Karpathy lui-même l'a fait tourner pendant 2 jours — ~700 expériences.
+
+Le budget de temps réel fixe de 5 minutes est un choix de conception clé — peu importe ce que l'agent modifie, chaque expérience prend exactement le même temps. Cela signifie que tous les résultats sont directement comparables sous le même budget temps — pas de débat sur « celui-ci a tourné plus longtemps donc c'est mieux ».
+
+### Sortie : Ce que vous voyez quand vous vous réveillez
+
+Après une nuit de bouclage, vous vous asseyez le matin et trouvez trois choses :
+
+**1. Historique Git (le cliquet qui n'avance que vers l'avant)**
+
+Seuls les commits qui se sont réellement améliorés restent sur la branche principale. Tout ce qui a échoué a été annulé. `git log` est un journal de recherche validé.
+
+**2. results.tsv (l'enregistrement complet des expériences)**
+
+Chaque expérience — succès ou échec — est journalisée :
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Un journal de recherche (propre résumé de l'agent)**
+
+L'agent écrit des messages de commit clairs sur ce qu'il a essayé, ce qui a fonctionné, ce qui n'a pas fonctionné, et ce qu'il prévoit d'essayer ensuite. Vous lisez ceux-ci — vous n'avez pas à lire les diffs de code.
+
+### Ce qu'il a réellement trouvé
+
+Résultats de la course initiale de 2 jours, ~700 expériences de Karpathy :
+
+- Sur ~700 tentatives, environ **20 améliorations réelles empilables** ont été trouvées
+- Réduit le temps d'entraînement de niveau GPT-2 de nanochat sur 8×H100 de **2,02 heures → 1,80 heure**, environ **11 % plus rapide**
+- Les découvertes incluaient : ajustements du taux d'apprentissage, réglage de l'optimiseur, échanges d'activation, optimisations de schéma d'attention, etc.
+
+Toutes les améliorations étaient-elles des découvertes bouleversantes ? Non. La plupart étaient de petites optimisations qui se sont empilées. Mais ces 20 améliorations valides auraient pris à un chercheur humain des semaines de travail manuel — l'agent l'a fait en 48 heures.
+
+### Le détail le plus révélateur : La boucle est écrite en anglais, pas en code.
+
+`program.md` est un document Markdown, pas un script Python. Il décrit une méthodologie de recherche — quoi modifier, quoi laisser tranquille, comment évaluer, comment gérer les cas d'échec, et une règle de fer : **ne jamais demander de l'aide humaine, juste continuer.** Un agent de codage lit ce document et l'exécute indéfiniment.
+
+C'est le modèle de l'ingénierie des boucles : ne donnez pas à l'agent une tâche. Donnez-lui une **méthodologie**. Laissez la méthodologie être la boucle. Un `program.md`, 630 lignes de code colle, et tout le reste, c'est l'agent qui se dirige lui-même.
+
+## Quatre coûts silencieux
+
+Quand une boucle démarre, vous ne verrez pas les problèmes immédiatement. Les quatre coûts suivants s'accumulent en silence, et au moment où vous vous en rendez compte, vous avez peut-être déjà payé cher.
+
+### 1. Dette de vérification
+
+Les boucles rapides vous tentent de sauter la vérification. « Ça a l'air bien » n'est pas la même chose que « confirmé correct ». Plus une boucle génère de code sans surveillance, plus la dette de vérification s'empile vite. La solution : **les conditions d'arrêt doivent être vérifiables par machine, jamais « ça semble à peu près juste ».**
+
+### 2. Pourriture de compréhension
+
+Plus une boucle livre du code vite, plus votre compréhension de votre propre base de code s'éloigne de la réalité. L'équipe de Cherny avait 80 % du code écrit par des agents — ce qui signifie que la plupart du code d'une équipe n'a pas été écrit par une personne. Si vous ne lisez pas et n'utilisez pas ce que la boucle produit, votre compréhension décline continuellement. **Les boucles rapides nécessitent une lecture rapide.**
+
+### 3. Abandon cognitif
+
+Quand la boucle tourne bien, la posture la plus confortable est d'arrêter d'avoir des opinions. Prenez ce qu'elle rend, ne pensez pas à la sortie. Mais c'est exactement là que le danger commence — vous utilisez la boucle pour éviter de penser, plutôt que pour amplifier la pensée. L'avertissement d'Osmani : « Deux personnes peuvent construire exactement la même boucle et obtenir des résultats opposés. L'une l'utilise pour aller plus vite sur un travail qu'elle comprend ; l'autre l'utilise pour éviter de comprendre le travail. La boucle ne sait pas la différence. Vous, si. »
+
+### 4. Explosion de tokens
+
+Chaque itération d'une boucle accumule plus de contexte : code écrit, erreurs rencontrées, décisions prises. Sans gestion du contexte, la taille du prompt grossit approximativement quadratiquement avec le nombre de tours. Codex résout ça avec une compaction automatique du contexte — une API dédiée compresse les anciens tours de conversation en résumés de contenu chiffrés, conservant les connaissances essentielles tout en rejetant les détails redondants. C'est une préoccupation d'ingénierie que vous devez aborder dès la première boucle, pas un ajout ultérieur.
+
+## Construire votre première boucle
+
+Vous n'avez pas besoin de commencer par un pipeline à l'échelle Stripe fusionnant 1 300 PR par semaine. Commencez par la plus petite chose qui fonctionne.
+
+### Étape 1 : Choisissez une tâche récurrente
+
+Trouvez quelque chose que vous faites manuellement au moins deux fois par semaine. Exemples :
+- Ouvrir GitHub le matin, vérifier les nouveaux tickets, trier et répondre
+- Lancer lint et les tests avant chaque revue de PR
+- Mettre à jour les docs de progression à la fin de chaque journée
+
+### Étape 2 : Écrivez un but et une condition d'arrêt
+
+Transformez la tâche en quelque chose qu'un `/goal` peut comprendre :
+
+```markdown
+Goal: Check the 10 most recent issues in the repo.
+For each issue:
+ - If it already has clear labels and an assignee, skip
+ - If untagged, add appropriate labels based on content
+ - If fixable in under 10 minutes, create a branch and attempt a fix
+Stop when: All qualifying issues have been processed, or an issue requires human decision.
+```
+
+### Étape 3 : Séparez maker et checker
+
+Ne laissez pas le même agent à la fois écrire le code et le juger. Divisez votre boucle en deux rôles :
+- Implémenteur : lit le ticket, écrit la correction, écrit les tests
+- Vérificateur : exécute indépendamment les tests, revoie le diff, juge si la correction résout réellement le problème
+
+### Étape 4 : Ajoutez de la mémoire
+
+Utilisez un fichier markdown pour enregistrer ce qui s'est passé à chaque exécution de boucle. La prochaine exécution commence par lire ce fichier — elle sait ce qui a été fait, ce qui est en attente, ce qui était bloqué. Ça bat n'importe quelle base de données complexe.
+
+### Étape 5 : Réglez une minuterie
+
+Utilisez `/loop` ou le cron de votre OS pour laisser la boucle démarrer sans vous. Commencez par une fois par jour. Observez pendant une semaine.
+
+### L'échelle de maturité
+
+Vous n'avez pas besoin d'atteindre le sommet en un saut. L'adoption des boucles est une échelle :
+
+1. **Niveau 1 : Coureur de but** — Vous pouvez utiliser `/goal` pour donner une tâche avec une condition d'arrêt ; l'agent boucle jusqu'à ce que ce soit atteint.
+2. **Niveau 2 : Tâche unique programmée** — Une automation exécute une tâche sur une minuterie (par ex., vérification CI matinale).
+3. **Niveau 3 : Boucle multi-agents** — Séparation maker et checker ; chaque découverte forke un worktree isolé.
+4. **Niveau 4 : Boucle auto-alimentée** — La boucle découvre automatiquement sa prochaine tâche à partir de l'état externe ; elle décide de quoi faire ensuite.
+5. **Niveau 5 : Orchestration de flotte** — Plusieurs boucles s'exécutent en parallèle, indépendantes mais partageant une couche mémoire.
+
+La plupart des équipes se situent actuellement entre le Niveau 2 et le Niveau 3. Le Niveau 1 est le chemin le plus rapide pour voir des retours.
+
+## Points clés
+
+- **L'ingénierie des boucles ne remplace pas l'ingénierie de harness — elle construit un étage au-dessus.** Le harness rend les exécutions uniques fiables. La boucle rend les exécutions continues autonomes.
+- **`/goal` est la boucle la plus simple possible :** but + vérification + condition d'arrêt. Ces trois choses vous font passer de l'intérieur à l'extérieur de la boucle.
+- **Six primitives (Automations / Worktrees / Skills / Connecteurs / Sous-agents / État externe) sont les blocs de construction de la boucle.** Pas toutes à chaque fois, mais vous devez savoir quand utiliser laquelle.
+- **Le maker et le checker doivent être séparés.** Un modèle qui note son propre travail n'est pas fiable. Un vérificateur indépendant — parfois un modèle complètement différent — est la garantie de fiabilité de base de toute boucle.
+- **Les boucles rendent la génération presque gratuite et laissent le jugement comme ressource rare.** Le temps que vous gagnez n'est pas pour vous reposer. C'est pour prendre plus de jugements.
+- **Quatre coûts silencieux s'accentuent plus les boucles tournent longtemps :** dette de vérification, pourriture de compréhension, abandon cognitif, explosion de tokens. Les boucles accélèrent la production — et le risque.
+- **Commencez petit.** Un `/goal`, un cron, un fichier mémoire markdown. Voyez le retour, puis empilez vers le haut.
+
+## Pour approfondir
+
+- [Addy Osmani : Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani : Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison : Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy : autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code : Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Corpus public de 50 boucles réelles
+- [The Neuron : Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Cours 12 : [Laisser un transfert propre à la fin de chaque session](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Le prérequis aux boucles : chaque session laisse un état propre pour que le tour suivant puisse démarrer automatiquement
+- Cours 5 : [Garder les tâches de longue durée continues à travers les sessions](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Connaissance préalable pour l'état externe et la mémoire
+- Cours 11 : [Pourquoi l'observabilité appartient à l'intérieur du harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Plus une boucle tourne vite, plus vous avez besoin d'observabilité pour attraper les problèmes
+- Cours 8 : [Pourquoi les listes de fonctionnalités sont des primitives de harness](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Les listes de fonctionnalités sont la source de données naturelle pour qu'une boucle auto-alimentée découvre sa prochaine tâche
+
+## Exercices
+
+1. **Transformez une tâche récurrente en `/goal` :** Trouvez quelque chose que vous faites manuellement au moins deux fois par semaine. Écrivez son but, sa méthode de vérification et sa condition d'arrêt. Exécutez-la une fois avec `/goal` et comparez le temps et la qualité par rapport à une exécution manuelle. C'est votre premier pas de Harness vers Boucle.
+
+2. **Séparez maker et checker :** Choisissez une tâche que vous avez déjà fait exécuter par un agent. Cette fois, écrivez deux prompts différents : un pour l'agent implémenteur et un pour l'agent vérificateur (utilisez des modèles différents — par ex., Claude pour l'implémentation, GPT pour la vérification, ou inversement). Le vérificateur doit pointer des problèmes spécifiques avec des preuves citées. Enregistrez le nombre et le type de problèmes trouvés dans chaque mode.
+
+3. **Donnez de la mémoire à votre boucle :** Créez un fichier d'état markdown pour votre boucle. À chaque itération, écrivez : ce qui a été fait ce tour, les résultats de vérification, le statut (réussi/échoué/bloqué), et quoi faire ensuite. Exécutez trois tours et observez la différence de comportement entre avoir et ne pas avoir de fichier mémoire.
+
+4. **Auditez les coûts silencieux de votre boucle :** Après que votre boucle ait tourné pendant une heure, évaluez ces quatre métriques :
+ - Combien de vérification était « ça semble juste » plutôt que « confirmé par machine » ? (Dette de vérification)
+ - Dans quelle mesure pouvez-vous expliquer le code que votre boucle a produit le plus récemment ? (Pourriture de compréhension)
+ - Combien de fois avez-vous pensé « je regarderai plus tard » et n'avez jamais regardé ? (Abandon cognitif)
+ - Comment évolue la taille du contexte de la boucle ? Est-ce qu'elle répète des informations redondantes ? (Explosion de tokens)
diff --git a/docs/fr/projects/project-07-loop-engineering-first-loop/index.md b/docs/fr/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..3945e0d
--- /dev/null
+++ b/docs/fr/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Projet 07. Construisez votre première boucle automatisée
+
+> Cours associé : [L13. Pourquoi vous devez arrêter de faire du prompting à votre agent](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Ce que vous allez faire
+
+C'est le projet de transition de « Harness » vers « Boucle ». Vous savez déjà comment configurer un agent avec un environnement, des instructions et un retour appropriés — maintenant vous allez transformer cette configuration en une boucle qui tourne toute seule.
+
+Vous ferez trois expériences progressives : d'abord transformer une tâche de manuel en `/goal`, puis transformer une tâche de surveillance en une minuterie `/loop`, et enfin construire une boucle maker-checker complète pour ressentir ce que c'est que **de sortir de la boucle.**
+
+## Fichiers du projet
+
+Chemin du dépôt : [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Répertoire | Ce qu'il contient | Ce que vous faites |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Un petit projet de base de connaissances avec un harness complet (état final P06), incluant AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Transformez ce harness en un harness qui peut boucler automatiquement. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Implémentations complètes de trois boucles : boucle de but, boucle de minuterie, boucle maker-checker, plus fichiers d'état de boucle et scripts de vérification. | Référence pour les modèles de conception de boucles et la gestion d'état. |
+
+## Outils que vous allez utiliser
+
+- Claude Code ou Codex
+- Git
+- Votre harness complet de P06
+- Un multiplexeur de terminal (tmux ou screen, pour observer les boucles de longue durée)
+- Optionnel : GitHub Actions ou cron (pour des expériences avancées pilotées par événement / programmées)
+
+## Étapes
+
+### Préparation
+
+1. Partez du même commit où vous avez terminé P06.
+2. Créez trois branches : `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Confirmez que votre harness fonctionne : lancez init.sh, vérifiez que le fichier d'état, la liste des fonctionnalités et les docs de transfert sont tous en place.
+4. Choisissez une **tâche cible** sur laquelle vous voulez que la boucle travaille de manière répétée. Choisissez quelque chose de taille moyenne avec des critères d'achèvement clairs — par ex., « ajouter des tests unitaires à tous les modules, atteindre 80 % de couverture » ou « ajouter une validation d'entrée à tous les points de terminaison API ».
+
+### Expérience 1 : Boucle de but — De l'exécution manuelle à l'exécution automatique
+
+Basculez sur la branche `p07-goal-loop`.
+
+1. **Écrivez la description du but** : Transformez votre tâche choisie en un fichier `goal.md` contenant :
+ - But clair (« ce qui compte comme terminé »)
+ - Méthode de vérification (« comment confirmer que c'est terminé » — lancer les tests ? lancer lint ? vérifier la couverture ?)
+ - Condition d'arrêt (« quand faut-il s'arrêter » — nombre maximum de tours ? limite de temps ? limite de budget ?)
+ - Contraintes (« quoi ne pas toucher » — config de production, schéma de base de données, etc.)
+
+2. **Première exécution manuelle** : Donnez la tâche à l'agent manuellement, vous-même. Enregistrez combien de tours cela a pris, combien de fois vous êtes intervenu, et la qualité du résultat. C'est votre ligne de base.
+
+3. **Exécutez avec `/goal`** : Utilisez le même `goal.md` comme entrée et exécutez-le en mode `/goal`. L'agent boucle tout seul jusqu'à ce que le but soit atteint ou que la condition d'arrêt se déclenche.
+
+4. **Comparez les résultats** :
+ - Différence du nombre de tours
+ - Différence de votre nombre d'interventions
+ - Différence de qualité du résultat (en utilisant le même standard de vérification)
+ - Différence du temps que vous avez passé
+
+5. **Itérez sur goal.md** : Si les résultats sont médiocres, révisez la description du but et relancez. Continuez jusqu'à ce que vous soyez satisfait des résultats, ou jusqu'à ce que vous ayez confirmé la limite de ce qu'une boucle de but peut faire sur cette tâche.
+
+### Expérience 2 : Boucle de minuterie — Transformer la surveillance en battement de cœur
+
+Basculez sur la branche `p07-timer-loop`.
+
+1. **Choisissez une tâche de surveillance** : Trouvez une vérification répétitive que vous faites normalement manuellement. Par exemple :
+ - Lancer la suite de tests toutes les heures, corriger les échecs
+ - Vérifier les mises à jour de sécurité des dépendances chaque matin
+ - Vérifier les violations de style de code après chaque commit
+ - Scanner périodiquement les commentaires TODO pour voir lesquels sont périmés
+
+2. **Écrivez le prompt/script de surveillance** : Décrivez clairement les étapes de surveillance — quoi vérifier, quoi faire quand des problèmes sont trouvés, et quand appeler un humain.
+
+3. **Exécutez avec `/loop` (ou Codex Thread automation)** :
+ - Réglez un intervalle raisonnable (10-30 minutes recommandé — trop court et vous serez ennuyé, trop long et vous ne verrez pas l'effet)
+ - Laissez tourner pendant au moins 2 heures (ou allez faire autre chose et revenez plus tard)
+
+4. **Enregistrez les résultats** :
+ - Combien de problèmes a-t-il trouvés ?
+ - Combien en a-t-il corrigés tout seul ?
+ - Combien étaient de faux positifs ?
+ - Combien en a-t-il empirés ?
+ - Combien de temps avez-vous passé à faire le suivi de ses résultats ?
+
+5. **Réfléchissez** : Cette tâche de surveillance vaut-elle la peine d'être automatisée ? Comparez le temps que vous avez gagné vs. le temps que vous avez passé à faire le suivi. Si ça n'en vaut pas la peine, avez-vous choisi la mauvaise tâche, ou la boucle est-elle mal conçue ?
+
+### Expérience 3 : Boucle Maker-Checker — Sortez de la boucle
+
+Basculez sur la branche `p07-maker-checker`.
+
+C'est la plus importante des trois expériences. Vous allez construire **une boucle complète qui n'a pas besoin de vous pour être là :**
+
+1. **Concevez la structure de la boucle** :
+ - **Agent maker** : implémente, écrit du code, modifie des fichiers
+ - **Agent checker** : vérifie, lance les tests, fait de la revue de code, passe / échoue
+ - **Fichier d'état** (`loop-state.md`) : enregistre le tour actuel, ce qui a été fait, les résultats de vérification, la suite
+ - **Condition d'arrêt** : N passes consécutives, ou nombre maximum de tours atteint
+
+2. **Écrivez trois prompts** :
+ - Instructions maker (quoi faire, comment le faire, quoi ne pas toucher)
+ - Instructions checker (quoi vérifier, comment vérifier, ce qui compte comme réussite, comment donner le feedback)
+ - Logique de contrôle de boucle (qui commence en premier, comment fonctionne le transfert, comment démarrer le tour suivant)
+
+3. **Exécutez au moins 5 tours** :
+ - Tour 1 : Maker implémente → Checker vérifie → Échec → Feedback au Maker
+ - Tour 2 : Maker révise en fonction du feedback → Checker vérifie → ...
+ - ...
+ - Jusqu'à la passe consécutive, ou vous l'arrêtez
+
+4. **Enregistrez l'état de chaque tour** :
+ - Numéro du tour
+ - Ce que le Maker a fait
+ - Quels problèmes le Checker a trouvés
+ - Réussi / échoué
+ - Êtes-vous intervenu ? (si oui, pourquoi ?)
+
+5. **Rétrospective finale** :
+ - Combien de fois êtes-vous intervenu ? Pourquoi ?
+ - Qu'est-ce qui se serait passé si vous n'étiez pas intervenu ?
+ - Le Checker a-t-il raté des problèmes ?
+ - Le Maker a-t-il continué à faire la même erreur ?
+ - Où est le plafond de qualité de cette boucle ? Capacité du Maker, ou capacité du Checker ?
+
+## Comment mesurer les résultats
+
+| Métrique | Exp 1 (But) | Exp 2 (Minuterie) | Exp 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Taux d'achèvement de la tâche | Le but a-t-il été atteint ? | Combien de cycles de surveillance se sont exécutés ? | Combien de tours jusqu'à la réussite ? |
+| Interventions humaines | Combien de fois êtes-vous intervenu ? | Combien de temps avez-vous passé à faire le suivi ? | Combien de fois êtes-vous intervenu ? |
+| Qualité du résultat | Comment ça se compare au manuel ? | Taux de faux positifs ? Problèmes ratés ? | Combien de problèmes le Checker a-t-il trouvés que vous n'auriez pas trouvés ? |
+| Temps gagné | Combien de temps avez-vous gagné ? | Ça vaut la peine d'être automatisé ? | Temps passé à concevoir la boucle vs. temps gagné |
+| Fiabilité | La condition d'arrêt était-elle digne de confiance ? | Est-ce que ça a dérapé ? | La boucle peut-elle se bloquer au même endroit ? |
+
+## Ce qu'il faut soumettre
+
+- `goal.md` (description du but de l'Expérience 1, au moins deux itérations)
+- Notes de comparaison de l'Expérience 1 : manuel vs. boucle de but
+- Prompt de surveillance de l'Expérience 2 + journal d'exécution de 2 heures
+- Les trois prompts de l'Expérience 3 (Maker / Checker / Contrôle de boucle)
+- `loop-state.md` de l'Expérience 3 (au moins 5 tours enregistrés)
+- Rétrospective finale : enseignements des trois expériences, comment votre compréhension de l'ingénierie des boucles a changé, quelles choses sont de bons candidats à la bouclisation et lesquelles ne le sont pas
+
+## Cours associés
+
+- [Cours 13 — Pourquoi vous devez arrêter de faire du prompting à votre agent](../../lectures/lecture-13-loop-engineering/index.md)
+- [Cours 12 — Pourquoi chaque session doit laisser un état propre](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (chaque tour d'une boucle a besoin d'un état propre)
+- [Cours 11 — Pourquoi l'observabilité appartient à l'intérieur du harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (vous avez besoin de voir ce qui se passe à l'intérieur de la boucle)
+- [Cours 05 — Pourquoi les fichiers d'état sont l'épine dorsale de la continuité](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (les fichiers d'état de boucle sont une extension des fichiers d'état)
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/ja/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/ja/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/code/index.md b/docs/ja/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/ja/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/ja/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/ja/lectures/lecture-13-loop-engineering/index.md b/docs/ja/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..8e349e7
--- /dev/null
+++ b/docs/ja/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> コード例: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> 演習プロジェクト: [プロジェクト 07. 初めての自動ループを構築する](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# 第13回 手動プロンプトから自律ループへ
+
+これまでの12回の講義で学んだことはすべて、次の前提に基づいています:**あなたがキーボードの前に座り、一度に一つずつ指示を入力すること。**
+
+あなたは `AGENTS.md` を書き(第1–4回)、状態管理を構築し(第5–6回)、機能リストでスコープを制約し(第7–8回)、セッション終了時にクリーンな引き継ぎを残し(第9、12回)、ランタイムを観測可能にしました(第10–11回)。しかし、そのすべてのトリガーは常にあなたでした。エージェントが自発的に仕事を始めることはなかったのです——「スタート」を押す人がいなかったからです。
+
+この講義は、スタートボタンをシステムに渡すことについてです。コントロールを放棄するのではなく——次のレイヤーに昇格させるのです。
+
+## /goal: 最もシンプルなループ
+
+ループエンジニアリングへの最良の入口は、複雑なアーキテクチャ図ではありません——一つのコマンドです。
+
+2026年初頭、Claude Code と OpenAI Codex は独立して同じ機能をリリースしました:`/goal`。ターミナルに次のように入力します:
+
+```
+/goal "すべてのテストがパスし、lint警告がゼロの状態で main にマージする"
+```
+
+そしてノートPCを閉じて寝ます。8時間後、エージェントは自ら分析し、コードを書き、テストし、修正し、マージしています。失敗すれば再試行し、行き詰まればアプローチを切り替え、完了すれば停止します——あなたが肩越しに「もう一度やって」と言う必要はありません。
+
+`/goal` と従来のプロンプトの唯一の違いは一つです。しかし、その一つがすべてを変えます:
+
+| | 従来のプロンプト | `/goal` |
+|---|---|---|
+| あなたが提供するもの | 次に何をするか | 最終状態がどうあるべきか |
+| エージェントがすること | 一度実行する | 達成するまでループする |
+| 完了を判断するのは | あなた | 検証可能な停止条件 |
+| 離席できるタイミング | できない | `/goal` を入力した瞬間 |
+
+`/goal` は本質的にループです。正確に3つの部分から構成されています:**ゴール、検証方法、停止条件。** たったこれだけで、ループの内側から外側に移動できるのです。
+
+### `/goal` が有機的に成長した経緯
+
+`/goal` はいきなりゼロから生まれたわけではありません。日常のワークフローから徐々に成長し、おおよそ4つの段階を経てきました:
+
+**段階1:手動で一つずつプロンプトする。** 最も初期の働き方は往復でした:「関数を書いて」「テストを追加して」「このロジックを直して」。エージェントは毎ステップの後に停止し、次に何をするかあなたの指示を待ちました。あなたがパイプライン全体のスケジューラーだったのです。
+
+**段階2:複数ステップを含む長いプロンプト。** その後、人々はステップを積み重ねた長いプロンプトを書き始めました:「まずコードを分析し、次に実装を書き、次にテストを実行し、失敗したら修正する」。エージェントは一度に数ステップ実行できるようになりましたが、あなたはまだ監視する必要がありました——途中で脱線するかもしれないし、ステップを終えても次に何をすればわからないかもしれないからです。
+
+**段階3:エージェントの自己反省と自己指示。** その後、エージェントは「内省」機能を得ました——各ステップの後に結果を見て、次に何をするか自分で決めるのです。ゴールを与えると、自分で分解し、自分で再試行します。しかし、一つの問題が浮上しました:いつ止めるのか?エージェント自身が言う「できました」は信用できるのか?実践は答え続けました——ノー。エージェントはあまりにも簡単に勝利宣言をします。
+
+**段階4:独立した停止判断——`/goal`。** 最後のステップは、「できたかどうかの判断」を仕事をするエージェントの手から取り上げ、独立した審判に渡すことでした。別のモデルでも、スクリプトでも、テストコマンドでも構いません——しかしルールは同じです:コードを書いた人が自分の採点をしてはならない。この時点で `/goal` は本当に機能しました:ゴールを与えると、ループし、独立した審判がいつ止めるか決め、あなたは離席できる。
+
+これら4つの段階は、どこかの会社が計画したロードマップではありません。エージェントでコードを書くすべての人が、同じ痛みに突き動かされて、独立してたどり着いた道です。Claude Code と Codex が2026年初頭にほぼ同時に `/goal` をリリースしたのは偶然ではありません——時が来たのです。
+
+### ループには一種類だけではない
+
+`/goal` は最も理解しやすいループですが、唯一の種類ではありません。ループは、トリガーの方法と停止の方法に基づいていくつかのカテゴリに分類されます:
+
+| 種類 | トリガー | 停止条件 | Claude Code | Codex | 最適な用途 |
+|------|---------|----------------|-------------|-------|----------|
+| **ターンベースループ** | 手動で各プロンプトを入力 | エージェントが完了と判断するか、あなたが中断する | 通常のチャット | 通常のチャット | 小さなタスク、探索的作業 |
+| **ゴールベースループ** | ゴールを与える | 独立した評価者が完了を確認するか、最大ターン数に達する | `/goal` | `/goal`(手動で有効化が必要) | 明確な完了基準のある複雑なタスク |
+| **時間ベースループ** | スケジュールされた間隔(N分/時間ごと) | 手動で停止するか、作業完了後に終了する | `/loop` | スレッドオートメーション | ステータス監視、定期チェック、反復作業 |
+| **イベント駆動ループ** | 外部イベント(PR作成、CI失敗、新規issue) | イベント処理後に停止するか、再試行回数の上限に達する | Routines(API / GitHub Webhook) | スタンドアロンオートメーション + プラグイン | リアクティブワークフロー、CI/CD連携 |
+
+これらは競合するものではありません——用途に応じた異なるツールです。小さなことにはターンベースで十分です。明確なゴールラインがある場合は `/goal` を使います。何かを監視する必要がある場合は `/loop` を使います。外部システムと連携する場合はイベント駆動を使います。
+
+### `/goal` と `/loop` を混同しないで
+
+どちらも「ループ」という言葉が含まれていますが、解決する問題は完全に異なります:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **それは何か** | 一つの大きなタスク、完了するまで実行 | 一つの小さなアクション、間隔をおいて繰り返し |
+| **停止条件** | ゴール達成、または予算の使い切り | 手動で停止するか、タスクが自発的に終了する |
+| **時間プロファイル** | 一度の長時間実行、数時間または数日かかる | 周期的な短時間実行、各実行は数分程度 |
+| **進捗** | 各反復でゴールラインに近づく | 各実行は独立しており、累積的な進捗はない |
+| **たとえ** | マラソン——スタートの合図で走り出し、ゴールラインで止まる | 目覚まし時計——スケジュール通りに鳴り、あなたが止める |
+| **典型的な用途** | 「テストカバレッジ付きで完全な支払いシステムを実装する」 | 「15分ごとにCIが壊れていないかチェックする」 |
+
+よくある間違い:`/goal` にすべきものを `/loop` に押し込むことです。たとえば `/loop 10m "支払いシステムの実装を続ける"` と書くのは間違いです。`/loop` は毎回同じ指示を独立して実行するだけで、前回どこまで進んだかを覚えていません。同じ出発点を何度も繰り返すだけになります。
+
+**どちらを使うべきかの一文テスト:それには終わりがあるか?**
+- 終わりがある → `/goal`
+- 終わりがなく、監視し続ける必要がある → `/loop`
+
+この講義のテーマであるループエンジニアリングは、いずれか一つのコマンドについてのものではありません。それは**これらすべての種類を含むシステムを設計できること——あなたがそこにいなくてもエージェントが働き続けられること——についてです。**
+
+毎回 `/goal` を入力する必要はありません。しかし、それがどこから来て、なぜこのような形になったのかを理解すること——それがループエンジニアリングの核心を理解することです。より複雑なループは、スケジューリング、並列性、隔離、メモリといった部品を、この同じ3つの基本——ゴール、検証、停止条件——の上に追加しているだけです。
+
+## 2026年6月:3人が1週間で同じ導火線に火をつけた
+
+2026年6月の第1週、コーディングエージェントのインフラを構築していた3人の実践者が——情報を交換することなく——異なる言葉で同じことを言いました。
+
+**Peter Steinberger**(OpenClawの生みの親、[彼の投稿は800万回閲覧されました](https://x.com/steipete/status/2063697162748260627)):「もうコーディングエージェントにプロンプトを与えるべきではない。エージェントにプロンプトを与えるループを設計すべきだ。」
+
+**Boris Cherny**(AnthropicのClaude Code責任者、[Acquiredポッドキャストにて](https://x.com/rohanpaul_ai/status/2063289804708835412)):「もうClaudeにプロンプトを与えていない。Claudeにプロンプトを与えて何をするか考えるループを動かしている。私の仕事はループを書くことだ。」
+
+**Addy Osmani**(Google Chromeのエンジニアリングリード)は2026年6月7日に[この概念に名前をつけ](https://addyosmani.com/blog/loop-engineering/)、一行で定義しました:
+
+> **ループエンジニアリングとは、エージェントにプロンプトを与える人としての自分自身を置き換えることです。その代わりにシステムを設計するのです。**
+
+Chernyは数字を明かしています:30日間連続で、Claude Codeへのすべてのコード貢献はAIによって自律的に行われ——259のマージされたPR、本番コードの80%以上がClaudeによって作成され、オープンエンドなソフトウェアタスクで76%の成功率を記録しました。
+
+3人。1週間。同じ結論。調整したからではありません——インフラが静かに臨界点を越えたからです。エージェントは、監視なしでも些細でないタスクを完了できるほど信頼できるようになっていました。スケジューリングのプリミティブ(`/loop`、`/goal`、cron)がツールに組み込まれるようになりました。1回のエージェント実行のコストが十分に低くなり、タイマーで繰り返し実行することが無駄に思えなくなりました。すべての部品が揃ったとき、それらを組み合わせる動きは、誰にでも同時に明らかになるのです。
+
+> 出典: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## ループの内側 vs. ループの外側
+
+2つの具体的なシナリオを対比させてみましょう。
+
+**シナリオA:あなたはループの内側にいる(第1–12回)。**
+
+```mermaid
+flowchart TD
+ You["あなた"] -->|"手動で指示を入力"| Agent["AIエージェント"]
+ Agent -->|"出力を生成"| Result["コード / テスト / ドキュメント"]
+ Result -->|"あなたが検査"| You
+ You -->|"不満、指示を修正"| Agent
+ You -->|"満足、次のタスクへ"| You
+```
+
+あなたは完全なharnessを持っています:`AGENTS.md` はエージェントにプロジェクトのルールを伝え、`feature_list.json` はスコープを制約し、`init.sh` は一貫した環境を保証し、`claude-progress.md` は進捗を記録します。**しかし、すべてのステップにはまだあなたの手動の開始が必要です。** 一つの機能を終え、進捗ファイルを読み、次に何をするか考え、指示を入力する。あなたがワークフロー全体のエンジンなのです。
+
+**シナリオB:あなたはループの外側にいる(ループエンジニアリング)。**
+
+```mermaid
+flowchart TD
+ subgraph Loop["あなたが設計したループシステム"]
+ Trigger["自動トリガー<br/>スケジュール / イベント / 前のタスク完了"] --> Discover["作業を発見<br/>進捗ファイルを読む / 課題トラッカー"]
+ Discover --> Dispatch["ディスパッチ<br/>サブエージェントを起動"]
+ Dispatch --> Verify["検証<br/>テスト / lint / 独立したレビュアーエージェント"]
+ Verify --> Persist["状態を保存<br/>進捗を更新 / コミット / PRを作成"]
+ Persist -->|"作業が残っている"| Discover
+ Persist -->|"完了またはブロック中"| Inbox["レビュー用受信箱にプッシュ"]
+ end
+ Inbox -->|"意思決定だけすればよい"| You["あなた"]
+```
+
+もう指示を入力する必要はありません。あなたが設計したシステムが、作業を発見し、ディスパッチし、結果を検証し、状態を記録し、次のステップを決定します。あなたの仕事は3つに縮小されます:**開始前にゴールと停止条件を定義すること、終了後に出力をレビューすること、システムがコースを外れたときにルールを調整すること。** レバレッジは「正しいプロンプトを書くこと」から「正しいループを設計すること」に移ります。
+
+> Osmani:「1年前、ループが欲しければ大量のbashを書いて、それを永遠に保守しなければならなかった。それはあなただけのものだった。今では部品がプロダクトの中に標準で付いてくる。」ゼロから作る必要はありません。部品がどう組み合わさるかを理解する必要があるのです。
+
+## コアコンセプト
+
+- **ループエンジニアリング**: 手動で段階的に人間が入力する代わりに、エージェントに自動的にプロンプトを与えるシステムを設計すること。人間はループの内側から外側に移り、レバレッジは「正しいプロンプトを書くこと」から「正しいループを設計すること」に移る。
+- **`/goal` モード**: 最もシンプルなループ——ゴール、検証方法、停止条件を与えると、エージェントはそれらが満たされるまでループする。手動プロンプトから自律ループへの架け橋。
+- **生成者/評価者の分離**: コードを書くエージェントとそれをチェックするエージェントは分離されなければならない。自分の仕事を採点するモデルは信用できない;独立した検証者——時には全く別のモデル——が、あらゆるループのベースライン信頼性保証となる。
+- **Worktreeの隔離**: 並列する各エージェントは独立したgit worktreeで作業し、ファイルの衝突を物理的に防ぐ。マルチエージェント並列実行のインフラストラクチャ前提条件。
+- **外部状態**: 単一の会話の外に存在するメモリ——マークダウンファイル、課題トラッカー、カンバンボード。モデルは実行ごとにすべてを忘れる;メモリはディスク上に存在しなければならない。
+- **4つの静かなコスト**: ループが長く実行されるほど鋭くなる4つの隠れたコスト——検証の借金、理解の腐敗、認知的降伏、トークンの爆発。ループは出力だけでなくリスクも加速させる。
+
+## ループの6つのプリミティブ
+
+Osmaniはループを5つのコアビルディングブロックに分解し、それらすべてに通じるメモリレイヤーを1つ追加しました——合計で6つですが、メモリレイヤーは特別な位置を占めています:それは他のものと同じレベルのコンポーネントではなく、他のすべてが依存する背骨なのです。
+
+下の図は全体像を一目で見るために6つすべてを輪にして描いています。しかし覚えておいてください:外部状態はループ上の単なる別の停留所ではなく——ループ全体がその上に成り立つ基盤なのです。
+
+```mermaid
+flowchart LR
+ A["オートメーション<br/>スケジュールされたトリガー"] --> W["Worktree<br/>並列隔離"]
+ W --> S["スキル<br/>体系化されたプロジェクト知識"]
+ S --> C["コネクター<br/>外部ツールアクセス"]
+ C --> SA["サブエージェント<br/>Maker / checker 分離"]
+ SA --> ES["外部状態<br/>反復間メモリ"]
+ ES --> A
+```
+
+### 1. オートメーション — 鼓動
+
+オートメーションがなければ、ループはループではありません——手動で行った一回限りの実行です。
+
+Claude Code と Codex はどちらも完全なスケジューリングシステムを持っていますが、異なる名前とレイヤーを使っています。大まかに軽いものから重いものへの対応:
+
+| レイヤー | Claude Code | Codex | 備考 |
+|-------|-------------|-------|-------|
+| セッション内ポーリング | `/loop` | スレッドオートメーション | 現在のセッションに紐付き、セッションが閉じると終了 |
+| ローカルスケジュールタスク | デスクトップスケジュールタスク | スタンドアロンオートメーション(ローカルモード) | マシンの電源が入っている間実行、ローカルファイルにアクセス可能 |
+| クラウドスケジュールタスク | Cloud Routines | —(ネイティブクラウドスケジューラーなし) | マシンの電源が切れていても実行 |
+| イベントトリガー | Routines(API / GitHub Webhook) | スタンドアロンオートメーション + プラグイン | 外部イベントによってトリガー |
+| 完全セルフホスト | GitHub Actions / セルフホストcron | `codex exec` + cron | 完全な制御 |
+
+**CodexのAutomationsタブ** がスケジューリングのエントリーポイントです。プロジェクト、プロンプト、実行間隔、ローカルチェックアウトで実行するかバックグラウンドworktreeで実行するかを選びます。何かを発見した実行はTriage受信箱に入り、何も発見しなかった実行は自動的にアーカイブされます。OpenAIは社内で、日次のissueトリアージ、CI失敗のサマリー、コミットのブリーフィング、先週導入されたバグの発見などにこれらを使用しています。
+
+Codexのオートメーションには2種類あります:
+- **スレッドオートメーション** — スレッドに紐付いたハートビート式の定期起床コール。コンテキストを保持します。長時間実行されるコマンドの監視やPRステータスのポーリングなど、単一の事柄を継続的にフォローアップするのに適しています。Claude Codeでの同等機能は `/loop` です。
+- **スタンドアロンオートメーション** — 各実行は新規に開始され、結果はTriageに送られます。ブリーフィングや依存関係スキャンなど、日次/週次の独立したタスクに適しています。Claude Codeでの同等機能はデスクトップスケジュールタスクです。
+
+Claude Codeのシステムはより細かく階層化されています:
+
+- **`/loop`** — 軽量なセッション内スケジュール繰り返し。ターミナルが開いている間動作し、セッションが閉じると終了し、7日後に自動的に期限切れになります。現在の作業セッション中の一時的な監視に適しています。
+- **デスクトップスケジュールタスク** — マシンの電源が入っている間実行され、セッションの再起動に耐え、分単位の間隔に対応。ローカルファイルアクセスが必要な反復作業に適しています。
+- **Cloud Routines** — Anthropicのクラウドインフラで実行され、マシンの電源が切れても動作し、最小間隔は1時間。3種類のトリガーをサポート:スケジュール、APIコール、GitHubウェブフック。ローカル環境を必要としない日次タスクに適しています。
+- **GitHub Actions / セルフホストcron** — 完全に制御下に置き、好きなように実行できます。特別な環境やセキュリティ要件があるシナリオに適しています。
+
+```bash
+# Claude Code: 30分ごとにテストを実行し、失敗を修正する(現在のセッション内)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: 15分ごとにデプロイステータスをチェック
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+オートメーションは鼓動です。それらがなければ、ループは目覚めることのない設計図に過ぎません。
+
+### 2. Worktree — スケールする隔離
+
+複数のエージェントを実行するとすぐに、ファイルの衝突が必然的な故障モードになります。2人のエンジニアが相談なしに同じ行にコミットするのと同じ頭痛の種が、2つのエージェントが同じファイルに書き込むことで起こります。
+
+`git worktree` がこれを解決します:各エージェントは独自のディレクトリで独自のブランチで作業します。物理的にお互いのチェックアウトに触れることができません。
+
+Claude Code と Codex はどちらもworktreeサポートを備えています。サブエージェントで `--worktree` または `isolation: worktree` を使うと、各ヘルパーはクリーンで独立したチェックアウトを取得し、後で自動的にクリーンアップします。Worktreeは機械的な衝突問題を取り除きます——しかし覚えておいてください:**あなたのレビュー帯域幅が依然として上限です。** 何人の並列エージェントを監督できるかが、実際に実行できるworktreeの数を決定します。
+
+### 3. スキル — プロジェクトを再説明するのをやめる
+
+スキルとは、セッションごとに同じプロジェクトコンテキストを再説明するのをやめる方法です。指示とメタデータを含む `SKILL.md`、オプションのスクリプト、参照、アセットを含むフォルダです。
+
+Codex と Claude Code は同じフォーマットをサポートしています。スキルは `/skill-name`(Codexは `$skill-name` もサポート)で直接呼び出すか、タスクがスキルの説明と一致したときに暗黙的にトリガーされます。
+
+スキルは根本的に、インテントの借金を返済することに関するものです。エージェントは毎セッション冷えた状態で始まります——あなたのインテントのギャップを自信満々な推測で埋めます。スキルとは、そのインテントを外側に書き留めたものです:慣習、ビルド手順、「あの一件があるからこのやり方はしない」——一度書けば、毎回読まれます。
+
+### 4. コネクター — ループが実際のツールに触れる
+
+ファイルシステムしか見えないループは小さなループです。コネクター(MCPプロトコル上に構築)は、エージェントが課題トラッカーを読んだり、データベースにクエリを実行したり、ステージングAPIを叩いたり、Slackにメッセージを投げたりすることを可能にします。
+
+Codex と Claude Code はどちらもMCPを話すので、一方で書いたコネクターは通常もう一方でも動作します。コネクターとは、「これが修正です」と言うだけのループと、PRを作成し、Linearチケットをリンクし、CIがグリーンになったらチャンネルに通知する——それを単独で、実際の環境の中で、ただターミナルの中だけでなく行うループとの違いなのです。
+
+### 5. サブエージェント — MakerをCheckerから遠ざける
+
+ループにおける最も構造的に価値のある設計選択は、書く人とチェックする人を分けることです。コードを書いたモデルは、自分の宿題を採点するにはあまりにも甘すぎます。異なる指示を与えられ、時には異なるモデルを使う2番目のエージェントが、最初のエージェントが自分自身に言い聞かせた見落としを捕まえます。
+
+古典的な3つの役割の分割:
+
+```mermaid
+flowchart LR
+ Explorer["Explorerエージェント<br/>コードベースを読み、問題を特定"] --> Implementer["Implementerエージェント<br/>修正を書き、テストを書く"]
+ Implementer --> Verifier["Verifierエージェント<br/>独立したレビュー、検証を実行"]
+ Verifier -->|"失敗"| Implementer
+ Verifier -->|"合格"| Output["出力"]
+```
+
+Claude Codeの `/goal` は内部でこれを実行しています——仕事をしたセッションではなく、フレッシュで独立したセッションがループを止めるべきかどうかを判断します。これは**生成者/評価者の分離**と呼ばれ、ループ設計における最も重要な信頼性保証です。
+
+### 6. 外部状態 — ループのメモリ
+
+モデルは実行ごとにすべてを忘れます。メモリはコンテキストウィンドウではなく、ディスク上に存在しなければなりません。
+
+これは単純すぎて重要でないように聞こえるかもしれませんが、長時間実行されるすべてのエージェントが依存している同じトリックです。マークダウンファイル、Linearボード——単一の会話の外に存在し、何が完了し、何が進行中で、何が次かを保持するものなら何でも。エージェントは忘れます。リポジトリは忘れません。
+
+これら6つのプリミティブがあなたのループ設計ツールキットです。すべてのループにすべてが必要なわけではありません。しかし、いつどれを使うべきかを知っておく必要があります。
+
+## 完全なループ、解剖
+
+6つすべてをつなぎ合わせると、実際の朝のトリアージループは次のようになります:
+
+```mermaid
+flowchart TD
+ Trigger["毎朝9:00に<br/>オートメーションが起動"] --> Read["外部状態を読む<br/>昨日のclaude-progress.md<br/>オープンなGitHub issues"]
+ Read --> Triage["Triageスキルが起動<br/>結果を分類し優先順位付け"]
+ Triage --> Fork["実行可能な各項目について<br/>隔離されたWorktreeをフォーク"]
+ Fork --> Implement["Implementerサブエージェント<br/>修正 + テストを書く"]
+ Implement --> Verify["Verifierサブエージェント<br/>独立してテスト + lint + レビューを実行"]
+ Verify -->|"失敗"| Retry["再試行キュー<br/>別のアプローチを試す"]
+ Retry --> Implement
+ Verify -->|"合格"| PR["コネクター:PRを作成<br/>issueをリンク、進捗ファイルを更新"]
+ PR --> Memory["外部状態に書き込む<br/>claude-progress.mdを更新<br/>今回の結果を記録"]
+ Memory -->|"作業が残っている"| Fork
+ Memory -->|"すべて完了またはブロック中"| Inbox["結果がTriage受信箱に届く<br/>レビュー待ち"]
+```
+
+これはもはや単一のエージェント実行ではありません。毎朝起動し、自ら床を掃き、あなたの注意が必要なものを目の前に置いてくれる、継続的に動作するシステムです。あなたの役割は次のようになります:**受信箱の中身をレビューし、意思決定をし、システムが対処できないパターンを見つけたらスキルとルールを洗練する。**
+
+Chernyはこのパターンを使って、IDEを一度も開くことなく30日で259のPRをマージしました。OpenAIのエンジニアたちは同じパターンを使って、約100万行のベータ製品を——自分で一行もコードを書くことなく——構築しました。
+
+## 生成者/評価者の分離:なぜモデルに自分の仕事を採点させてはいけないのか
+
+これがループエンジニアリングで最も難しい教訓です。
+
+あなたの最も優秀なエージェントが美しいコードを書きます。ロジックは明確で、コメントは行き届いており、すべての関数にはテストがあります。あなたは満足します。
+
+しかし、ここに問題があります:**もしそのコードを書いたエージェントに、自分が良い仕事をしたかどうかを判断させたら、何と言うでしょうか?**
+
+答えは何度も経験によって確認されています:高い点数をつけるでしょう。不正直だからではなく、作者だからです——生成中にこの道が正しいと自分自身に言い聞かせているのです。振り返っても、過ちは見えません;自分の推論プロセスが見えるだけです。
+
+これはClaudeの問題ではありません。GPTの問題でもありません。これはすべての生成モデルの性質です。**モデルは自分の出力の最高の弁護士です。**
+
+解決策:同じ実体(同じモデル、同じプロンプト)に仕事とレビューの両方をさせてはならない。
+
+- Claude Codeの `/goal` は、ゴールが達成されたかどうかを判断するために独立したスーパーバイザーセッションを使用します——試行したセッションではありません。
+- Codexのサブエージェントシステムでは、異なるモデルと異なる推論努力を使う検証者エージェントを定義できます。
+- コミュニティの「敵対的検証」の慣習では、各発見に対してN人の独立した懐疑論者を生成し、それぞれに反証するようプロンプトします——過半数が拒否すればその発見は棄却されます。
+
+覚えておくべき一文:**あなたのチームの誰かは、あなたを信じてはいけない。**
+
+## Karpathyのautoresearch:ループの模範
+
+よく設計され、実際に動いているループがどんなものかを見たいなら、[Karpathyのautoresearch](https://github.com/karpathy/autoresearch) が教科書的な例です。
+
+2026年3月、Karpathyは630行のPythonプロジェクトをリリースしました。GPUを1つと研究の方向性を与えると、一晩中動き続け——何百ものML学習実験を完了し、本当に改善するものだけを保持します。このプロジェクトはリリース後数日で66,000スター以上を獲得しました。
+
+### 3つのファイル、3つの役割
+
+システム全体にはわずか3つのコアファイルしかありませんが、役割分担は非常に明確です:
+
+| ファイル | 編集するのは誰か | 何をするか |
+|------|-------------|-------------|
+| `prepare.py` | 誰も(読み取り専用) | データ準備、トークナイザー、評価harness。固定インフラ。 |
+| `train.py` (約630行) | **AIエージェント** | モデル定義、オプティマイザー、学習ループ。エージェントの遊び場——何でも変更してよい。 |
+| `program.md` | **あなた** | 自然言語で書かれた研究方法論。あなたが編集するのはこれだけ。エージェントにどう探索し、どう評価し、何に触れてはいけないかを伝える。 |
+
+この3つの分割が設計の核心です:**人間はコードに触れず、方向性に触れる;エージェントは方向性に触れず、コードに触れる。** あなたの仕事はPythonを書くことから「研究組織の文化を書くこと」に移ります。
+
+### 入力:program.mdはどのようなものか
+
+`program.md` はループの頭脳です。コードではありません——マークダウンで書かれた研究指示書です。大まかに以下が含まれます:
+
+- **ゴール**: `val_bpb`(検証ビット/バイト、低いほど良い)を最適化する
+- **制約**: `prepare.py` には触れない、VRAM予算内に収める、学習時間は固定で5分
+- **探索の方向性**: 異なるアーキテクチャ、オプティマイザー、LRスケジュールを試す
+- **評価ルール**: 何を改善と見なすか、結果をどう記録するか、失敗したらどうするか
+- **鉄則**: 絶対に止まらない。ループが始まったら、永遠に続ける
+
+エージェントへのキックオフプロンプトは一文で十分です:
+
+```
+program.mdを見て、新しい実験を始めましょう!
+```
+
+後はエージェントがドキュメントを読んで自分で決定します。
+
+### 9ステップのラチェットループ
+
+autoresearchの核心には**ラチェット**があります——前に進むだけで、後ろには戻らない。各反復は厳密に9つのステップに従います:
+
+```mermaid
+flowchart TD
+ 1["1. 方向性を読む<br/>program.mdを読み込む"] --> 2["2. 現在の状態を調査<br/>train.py + 過去の結果を読む"]
+ 2 --> 3["3. 仮説を立てる<br/>試すべき変更を考える"]
+ 3 --> 4["4. コードを修正<br/>train.pyを編集"]
+ 4 --> 5["5. スナップショット<br/>git commit"]
+ 5 --> 6["6. 学習を実行<br/>固定で5分の実時間"]
+ 6 --> 7{"7. 評価<br/>val_bpbは改善したか?"}
+ 7 -->|はい| 8a["8a. 維持<br/>コミットはそのまま<br/>results.tsvに書き込む"]
+ 7 -->|いいえ| 8b["8b. 元に戻す<br/>git reset HEAD~1<br/>失敗を記録"]
+ 8a --> 9["9. 次のラウンド<br/>ステップ1に戻る"]
+ 8b --> 9
+```
+
+1時間に約12回の実験を実行します。一晩(8時間)で約100回の実験になります。Karpathy自身は2日間実行しました——約700回の実験です。
+
+固定の5分実時間予算は重要な設計選択です——エージェントが何を変更しようとも、すべての実験にはまったく同じ時間がかかります。これは、同じ時間予算のもとですべての結果が直接比較可能であることを意味します——「これは長く実行したから良い」という議論は成り立ちません。
+
+### 出力:目覚めたときに見るもの
+
+一晩ループが回った後、朝座って3つのものを見つけます:
+
+**1. Git履歴(前進のみのラチェット)**
+
+実際に改善したコミットだけがメインブランチに残ります。失敗したものはすべてロールバックされました。`git log` は検証済みの研究ログになります。
+
+**2. results.tsv(完全な実験記録)**
+
+すべての実験——成功か失敗か——が記録されます:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. 研究ログ(エージェント自身のサマリー)**
+
+エージェントは明確なコミットメッセージを書きます——何を試したか、何がうまくいったか、うまくいかなかったか、次に何を試す予定か。コードの差分を読む必要はなく、それらを読みます。
+
+### 実際に何が見つかったか
+
+Karpathyの最初の2日間、約700回の実験ランからの結果:
+
+- 約700回の試行のうち、約**20個の積み重ね可能な真の改善**が見つかった
+- nanochatのGPT-2レベルの学習時間を、8×H100上で**2.02時間 → 1.80時間**に短縮、約**11%の高速化**
+- 発見内容:学習率調整、オプティマイザーチューニング、活性化関数の交換、アテンションパターンの最適化など
+
+すべての改善が画期的な発見だったわけではありません。ほとんどは積み重ね可能な小さな最適化でした。しかし、これら20個の有効な改善は、人間の研究者なら数週間の手作業がかかったであろうものです——エージェントは48時間でそれを成し遂げました。
+
+### 最も物語を語る詳細:ループは英語で書かれている、コードではなく
+
+`program.md` はPythonスクリプトではなく、マークダウンドキュメントです。研究方法論——何を修正し、何には触れず、どう評価し、失敗ケースにどう対処するか、そして一つの鉄則:**人間を頼るな、ただ前進し続けろ**——を記述しています。コーディングエージェントがこのドキュメントを読み、無期限に実行します。
+
+これがループエンジニアリングのテンプレートです:エージェントにタスクを与えるのではない。**方法論**を与えるのです。方法論そのものをループにするのです。一つの `program.md`、630行の接着コード、そして残りはすべてエージェントが自らを動かしています。
+
+## 4つの静かなコスト
+
+ループが動き始めても、問題はすぐには見えません。以下の4つのコストは静かに蓄積し、気づいた頃には既に大きな代償を払っているかもしれません。
+
+### 1. 検証の借金
+
+速いループは検証をスキップしたくなります。「大丈夫そう」は「正しいと確認された」と同じではありません。ループが監視なしで生成するコードが多いほど、検証の借金は早く積み上がります。解決策:**停止条件は機械で検証可能でなければならない、「だいたい合ってる」では決してならない。**
+
+### 2. 理解の腐敗
+
+ループがコードを出荷するのが速いほど、自分自身のコードベースに対する理解が現実から乖離していきます。Chernyのチームはコードの80%がエージェントによって作成されていました——つまり、チームのコードの大部分が人間によって書かれていないのです。ループが生み出したものを読んで使わなければ、理解は継続的に減衰します。**速いループには速い読みが必要です。**
+
+### 3. 認知的降伏
+
+ループがスムーズに動くと、最も心地よい姿勢は意見を持つのをやめることです。戻ってきたものを何でも受け入れ、出力について考えない。しかし、それこそが危険の始まりです——ループを考えるためではなく、考えないために使っているのです。Osmaniの警告:「二人の人間がまったく同じループを構築して、正反対の結果を得ることがある。一方は理解している仕事をより速く進めるために使い、もう一方は仕事を理解することを避けるために使う。ループはその違いを知らない。あなたは知っている。」
+
+### 4. トークンの爆発
+
+ループの各反復はより多くのコンテキストを蓄積します:書かれたコード、遭遇したエラー、下された決定。コンテキスト管理がなければ、プロンプトサイズはターン数のおよそ2乗で成長します。Codexは自動コンテキスト圧縮でこれに対処しています——専用のAPIが古い会話ターンを暗号化されたコンテンツサマリーに圧縮し、冗長な詳細を捨てつつ本質的な知識を保持します。これは後付けではなく、最初のループから対処しなければならないエンジニアリング上の関心事です。
+
+## 最初のループを構築する
+
+Stripe規模のパイプライン——週に1,300のPRをマージする——から始める必要はありません。動く最小のものから始めましょう。
+
+### ステップ1:一つの定期的なタスクを選ぶ
+
+少なくとも週に2回は手動で行っていることを見つけてください。例:
+- 朝にGitHubを開いて新しいissueをチェックし、トリアージして対応する
+- すべてのPRレビューの前にlintとテストを実行する
+- 各日の終わりに進捗ドキュメントを更新する
+
+### ステップ2:ゴールと停止条件を書く
+
+タスクを `/goal` が理解できるものに変えます:
+
+```markdown
+ゴール:リポジトリの最新10件のissueをチェックする。
+各issueについて:
+ - 既に明確なラベルと担当者がいる場合はスキップ
+ - タグがない場合は、内容に基づいて適切なラベルを追加
+ - 10分以内に修正可能な場合は、ブランチを作成して修正を試みる
+停止条件:該当するすべてのissueが処理されたか、人間の判断が必要なissueに遭遇したとき。
+```
+
+### ステップ3:MakerとCheckerを分割する
+
+同じエージェントにコードを書かせて判断させてはいけません。ループを2つの役割に分割します:
+- Implementer:issueを読み、修正を書き、テストを書く
+- Verifier:独立してテストを実行し、差分をレビューし、修正が実際に問題を解決しているか判断する
+
+### ステップ4:メモリを追加する
+
+マークダウンファイルを使って、各ループ実行で何が起こったかを記録します。次の実行はこのファイルを読んで始まります——何が終わったか、何が保留中か、何がブロックされているかを知っています。これはどんな複雑なデータベースよりも優れています。
+
+### ステップ5:タイマーを設定する
+
+`/loop` またはOSのcronを使って、あなたなしでもループが始まるようにします。1日1回から始めましょう。1週間観察してください。
+
+### 成熟度のはしご
+
+一気に頂上に到達する必要はありません。ループの採用ははしごです:
+
+1. **レベル1:ゴールランナー** — `/goal` を使って停止条件付きのタスクを与えられる;エージェントは達成するまでループする。
+2. **レベル2:スケジュールされた単一タスク** — 一つのオートメーションがタイマーで一つのタスクを実行する(例:朝のCIチェック)。
+3. **レベル3:マルチエージェントループ** — MakerとCheckerが分割される;各発見は隔離されたworktreeをフォークする。
+4. **レベル4:自走ループ** — ループは外部状態から次のタスクを自動的に発見する;次に何をするか自分で決める。
+5. **レベル5:フリートオーケストレーション** — 複数のループが並行して実行され、独立しているがメモリレイヤーを共有する。
+
+ほとんどのチームは現在レベル2とレベル3の間にいます。レベル1がリターンを得るための最速の道です。
+
+## 主なまとめ
+
+- **ループエンジニアリングはハーネスエンジニアリングを置き換えるのではなく、その上の階を建てる。** ハーネスは単一実行を信頼できるものにする。ループは継続的な実行を自律的にする。
+- **`/goal` は最もシンプルなループである:** ゴール + 検証 + 停止条件。この3つで、ループの内側から外側に移れる。
+- **6つのプリミティブ(オートメーション / Worktree / スキル / コネクター / サブエージェント / 外部状態)がループのビルディングブロックである。** 毎回すべてを使うわけではないが、いつどれを使うべきかを知っておく必要がある。
+- **MakerとCheckerは分離されなければならない。** 自分の仕事を採点するモデルは信用できない。独立した検証者——時には全く別のモデル——が、あらゆるループのベースライン信頼性保証となる。
+- **ループは生成をほぼ無料にし、判断を希少なリソースとして残す。** 節約した時間は休むためではない。より多くの判断をするためである。
+- **ループが長く実行されるほど鋭くなる4つの静かなコスト:** 検証の借金、理解の腐敗、認知的降伏、トークンの爆発。ループは出力——そしてリスク——を加速させる。
+- **小さく始める。** 一つの `/goal`、一つのcron、一つのマークダウンメモリファイル。リターンを確認してから上に積み上げる。
+
+## さらに読む
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — 50の実際のループからなる公開コーパス
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- 第12回:[セッションの終わりにクリーンな引き継ぎを残す](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — ループの前提条件:各セッションがクリーンな状態を残すことで、次のラウンドが自動的に開始できる
+- 第5回:[長時間実行タスクをセッション間で継続させる](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — 外部状態とメモリの前提知識
+- 第11回:[なぜ観測可能性はハーネスの内部にあるべきか](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — ループが速く動くほど、問題を捕まえるための観測可能性が必要になる
+- 第8回:[なぜ機能リストはハーネスのプリミティブなのか](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — 機能リストは、自走ループが次のタスクを発見するための自然なデータソースとなる
+
+## 演習
+
+1. **定期的なタスクを `/goal` に変える:** 週に少なくとも2回は手動で行っていることを見つけてください。そのゴール、検証方法、停止条件を書き出してください。`/goal` で一度実行し、手動で行う場合と時間と品質を比較してください。これがハーネスからループへのあなたの第一歩です。
+
+2. **MakerとCheckerを分離する:** 以前にエージェントに実行させたことのあるタスクを選んでください。今回は、2つの異なるプロンプトを書いてください:Implementerエージェント用とVerifierエージェント用です(異なるモデルを使ってください——例えば実装にはClaude、検証にはGPT、あるいはその逆)。Verifierは、証拠を引用して具体的な問題点を指摘しなければなりません。各モードで発見された問題の数と種類を記録してください。
+
+3. **ループにメモリを与える:** ループ用のマークダウン状態ファイルを作成してください。各反復で、今回何をしたか、検証結果、ステータス(合格/不合格/ブロック中)、次に何をするかを書いてください。3ラウンド実行し、メモリファイルがある場合とない場合の行動の違いを観察してください。
+
+4. **ループの静かなコストを監査する:** ループが1時間実行された後、以下の4つの指標を評価してください:
+ - どれだけの検証が「機械で確認された」ではなく「なんとなく大丈夫」だったか?(検証の借金)
+ - ループが最近生成したコードをどれくらい上手く説明できるか?(理解の腐敗)
+ - 「後で見よう」と思って結局見なかったのは何回か?(認知的降伏)
+ - ループのコンテキストサイズの傾向はどうか?冗長な情報を繰り返していないか?(トークンの爆発)
diff --git a/docs/ja/projects/project-07-loop-engineering-first-loop/index.md b/docs/ja/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..1eb2ff8
--- /dev/null
+++ b/docs/ja/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# プロジェクト 07. 初めての自動ループを構築する
+
+> 関連講義: [第13回 なぜエージェントにプロンプトを与えるのをやめるべきか](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## このプロジェクトですること
+
+これは「ハーネス」から「ループ」への移行プロジェクトです。適切な環境、指示、フィードバックを備えたエージェントのセットアップ方法は既に知っています——今度はそのセットアップを、自ら動き出すループに変えます。
+
+3つの段階的な実験を行います:まずタスクを手動から `/goal` に変え、次に監視タスクを `/loop` タイマーに変え、最後に完全なmaker-checkerループを構築して、**あなたがループの外側に出る**とはどういうことかを体験します。
+
+## プロジェクトファイル
+
+リポジトリパス: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| ディレクトリ | 中身 | あなたがすること |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | 完全なハーネス(P06最終状態)を備えた小さなナレッジベースプロジェクト。AGENTS.md、feature_list.json、init.sh、session-handoff.md、clean-state-checklist.md を含む。 | このハーネスを自動でループできるものに変える。 |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | 3つのループの完全な実装:ゴールループ、タイマーループ、maker-checkerループ。ループ状態ファイルと検証スクリプトも含む。 | ループ設計パターンと状態管理のリファレンス。 |
+
+## 使用するツール
+
+- Claude Code または Codex
+- Git
+- P06 の完全なハーネス
+- ターミナルマルチプレクサ(tmux または screen、長時間実行されるループを観察するため)
+- オプション:GitHub Actions または cron(高度なイベント駆動 / スケジュール実験用)
+
+## ステップ
+
+### 準備
+
+1. P06を終えたのと同じコミットから始めてください。
+2. 3つのブランチを作成してください:`p07-goal-loop`、`p07-timer-loop`、`p07-maker-checker`。
+3. ハーネスが動作することを確認してください:init.shを実行し、状態ファイル、機能リスト、引き継ぎドキュメントがすべて揃っていることを確認します。
+4. ループに繰り返し取り組ませたい**対象タスク**を一つ選んでください。完了基準が明確な中規模のものを選んでください——例:「すべてのモジュールに単体テストを追加してカバレッジ80%に達する」または「すべてのAPIエンドポイントに入力検証を追加する」。
+
+### 実験1:ゴールループ — 手動実行から自動実行へ
+
+`p07-goal-loop` ブランチに切り替えてください。
+
+1. **ゴールの説明を書く**:選んだタスクを `goal.md` ファイルにしてください。含める内容:
+ - 明確なゴール(「何をもって完了とするか」)
+ - 検証方法(「どうやって完了を確認するか」——テストを実行する?lintを実行する?カバレッジをチェックする?)
+ - 停止条件(「いつ止めるべきか」——最大ターン数?時間制限?予算制限?)
+ - 制約(「何に触れてはいけないか」——本番環境の設定、データベーススキーマなど)
+
+2. **最初の手動実行**:自分でタスクをエージェントに手動で与えてください。何ターンかかったか、何回介入したか、結果の品質を記録してください。これがベースラインになります。
+
+3. **`/goal` で実行**:同じ `goal.md` を入力として使い、`/goal` モードで実行してください。エージェントは、ゴールに到達するか停止条件がトリガーされるまで、自らループします。
+
+4. **結果を比較する**:
+ - ターン数の違い
+ - 介入回数の違い
+ - 結果の品質の違い(同じ検証基準を使用)
+ - 費やした時間の違い
+
+5. **goal.mdを反復する**:結果が芳しくなければ、ゴールの説明を修正して再実行してください。結果に満足するか、このタスクでゴールループができることの限界を確認するまで続けてください。
+
+### 実験2:タイマーループ — 監視を鼓動に変える
+
+`p07-timer-loop` ブランチに切り替えてください。
+
+1. **監視タスクを選ぶ**:普段手動で行っている反復的なチェックを見つけてください。例:
+ - 1時間ごとにテストスイートを実行し、失敗を修正する
+ - 毎朝、依存関係のセキュリティアップデートを確認する
+ - 各コミットの後、コーディングスタイルの違反がないかチェックする
+ - 定期的にTODOコメントをスキャンして、古くなっているものがないか確認する
+
+2. **監視プロンプト/スクリプトを書く**:監視の手順を明確にレイアウトしてください——何をチェックするか、問題が見つかったら何をするか、いつ人間を呼ぶか。
+
+3. **`/loop`(またはCodexスレッドオートメーション)で実行**:
+ - 適度な間隔を設定してください(10~30分を推奨——短すぎると煩わしく、長すぎると効果が見えません)
+ - 少なくとも2時間は動かしてください(または他のことをしてから後で戻ってきてください)
+
+4. **結果を記録する**:
+ - いくつの問題を発見したか?
+ - いくつを自分で修正したか?
+ - いくつが誤検知だったか?
+ - いくつを悪化させたか?
+ - 結果のフォローアップにどれくらいの時間を費やしたか?
+
+5. **振り返る**:この監視タスクは自動化する価値がありますか?節約した時間とフォローアップに費やした時間を比較してください。価値がないとしたら、タスクの選び方が悪かったのか、それともループの設計が悪かったのか?
+
+### 実験3:Maker-Checkerループ — ループから自分を外す
+
+`p07-maker-checker` ブランチに切り替えてください。
+
+これは3つの実験の中で最も重要です。**あなたがそこにいなくても動く完全なループ**を構築します:
+
+1. **ループ構造を設計する**:
+ - **Makerエージェント**: 実装する、コードを書く、ファイルを修正する
+ - **Checkerエージェント**: 検証する、テストを実行する、コードレビューをする、合格 / 不合格を判定する
+ - **状態ファイル**(`loop-state.md`):現在のラウンド、何をしたか、検証結果、次は何かを記録する
+ - **停止条件**:N回連続合格、または最大ラウンド数に到達
+
+2. **3つのプロンプトを書く**:
+ - Makerの指示(何をするか、どうやるか、何に触れてはいけないか)
+ - Checkerの指示(何を検証するか、どう検証するか、何をもって合格とするか、どうフィードバックするか)
+ - ループ制御ロジック(誰が最初か、引き継ぎはどう行うか、次のラウンドをどう始めるか)
+
+3. **少なくとも5ラウンド実行する**:
+ - ラウンド1:Makerが実装 → Checkerが検証 → 不合格 → Makerへフィードバック
+ - ラウンド2:Makerがフィードバックに基づいて修正 → Checkerが検証 → ...
+ - ...
+ - 連続合格するか、あなたが打ち切るまで
+
+4. **各ラウンドの状態を記録する**:
+ - ラウンド番号
+ - Makerが何をしたか
+ - Checkerがどんな問題を発見したか
+ - 合格 / 不合格
+ - あなたは介入したか?(もしそうなら、なぜ?)
+
+5. **最終レトロ**:
+ - 何回介入したか?なぜ?
+ - 介入しなかったら何が起こったか?
+ - Checkerは見落とした問題があったか?
+ - Makerは同じ間違いを繰り返していたか?
+ - このループの品質の天井はどこか?Makerの能力か、それともCheckerの能力か?
+
+## 結果の測り方
+
+| 指標 | 実験1(ゴール) | 実験2(タイマー) | 実験3(Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| タスク完了率 | ゴールは達成されたか? | 何サイクルの監視が実行されたか? | 合格までに何ラウンドかかったか? |
+| 人間の介入 | 何回介入したか? | フォローアップにどれくらいの時間を費やしたか? | 何回介入したか? |
+| 結果の品質 | 手動と比べてどうか? | 誤検知率?見落とした問題? | Checkerが発見した問題のうち、あなたなら見つけられなかったものはいくつあるか? |
+| 節約時間 | どれくらいの時間を節約したか? | 自動化する価値はあるか? | ループの設計に費やした時間 vs. 節約した時間 |
+| 信頼性 | 停止条件は信用できるものだったか? | 暴走したか? | ループは同じ場所で動けなくなることがあるか? |
+
+## 提出するもの
+
+- `goal.md`(実験1のゴールの説明、少なくとも2回の反復)
+- 実験1の比較メモ:手動 vs ゴールループ
+- 実験2の監視プロンプト + 2時間の実行ログ
+- 実験3の3つのプロンプト(Maker / Checker / ループ制御)
+- 実験3の `loop-state.md`(少なくとも5ラウンド記録)
+- 最終レトロ:3つの実験すべてからの学び、ループエンジニアリングに対する理解がどう変わったか、どんなものがループ化の良い候補でどんなものはそうでないか
+
+## 関連講義
+
+- [第13回 — なぜエージェントにプロンプトを与えるのをやめるべきか](../../lectures/lecture-13-loop-engineering/index.md)
+- [第12回 — なぜすべてのセッションはクリーンな状態を残さなければならないか](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md)(ループの各ラウンドにはクリーンな状態が必要)
+- [第11回 — なぜ観測可能性はハーネスの内部にあるべきか](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md)(ループの内部で何が起こっているかを見る必要がある)
+- [第05回 — なぜ状態ファイルは継続性のバックボーンなのか](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md)(ループ状態ファイルは状態ファイルの拡張)
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/ko/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/ko/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/code/index.md b/docs/ko/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/ko/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/ko/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/ko/lectures/lecture-13-loop-engineering/index.md b/docs/ko/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..2be56d7
--- /dev/null
+++ b/docs/ko/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> 코드 예제: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> 실습 프로젝트: [프로젝트 07. 첫 번째 자동 루프 구축하기](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# 13강. 수동 프롬프팅에서 자율 루프로
+
+지난 12개 강의에서 배운 모든 것은 하나의 가정에 기반합니다: **여러분이 키보드 앞에 앉아 한 번에 하나씩 지시를 입력한다는 것.**
+
+`AGENTS.md`를 작성했고(1-4강), 상태 관리를 구축했으며(5-6강), 기능 목록으로 범위를 제한했고(7-8강), 세션 종료 시 깔끔한 인계를 남겼으며(9, 12강), 런타임을 관찰 가능하게 만들었습니다(10-11강). 하지만 이 모든 것의 트리거는 항상 여러분이었습니다. 에이전트는 스스로 언제 작업을 시작할지 결정하지 않았습니다 — 누군가 "시작" 버튼을 누르지 않았기 때문입니다.
+
+이 강의는 시작 버튼을 시스템에 넘기는 것에 관한 것입니다. 통제권을 포기하는 것이 아니라 — 다음 단계로 끌어올리는 것입니다.
+
+## /goal: 가장 단순한 루프
+
+루프 엔지니어링으로 가는 가장 좋은 입문은 복잡한 아키텍처 다이어그램이 아니라 — 단 하나의 명령어입니다.
+
+2026년 초, Claude Code와 OpenAI Codex는 독립적으로 동일한 기능을 출시했습니다: `/goal`. 터미널에 입력합니다:
+
+```
+/goal "모든 테스트 통과, 린트 경고 제로, main에 병합"
+```
+
+그러고 나서 노트북을 닫고 잠자리에 듭니다. 8시간 후, 에이전트는 스스로 분석하고, 코딩하고, 테스트하고, 수정하고, 병합합니다. 실패하면 재시도하고, 막히면 접근 방식을 바꾸고, 완료되면 멈춥니다 — 여러분이 어깨 너머로 "다시 시도해봐"라고 말하지 않아도 됩니다.
+
+`/goal`과 전통적인 프롬프트의 유일한 차이점은 한 가지입니다. 하지만 그 한 가지가 모든 것을 바꿉니다:
+
+| | 전통적인 프롬프트 | `/goal` |
+|---|---|---|
+| 여러분이 제공하는 것 | 다음에 할 일 | 최종 상태가 어떤 모습인지 |
+| 에이전트가 하는 일 | 한 번 실행 | 달성될 때까지 반복 |
+| 누가 완료를 판단하는가 | 당신 | 검증 가능한 중단 조건 |
+| 언제 자리를 떠날 수 있는가 | 떠날 수 없음 | `/goal`을 입력하는 순간 |
+
+`/goal`은 본질적으로 하나의 루프입니다. 정확히 세 가지 부분으로 구성됩니다: **목표, 검증 방법, 중단 조건.** 이 세 가지만으로 여러분은 루프 내부에서 외부로 이동하게 됩니다.
+
+### `/goal`이 어떻게 자연스럽게 성장했는가
+
+`/goal`은 갑자기 0에서 1로 튀어나온 것이 아닙니다. 일상적인 워크플로우에서 점진적으로 성장했으며, 대략 네 단계를 거쳤습니다:
+
+**1단계: 수동으로 하나씩 프롬프팅.** 가장 초기의 작업 방식은 주고받는 것이었습니다: "함수 작성해줘", "테스트 추가해줘", "이 로직 고쳐줘". 에이전트는 매 단계마다 멈추고 다음에 무엇을 할지 말해주길 기다렸습니다. 여러분이 전체 파이프라인의 스케줄러였습니다.
+
+**2단계: 여러 단계가 포함된 긴 프롬프트.** 그런 사람들이 단계를 쌓아 올린 긴 프롬프트를 쓰기 시작했습니다: "먼저 코드를 분석하고, 그 다음 구현을 작성하고, 테스트를 실행하고, 실패하면 고쳐줘". 에이전트는 한 번에 여러 단계를 실행할 수 있었지만, 여전히 지켜봐야 했습니다 — 중간에 방향을 잃을 수도 있고, 단계를 마치고 다음에 무엇을 해야 할지 몰랐기 때문입니다.
+
+**3단계: 에이전트 자기 성찰과 자기 주도.** 그 후, 에이전트는 "내성"을 갖게 되었습니다 — 매 단계 후 결과를 보고 다음에 무엇을 할지 결정했습니다. 목표를 주면 스스로 세분화하고 스스로 재시도했습니다. 하지만 문제가 생겼습니다: 언제 멈춰야 할까? 에이전트 스스로 말하는 "다 됐어"가 믿을만할까? 실천은 계속해서 답했습니다 — 아니요. 에이전트는 너무 쉽게 성공을 선언합니다.
+
+**4단계: 독립적인 중단 판단 — `/goal`.** 마지막 단계는 "다 됐는지 판단하는 것"을 작업을 수행하는 에이전트의 손에서 빼내어 독립적인 심판에게 넘기는 것이었습니다. 다른 모델일 수도, 스크립트일 수도, 테스트 명령일 수도 있지만 — 규칙은 같았습니다: 코드를 작성한 사람이 자신의 숙제를 채점할 수 없다는 것. 이 시점에서 `/goal`은 진정으로 작동했습니다: 목표를 주면 루프를 돌고, 독립적인 심판이 멈출 때를 결정하고, 여러분은 자리를 떠날 수 있었습니다.
+
+이 네 단계는 어느 한 회사가 계획한 로드맵이 아니었습니다. 에이전트로 코딩하는 모든 사람이 같은 고통에 밀려 독립적으로 도달한 경로였습니다. Claude Code와 Codex가 2026년 초에 거의 동시에 `/goal`을 출시한 것은 우연이 아니었습니다 — 때가 되었을 뿐입니다.
+
+### 루프에는 한 종류만 있는 것이 아니다
+
+`/goal`은 이해하기 가장 쉬운 루프지만, 유일한 종류는 아닙니다. 루프는 트리거 방식과 중단 방식에 따라 카테고리로 나뉩니다:
+
+| 유형 | 트리거 | 중단 조건 | Claude Code | Codex | 적합한 용도 |
+|------|---------|----------------|-------------|-------|----------|
+| **턴 기반 루프** | 수동으로 각 프롬프트 입력 | 에이전트가 완료했다고 생각하거나, 사용자가 중단 | 일반 채팅 | 일반 채팅 | 작은 작업, 탐색적 작업 |
+| **목표 기반 루프** | 목표를 제시 | 독립 평가자가 완료를 확인하거나, 최대 턴에 도달 | `/goal` | `/goal` (수동 활성화 필요) | 명확한 완료 기준이 있는 복잡한 작업 |
+| **시간 기반 루프** | 예약된 간격 (N분/시간마다) | 수동으로 멈추거나, 작업 완료 후 종료 | `/loop` | 스레드 자동화 | 상태 폴링, 주기적 확인, 반복 작업 |
+| **이벤트 기반 루프** | 외부 이벤트 (PR 오픈, CI 실패, 새 이슈) | 이벤트 처리 후 중단하거나, 재시도 한도 도달 | Routines (API / GitHub Webhook) | 독립 실행형 자동화 + 플러그인 | 반응형 워크플로우, CI/CD 통합 |
+
+이것들은 경쟁 관계가 아닙니다 — 각기 다른 일을 위한 다른 도구일 뿐입니다. 작은 일에는 턴 기반으로 충분합니다. 명확한 결승선이 있을 때는 `/goal`을 사용하세요. 무언가를 감시해야 할 때는 `/loop`를 사용하세요. 외부 시스템과 통합할 때는 이벤트 기반을 사용하세요.
+
+### `/goal`과 `/loop`를 혼동하지 마세요
+
+둘 다 이름에 "루프"가 들어가지만, 완전히 다른 문제를 해결합니다:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **정의** | 하나의 큰 작업, 완료될 때까지 실행 | 하나의 작은 행동, 간격마다 반복 |
+| **중단 조건** | 목표 달성 또는 예산 소진 | 수동으로 멈추거나, 작업이 스스로 종료 |
+| **시간 프로필** | 한 번의 긴 실행, 몇 시간 또는 며칠이 걸릴 수 있음 | 주기적인 짧은 실행, 각 실행은 몇 분 정도 |
+| **진행 상황** | 매 반복마다 결승선에 가까워짐 | 각 실행은 독립적, 누적 진행 없음 |
+| **비유** | 마라톤 달리기 — 출발 총이 울리면 결승선에서 멈춤 | 알람 시계 — 정해진 시간에 울리면 끔 |
+| **일반적인 사용** | "테스트 커버리지가 있는 완전한 결제 시스템 구현" | "15분마다 CI가 고장났는지 확인" |
+
+흔한 실수: `/goal`이어야 할 것을 `/loop`에 욱여넣는 것. `/loop 10m "계속 결제 시스템 구현해"`라고 쓰는 것 — 그건 틀렸습니다. `/loop`는 매번 같은 지시를 독립적으로 실행하며, 지난 번에 어디까지 했는지 기억하지 못합니다. 그냥 계속 같은 시작점에서 반복될 뿐입니다.
+
+**어떤 것을 사용해야 할지 판단하는 한 문장 테스트: 이 일에 끝이 있는가?**
+- 끝이 있다 → `/goal`
+- 끝이 없고 계속 지켜봐야 함 → `/loop`
+
+이 강의의 주제인 루프 엔지니어링은 어느 한 명령어에 관한 것이 아닙니다. **이 모든 유형을 포함하는 시스템을 설계할 수 있는 것에 관한 것입니다 — 그래서 여러분이 없어도 에이전트가 계속 작업할 수 있게 하는 것입니다.**
+
+매번 `/goal`을 입력할 필요는 없습니다. 하지만 그것이 어디서 왔고 왜 그런 모습인지 이해하는 것 — 그것이 루프 엔지니어링의 핵심을 이해하는 것입니다. 더 복잡한 루프는 스케줄링, 병렬성, 격리, 메모리 같은 부품을 이 세 가지 기본 요소 위에 얹을 뿐입니다: 목표, 검증, 중단 조건.
+
+## 2026년 6월: 세 사람이 한 주 동안 같은 성냥을 붙였다
+
+2026년 6월 첫째 주, 코딩 에이전트 인프라를 구축하는 세 명의 실무자가 — 서로 의견을 나누지 않고 — 다른 말로 같은 말을 했습니다.
+
+**Peter Steinberger** (OpenClaw 창시자, [그의 글은 8백만 뷰를 돌파](https://x.com/steipete/status/2063697162748260627)): "더 이상 코딩 에이전트에게 프롬프트해서는 안 됩니다. 에이전트에게 프롬프트하는 루프를 설계해야 합니다."
+
+**Boris Cherny** (Anthropic의 Claude Code 책임자, [Acquired 팟캐스트에서](https://x.com/rohanpaul_ai/status/2063289804708835412)): "더 이상 Claude에게 프롬프트하지 않습니다. Claude에게 프롬프트하고 무엇을 해야 할지 알아내는 루프를 돌리고 있습니다. 제 일은 루프를 쓰는 것입니다."
+
+**Addy Osmani** (Google Chrome 엔지니어링 리드)는 2026년 6월 7일에 [이 개념에 이름을 붙이고](https://addyosmani.com/blog/loop-engineering/) 한 줄 정의를 내렸습니다:
+
+> **루프 엔지니어링은 에이전트에게 프롬프트하는 사람으로서의 자신을 대체하는 것입니다. 대신 그 일을 하는 시스템을 설계하는 것입니다.**
+
+Cherny는 수치를 공개했습니다: 연속 30일 이상, Claude Code에 대한 모든 코드 기여는 AI가 자율적으로 수행했습니다 — 259개의 병합된 PR, 프로덕션 코드의 80% 이상이 Claude가 작성했으며, 개방형 소프트웨어 작업에서 76%의 성공률을 보였습니다.
+
+세 사람. 한 주. 같은 결론. 조율해서가 아니라 — 인프라가 조용히 임계점을 넘었기 때문입니다. 에이전트는 감독 없이도 사소하지 않은 작업을 완료할 만큼 충분히 신뢰할 수 있게 되었습니다. 스케줄링 프리미티브(`/loop`, `/goal`, cron)가 이제 도구에 내장되었습니다. 단일 에이전트 실행 비용은 타이머로 반복해서 실행하는 것이 낭비로 보이지 않을 만큼 충분히 낮아졌습니다. 모든 부품이 갖춰지면, 그것들을 결합하는 움직임은 모두에게 동시에 당연해집니다.
+
+> 출처: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## 루프 내부 대 루프 외부
+
+두 가지 구체적인 시나리오를 대조해 봅시다.
+
+**시나리오 A: 여러분이 루프 내부에 있음 (1-12강).**
+
+```mermaid
+flowchart TD
+ You["당신"] -->|"수동으로 지시 입력"| Agent["AI 에이전트"]
+ Agent -->|"결과물 생성"| Result["코드 / 테스트 / 문서"]
+ Result -->|"당신이 검사"| You
+ You -->|"불만족, 지시 수정"| Agent
+ You -->|"만족, 다음 작업으로 이동"| You
+```
+
+완전한 하네스가 있습니다: `AGENTS.md`는 에이전트에게 프로젝트 규칙을 알려주고, `feature_list.json`은 범위를 제한하며, `init.sh`는 일관된 환경을 보장하고, `claude-progress.md`는 진행 상황을 기록합니다. **하지만 모든 단계는 여전히 여러분의 수동 시작이 필요합니다.** 하나의 기능을 마치고, 진행 파일을 읽고, 다음에 무엇을 할지 생각하고, 지시를 입력합니다. 여러분이 전체 워크플로우의 엔진입니다.
+
+**시나리오 B: 여러분이 루프 외부에 있음 (루프 엔지니어링).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["당신이 설계한 루프 시스템"]
+ Trigger["자동 트리거<br/>일정 / 이벤트 / 이전 작업 완료"] --> Discover["작업 발견<br/>진행 파일 / 이슈 트래커 읽기"]
+ Discover --> Dispatch["할당<br/>서브 에이전트 생성"]
+ Dispatch --> Verify["검증<br/>테스트 / 린트 / 독립 리뷰어 에이전트"]
+ Verify --> Persist["상태 저장<br/>진행 업데이트 / 커밋 / PR 오픈"]
+ Persist -->|"남은 작업 있음"| Discover
+ Persist -->|"완료 또는 차단"| Inbox["검토 받은 편지함으로 푸시"]
+ end
+ Inbox -->|"결정만 내면 됨"| You["당신"]
+```
+
+더 이상 지시를 입력하지 않습니다. 여러분이 설계한 시스템이 작업을 발견하고, 할당하고, 결과를 검증하고, 상태를 기록하고, 다음 단계를 결정합니다. 여러분의 역할은 세 가지로 줄어듭니다: **시작하기 전에 목표와 중단 조건을 정의하고, 끝난 후 결과를 검토하고, 시스템이 방향을 잃을 때 규칙을 조정하는 것.** 레버리지는 "올바른 프롬프트를 쓰는 것"에서 "올바른 루프를 설계하는 것"으로 이동합니다.
+
+> Osmani: "1년 전만 해도 루프를 원하면 bash 더미를 쓰고 그 더미를 영원히 유지보수해야 했고 그건 당신 것이고 오직 당신의 것이었습니다. 이제 부품들이 제품 안에 그냥 탑재되어 나옵니다." 처음부터 구축할 필요가 없습니다. 부품들이 어떻게 맞춰지는지 이해하면 됩니다.
+
+## 핵심 개념
+
+- **루프 엔지니어링**: 수동적인 단계별 인간 입력을 대체하여, 에이전트에게 자동으로 프롬프트하는 시스템을 설계하는 것. 인간은 루프 내부에서 외부로 이동하고, 레버리지는 "올바른 프롬프트를 쓰는 것"에서 "올바른 루프를 설계하는 것"으로 이동합니다.
+- **`/goal` 모드**: 가장 단순한 루프 — 목표, 검증 방법, 중단 조건을 제공하면 에이전트가 충족될 때까지 반복합니다. 수동 프롬프팅에서 자율 루프로 가는 다리입니다.
+- **생성자/평가자 분리**: 코드를 작성하는 에이전트와 코드를 검사하는 에이전트는 분리되어야 합니다. 자신의 작업을 채점하는 모델은 믿을 수 없습니다; 때로는 완전히 다른 모델을 사용하는 독립적인 검증자가 모든 루프의 기본 신뢰성 보장 장치입니다.
+- **워크트리 격리**: 각 병렬 에이전트는 독립적인 git 워크트리에서 작업하여 파일 충돌을 물리적으로 방지합니다. 다중 에이전트 병렬 실행을 위한 인프라 전제 조건입니다.
+- **외부 상태**: 단일 대화 외부에 존재하는 메모리 — 마크다운 파일, 이슈 트래커, 칸반 보드. 모델은 실행 사이에 모든 것을 잊어버립니다; 메모리는 디스크에 존재해야 합니다.
+- **네 가지 조용한 비용**: 루프가 오래 실행될수록 더 심각해지는 네 가지 숨겨진 비용 — 검증 부채, 이해 부패, 인지 항복, 토큰 폭발. 루프는 결과물만 가속하는 것이 아니라 위험도 가속합니다.
+
+## 루프의 여섯 가지 프리미티브
+
+Osmani는 루프를 다섯 가지 핵심 빌딩 블록으로 분해했으며, 모두를 관통하는 메모리 레이어 하나를 더했습니다 — 총 여섯 가지이지만, 메모리 레이어는 특별한 지위를 차지합니다: 다른 것들과 같은 수준의 컴포넌트가 아니라; 다른 모든 것이 의존하는 척추입니다.
+
+아래 다이어그램은 여섯 가지를 모두 고리로 그려 한눈에 전체 그림을 볼 수 있게 합니다. 하지만 기억하세요: 외부 상태는 루프의 또 다른 정거장이 아니라 — 전체 루프가 놓여 있는 기반입니다.
+
+```mermaid
+flowchart LR
+ A["자동화<br/>예약된 트리거"] --> W["워크트리<br/>병렬 격리"]
+ W --> S["스킬<br/>문서화된 프로젝트 지식"]
+ S --> C["커넥터<br/>외부 도구 접근"]
+ C --> SA["서브 에이전트<br/>메이커 / 체커 분리"]
+ SA --> ES["외부 상태<br/>반복 간 메모리"]
+ ES --> A
+```
+
+### 1. 자동화 — 심장 박동
+
+자동화가 없으면 루프는 루프가 아닙니다 — 수동으로 한 번 실행한 것에 불과합니다.
+
+Claude Code와 Codex 모두 완전한 스케줄링 시스템을 가지고 있지만, 다른 이름과 레이어를 사용합니다. 가벼운 것부터 무거운 것까지 대략적으로 매핑하면:
+
+| 레이어 | Claude Code | Codex | 비고 |
+|-------|-------------|-------|-------|
+| 세션 내 폴링 | `/loop` | 스레드 자동화 | 현재 세션에 묶여 있으며 세션이 닫히면 종료 |
+| 로컬 예약 작업 | 데스크톱 예약 작업 | 독립 실행형 자동화 (로컬 모드) | 컴퓨터가 켜져 있을 때 실행, 로컬 파일 접근 가능 |
+| 클라우드 예약 작업 | Cloud Routines | — (네이티브 클라우드 스케줄러 없음) | 컴퓨터가 꺼져 있어도 실행 |
+| 이벤트 트리거 | Routines (API / GitHub Webhook) | 독립 실행형 자동화 + 플러그인 | 외부 이벤트에 의해 트리거 |
+| 완전 자체 호스팅 | GitHub Actions / 자체 호스팅 cron | `codex exec` + cron | 완전한 통제 |
+
+**Codex의 Automations 탭**은 스케줄링 진입점입니다. 프로젝트, 프롬프트, 주기, 로컬 체크아웃에서 실행할지 백그라운드 워크트리에서 실행할지를 선택합니다. 무언가를 발견한 실행은 트리아주 받은 편지함에 들어가고; 아무것도 발견하지 못한 실행은 자동 보관됩니다. OpenAI는 내부적으로 일일 이슈 트리아주, CI 실패 요약, 커밋 브리핑, 지난 주에 도입된 버그 찾기에 이것들을 사용합니다.
+
+Codex 자동화는 두 가지 종류가 있습니다:
+- **스레드 자동화** — 스레드에 연결된 하트비트 스타일의 반복적인 알람으로, 컨텍스트를 보존합니다. 오래 실행되는 명령을 모니터링하거나 PR 상태를 폴링하는 것처럼 한 가지 일에 대해 지속적으로 후속 조치를 취하는 데 좋습니다. Claude Code의 상응 기능은 `/loop`입니다.
+- **독립 실행형 자동화** — 각 실행은 새로 시작하며, 결과는 트리아주로 갑니다. 브리핑이나 의존성 스캔처럼 일일/주간 독립적인 작업에 좋습니다. Claude Code의 상응 기능은 데스크톱 예약 작업입니다.
+
+Claude Code의 시스템은 더 세분화된 레이어로 되어 있습니다:
+
+- **`/loop`** — 가벼운 세션 내 예약 반복. 터미널이 열려 있을 때 작동하고 세션이 닫히면 종료되며 7일 후 자동 만료됩니다. 현재 작업 세션 중 임시 모니터링에 좋습니다.
+- **데스크톱 예약 작업** — 컴퓨터가 켜져 있을 때 실행되고 세션 재시작에도 살아남으며, 분 단위 간격이 가능합니다. 로컬 파일 접근이 필요한 반복 작업에 좋습니다.
+- **Cloud Routines** — Anthropic의 클라우드 인프라에서 실행되며 컴퓨터가 꺼져도 살아남고, 최소 1시간 간격입니다. 세 가지 트리거 유형을 지원합니다: 예약, API 호출, GitHub 웹훅. 로컬 환경이 필요 없는 일일 작업에 좋습니다.
+- **GitHub Actions / 자체 호스팅 cron** — 완전히 사용자의 통제 하에 있으며, 원하는 대로 실행할 수 있습니다. 특별한 환경이나 보안 요구 사항이 있는 시나리오에 좋습니다.
+
+```bash
+# Claude Code: 30분마다 테스트 실행하고 실패한 테스트 수정 (현재 세션 내)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: 15분마다 배포 상태 확인
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+자동화는 심장 박동입니다. 이것들이 없으면 루프는 깨어나지 않는 설계도에 불과합니다.
+
+### 2. 워크트리 — 규모에 따른 격리
+
+에이전트를 둘 이상 실행하는 순간, 파일 충돌은 피할 수 없는 실패 모드가 됩니다. 두 에이전트가 같은 파일에 쓰는 것은 두 엔지니어가 서로 상의하지 않고 같은 라인에 커밋하는 것과 똑같은 골칫거리입니다.
+
+`git worktree`가 이것을 해결합니다: 각 에이전트는 자체 디렉토리에서 자체 브랜치로 작업합니다. 물리적으로 서로의 체크아웃을 건드릴 수 없습니다.
+
+Claude Code와 Codex 모두 워크트리 지원을 탑재하고 있습니다. 서브 에이전트에 `--worktree`나 `isolation: worktree`를 사용하면, 각 헬퍼는 깨끗하고 독립적인 체크아웃을 받으며 작업이 끝나면 스스로 정리합니다. 워크트리는 기계적인 충돌 문제를 제거합니다 — 하지만 기억하세요: **여러분의 검토 대역폭이 여전히 상한선입니다.** 얼마나 많은 병렬 에이전트를 감독할 수 있는지가 실제로 몇 개의 워크트리를 실행할 수 있는지를 결정합니다.
+
+### 3. 스킬 — 프로젝트 설명을 반복하지 마세요
+
+스킬은 매 세션마다 같은 프로젝트 컨텍스트를 다시 설명하지 않게 하는 방법입니다. 지침과 메타데이터가 담긴 `SKILL.md`와 선택적인 스크립트, 참고 자료, 에셋이 포함된 폴더입니다.
+
+Codex와 Claude Code는 동일한 형식을 지원합니다. 스킬은 `/skill-name`으로 직접 호출하거나(Codex는 `$skill-name`도 지원), 작업이 스킬 설명과 일치할 때 암시적으로 트리거됩니다.
+
+스킬은 근본적으로 여러분의 의도 부채를 갚는 것에 관한 것입니다. 에이전트는 매 세션을 차갑게 시작합니다 — 여러분의 의도의 빈틈을 자신만의 추측으로 채웁니다. 스킬은 그 의도가 외부에 적혀 있는 것입니다: 규칙, 빌드 단계, "우리는 저번 사건 때문에 이렇게 하지 않아" 같은 것들 — 한 번 쓰고, 매 실행마다 읽습니다.
+
+### 4. 커넥터 — 루프가 실제 도구와 닿게 하라
+
+파일시스템만 볼 수 있는 루프는 작은 루프입니다. 커넥터(MCP 프로토콜 기반)는 에이전트가 이슈 트래커를 읽고, 데이터베이스를 쿼리하고, 스테이징 API를 호출하고, Slack에 메시지를 남길 수 있게 합니다.
+
+Codex와 Claude Code 모두 MCP를 사용하므로, 한쪽에 작성한 커넥터는 보통 다른 쪽에서도 작동합니다. 커넥터는 "여기 수정사항이 있어"와, PR을 열고 Linear 티켓을 연결하고 CI가 초록불이 되면 채널을 알리는 루프 사이의 차이입니다 — 단말기에서만이 아니라, 여러분의 실제 환경 안에서 스스로 말이죠.
+
+### 5. 서브 에이전트 — 메이커를 체커로부터 멀리하라
+
+루프에서 구조적으로 가장 가치 있는 설계 선택은 작성하는 사람과 검사하는 사람을 분리하는 것입니다. 코드를 작성한 모델은 자신의 숙제를 채점할 때 너무 관대합니다. 다른 지시를 받고 때로는 다른 모델을 사용하는 두 번째 에이전트가 첫 번째 에이전트가 스스로 납득해 버린 것을 잡아냅니다.
+
+고전적인 세 역할 분담:
+
+```mermaid
+flowchart LR
+ Explorer["탐색 에이전트<br/>코드베이스 읽기, 이슈 찾기"] --> Implementer["구현 에이전트<br/>수정 작성, 테스트 작성"]
+ Implementer --> Verifier["검증 에이전트<br/>독립 리뷰, 검증 실행"]
+ Verifier -->|"실패"| Implementer
+ Verifier -->|"통과"| Output["결과물"]
+```
+
+Claude Code의 `/goal`은 내부적으로 이것을 실행합니다 — 작업을 수행한 세션이 아니라, 새롭고 독립적인 세션이 루프를 멈춰야 할지 판단합니다. 이것을 **생성자/평가자 분리**라고 하며, 루프 설계에서 단일로 가장 중요한 신뢰성 보장 장치입니다.
+
+### 6. 외부 상태 — 루프의 메모리
+
+모델은 실행 사이에 모든 것을 잊어버립니다. 메모리는 컨텍스트 창이 아니라 디스크에 존재해야 합니다.
+
+이것은 너무 단순해서 중요하지 않게 들릴 수 있지만, 모든 오래 실행되는 에이전트가 의존하는 같은 트릭입니다. 마크다운 파일, Linear 보드 — 단일 대화 외부에 존재하며 무엇이 완료되었고 무엇이 진행 중이며 무엇이 다음인지 담고 있는 것이라면 무엇이든. 에이전트는 잊어버립니다. 리포지토리는 잊지 않습니다.
+
+이 여섯 가지 프리미티브가 여러분의 루프 설계 도구 상자입니다. 모든 루프에 이것들이 모두 필요한 것은 아닙니다. 하지만 언제 어느 것을 꺼내 써야 할지 알아야 합니다.
+
+## 완전한 루프, 해부하기
+
+여섯 가지를 모두 연결하면 실제 아침 트리아주 루프가 어떤 모습인지 알 수 있습니다:
+
+```mermaid
+flowchart TD
+ Trigger["매일 오전 9시<br/>자동화 발동"] --> Read["외부 상태 읽기<br/>어제의 claude-progress.md<br/>열린 GitHub 이슈"]
+ Read --> Triage["트리아주 스킬 발동<br/>발견 사항 분류 및 우선순위 지정"]
+ Triage --> Fork["실행 가능한 항목마다<br/>격리된 워크트리 포크"]
+ Fork --> Implement["구현 서브 에이전트<br/>수정 + 테스트 작성"]
+ Implement --> Verify["검증 서브 에이전트<br/>독립적으로 테스트 + 린트 + 리뷰 실행"]
+ Verify -->|"실패"| Retry["재시도 큐<br/>다른 접근 시도"]
+ Retry --> Implement
+ Verify -->|"통과"| PR["커넥터: PR 오픈<br/>이슈 연결, 진행 파일 업데이트"]
+ PR --> Memory["외부 상태에 쓰기<br/>claude-progress.md 업데이트<br/>이번 라운드 결과 기록"]
+ Memory -->|"남은 작업 있음"| Fork
+ Memory -->|"모두 완료 또는 차단"| Inbox["결과가 트리아주 받은 편지함에 도착<br/>검토 대기 중"]
+```
+
+이것은 더 이상 단일 에이전트 실행이 아닙니다. 매일 아침 깨어나서 스스로 정리하고 여러분의 주의가 필요한 것들을 앞에 내놓는, 지속적으로 작동하는 시스템입니다. 여러분의 역할은 다음과 같습니다: **받은 편지함 내용을 검토하고, 결정을 내리고, 시스템이 처리할 수 없는 패턴을 발견하면 스킬과 규칙을 개선하는 것.**
+
+Cherny는 이 패턴을 사용하여 IDE를 한 번도 열지 않고 30일 만에 259개의 PR을 병합했습니다. OpenAI 엔지니어들은 같은 패턴을 사용하여 대략 백만 줄 규모의 베타 제품을 손으로 — 직접 코드를 한 줄도 쓰지 않고 구축했습니다.
+
+## 생성자/평가자 분리: 왜 모델이 자신의 작업을 채점하게 하면 안 되는가
+
+이것은 루프 엔지니어링에서 가장 어려운 교훈입니다.
+
+가장 똑똑한 에이전트가 아름다운 코드를 작성합니다. 로직은 명확하고, 주석은 철저하며, 모든 함수에는 테스트가 있습니다. 여러분은 만족합니다.
+
+하지만 질문이 있습니다: **그 코드를 작성한 에이전트가 자기가 잘했는지 판단하게 하면, 뭐라고 할까요?**
+
+그 답은 경험을 통해 거듭 확인되었습니다: 스스로 높은 점수를 줄 것입니다. 부정직해서가 아니라, 작성자이기 때문입니다 — 생성하는 동안 이 경로가 옳다고 스스로 납득했기 때문입니다. 뒤돌아 볼 때, 실수를 보는 것이 아니라 자신의 추론 과정을 보는 것입니다.
+
+이것은 Claude의 문제가 아닙니다. GPT의 문제가 아닙니다. 이것은 모든 생성 모델의 속성입니다. **모델은 자신의 출력물의 최고 변호사입니다.**
+
+해결책: 같은 존재(같은 모델, 같은 프롬프트)가 작업과 리뷰를 모두 하게 하지 마세요.
+
+- Claude Code의 `/goal`은 목표가 달성되었는지 판단하기 위해 독립적인 감독자 세션을 사용합니다 — 시도한 세션이 아니라.
+- Codex의 서브 에이전트 시스템을 사용하면 다른 모델과 다른 추론 노력으로 검증자 에이전트를 정의할 수 있습니다.
+- "적대적 검증"이라는 커뮤니티 관행은 발견 사항마다 N명의 독립적인 회의론자를 생성하며, 각자는 반박하도록 프롬프트됩니다 — 다수가 거부하면 발견 사항은 폐기됩니다.
+
+기억할 한 문장: **당신의 팀원 중 누군가는 당신을 믿지 않아야 합니다.**
+
+## Karpathy의 autoresearch: 루프의 모범 사례
+
+잘 설계되고 실제로 돌아가는 루프가 어떤 모습인지 보고 싶다면, [Karpathy의 autoresearch](https://github.com/karpathy/autoresearch)가 교과서적인 예시입니다.
+
+2026년 3월, Karpathy는 630줄짜리 Python 프로젝트를 공개했습니다. GPU 하나와 연구 방향만 주면 밤새도록 실행됩니다 — 수백 개의 ML 훈련 실험을 완료하고, 진정으로 개선된 것만 남깁니다. 이 프로젝트는 공개된 지 며칠 만에 66,000개 이상의 스타를 받았습니다.
+
+### 세 개의 파일, 세 가지 역할
+
+전체 시스템에는 핵심 파일이 세 개뿐이지만, 역할 분담은 매우 명확합니다:
+
+| 파일 | 누가 편집하는가 | 하는 일 |
+|------|-------------|-------------|
+| `prepare.py` | 아무도 (읽기 전용) | 데이터 준비, 토크나이저, 평가 하네스. 고정된 인프라. |
+| `train.py` (~630줄) | **AI 에이전트** | 모델 정의, 옵티마이저, 훈련 루프. 에이전트의 놀이터 — 무엇이든 바꿀 수 있음. |
+| `program.md` | **당신** | 자연어로 작성된 연구 방법론. 당신은 이것만 편집합니다. 에이전트에게 어떻게 탐색하고, 어떻게 평가하며, 무엇을 건드리지 말아야 할지 알려줍니다. |
+
+이 삼자 분할이 설계의 핵심입니다: **인간은 코드를 건드리지 않고, 방향을 건드립니다; 에이전트는 방향을 건드리지 않고, 코드를 건드립니다.** 여러분의 일은 Python을 쓰는 것에서 "연구 조직 문화를 쓰는 것"으로 바뀝니다.
+
+### 입력: program.md의 모습
+
+`program.md`는 루프의 두뇌입니다. 코드가 아니라 — 마크다운으로 작성된 연구 지침서입니다. 대략 다음을 담고 있습니다:
+
+- **목표**: `val_bpb` 최적화 (검증 바이트 당 비트, 낮을수록 좋음)
+- **제약 조건**: `prepare.py`는 건드리지 말 것, VRAM 예산 내에서 유지, 고정 5분 훈련
+- **탐색 방향**: 다른 아키텍처, 옵티마이저, LR 스케줄 시도
+- **평가 규칙**: 무엇을 개선으로 간주하는지, 결과를 어떻게 기록하는지, 실패 시 무엇을 하는지
+- **철칙**: 절대 멈추지 마라. 루프가 시작되면 영원히 계속해라
+
+에이전트에게 주는 시작 프롬프트는 한 문장처럼 짧을 수 있습니다:
+
+```
+program.md를 한번 보고 새 실험을 시작해봅시다!
+```
+
+나머지는 에이전트가 문서를 읽고 스스로 결정하는 것입니다.
+
+### 아홉 단계 래칫 루프
+
+autoresearch의 핵심은 **래칫**입니다 — 앞으로만 나가고 뒤로는 절대 가지 않습니다. 각 반복은 엄격하게 아홉 단계를 따릅니다:
+
+```mermaid
+flowchart TD
+ 1["1. 방향 읽기<br/>program.md 로드"] --> 2["2. 현재 상태 조사<br/>train.py + 과거 결과 읽기"]
+ 2 --> 3["3. 가설 제안<br/>시도해볼 변경 생각하기"]
+ 3 --> 4["4. 코드 수정<br/>train.py 편집"]
+ 4 --> 5["5. 스냅샷<br/>git commit"]
+ 5 --> 6["6. 훈련 실행<br/>고정 5분 실제 시간"]
+ 6 --> 7{"7. 평가<br/>val_bpb가 개선되었는가?"}
+ 7 -->|예| 8a["8a. 유지<br/>커밋 유지<br/>results.tsv에 기록"]
+ 7 -->|아니오| 8b["8b. 되돌리기<br/>git reset HEAD~1<br/>실패 기록"]
+ 8a --> 9["9. 다음 라운드<br/>1단계로 돌아가기"]
+ 8b --> 9
+```
+
+대략 시간당 12개의 실험을 실행합니다. 밤새 실행(8시간)하면 약 100개의 실험이 됩니다. Karpathy 본인은 2일 동안 실행했습니다 — 약 700개의 실험.
+
+고정된 5분 실제 시간 예산은 핵심 설계 선택입니다 — 에이전트가 무엇을 바꾸든, 모든 실험은 정확히 같은 시간이 걸립니다. 이것은 모든 결과가 같은 시간 예산 하에서 직접 비교 가능하다는 것을 의미합니다 — "이건 더 오래 돌렸으니 더 좋아" 같은 논쟁이 없습니다.
+
+### 출력: 잠에서 깼을 때 보이는 것
+
+밤새 루프를 돌리고 나면, 아침에 앉아서 세 가지를 발견하게 됩니다:
+
+**1. Git 히스토리 (앞으로만 나아가는 래칫)**
+
+실제로 개선된 커밋만 메인 브랜치에 남습니다. 실패한 모든 것은 롤백되었습니다. `git log`는 검증된 연구 로그입니다.
+
+**2. results.tsv (전체 실험 기록)**
+
+단일 실험마다 — 성공이든 실패든 — 기록됩니다:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. 연구 로그 (에이전트 자신의 요약)**
+
+에이전트는 무엇을 시도했고, 무엇이 효과가 있었고, 무엇이 효과가 없었고, 다음에 무엇을 시도할 계획인지에 대해 명확한 커밋 메시지를 작성합니다. 여러분은 그것들을 읽습니다 — 코드 diff를 읽을 필요가 없습니다.
+
+### 실제로 무엇을 발견했는가
+
+Karpathy의 초기 2일, 약 700개 실험 실행 결과:
+
+- 약 700번의 시도 중, **누적 가능한 실제 개선 사항이 약 20개** 발견되었습니다
+- nanochat의 GPT-2 수준 훈련 시간을 8×H100에서 **2.02시간 → 1.80시간**으로 단축했으며, 약 **11% 더 빨라졌습니다**
+- 발견 사항에는 학습률 조정, 옵티마이저 튜닝, 활성화 함수 교체, 어텐션 패턴 최적화 등이 포함되었습니다
+
+모든 개선 사항이 충격적인 발견이었을까요? 아닙니다. 대부분은 누적되는 작은 최적화였습니다. 하지만 그 20개의 유효한 개선 사항은 인간 연구자가 몇 주 동안 수동으로 작업했을 것입니다 — 에이전트는 48시간 만에 해냈습니다.
+
+### 가장 시사하는 디테일: 루프는 코드가 아니라 영어로 쓰여 있다
+
+`program.md`는 Python 스크립트가 아니라 마크다운 문서입니다. 연구 방법론을 설명합니다 — 무엇을 수정하고, 무엇을 건드리지 말며, 어떻게 평가하고, 실패 사례를 어떻게 처리하는지, 그리고 하나의 철칙: **인간의 도움을 요청하지 마라, 그냥 계속해라.** 코딩 에이전트가 이 문서를 읽고 무한정 실행합니다.
+
+이것이 루프 엔지니어링의 템플릿입니다: 에이전트에게 작업을 주지 마세요. **방법론**을 주세요. 방법론이 루프가 되게 하세요. 하나의 `program.md`, 630줄의 접착 코드, 그리고 나머지 모든 것은 에이전트가 스스로 실행하는 것입니다.
+
+## 네 가지 조용한 비용
+
+루프가 실행되기 시작하면, 문제를 즉시 보지 못할 것입니다. 다음 네 가지 비용이 조용히 쌓이며, 알아차릴 때쯤에는 이미 큰 대가를 치렀을 수 있습니다.
+
+### 1. 검증 부채
+
+빠른 루프는 검증을 건너뛰게 유혹합니다. "괜찮아 보여"는 "확인된 정답"과 같지 않습니다. 루프가 감독 없이 생성하는 코드가 많을수록 검증 부채는 더 빨리 쌓입니다. 해결책: **중단 조건은 기계로 검증 가능해야 하며, 절대 "대충 맞는 느낌"이어서는 안 됩니다.**
+
+### 2. 이해 부패
+
+루프가 코드를 더 빨리 배포할수록, 여러분의 자신의 코드베이스에 대한 이해는 현실에서 더 멀어집니다. Cherny의 팀은 코드의 80%를 에이전트가 작성했습니다 — 팀 코드의 대부분이 사람이 작성하지 않았다는 의미입니다. 루프가 생산하는 것을 읽고 사용하지 않으면, 여러분의 이해는 지속적으로 쇠퇴합니다. **빠른 루프는 빠른 읽기를 요구합니다.**
+
+### 3. 인지 항복
+
+루프가 순조롭게 돌아가면, 가장 편안한 자세는 의견을 갖지 않는 것입니다. 주는 대로 받고, 결과물에 대해 생각하지 않는 것입니다. 하지만 그것이 바로 위험이 시작되는 곳입니다 — 루프를 생각을 증폭시키는 데 쓰는 것이 아니라, 생각을 피하는 데 쓰고 있는 것입니다. Osmani의 경고: "두 사람이 똑같은 루프를 만들고도 정반대의 결과를 얻을 수 있습니다. 한 사람은 이해하는 일에서 더 빨리 가기 위해 그것을 사용하고; 다른 사람은 일을 이해하는 것을 피하기 위해 그것을 사용합니다. 루프는 그 차이를 모릅니다. 당신은 알고요."
+
+### 4. 토큰 폭발
+
+루프의 매 반복은 더 많은 컨텍스트를 축적합니다: 작성된 코드, 마주친 오류, 내려진 결정. 컨텍스트 관리가 없으면, 프롬프트 크기는 턴 수에 따라 대략 2차 함수적으로 증가합니다. Codex는 자동 컨텍스트 압축으로 이것을 해결합니다 — 전용 API가 이전 대화 턴을 암호화된 내용 요약으로 압축하여, 필수 지식은 유지하면서 중복된 세부 사항은 버립니다. 이것은 나중에 덧붙이는 것이 아니라, 첫 루프부터 다루어야 하는 엔지니어링 문제입니다.
+
+## 첫 번째 루프 구축하기
+
+Stripe 규모의 파이프라인이 주 1,300개의 PR을 병합하는 것부터 시작할 필요는 없습니다. 작동하는 가장 작은 것부터 시작하세요.
+
+### 1단계: 반복적인 작업 하나 고르기
+
+일주일에 적어도 두 번은 수동으로 하는 것을 찾으세요. 예시:
+- 아침에 GitHub를 열고 새 이슈를 확인하고, 분류하고 응답하기
+- 모든 PR 리뷰 전에 린트와 테스트 실행하기
+- 매일 끝에 진행 문서 업데이트하기
+
+### 2단계: 목표와 중단 조건 작성하기
+
+작업을 `/goal`이 이해할 수 있는 것으로 바꾸세요:
+
+```markdown
+목표: 리포지토리에서 가장 최근 이슈 10개를 확인합니다.
+각 이슈마다:
+ - 이미 명확한 레이블과 담당자가 있으면 건너뛴다
+ - 태그가 없으면 내용에 따라 적절한 레이블을 추가한다
+ - 10분 이내에 고칠 수 있으면 브랜치를 만들고 수정을 시도한다
+중단 조건: 모든 해당 이슈가 처리되었거나, 인간의 결정이 필요한 이슈가 있을 때.
+```
+
+### 3단계: 메이커와 체커 분리하기
+
+같은 에이전트가 코드를 작성하고 판단하게 하지 마세요. 루프를 두 역할로 나누세요:
+- 구현자: 이슈를 읽고, 수정을 작성하고, 테스트를 작성합니다
+- 검증자: 독립적으로 테스트를 실행하고, diff를 리뷰하고, 수정이 실제로 문제를 해결하는지 판단합니다
+
+### 4단계: 메모리 추가하기
+
+마크다운 파일을 사용하여 각 루프 실행에서 무슨 일이 있었는지 기록하세요. 다음 실행은 이 파일을 읽고 시작합니다 — 무엇이 완료되었고, 무엇이 보류 중이며, 무엇이 차단되었는지 알 수 있습니다. 이것은 어떤 복잡한 데이터베이스보다 낫습니다.
+
+### 5단계: 타이머 설정하기
+
+`/loop`나 OS cron을 사용하여 루프가 여러분 없이도 시작하게 하세요. 하루에 한 번으로 시작하세요. 일주일 동안 관찰하세요.
+
+### 성숙도 사다리
+
+한 번에 정상에 도달할 필요는 없습니다. 루프 도입은 사다리입니다:
+
+1. **레벨 1: 목표 실행자** — `/goal`을 사용하여 중단 조건이 있는 작업을 줄 수 있습니다; 에이전트가 충족될 때까지 반복합니다.
+2. **레벨 2: 예약된 단일 작업** — 하나의 자동화가 타이머로 하나의 작업을 실행합니다 (예: 아침 CI 확인).
+3. **레벨 3: 다중 에이전트 루프** — 메이커와 체커가 분리됨; 각 발견 사항마다 격리된 워크트리를 포크합니다.
+4. **레벨 4: 자기 공급 루프** — 루프가 외부 상태에서 다음 작업을 스스로 발견합니다; 다음에 무엇을 할지 스스로 결정합니다.
+5. **레벨 5: 함대 오케스트레이션** — 여러 루프가 병렬로 실행되며, 독립적이지만 메모리 레이어를 공유합니다.
+
+대부분의 팀은 현재 레벨 2와 레벨 3 사이에 있습니다. 레벨 1이 성과를 보는 가장 빠른 길입니다.
+
+## 핵심 요약
+
+- **루프 엔지니어링은 하네스 엔지니어링을 대체하지 않습니다 — 그 위에 한 층을 더 쌓을 뿐입니다.** 하네스는 단일 실행을 신뢰할 수 있게 만듭니다. 루프는 지속적인 실행을 자율적으로 만듭니다.
+- **`/goal`은 가장 단순한 루프입니다:** 목표 + 검증 + 중단 조건. 이 세 가지가 여러분을 루프 내부에서 외부로 이동시킵니다.
+- **여섯 가지 프리미티브 (자동화 / 워크트리 / 스킬 / 커넥터 / 서브 에이전트 / 외부 상태)가 루프의 빌딩 블록입니다.** 매번 모두 필요한 것은 아니지만, 언제 어느 것을 꺼내 써야 할지 알아야 합니다.
+- **메이커와 체커는 분리되어야 합니다.** 자신의 작업을 채점하는 모델은 믿을 수 없습니다. 때로는 완전히 다른 모델인 독립적인 검증자가 모든 루프의 기본 신뢰성 보장 장치입니다.
+- **루프는 생성을 거의 공짜로 만들고 판단을 희소 자원으로 남깁니다.** 절약한 시간을 쉬는 데 쓰지 마세요. 더 많은 판단을 내리는 데 쓰세요.
+- **루프가 오래 실행될수록 네 가지 조용한 비용은 더 심각해집니다:** 검증 부채, 이해 부패, 인지 항복, 토큰 폭발. 루프는 결과물을 가속합니다 — 그리고 위험도.
+- **작게 시작하세요.** 하나의 `/goal`, 하나의 cron, 하나의 마크다운 메모리 파일. 성과를 확인하고, 그 다음 위로 쌓아 올리세요.
+
+## 더 읽을거리
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — 50개의 실제 루프로 구성된 공개 코퍼스
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- 12강: [모든 세션은 깨끗한 상태를 남겨야 합니다](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — 루프의 전제 조건: 각 세션이 깨끗한 상태를 남겨야 다음 라운드가 자동으로 시작될 수 있음
+- 5강: [오래 실행되는 작업을 세션 간에 연속적으로 유지하는 이유](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — 외부 상태와 메모리에 대한 선행 지식
+- 11강: [왜 관찰 가능성은 하네스 내부에 속하는가](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — 루프가 빠르게 실행될수록 문제를 잡기 위해 관찰 가능성이 더 필요함
+- 8강: [왜 기능 목록은 하네스 프리미티브인가](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — 기능 목록은 자기 공급 루프가 다음 작업을 발견하기 위한 자연스러운 데이터 소스임
+
+## 연습문제
+
+1. **반복적인 작업을 `/goal`로 바꾸기:** 일주일에 적어도 두 번은 수동으로 하는 것을 찾으세요. 목표, 검증 방법, 중단 조건을 적어보세요. `/goal`로 한 번 실행해보고 수동으로 하는 것과 시간과 품질을 비교해보세요. 이것이 하네스에서 루프로 가는 여러분의 첫걸음입니다.
+
+2. **메이커와 체커 분리하기:** 이전에 에이전트가 실행했던 작업을 하나 고르세요. 이번에는 두 가지 다른 프롬프트를 작성하세요: 구현자 에이전트를 위한 것과 검증자 에이전트를 위한 것입니다 (다른 모델을 사용하세요 — 예: 구현에는 Claude, 검증에는 GPT, 또는 그 반대로). 검증자는 구체적인 이슈를 증거와 함께 지적해야 합니다. 각 모드에서 발견된 이슈의 수와 유형을 기록하세요.
+
+3. **루프에 메모리 주기:** 루프를 위한 마크다운 상태 파일을 만드세요. 각 반복마다 다음을 적으세요: 이번 라운드에 한 일, 검증 결과, 상태 (통과/실패/차단), 다음에 할 일. 세 라운드를 실행하고 메모리 파일이 있을 때와 없을 때의 행동 차이를 관찰하세요.
+
+4. **루프의 조용한 비용 감사하기:** 루프가 한 시간 동안 실행된 후, 다음 네 가지 지표를 평가하세요:
+ - 얼마나 많은 검증이 "기계로 확인됨"이 아니라 "그냥 맞는 느낌"이었는가? (검증 부채)
+ - 루프가 가장 최근에 생성한 코드를 얼마나 잘 설명할 수 있는가? (이해 부패)
+ - "나중에 볼게"라고 생각하고 결국 보지 않은 횟수는 몇 번인가? (인지 항복)
+ - 루프의 컨텍스트 크기는 어떻게 변하고 있는가? 중복된 정보를 반복하고 있는가? (토큰 폭발)
diff --git a/docs/ko/projects/project-07-loop-engineering-first-loop/index.md b/docs/ko/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..198020a
--- /dev/null
+++ b/docs/ko/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# 프로젝트 07. 첫 번째 자동 루프 구축하기
+
+> 관련 강의: [L13. 왜 에이전트에게 프롬프트하는 것을 그만둬야 하는가](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## 할 일
+
+이것은 "하네스"에서 "루프"로 넘어가는 전환 프로젝트입니다. 여러분은 이미 적절한 환경, 지침, 피드백으로 에이전트를 설정하는 방법을 알고 있습니다 — 이제 그 설정을 스스로 돌아가는 루프로 바꿀 것입니다.
+
+세 가지 점진적인 실험을 할 것입니다: 먼저 작업을 수동에서 `/goal`으로 바꾸고, 그 다음 모니터링 작업을 `/loop` 타이머로 바꾸고, 마지막으로 완전한 메이커-체커 루프를 구축하여 **여러분이 루프 밖으로 나갔을 때 어떤 느낌인지** 경험할 것입니다.
+
+## 프로젝트 파일
+
+리포지토리 경로: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| 디렉토리 | 내용 | 하는 일 |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | 완전한 하네스(P06 최종 상태)가 있는 작은 지식 베이스 프로젝트로, AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md가 포함되어 있습니다. | 이 하네스를 자동으로 반복할 수 있는 하네스로 바꾸세요. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | 목표 루프, 타이머 루프, 메이커-체커 루프라는 세 가지 루프의 완전한 구현체와 루프 상태 파일, 검증 스크립트가 포함되어 있습니다. | 루프 설계 패턴과 상태 관리의 참고 자료 |
+
+## 사용할 도구
+
+- Claude Code 또는 Codex
+- Git
+- P06에서 가져온 완전한 하네스
+- 터미널 멀티플렉서 (tmux 또는 screen, 오래 실행되는 루프 관찰용)
+- 선택 사항: GitHub Actions 또는 cron (고급 이벤트 기반 / 예약 실험용)
+
+## 단계
+
+### 준비
+
+1. P06를 마쳤던 같은 커밋에서 시작하세요.
+2. 세 개의 브랜치를 만드세요: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. 하네스가 작동하는지 확인하세요: init.sh를 실행하고, 상태 파일, 기능 목록, 인계 문서가 모두 제자리에 있는지 확인하세요.
+4. 루프가 반복적으로 작업할 **대상 작업**을 하나 고르세요. 완료 기준이 명확한 중간 규모의 작업을 고르세요 — 예: "모든 모듈에 단위 테스트를 추가하여 80% 커버리지 달성" 또는 "모든 API 엔드포인트에 입력 유효성 검사 추가".
+
+### 실험 1: 목표 루프 — 수동 실행에서 자동 실행으로
+
+`p07-goal-loop` 브랜치로 전환하세요.
+
+1. **목표 설명 작성**: 선택한 작업을 `goal.md` 파일로 만드세요. 다음을 포함합니다:
+ - 명확한 목표 ("무엇이 완료로 간주되는가")
+ - 검증 방법 ("어떻게 완료를 확인하는가" — 테스트 실행? 린트 실행? 커버리지 확인?)
+ - 중단 조건 ("언제 멈춰야 하는가" — 최대 턴? 시간 제한? 예산 제한?)
+ - 제약 조건 ("무엇을 건드리지 말아야 하는가" — 프로덕션 설정, 데이터베이스 스키마 등)
+
+2. **첫 수동 실행**: 직접 에이전트에게 작업을 수동으로 주세요. 몇 턴이 걸렸는지, 몇 번 개입했는지, 결과 품질이 어땠는지 기록하세요. 이것이 여러분의 기준선입니다.
+
+3. **`/goal`로 실행**: 같은 `goal.md`를 입력으로 사용하여 `/goal` 모드로 실행하세요. 에이전트는 목표가 달성되거나 중단 조건이 발동될 때까지 스스로 반복합니다.
+
+4. **결과 비교**:
+ - 턴 수의 차이
+ - 개입 횟수의 차이
+ - 결과 품질의 차이 (같은 검증 기준 사용)
+ - 소요 시간의 차이
+
+5. **goal.md 반복하기**: 결과가 좋지 않으면 목표 설명을 수정하고 다시 실행하세요. 결과에 만족하거나, 이 작업에서 목표 루프가 할 수 있는 한계를 확인할 때까지 계속하세요.
+
+### 실험 2: 타이머 루프 — 모니터링을 심장 박동으로 바꾸기
+
+`p07-timer-loop` 브랜치로 전환하세요.
+
+1. **모니터링 작업 고르기**: 평소에 수동으로 하는 반복적인 확인을 찾으세요. 예를 들어:
+ - 매시간 테스트 스위트 실행하고 실패한 것 고치기
+ - 매일 아침 의존성 보안 업데이트 확인하기
+ - 매 커밋마다 코딩 스타일 위반 확인하기
+ - 주기적으로 TODO 주석을 스캔하여 오래된 것 확인하기
+
+2. **모니터링 프롬프트/스크립트 작성**: 모니터링 단계를 명확하게 적으세요 — 무엇을 확인할지, 문제가 발견되면 무엇을 할지, 언제 인간을 호출할지.
+
+3. **`/loop` (또는 Codex 스레드 자동화)로 실행**:
+ - 적절한 간격을 설정하세요 (10-30분 권장 — 너무 짧으면 짜증나고 너무 길면 효과를 못 봄)
+ - 최소 2시간 동안 실행하세요 (또는 다른 일을 하고 나중에 돌아오세요)
+
+4. **결과 기록**:
+ - 몇 개의 문제를 발견했는가?
+ - 몇 개를 스스로 고쳤는가?
+ - 몇 개가 거짓 양성이었는가?
+ - 몇 개를 더 악화시켰는가?
+ - 결과를 후속 조치하는 데 얼마나 시간을 썼는가?
+
+5. **반성하기**: 이 모니터링 작업을 자동화할 가치가 있는가? 절약한 시간과 후속 조치에 쓴 시간을 비교해보세요. 가치가 없다면, 잘못된 작업을 고른 것인가, 아니면 루프가 잘못 설계된 것인가?
+
+### 실험 3: 메이커-체커 루프 — 루프에서 자신을 빼내기
+
+`p07-maker-checker` 브랜치로 전환하세요.
+
+이것은 세 실험 중 가장 중요합니다. **여러분이 거기 없어도 돌아가는 완전한 루프**를 구축할 것입니다:
+
+1. **루프 구조 설계**:
+ - **메이커 에이전트**: 구현하고, 코드를 작성하고, 파일을 수정합니다
+ - **체커 에이전트**: 검증하고, 테스트를 실행하고, 코드 리뷰를 하고, 통과 / 실패를 판단합니다
+ - **상태 파일** (`loop-state.md`): 현재 라운드, 한 일, 검증 결과, 다음 할 일을 기록합니다
+ - **중단 조건**: N회 연속 통과, 또는 최대 라운드 도달
+
+2. **세 개의 프롬프트 작성**:
+ - 메이커 지침 (무엇을 할지, 어떻게 할지, 무엇을 건드리지 말아야 할지)
+ - 체커 지침 (무엇을 검증할지, 어떻게 검증할지, 무엇을 통과로 간주할지, 어떻게 피드백을 줄지)
+ - 루프 제어 로직 (누가 먼저 하는지, 인계가 어떻게 작동하는지, 다음 라운드를 어떻게 시작하는지)
+
+3. **최소 5라운드 실행**:
+ - 1라운드: 메이커 구현 → 체커 검증 → 실패 → 메이커에게 피드백
+ - 2라운드: 메이커가 피드백 기반으로 수정 → 체커 검증 → ...
+ - ...
+ - 연속 통과할 때까지, 또는 당신이 중단할 때까지
+
+4. **각 라운드의 상태 기록**:
+ - 라운드 번호
+ - 메이커가 한 일
+ - 체커가 발견한 문제점
+ - 통과 / 실패
+ - 당신이 개입했는가? (했다면 왜?)
+
+5. **최종 회고**:
+ - 몇 번 개입했는가? 왜?
+ - 개입하지 않았다면 무슨 일이 벌어졌을까?
+ - 체커가 놓친 문제가 있는가?
+ - 메이커가 계속 같은 실수를 저지르는가?
+ - 이 루프의 품질 상한선은 어디인가? 메이커 역량인가, 아니면 체커 역량인가?
+
+## 결과 측정 방법
+
+| 지표 | 실험 1 (목표) | 실험 2 (타이머) | 실험 3 (메이커-체커) |
+|--------|-------------|--------------|----------------------|
+| 작업 완료율 | 목표에 도달했는가? | 몇 개의 모니터링 사이클이 실행되었는가? | 통과할 때까지 몇 라운드가 걸렸는가? |
+| 인간 개입 | 몇 번 개입했는가? | 후속 조치에 얼마나 시간을 썼는가? | 몇 번 개입했는가? |
+| 결과 품질 | 수동과 비교했을 때 어때? | 거짓 양성률? 놓친 이슈? | 체커가 당신이 못 찾았을 문제를 몇 개나 찾았는가? |
+| 절약 시간 | 얼마나 시간을 절약했는가? | 자동화할 가치가 있는가? | 루프를 설계하는 데 쓴 시간 대비 절약한 시간 |
+| 신뢰성 | 중단 조건이 믿을만했는가? | 통제 불능이 되었는가? | 루프가 같은 곳에서 막힐 수 있는가? |
+
+## 제출할 것
+
+- `goal.md` (실험 1의 목표 설명, 최소 두 번의 반복)
+- 실험 1 비교 노트: 수동 대 목표 루프
+- 실험 2 모니터링 프롬프트 + 2시간 실행 로그
+- 실험 3의 세 가지 프롬프트 (메이커 / 체커 / 루프 제어)
+- 실험 3의 `loop-state.md` (최소 5라운드 기록)
+- 최종 회고: 세 실험 모두에서 얻은 교훈, 루프 엔지니어링에 대한 여러분의 이해가 어떻게 바뀌었는지, 어떤 것들이 루프화할 좋은 후보이고 어떤 것들은 아닌지
+
+## 관련 강의
+
+- [13강 — 왜 에이전트에게 프롬프트하는 것을 그만둬야 하는가](../../lectures/lecture-13-loop-engineering/index.md)
+- [12강 — 왜 모든 세션은 깨끗한 상태를 남겨야 하는가](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (루프의 모든 라운드에는 깨끗한 상태가 필요합니다)
+- [11강 — 왜 관찰 가능성은 하네스 내부에 속하는가](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (루프 내부에서 무슨 일이 일어나는지 볼 수 있어야 합니다)
+- [5강 — 왜 상태 파일은 연속성의 중심인가](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (루프 상태 파일은 상태 파일의 확장입니다)
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/code/index.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/pt-BR/lectures/lecture-13-loop-engineering/index.md b/docs/pt-BR/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..33489f0
--- /dev/null
+++ b/docs/pt-BR/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Exemplos de código: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/pt-BR/lectures/lecture-13-loop-engineering/code/)
+> Projeto prático: [Projeto 07. Construa Seu Primeiro Loop Automatizado](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Aula 13. Do Prompting Manual aos Loops Autônomos
+
+Tudo o que você aprendeu nas primeiras doze aulas se baseia em uma premissa: **você está sentado ao teclado, digitando instruções uma de cada vez.**
+
+Você escreveu o `AGENTS.md` (Aulas 1–4), construiu o gerenciamento de estado (Aulas 5–6), restringiu o escopo com listas de funcionalidades (Aulas 7–8), deixou transferências limpas ao final das sessões (Aulas 9, 12) e tornou o runtime observável (Aulas 10–11). Mas o gatilho para tudo isso sempre foi você. O agente nunca decidiu por conta própria quando começar a trabalhar — porque ninguém pressionou "iniciar".
+
+Esta aula trata de entregar o botão de iniciar ao sistema. Não é abrir mão do controle — é elevá-lo ao próximo nível.
+
+## /goal: O Loop Mais Simples Possível
+
+A melhor entrada para a engenharia de loops não é um diagrama de arquitetura complexo — é um único comando.
+
+No início de 2026, o Claude Code e o OpenAI Codex lançaram independentemente o mesmo recurso: `/goal`. Você digita no terminal:
+
+```
+/goal "Todos os testes passam, zero avisos de lint, merge na main"
+```
+
+Depois você fecha o laptop e vai dormir. Oito horas depois, o agente analisou, codificou, testou, corrigiu e mesclou por conta própria. Ele tenta novamente em caso de falha, muda de abordagem quando fica preso e para quando termina — sem você ficar de olho dizendo "tente de novo".
+
+A única diferença entre `/goal` e um prompt tradicional é uma coisa. Mas essa coisa muda tudo:
+
+| | Prompt Tradicional | `/goal` |
+|---|---|---|
+| O que você fornece | O que fazer em seguida | Como é o estado final |
+| O que o agente faz | Executa uma vez | Repete até atingir |
+| Quem julga se terminou | Você | Uma condição de parada verificável |
+| Quando você pode ir embora | Não pode | No momento em que digita `/goal` |
+
+`/goal` é essencialmente um loop. Ele tem exatamente três partes: **um objetivo, um método de verificação e uma condição de parada.** Apenas essas três coisas movem você de dentro do loop para fora dele.
+
+### Como `/goal` Cresceu Organicamente
+
+`/goal` não pulou de 0 para 1 do nada. Ele cresceu gradualmente a partir de fluxos de trabalho cotidianos, passando por aproximadamente quatro estágios:
+
+**Estágio 1: Prompting manual um a um.** A forma mais antiga de trabalhar era de ida e volta: "escreva uma função", "adicione um teste", "conserte essa lógica". O agente parava após cada passo e esperava você dizer o que vem a seguir. Você era o agendador de todo o pipeline.
+
+**Estágio 2: Prompts longos com múltiplos passos.** Depois as pessoas começaram a escrever prompts mais longos que empilhavam passos: "primeiro analise o código, depois escreva a implementação, depois execute os testes e, se falharem, conserte-os". O agente podia executar vários passos de uma vez, mas você ainda tinha que observar — porque ele poderia desviar no meio do caminho, ou terminar um passo e não saber o que fazer em seguida.
+
+**Estágio 3: Auto-reflexão e autodireção do agente.** Depois disso, os agentes ganharam "introspecção" — após cada passo eles olhavam o resultado e decidiam o que fazer em seguida. Você dava um objetivo, e eles o decompunham sozinhos e tentavam novamente por conta própria. Mas um problema surgiu: quando eles param? "Estou pronto" vindo do próprio agente conta? A prática sempre respondia — não. Os agentes declaram vitória com muita facilidade.
+
+**Estágio 4: Julgamento de parada independente — `/goal`.** O passo final foi tirar "julgar se está pronto" das mãos do agente que faz o trabalho e entregar a um juiz independente. Pode ser um modelo diferente, um script ou um comando de teste — mas a regra era a mesma: quem escreve o código não pode corrigir a própria lição de casa. Neste ponto, `/goal` realmente funcionou: você dá o objetivo, ele repete, um juiz independente decide quando parar, e você pode ir embora.
+
+Esses quatro estágios não foram um roteiro planejado por nenhuma empresa. Eles foram o caminho que todos que codificavam com agentes chegaram, independentemente, impulsionados pelos mesmos pontos de dor. O Claude Code e o Codex lançando `/goal` quase simultaneamente no início de 2026 não foi coincidência — a hora havia chegado.
+
+### Há Mais de um Tipo de Loop
+
+`/goal` é o loop mais fácil de entender, mas não é o único tipo. Os loops se dividem em categorias com base em como são acionados e como param:
+
+| Tipo | Gatilho | Condição de Parada | Claude Code | Codex | Melhor Para |
+|------|---------|-------------------|-------------|-------|-------------|
+| **Loop baseado em turnos** | Você digita cada prompt manualmente | O agente acha que terminou, ou você interrompe | Chat normal | Chat normal | Tarefas pequenas, trabalho exploratório |
+| **Loop baseado em objetivo** | Você dá um objetivo | Avaliador independente confirma que terminou, ou máximo de turnos atingido | `/goal` | `/goal` (requer habilitação manual) | Tarefas complexas com critérios de conclusão claros |
+| **Loop baseado em tempo** | Intervalo agendado (a cada N minutos/horas) | Você para manualmente, ou ele sai após concluir o trabalho | `/loop` | Thread automation | Verificar status, verificações periódicas, trabalho recorrente |
+| **Loop orientado a eventos** | Evento externo (PR aberta, CI falhou, nova issue) | Para após lidar com o evento, ou atinge o limite de tentativas | Routines (API / GitHub Webhook) | Standalone automation + plugins | Fluxos de trabalho reativos, integração CI/CD |
+
+Estes não são concorrentes — são ferramentas diferentes para trabalhos diferentes. Baseado em turnos serve para coisas pequenas. Use `/goal` quando há uma linha de chegada clara. Use `/loop` quando precisa observar algo. Use orientado a eventos quando estiver integrando com sistemas externos.
+
+### Não Confunda `/goal` e `/loop`
+
+Ambos têm "loop" no nome, mas resolvem problemas completamente diferentes:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **O que é** | Uma tarefa grande, executa até terminar | Uma ação pequena, repete em intervalo |
+| **Condição de parada** | Objetivo atingido, ou orçamento esgotado | Você para manualmente, ou a tarefa sai sozinha |
+| **Perfil de tempo** | Uma execução longa, pode levar horas ou dias | Pulsos curtos periódicos, cada execução pode durar alguns minutos |
+| **Progresso** | Fica mais perto da linha de chegada a cada iteração | Cada execução é independente, sem progresso cumulativo |
+| **Analogia** | Correr uma maratona — tiro de partida soa, você para na linha de chegada | Um despertador — toca em horário programado, você desliga |
+| **Uso típico** | "Implementar o sistema de pagamento completo com cobertura de testes" | "Verificar se a CI está quebrada a cada 15 minutos" |
+
+Um erro comum: enfiar algo que deveria ser `/goal` em um `/loop`. Como escrever `/loop 10m "continue implementando o sistema de pagamento"` — isso está errado. `/loop` executa a mesma instrução independentemente a cada vez, ele não lembra onde parou da última vez. Você apenas terá o mesmo ponto de partida repetidamente.
+
+**Teste de uma frase para qual usar: essa coisa tem fim?**
+- Tem fim → `/goal`
+- Não tem fim, você só precisa continuar observando → `/loop`
+
+Engenharia de Loops, o assunto desta aula, não é sobre nenhum comando específico. É sobre **ser capaz de projetar sistemas que incluem todos esses tipos — para que seu agente possa continuar trabalhando mesmo quando você não está lá.**
+
+Você não precisa digitar `/goal` toda vez. Mas entender de onde ele veio e por que é como é — isso é entender o núcleo da engenharia de loops. Loops mais complexos apenas adicionam peças como agendamento, paralelismo, isolamento e memória sobre esses mesmos três fundamentos: objetivo, verificação, condição de parada.
+
+## Junho de 2026: Três Pessoas Acenderam o Mesmo Fusível em Uma Semana
+
+Na primeira semana de junho de 2026, três profissionais que construíam infraestrutura de agentes de codificação — sem comparar notas — disseram a mesma coisa em palavras diferentes.
+
+**Peter Steinberger** (criador do OpenClaw, [sua postagem alcançou 8 milhões de visualizações](https://x.com/steipete/status/2063697162748260627)): "Você não deveria mais estar dando prompt em agentes de codificação. Você deveria estar projetando loops que dão prompt em seus agentes."
+
+**Boris Cherny** (chefe do Claude Code na Anthropic, [no podcast Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): "Eu não dou mais prompt no Claude. Tenho loops rodando que dão prompt no Claude e descobrem o que fazer. Meu trabalho é escrever loops."
+
+**Addy Osmani** (líder de engenharia no Google Chrome) [batizou o conceito](https://addyosmani.com/blog/loop-engineering/) em 7 de junho de 2026, e deu uma definição em uma linha:
+
+> **Loop engineering é substituir você mesmo como a pessoa que dá prompt ao agente. Você projeta o sistema que faz isso em vez de você.**
+
+Cherny divulgou números: por mais de 30 dias consecutivos, todas as contribuições de código para o Claude Code foram feitas autonomamente por IA — 259 PRs mescladas, mais de 80% do código de produção autoriado pelo Claude, e uma taxa de sucesso de 76% em tarefas de software abertas.
+
+Três pessoas. Uma semana. A mesma conclusão. Não porque coordenaram — mas porque a infraestrutura havia silenciosamente cruzado um limiar. Os agentes haviam se tornado confiáveis o suficiente para terminar tarefas não triviais sem supervisão. Primitivas de agendamento (`/loop`, `/goal`, cron) agora estavam embutidas nas ferramentas. O custo de uma única execução de agente havia caído o suficiente para que rodar uma repetidamente em um temporizador parasse de parecer desperdício. Quando todas as peças estão presentes, o movimento que as combina se torna óbvio para todos ao mesmo tempo.
+
+> Fonte: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Dentro do Loop vs. Fora do Loop
+
+Vamos contrastar dois cenários concretos.
+
+**Cenário A: Você está dentro do loop (Aulas 1–12).**
+
+```mermaid
+flowchart TD
+ You["Você"] -->|"Digita instrução manualmente"| Agent["Agente de IA"]
+ Agent -->|"Produz saída"| Result["Código / testes / docs"]
+ Result -->|"Você inspeciona"| You
+ You -->|"Insatisfeito, modifica instrução"| Agent
+ You -->|"Satisfeito, passa para próxima tarefa"| You
+```
+
+Você tem um harness completo: `AGENTS.md` diz ao agente as regras do projeto, `feature_list.json` restringe o escopo, `init.sh` garante ambiente consistente, `claude-progress.md` registra o progresso. **Mas cada passo ainda requer sua iniciação manual.** Termine uma funcionalidade, leia o arquivo de progresso, pense no que vem a seguir, digite a instrução. Você é o motor de todo o fluxo de trabalho.
+
+**Cenário B: Você está fora do loop (Engenharia de Loops).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["O sistema de loop que você projetou"]
+ Trigger["Gatilho automático<br/>Agendamento / Evento / Tarefa anterior concluída"] --> Discover["Descobrir trabalho<br/>Ler arquivo de progresso / rastreador de issues"]
+ Discover --> Dispatch["Despachar<br/>Criar sub-agente"]
+ Dispatch --> Verify["Verificar<br/>Testes / lint / Agente revisor independente"]
+ Verify --> Persist["Persistir estado<br/>Atualizar progresso / Commit / Abrir PR"]
+ Persist -->|"Ainda há trabalho"| Discover
+ Persist -->|"Pronto ou bloqueado"| Inbox["Enviar para sua caixa de revisão"]
+ end
+ Inbox -->|"Você só precisa tomar decisões"| You["Você"]
+```
+
+Você não digita mais instruções. O sistema que você projetou descobre o trabalho, o despacha, verifica os resultados, registra o estado e decide o próximo passo. Seu trabalho se reduz a três coisas: **definir o objetivo e a condição de parada antes de começar, revisar a saída depois que terminar, e ajustar as regras quando o sistema desviar do curso.** A alavanca passa de "escrever o prompt certo" para "projetar o loop certo".
+
+> Osmani: "Um ano atrás, se você quisesse um loop, escrevia uma pilha de bash e mantinha aquela pilha para sempre e era sua e só sua. Agora as peças simplesmente vêm dentro dos produtos." Você não precisa construir do zero. Precisa entender como as peças se encaixam.
+
+## Conceitos Fundamentais
+
+- **Engenharia de Loops (Loop Engineering)**: Projetar um sistema que automaticamente dá prompt ao seu agente, substituindo a entrada humana passo a passo manual. O humano se move de dentro do loop para fora dele, e a alavanca muda de "escrever o prompt certo" para "projetar o loop certo".
+- **Modo `/goal`**: O loop mais simples possível — forneça um objetivo, método de verificação e condição de parada; o agente repete até atingir. A ponte do prompting manual para loops autônomos.
+- **Separação Gerador/Avaliador**: O agente que escreve o código e o agente que o verifica devem estar separados. Um modelo corrigindo o próprio trabalho não é confiável; um verificador independente — às vezes usando um modelo completamente diferente — é a garantia básica de confiabilidade de qualquer loop.
+- **Isolamento por Worktree (Worktree Isolation)**: Cada agente paralelo trabalha em um git worktree independente, prevenindo fisicamente colisões de arquivos. O pré-requisito de infraestrutura para execução paralela multi-agente.
+- **Estado Externo (External State)**: Memória que vive fora de uma única conversa — arquivos markdown, rastreadores de issues, quadros kanban. Os modelos esquecem tudo entre as execuções; a memória deve viver no disco.
+- **Quatro Custos Silenciosos**: Quatro custos ocultos que se tornam mais agudos quanto mais tempo um loop roda — dívida de verificação, deterioração da compreensão, rendição cognitiva, explosão de tokens. Os loops aceleram não apenas a saída, mas o risco.
+
+## As Seis Primitivas de um Loop
+
+Osmani decompôs um loop em cinco blocos de construção centrais, mais uma camada de memória que atravessa todos eles — seis coisas no total, mas a camada de memória ocupa um status especial: não é um componente no mesmo nível dos outros; é a espinha dorsal de que tudo depende.
+
+O diagrama abaixo desenha todas as seis como um anel para que você possa ver o quadro completo de relance. Mas lembre-se: Estado Externo não é apenas outra parada no loop — é a base em que todo o loop descansa.
+
+```mermaid
+flowchart LR
+ A["Automações<br/>Gatilhos agendados"] --> W["Worktrees<br/>Isolamento paralelo"]
+ W --> S["Skills<br/>Conhecimento codificado do projeto"]
+ S --> C["Conectores<br/>Acesso a ferramentas externas"]
+ C --> SA["Sub-agentes<br/>Divisão maker / checker"]
+ SA --> ES["Estado Externo<br/>Memória entre iterações"]
+ ES --> A
+```
+
+### 1. Automações — O Batimento Cardíaco
+
+Sem automação, um loop não é um loop — é uma execução única que você fez manualmente.
+
+Tanto o Claude Code quanto o Codex têm sistemas completos de agendamento, mas usam nomes e camadas diferentes. Mapeamento grosso do mais leve ao mais pesado:
+
+| Camada | Claude Code | Codex | Observações |
+|--------|-------------|-------|-------------|
+| Polling na sessão | `/loop` | Thread automation | Vinculado à sessão atual, morre quando a sessão fecha |
+| Tarefas agendadas locais | Desktop scheduled tasks | Standalone automation (modo local) | Roda enquanto a máquina está ligada, pode acessar arquivos locais |
+| Tarefas agendadas na nuvem | Cloud Routines | — (sem agendador nativo na nuvem) | Roda enquanto a máquina está desligada |
+| Gatilhos de eventos | Routines (API / GitHub Webhook) | Standalone automation + plugins | Acionados por eventos externos |
+| Totalmente auto-hospedado | GitHub Actions / cron auto-hospedado | `codex exec` + cron | Controle total |
+
+**A aba Automations do Codex** é o ponto de entrada para agendamento. Escolha o projeto, o prompt, a cadência e se roda no seu checkout local ou em um worktree em segundo plano. Execuções que encontram algo vão para uma caixa de entrada de Triagem; execuções que não encontram nada são arquivadas automaticamente. A OpenAI os usa internamente para triagem diária de issues, resumos de falha de CI, briefings de commit e caça a bugs introduzidos na semana passada.
+
+As automações do Codex vêm em dois sabores:
+- **Thread automation** — Chamadas de despertar recorrentes no estilo batimento cardíaco vinculadas a uma thread, preservando o contexto. Bom para acompanhamento contínuo em uma única coisa, como monitorar um comando de longa duração ou verificar o status de um PR. O equivalente no Claude Code é `/loop`.
+- **Standalone automation** — Cada execução começa do zero, os resultados vão para a Triagem. Bom para tarefas diárias/semanais independentes como briefings ou varreduras de dependências. O equivalente no Claude Code é Desktop scheduled tasks.
+
+O sistema do Claude Code é camadas mais granularmente:
+
+- **`/loop`** — Repetição agendada leve na sessão. Funciona enquanto seu terminal está aberto, morre quando a sessão fecha, expira automaticamente após 7 dias. Bom para monitoramento temporário durante sua sessão de trabalho atual.
+- **Desktop scheduled tasks** — Roda enquanto sua máquina está ligada, sobrevive a reinícios de sessão, intervalos em nível de minuto. Bom para trabalho recorrente que precisa de acesso a arquivos locais.
+- **Cloud Routines** — Roda na infraestrutura de nuvem da Anthropic, sobrevive a sua máquina desligada, intervalo mínimo de 1 hora. Suporta três tipos de gatilho: agendado, chamada de API, webhook do GitHub. Bom para tarefas diárias que não precisam do seu ambiente local.
+- **GitHub Actions / cron auto-hospedado** — Totalmente sob seu controle, roda como você quiser. Bom para cenários com requisitos especiais de ambiente ou segurança.
+
+```bash
+# Claude Code: rodar testes a cada 30 min, corrigir falhas (dentro da sessão atual)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: verificar status do deploy a cada 15 minutos
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Automações são o batimento cardíaco. Sem elas, o loop é uma planta que nunca acorda.
+
+### 2. Worktrees — Isolamento em Escala
+
+Assim que você roda mais de um agente, colisões de arquivos se tornam o modo de falha inevitável. Dois agentes escrevendo no mesmo arquivo é exatamente a dor de cabeça de dois engenheiros fazendo commit nas mesmas linhas sem se consultar.
+
+`git worktree` resolve isso: cada agente trabalha em seu próprio branch em seu próprio diretório. Eles fisicamente não podem tocar no checkout um do outro.
+
+Tanto o Claude Code quanto o Codex vêm com suporte a worktree. Quando você usa `--worktree` ou `isolation: worktree` em um sub-agente, cada auxiliar recebe um checkout limpo e independente que se limpa sozinho. Worktrees removem o problema mecânico de colisão — mas lembre-se: **sua banda de revisão ainda é o teto.** Quantos agentes paralelos você consegue supervisionar determina quantos worktrees você consegue realmente rodar.
+
+### 3. Skills — Pare de Reexplicar Seu Projeto
+
+Uma skill é como você para de reexplicar o mesmo contexto do projeto toda sessão. É uma pasta contendo um `SKILL.md` com instruções e metadados, além de scripts opcionais, referências e ativos.
+
+O Codex e o Claude Code suportam o mesmo formato. Skills são invocadas diretamente com `/skill-name` (o Codex também suporta `$skill-name`), ou acionadas implicitamente quando a tarefa corresponde à descrição da skill.
+
+Skills são fundamentalmente sobre pagar sua dívida de intenção. Um agente começa toda sessão frio — ele preenche qualquer lacuna na sua intenção com um palpite confiante. Uma skill é essa intenção escrita do lado de fora: as convenções, os passos de build, o "nós não fazemos assim por causa daquele incidente" — escrito uma vez, lido toda execução.
+
+### 4. Conectores — Seu Loop Toca Ferramentas Reais
+
+Um loop que só consegue ver o sistema de arquivos é um loop pequeno. Conectores (construídos sobre o protocolo MCP) permitem que o agente leia seu rastreador de issues, consulte um banco de dados, acesse uma API de staging, envie uma mensagem no Slack.
+
+Tanto o Codex quanto o Claude Code falam MCP, então o conector que você escreveu para um geralmente funciona no outro. Conectores são a diferença entre "aqui está a correção" e um loop que abre o PR, vincula o ticket do Linear e avisa o canal quando a CI ficar verde — sozinho, dentro do seu ambiente real, não apenas em um terminal.
+
+### 5. Sub-agentes — Mantenha o Maker Longe do Checker
+
+A escolha de design estruturalmente mais valiosa em um loop é separar quem escreve de quem verifica. O modelo que escreveu o código é generoso demais corrigindo a própria lição de casa. Um segundo agente, com instruções diferentes e às vezes um modelo diferente, pega o que o primeiro agente se convenceu.
+
+A divisão clássica de três papéis:
+
+```mermaid
+flowchart LR
+ Explorer["Agente Explorador<br/>Ler base de código, localizar problemas"] --> Implementer["Agente Implementador<br/>Escrever correção, escrever testes"]
+ Implementer --> Verifier["Agente Verificador<br/>Revisão independente, rodar verificação"]
+ Verifier -->|"Falha"| Implementer
+ Verifier -->|"Passa"| Output["Saída"]
+```
+
+O `/goal` do Claude Code roda isso por baixo dos panos — uma sessão nova e independente julga se o loop deve parar, não a sessão que fez o trabalho. Isso se chama **separação gerador/avaliador**, e é a garantia de confiabilidade mais importante no design de loops.
+
+### 6. Estado Externo — A Memória do Loop
+
+Os modelos esquecem tudo entre as execuções. A memória deve viver no disco, não na janela de contexto.
+
+Isso parece simples demais para importar, mas é o mesmo truque do qual todo agente de longa duração depende. Um arquivo markdown, um quadro do Linear — qualquer coisa que viva fora de uma única conversa e guarde o que está feito, o que está em andamento e o que vem a seguir. O agente esquece. O repositório não esquece.
+
+Essas seis primitivas são seu kit de ferramentas de design de loops. Você não precisa de todas elas para todo loop. Mas precisa saber quando pegar qual.
+
+## Um Loop Completo, Anatomizado
+
+Conecte todas as seis e é assim que um loop de triagem matinal real se parece:
+
+```mermaid
+flowchart TD
+ Trigger["Todas as manhãs às 9:00<br/>Automação dispara"] --> Read["Ler estado externo<br/>claude-progress.md de ontem<br/>Issues abertas no GitHub"]
+ Read --> Triage["Skill de Triagem entra em ação<br/>Classificar e priorizar descobertas"]
+ Triage --> Fork["Para cada item acionável<br/>Criar um Worktree isolado"]
+ Fork --> Implement["Sub-agente Implementador<br/>Escrever correção + testes"]
+ Implement --> Verify["Sub-agente Verificador<br/>Rodar testes + lint + revisão independentemente"]
+ Verify -->|"Falha"| Retry["Fila de retentativa<br/>Tentar abordagem diferente"]
+ Retry --> Implement
+ Verify -->|"Passa"| PR["Conector: Abrir PR<br/>Vincular issue, atualizar arquivo de progresso"]
+ PR --> Memory["Escrever no Estado Externo<br/>Atualizar claude-progress.md<br/>Registrar resultados desta rodada"]
+ Memory -->|"Ainda há trabalho"| Fork
+ Memory -->|"Tudo pronto ou bloqueado"| Inbox["Resultados chegam na caixa de Triagem<br/>Esperando sua revisão"]
+```
+
+Isso não é mais uma única execução de agente. É um sistema operacional continuamente que acorda todas as manhãs, varre o chão sozinho e coloca as coisas que precisam da sua atenção na sua frente. Seu papel se torna: **revisar o conteúdo da caixa de entrada, tomar decisões e, quando identificar um padrão que o sistema não consegue lidar, refinar as skills e regras.**
+
+Cherny usou esse padrão para mesclar 259 PRs em 30 dias sem abrir uma IDE uma única vez. Engenheiros da OpenAI usaram o mesmo padrão para construir um produto beta de aproximadamente um milhão de linhas — sem escrever uma única linha de código eles mesmos.
+
+## Separação Gerador/Avaliador: Por Que Você Não Pode Deixar o Modelo Corrigir o Próprio Trabalho
+
+Esta é a lição mais difícil da engenharia de loops.
+
+Seu agente mais inteligente escreve um pedaço de código bonito. A lógica é clara, os comentários são completos, e cada função tem um teste. Você está satisfeito.
+
+Mas aqui está a pergunta: **se você deixar o agente que escreveu aquele código julgar se fez um bom trabalho, o que ele dirá?**
+
+A resposta foi confirmada pela experiência repetidamente: ele dará a si mesmo uma nota alta. Não porque seja desonesto, mas porque é o autor — ele se convenceu de que esse caminho estava correto durante a geração. Quando olha para trás, não vê erros; vê seu próprio processo de raciocínio.
+
+Isso não é um problema do Claude. Isso não é um problema do GPT. Isso é uma propriedade de todos os modelos generativos. **Um modelo é o melhor advogado de defesa da sua própria saída.**
+
+A correção: nunca deixe a mesma entidade (mesmo modelo, mesmo prompt) fazer tanto o trabalho quanto a revisão.
+
+- O `/goal` do Claude Code usa uma sessão de supervisão independente para julgar se o objetivo foi atingido — não a sessão que o tentou.
+- O sistema de sub-agentes do Codex permite definir um agente verificador usando um modelo diferente com esforço de raciocínio diferente.
+- A prática comunitária de "adversarial verify" cria N céticos independentes por descoberta, cada um com prompt para refutar — rejeição majoritária mata a descoberta.
+
+Uma frase para lembrar: **alguém na sua equipe não deve acreditar em você.**
+
+## autoresearch do Karpathy: O Exemplar de Loop
+
+Se você quer ver como é um loop bem projetado e realmente rodando, o [autoresearch do Karpathy](https://github.com/karpathy/autoresearch) é o exemplo didático.
+
+Em março de 2026, Karpathy lançou um projeto Python de 630 linhas. Dê a ele uma GPU e uma direção de pesquisa, e ele roda a noite toda — completando centenas de experimentos de treinamento de ML, mantendo apenas aqueles que realmente melhoram. O projeto atingiu 66.000+ estrelas em poucos dias do lançamento.
+
+### Três Arquivos, Três Papéis
+
+Todo o sistema tem apenas três arquivos centrais, mas a divisão de trabalho é afiada como navalha:
+
+| Arquivo | Quem Edita | O Que Faz |
+|---------|-----------|-----------|
+| `prepare.py` | Ninguém (somente leitura) | Preparação de dados, tokenizador, avaliação. Infraestrutura fixa. |
+| `train.py` (~630 linhas) | **Agente de IA** | Definição do modelo, otimizador, loop de treinamento. O playground do agente — mude qualquer coisa. |
+| `program.md` | **Você** | Metodologia de pesquisa escrita em linguagem natural. Você só edita isso. Diga ao agente como explorar, como avaliar, o que não tocar. |
+
+Essa divisão em três vias é a alma do design: **humanos não tocam código, tocam direção; agentes não tocam direção, tocam código.** Seu trabalho muda de escrever Python para "escrever a cultura da organização de pesquisa".
+
+### Entrada: Como é program.md
+
+`program.md` é o cérebro do loop. Não é código — é um manual de instruções de pesquisa escrito em Markdown. Ele contém aproximadamente:
+
+- **Objetivo**: otimizar `val_bpb` (bits por byte de validação, menor é melhor)
+- **Restrições**: não tocar em `prepare.py`, ficar dentro do orçamento de VRAM, treinamento fixo de 5 minutos
+- **Direções de exploração**: tentar diferentes arquiteturas, otimizadores, agendas de LR
+- **Regras de avaliação**: o que conta como melhoria, como registrar resultados, o que fazer em caso de falha
+- **Regra de ferro**: nunca pare. Uma vez que o loop comece, continue para sempre
+
+Seu prompt de inicialização para o agente pode ser tão curto quanto uma frase:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+O resto fica por conta do agente lendo o documento e tomando suas próprias decisões.
+
+### O Loop de Catraca de Nove Passos
+
+No coração do autoresearch está uma **catraca** — ela só se move para frente, nunca para trás. Cada iteração segue estritamente nove passos:
+
+```mermaid
+flowchart TD
+ 1["1. Ler direção<br/>Carregar program.md"] --> 2["2. Levantar estado atual<br/>Ler train.py + resultados passados"]
+ 2 --> 3["3. Propor hipótese<br/>Pensar em uma mudança para tentar"]
+ 3 --> 4["4. Modificar código<br/>Editar train.py"]
+ 4 --> 5["5. Snapshot<br/>git commit"]
+ 5 --> 6["6. Rodar treinamento<br/>5 min fixos de relógio"]
+ 6 --> 7{"7. Avaliar<br/>val_bpb melhorou?"}
+ 7 -->|Sim| 8a["8a. Manter<br/>Commit fica<br/>Escrever em results.tsv"]
+ 7 -->|Não| 8b["8b. Reverter<br/>git reset HEAD~1<br/>Registrar a falha"]
+ 8a --> 9["9. Próxima rodada<br/>Voltar para passo 1"]
+ 8b --> 9
+```
+
+Ele roda aproximadamente 12 experimentos por hora. Uma execução noturna (8 horas) são cerca de 100 experimentos. O próprio Karpathy o rodou por 2 dias — ~700 experimentos.
+
+O orçamento fixo de 5 minutos de relógio é uma escolha chave de design — não importa o que o agente mude, cada experimento leva exatamente o mesmo tempo. Isso significa que todos os resultados são diretamente comparáveis sob o mesmo orçamento de tempo — sem discussão sobre "esse rodou mais tempo então é melhor".
+
+### Saída: O Que Você Vê Quando Acorda
+
+Depois de uma noite de loops, você se senta de manhã e encontra três coisas:
+
+**1. Histórico do git (a catraca que só anda para frente)**
+
+Apenas commits que realmente melhoraram ficam na branch principal. Tudo que falhou foi revertido. `git log` é um log de pesquisa validado.
+
+**2. results.tsv (o registro completo de experimentos)**
+
+Cada experimento — sucesso ou falha — é registrado:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Um log de pesquisa (resumo do próprio agente)**
+
+O agente escreve mensagens de commit claras sobre o que tentou, o que funcionou, o que não funcionou e o que planeja tentar em seguida. Você lê essas — não precisa ler os diffs de código.
+
+### O Que Ele Realmente Encontrou
+
+Resultados da execução inicial de 2 dias, ~700 experimentos de Karpathy:
+
+- De ~700 tentativas, cerca de **20 melhorias reais empilháveis** foram encontradas
+- Reduziu o tempo de treinamento em nível GPT-2 do nanochat em 8×H100 de **2,02 horas → 1,80 horas**, cerca de **11% mais rápido**
+- Descobertas incluíram: ajustes de taxa de aprendizado, ajuste de otimizador, trocas de ativação, otimizações de padrão de atenção, etc.
+
+Todas as melhorias foram descobertas revolucionárias? Não. A maioria eram pequenas otimizações que se empilharam. Mas essas 20 melhorias válidas teriam levado semanas de trabalho manual a um pesquisador humano — o agente fez em 48 horas.
+
+### O Detalhe Mais Revelador: O Loop Está Escrito em Inglês, Não em Código.
+
+`program.md` é um documento Markdown, não um script Python. Ele descreve uma metodologia de pesquisa — o que modificar, o que deixar em paz, como avaliar, como lidar com casos de falha e uma regra de ferro: **nunca peça ajuda humana, apenas continue.** Um agente de codificação lê este documento e o executa indefinidamente.
+
+Este é o modelo para engenharia de loops: não dê ao agente uma tarefa. Dê a ele uma **metodologia**. Deixe a metodologia ser o loop. Um `program.md`, 630 linhas de código cola, e tudo o mais é o agente rodando a si mesmo.
+
+## Quatro Custos Silenciosos
+
+Quando um loop começa a rodar, você não verá os problemas imediatamente. Os quatro custos a seguir se acumulam silenciosamente, e quando você perceber, pode já ter pago caro.
+
+### 1. Dívida de Verificação
+
+Loops rápidos tentam você a pular a verificação. "Parece bom" não é a mesma coisa que "confirmado correto". Quanto mais código um loop gera sem supervisão, mais rápido a dívida de verificação se acumula. A correção: **condições de parada devem ser verificáveis por máquina, nunca "parece mais ou menos certo".**
+
+### 2. Deterioração da Compreensão
+
+Quanto mais rápido um loop entrega código, mais a sua compreensão da sua própria base de código se afasta da realidade. A equipe de Cherny tinha 80% do código autoriado por agentes — o que significa que a maior parte do código de uma equipe não foi escrita por uma pessoa. Se você não ler e usar o que o loop produz, sua compreensão decai continuamente. **Loops rápidos exigem leitura rápida.**
+
+### 3. Rendição Cognitiva
+
+Quando o loop roda suavemente, a postura mais confortável é parar de ter opiniões. Pegue o que ele devolver, não pense sobre a saída. Mas é exatamente aí que o perigo começa — você está usando o loop para evitar pensar, em vez de ampliar o pensamento. O aviso de Osmani: "Duas pessoas podem construir o mesmo loop exato e obter resultados opostos. Uma usa para ir mais rápido em trabalho que entende; a outra usa para evitar entender o trabalho. O loop não sabe a diferença. Você sabe."
+
+### 4. Explosão de Tokens
+
+Cada iteração de um loop acumula mais contexto: código escrito, erros encontrados, decisões tomadas. Sem gerenciamento de contexto, o tamanho do prompt cresce aproximadamente quadraticamente com o número de turnos. O Codex resolve isso com compactação automática de contexto — uma API dedicada comprime turnos mais antigos de conversa em resumos criptografados de conteúdo, retendo conhecimento essencial enquanto descarta detalhes redundantes. Esta é uma preocupação de engenharia que você deve abordar desde o primeiro loop, não um complemento posterior.
+
+## Construindo Seu Primeiro Loop
+
+Você não precisa começar com um pipeline em escala Stripe mesclando 1.300 PRs por semana. Comece com a menor coisa que funciona.
+
+### Passo 1: Escolha Uma Tarefa Recorrente
+
+Encontre algo que você faz manualmente pelo menos duas vezes por semana. Exemplos:
+- Abrir o GitHub de manhã, verificar novas issues, triar e responder
+- Rodar lint e testes antes de cada revisão de PR
+- Atualizar docs de progresso ao final de cada dia
+
+### Passo 2: Escreva um Objetivo e Condição de Parada
+
+Transforme a tarefa em algo que um `/goal` consegue entender:
+
+```markdown
+Goal: Check the 10 most recent issues in the repo.
+For each issue:
+ - If it already has clear labels and an assignee, skip
+ - If untagged, add appropriate labels based on content
+ - If fixable in under 10 minutes, create a branch and attempt a fix
+Stop when: All qualifying issues have been processed, or an issue requires human decision.
+```
+
+### Passo 3: Separe Maker e Checker
+
+Não deixe o mesmo agente tanto escrever o código quanto julgá-lo. Divida seu loop em dois papéis:
+- Implementador: lê a issue, escreve a correção, escreve os testes
+- Verificador: roda testes independentemente, revisa o diff, julga se a correção realmente resolve o problema
+
+### Passo 4: Adicione Memória
+
+Use um arquivo markdown para registrar o que aconteceu em cada execução do loop. A próxima execução começa lendo este arquivo — ela sabe o que foi feito, o que está pendente, o que estava bloqueado. Isso supera qualquer banco de dados complexo.
+
+### Passo 5: Defina um Temporizador
+
+Use `/loop` ou o cron do seu SO para deixar o loop começar sem você. Comece com uma vez por dia. Observe por uma semana.
+
+### A Escada de Maturidade
+
+Você não precisa chegar ao topo de um salto. A adoção de loops é uma escada:
+
+1. **Nível 1: Executor de Objetivo** — Você consegue usar `/goal` para dar uma tarefa com condição de parada; o agente repete até atingir.
+2. **Nível 2: Tarefa Única Agendada** — Uma automação roda uma tarefa em um temporizador (ex: verificação matinal de CI).
+3. **Nível 3: Loop Multi-Agente** — Divisão entre maker e checker; cada descoberta cria um worktree isolado.
+4. **Nível 4: Loop Auto-Alimentado** — O loop descobre automaticamente sua próxima tarefa a partir do estado externo; ele decide o que fazer em seguida.
+5. **Nível 5: Orquestração de Frota** — Múltiplos loops rodam em paralelo, independentes mas compartilhando uma camada de memória.
+
+A maioria das equipes está atualmente entre o Nível 2 e o Nível 3. O Nível 1 é o caminho mais rápido para ver retornos.
+
+## Principais Conclusões
+
+- **Engenharia de Loops não substitui Engenharia de Harness — ela constrói um andar acima dela.** O harness torna execuções únicas confiáveis. O loop torna execuções contínuas autônomas.
+- **`/goal` é o loop mais simples possível:** objetivo + verificação + condição de parada. Essas três coisas movem você de dentro do loop para fora dele.
+- **Seis primitivas (Automações / Worktrees / Skills / Conectores / Sub-agentes / Estado Externo) são os blocos de construção do loop.** Nem todas todas as vezes, mas você precisa saber quando pegar qual.
+- **O maker e o checker devem estar separados.** Um modelo corrigindo o próprio trabalho não é confiável. Um verificador independente — às vezes um modelo completamente diferente — é a garantia básica de confiabilidade de qualquer loop.
+- **Loops tornam a geração quase gratuita e deixam o julgamento como o recurso escasso.** O tempo que você economiza não é para descansar. É para fazer mais julgamentos.
+- **Quatro custos silenciosos se tornam mais agudos quanto mais os loops rodam:** dívida de verificação, deterioração da compreensão, rendição cognitiva, explosão de tokens. Loops aceleram a saída — e o risco.
+- **Comece pequeno.** Um `/goal`, um cron, um arquivo de memória markdown. Veja o retorno, depois empilhe para cima.
+
+## Leitura Adicional
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Corpus público de 50 loops reais
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Aula 12: [Deixe uma Transferência Limpa ao Final de Cada Sessão](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — O pré-requisito para loops: cada sessão deixa estado limpo para que a próxima rodada possa começar automaticamente
+- Aula 5: [Mantenha Tarefas de Longa Duração Contínuas Entre Sessões](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Conhecimento pré-requisito para estado externo e memória
+- Aula 11: [Por Que a Observabilidade Pertence ao Harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Quanto mais rápido um loop roda, mais você precisa de observabilidade para pegar problemas
+- Aula 8: [Por Que Listas de Funcionalidades São Primitivas do Harness](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Listas de funcionalidades são a fonte de dados natural para um loop auto-alimentado descobrir sua próxima tarefa
+
+## Exercícios
+
+1. **Transforme uma tarefa recorrente em um `/goal`:** Encontre algo que você faz manualmente pelo menos duas vezes por semana. Escreva seu objetivo, método de verificação e condição de parada. Rode uma vez com `/goal` e compare o tempo e a qualidade contra fazer manualmente. Este é seu primeiro passo do Harness para o Loop.
+
+2. **Separe maker e checker:** Escolha uma tarefa que você já fez um agente executar. Desta vez, escreva dois prompts diferentes: um para o agente implementador e um para o agente verificador (use modelos diferentes — ex: Claude para implementação, GPT para verificação, ou vice-versa). O verificador deve apontar problemas específicos com evidência citada. Registre o número e o tipo de problemas encontrados em cada modo.
+
+3. **Dê memória ao seu loop:** Crie um arquivo de estado markdown para seu loop. Em cada iteração, escreva: o que foi feito nesta rodada, resultados da verificação, status (passou/falhou/bloqueado) e o que fazer em seguida. Rode três rodadas e observe a diferença comportamental entre ter e não ter um arquivo de memória.
+
+4. **Audite os custos silenciosos do seu loop:** Depois que seu loop rodou por uma hora, avalie estas quatro métricas:
+ - Quanta verificação foi "parece certo" em vez de "confirmada por máquina"? (Dívida de verificação)
+ - Quão bem você consegue explicar o código que seu loop produziu mais recentemente? (Deterioração da compreensão)
+ - Quantas vezes você pensou "vou olhar depois" e nunca olhou? (Rendição cognitiva)
+ - Como está a tendência do tamanho do contexto do loop? Ele está repetindo informações redundantes? (Explosão de tokens)
diff --git a/docs/pt-BR/projects/project-07-loop-engineering-first-loop/index.md b/docs/pt-BR/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..3b0af33
--- /dev/null
+++ b/docs/pt-BR/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Projeto 07. Construa Seu Primeiro Loop Automatizado
+
+> Aula relacionada: [L13. Por Que Você Precisa Parar de Dar Prompt no Seu Agente](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## O Que Você Fará
+
+Este é o projeto de transição do "Harness" para o "Loop". Você já sabe como configurar um agente com ambiente, instruções e feedback adequados — agora você transformará essa configuração em um loop que roda sozinho.
+
+Você fará três experimentos progressivos: primeiro transformar uma tarefa de manual para `/goal`, depois transformar uma tarefa de monitoramento em um temporizador `/loop`, e finalmente construir um loop completo maker-checker para experimentar como é quando **você sai do loop.**
+
+## Arquivos do Projeto
+
+Caminho no repositório: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Diretório | O Que Há Dentro | O Que Você Faz |
+|-----------|----------------|---------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Um pequeno projeto de base de conhecimento com um harness completo (estado final do P06), incluindo AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Transforme este harness em um que consegue fazer loop automaticamente. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Implementações completas de três loops: loop de objetivo, loop de temporizador, loop maker-checker, além de arquivos de estado de loop e scripts de verificação. | Referência para padrões de design de loop e gerenciamento de estado. |
+
+## Ferramentas Que Você Usará
+
+- Claude Code ou Codex
+- Git
+- Seu harness completo do P06
+- Um multiplexador de terminal (tmux ou screen, para observar loops de longa duração)
+- Opcional: GitHub Actions ou cron (para experimentos avançados orientados a eventos / agendados)
+
+## Passos
+
+### Preparação
+
+1. Comece do mesmo commit onde você terminou o P06.
+2. Crie três branches: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Confirme que seu harness funciona: rode init.sh, verifique se arquivo de estado, lista de funcionalidades e docs de transferência estão todos no lugar.
+4. Escolha uma **tarefa alvo** que você quer que o loop trabalhe repetidamente. Escolha algo de tamanho médio com critérios de conclusão claros — ex: "adicionar testes unitários a todos os módulos, atingindo 80% de cobertura" ou "adicionar validação de entrada a todos os endpoints da API".
+
+### Experimento 1: Loop de Objetivo — Da Execução Manual para Execução Automática
+
+Mude para a branch `p07-goal-loop`.
+
+1. **Escreva a descrição do objetivo**: Transforme sua tarefa escolhida em um arquivo `goal.md` contendo:
+ - Objetivo claro ("o que conta como pronto")
+ - Método de verificação ("como confirmar que está pronto" — rodar testes? rodar lint? verificar cobertura?)
+ - Condição de parada ("quando deve parar" — máximo de turnos? limite de tempo? limite de orçamento?)
+ - Restrições ("o que não tocar" — config de produção, schema do banco de dados, etc.)
+
+2. **Primeira execução manual**: Dê a tarefa ao agente manualmente, você mesmo. Registre quantos turnos levou, quantas vezes você interveio e a qualidade do resultado. Este é seu baseline.
+
+3. **Rode com `/goal`**: Use o mesmo `goal.md` como entrada e rode no modo `/goal`. O agente repete sozinho até que o objetivo seja atingido ou a condição de parada dispare.
+
+4. **Compare os resultados**:
+ - Diferença na contagem de turnos
+ - Diferença na sua contagem de intervenções
+ - Diferença na qualidade do resultado (usando o mesmo padrão de verificação)
+ - Diferença no tempo que você gastou
+
+5. **Itere no goal.md**: Se os resultados forem ruins, revise a descrição do objetivo e rode novamente. Continue até que você esteja satisfeito com os resultados, ou até que tenha confirmado o limite do que um loop de objetivo consegue fazer nesta tarefa.
+
+### Experimento 2: Loop de Temporizador — Transforme Monitoramento em Batimento Cardíaco
+
+Mude para a branch `p07-timer-loop`.
+
+1. **Escolha uma tarefa de monitoramento**: Encontre uma verificação repetitiva que você normalmente faz manualmente. Por exemplo:
+ - Rodar a suíte de testes a cada hora, corrigir falhas
+ - Verificar atualizações de segurança de dependências todas as manhãs
+ - Verificar violações de estilo de código após cada commit
+ - Periodicamente escanear comentários TODO para ver quais estão obsoletos
+
+2. **Escreva o prompt/script de monitoramento**: Descreva os passos de monitoramento claramente — o que verificar, o que fazer quando forem encontrados problemas e quando chamar um humano.
+
+3. **Rode com `/loop` (ou Codex Thread automation)**:
+ - Defina um intervalo razoável (10-30 minutos recomendado — muito curto e você ficará irritado, muito longo e você não verá o efeito)
+ - Deixe rodar por pelo menos 2 horas (ou vá fazer outra coisa e volte depois)
+
+4. **Registre os resultados**:
+ - Quantos problemas ele encontrou?
+ - Quantos ele consertou sozinho?
+ - Quantos foram falsos positivos?
+ - Quantos ele piorou?
+ - Quanto tempo você gastou acompanhando seus resultados?
+
+5. **Reflita**: Vale a pena automatizar esta tarefa de monitoramento? Compare o tempo que você economizou vs. o tempo que gastou acompanhando. Se não vale a pena, você escolheu a tarefa errada, ou o loop está mal projetado?
+
+### Experimento 3: Loop Maker-Checker — Tire Você Mesmo do Loop
+
+Mude para a branch `p07-maker-checker`.
+
+Este é o mais importante dos três experimentos. Você construirá um **loop completo que não precisa de você lá:**
+
+1. **Projete a estrutura do loop**:
+ - **Agente Maker**: implementa, escreve código, modifica arquivos
+ - **Agente Checker**: verifica, roda testes, faz revisão de código, aprova / reprova
+ - **Arquivo de estado** (`loop-state.md`): registra rodada atual, o que foi feito, resultados da verificação, o que vem a seguir
+ - **Condição de parada**: N aprovações consecutivas, ou máximo de rodadas atingido
+
+2. **Escreva três prompts**:
+ - Instruções do Maker (o que fazer, como fazer, o que não tocar)
+ - Instruções do Checker (o que verificar, como verificar, o que conta como aprovação, como dar feedback)
+ - Lógica de controle do loop (quem vai primeiro, como funciona a transferência, como começar a próxima rodada)
+
+3. **Rode pelo menos 5 rodadas**:
+ - Rodada 1: Maker implementa → Checker verifica → Reprova → Feedback para o Maker
+ - Rodada 2: Maker revisa com base no feedback → Checker verifica → ...
+ - ...
+ - Até aprovação consecutiva, ou você encerra
+
+4. **Registre o estado de cada rodada**:
+ - Número da rodada
+ - O que o Maker fez
+ - Quais problemas o Checker encontrou
+ - Aprovou / reprovou
+ - Você interviu? (se sim, por quê?)
+
+5. **Retrospectiva final**:
+ - Quantas vezes você interviu? Por quê?
+ - O que teria acontecido se você não tivesse intervido?
+ - O Checker deixou passar algum problema?
+ - O Maker continuou cometendo o mesmo erro?
+ - Onde está o teto de qualidade deste loop? Capacidade do Maker, ou capacidade do Checker?
+
+## Como Medir Resultados
+
+| Métrica | Exp 1 (Objetivo) | Exp 2 (Temporizador) | Exp 3 (Maker-Checker) |
+|---------|-----------------|---------------------|----------------------|
+| Taxa de conclusão da tarefa | O objetivo foi atingido? | Quantos ciclos de monitoramento rodaram? | Quantas rodadas até aprovar? |
+| Intervenções humanas | Quantas vezes você interveio? | Quanto tempo você gastou acompanhando? | Quantas vezes você interviu? |
+| Qualidade do resultado | Como se compara ao manual? | Taxa de falsos positivos? Problemas perdidos? | Quantos problemas o Checker encontrou que você não teria? |
+| Tempo economizado | Quanto tempo você economizou? | Vale a pena automatizar? | Tempo gasto projetando o loop vs. tempo economizado |
+| Confiabilidade | A condição de parada era confiável? | Ele fugiu do controle? | O loop consegue ficar preso no mesmo lugar? |
+
+## O Que Entregar
+
+- `goal.md` (descrição do objetivo do Experimento 1, pelo menos duas iterações)
+- Notas de comparação do Experimento 1: manual vs. loop de objetivo
+- Prompt de monitoramento do Experimento 2 + log de execução de 2 horas
+- Três prompts do Experimento 3 (Maker / Checker / Controle do loop)
+- `loop-state.md` do Experimento 3 (pelo menos 5 rodadas registradas)
+- Retrospectiva final: lições dos três experimentos, como sua compreensão de engenharia de loops mudou, quais coisas são boas candidatas para loop-ificação e quais não são
+
+## Aulas Relacionadas
+
+- [Aula 13 — Por Que Você Precisa Parar de Dar Prompt no Seu Agente](../../lectures/lecture-13-loop-engineering/index.md)
+- [Aula 12 — Por Que Toda Sessão Deve Deixar um Estado Limpo](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (cada rodada de um loop precisa de estado limpo)
+- [Aula 11 — Por Que a Observabilidade Pertence ao Harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (você precisa ver o que está acontecendo dentro do loop)
+- [Aula 05 — Por Que Arquivos de Estado São a Espinha Dorsal da Continuidade](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (arquivos de estado de loop são uma extensão dos arquivos de estado)
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/ru/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/ru/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/code/index.md b/docs/ru/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/ru/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/ru/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/ru/lectures/lecture-13-loop-engineering/index.md b/docs/ru/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..f09467f
--- /dev/null
+++ b/docs/ru/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Примеры кода: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Практический проект: [Project 07. Build Your First Automated Loop](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Лекция 13. От ручных запросов к автономным циклам
+
+Всё, что вы изучили в первых двенадцати лекциях, основано на одном предположении: **вы сидите за клавиатурой и вводите инструкции одну за другой.**
+
+Вы написали `AGENTS.md` (лекции 1–4), построили управление состоянием (лекции 5–6), ограничили область применения списками функций (лекции 7–8), оставляли чистые передачи в конце сессии (лекции 9, 12) и сделали среду выполнения наблюдаемой (лекции 10–11). Но триггером для всего этого всегда были вы. Агент никогда не решал сам, когда начинать работать — потому что никто не нажимал «старт».
+
+Эта лекция о том, как передать кнопку «старт» системе. Не отказаться от контроля — а поднять его на следующий уровень.
+
+## /goal: Простейший возможный цикл
+
+Лучший вход в loop engineering — это не сложная архитектурная диаграмма, а одна команда.
+
+В начале 2026 года Claude Code и OpenAI Codex независимо друг от друга выпустили одну и ту же функцию: `/goal`. Вы вводите в терминале:
+
+```
+/goal "All tests pass, zero lint warnings, merge to main"
+```
+
+Затем вы закрываете ноутбук и идёте спать. Восемь часов спустя агент самостоятельно проанализировал, написал код, протестировал, исправил и выполнил слияние. Он повторяет попытки при неудаче, меняет подход, когда заходит в тупик, и останавливается, когда готов — без того, чтобы вы стояли у него за спиной и говорили «попробуй ещё раз».
+
+Единственная разница между `/goal` и традиционным запросом — одна вещь. Но эта вещь меняет всё:
+
+| | Традиционный запрос | `/goal` |
+|---|---|---|
+| Что вы предоставляете | Что делать дальше | Как выглядит конечное состояние |
+| Что делает агент | Выполняет один раз | Циклически повторяет до достижения |
+| Кто оценивает готовность | Вы | Проверяемое условие остановки |
+| Когда можно уйти | Нельзя | В тот момент, когда вы вводите `/goal` |
+
+`/goal` — это по сути цикл. У него есть ровно три части: **цель, метод верификации и условие остановки.** Только эти три вещи переносят вас изнутри цикла наружу.
+
+### Как `/goal` рос органически
+
+`/goal` не появился из ниоткуда. Он постепенно вырос из повседневных рабочих процессов, пройдя примерно четыре этапа:
+
+**Этап 1: Ручные запросы один за другим.** Самый ранний способ работы — это диалог: «напиши функцию», «добавь тест», «исправь эту логику». Агент останавливался после каждого шага и ждал, что вы скажете, что дальше. Вы были планировщиком всего конвейера.
+
+**Этап 2: Длинные запросы с несколькими шагами.** Затем люди стали писать более длинные запросы, в которых шаги складывались вместе: «сначала проанализируй код, затем напиши реализацию, затем запусти тесты, и если они упадут — исправь». Агент мог выполнить несколько шагов за один раз, но вам всё равно приходилось следить — потому что он мог сбиться с пути на полпути, или закончить шаг и не знать, что делать дальше.
+
+**Этап 3: Саморефлексия и самоуправление агента.** После этого агенты получили «интроспекцию» — после каждого шага они смотрели на результат и решали, что делать дальше. Вы давали цель, а они сами её разбивали и самостоятельно повторяли попытки. Но возникла проблема: когда им останавливаться? Считается ли «я закончил», исходящее от самого агента? Практика постоянно отвечала — нет. Агенты слишком легко заявляют о победе.
+
+**Этап 4: Независимая оценка остановки — `/goal`.** Последним шагом было изъятие «оценки готовности» из рук агента, выполняющего работу, и передача её независимому судье. Это может быть другая модель, скрипт или тестовая команда — но правило было одинаковым: человек, пишущий код, не может проверять свою домашнюю работу. В этот момент `/goal` по-настоящему заработал: вы даёте цель, он циклически повторяет, независимый судья решает, когда остановиться, и вы можете уйти.
+
+Эти четыре этапа не были дорожной картой, спланированной какой-либо одной компанией. Это был путь, к которому независимо пришли все, кто программирует с агентами, под давлением одних и тех же болевых точек. Тот факт, что Claude Code и Codex выпустили `/goal` почти одновременно в начале 2026 года, не был совпадением — время пришло.
+
+### Существует не один вид цикла
+
+`/goal` — самый простой для понимания цикл, но не единственный. Циклы делятся на категории в зависимости от того, как они запускаются и как останавливаются:
+
+| Тип | Триггер | Условие остановки | Claude Code | Codex | Лучше всего подходит для |
+|------|---------|----------------|-------------|-------|----------|
+| **Пошаговый цикл** | Вы вводите каждый запрос вручную | Агент считает, что закончил, или вы прерываете | Обычный чат | Обычный чат | Небольшие задачи, исследовательская работа |
+| **Цикл на основе цели** | Вы даёте цель | Независимый оценщик подтверждает готовность, или достигнуто максимальное количество шагов | `/goal` | `/goal` (требуется ручное включение) | Сложные задачи с чёткими критериями завершения |
+| **Цикл на основе времени** | Запланированный интервал (каждые N минут/часов) | Вы останавливаете вручную, или он завершает работу после выполнения | `/loop` | Thread automation | Опрос статуса, периодические проверки, повторяющаяся работа |
+| **Событийно-ориентированный цикл** | Внешнее событие (открыт PR, CI упал, новый issue) | Останавливается после обработки события или достигает предела повторов | Routines (API / GitHub Webhook) | Standalone automation + plugins | Реактивные рабочие процессы, интеграция CI/CD |
+
+Они не конкурируют — это разные инструменты для разных задач. Пошаговый подходит для мелочей. Используйте `/goal`, когда есть чёткая финишная черта. Используйте `/loop`, когда нужно за чем-то следить. Используйте событийно-ориентированный, когда вы интегрируетесь с внешними системами.
+
+### Не путайте `/goal` и `/loop`
+
+Оба имеют в названии «loop», но решают совершенно разные задачи:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Что это** | Одна большая задача, выполняется до завершения | Одно небольшое действие, повторяется с интервалом |
+| **Условие остановки** | Цель достигнута, или бюджет исчерпан | Вы останавливаете вручную, или задача завершается сама |
+| **Профиль времени** | Один долгий запуск, может занимать часы или дни | Периодические короткие вспышки, каждый запуск может длиться несколько минут |
+| **Прогресс** | С каждым повторением приближается к финишу | Каждый запуск независим, совокупного прогресса нет |
+| **Аналогия** | Бег марафона — выстрел стартового пистолета, вы останавливаетесь на финише | Будильник — звонит по расписанию, вы его выключаете |
+| **Типичное использование** | «Внедри полную платёжную систему с покрытием тестами» | «Проверяй, сломался ли CI, каждые 15 минут» |
+
+Распространённая ошибка: запихивать то, что должно быть `/goal`, в `/loop`. Например, написать `/loop 10m "продолжай внедрять платёжную систему"` — это неправильно. `/loop` каждый раз выполняет одну и ту же инструкцию независимо, он не запоминает, где остановился в прошлый раз. Вы просто получите одну и ту же начальную точку снова и снова.
+
+**Одно предложение для проверки, что использовать: у этой вещи есть конец?**
+- Есть конец → `/goal`
+- Нет конца, нужно просто продолжать следить → `/loop`
+
+Loop Engineering, тема этой лекции — не о какой-то одной команде. Это о **возможности проектировать системы, включающие все эти типы — чтобы ваш агент мог продолжать работать, даже когда вас нет рядом.**
+
+Вам не нужно каждый раз вводить `/goal`. Но понимание того, откуда она взялась и почему выглядит именно так — это понимание ядра loop engineering. Более сложные циклы просто добавляют такие части, как планирование, параллелизм, изоляция и память, поверх этих же трёх основ: цель, верификация, условие остановки.
+
+## Июнь 2026: Три человека зажгли один и тот же фитиль за одну неделю
+
+В первую неделю июня 2026 года три практика, строящих инфраструктуру для кодовых агентов — не обмениваясь заметками — сказали одно и то же разными словами.
+
+**Питер Стайнбергер** (создатель OpenClaw, [его пост набрал 8 миллионов просмотров](https://x.com/steipete/status/2063697162748260627)): «Вы больше не должны делать запросы к кодовым агентам. Вы должны проектировать циклы, которые делают запросы к вашим агентам.»
+
+**Борис Черный** (руководитель Claude Code в Anthropic, [на подкасте Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): «Я больше не делаю запросы к Claude. У меня запущены циклы, которые делают запросы к Claude и решают, что делать. Моя работа — писать циклы.»
+
+**Эдди Османи** (инженерный руководитель в Google Chrome) [назвал концепцию](https://addyosmani.com/blog/loop-engineering/) 7 июня 2026 года и дал ей однострочное определение:
+
+> **Loop engineering — это замена себя как человека, который делает запросы к агенту. Вы проектируете систему, которая делает это вместо вас.**
+
+Черный сообщил цифры: более 30 дней подряд все вклад кода в Claude Code вносились автономно ИИ — 259 слитых PR, более 80% производственного кода, написанного Claude, и 76% успеха в открытых программных задачах.
+
+Три человека. Одна неделя. Один и тот же вывод. Не потому, что они скоординировались — а потому, что инфраструктура тихо пересекла порог. Агенты стали достаточно надёжными, чтобы завершать нетривиальные задачи без присмотра. Примитивы планирования (`/loop`, `/goal`, cron) теперь встроены в инструменты. Стоимость одного запуска агента упала достаточно низко, чтобы запускать его повторно по таймеру перестало выглядеть расточительным. Когда все части на месте, шаг, который их объединяет, становится очевидным для всех сразу.
+
+> Источник: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Внутри цикла vs. снаружи цикла
+
+Давайте сопоставим два конкретных сценария.
+
+**Сценарий А: Вы внутри цикла (лекции 1–12).**
+
+```mermaid
+flowchart TD
+ You["Вы"] -->|"Вручную вводите инструкцию"| Agent["AI-агент"]
+ Agent -->|"Создаёт вывод"| Result["Код / тесты / документация"]
+ Result -->|"Вы проверяете"| You
+ You -->|"Не удовлетворены, изменяете инструкцию"| Agent
+ You -->|"Удовлетворены, переходите к следующей задаче"| You
+```
+
+У вас есть полный комплект harness: `AGENTS.md` говорит агенту правила проекта, `feature_list.json` ограничивает область применения, `init.sh` обеспечивает согласованность окружения, `claude-progress.md` записывает прогресс. **Но каждый шаг всё ещё требует вашего ручного запуска.** Закончили одну функцию, прочитали файл прогресса, подумали, что дальше, ввели инструкцию. Вы — двигатель всего рабочего процесса.
+
+**Сценарий Б: Вы снаружи цикла (Loop Engineering).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Система циклов, которую вы спроектировали"]
+ Trigger["Автотриггер<br/>Расписание / Событие / Предыдущая задача завершена"] --> Discover["Обнаружить работу<br/>Прочитать файл прогресса / трекер задач"]
+ Discover --> Dispatch["Распределить<br/>Запустить суб-агента"]
+ Dispatch --> Verify["Проверить<br/>Тесты / линтер / Независимый агент-рецензент"]
+ Verify --> Persist["Сохранить состояние<br/>Обновить прогресс / Коммит / Открыть PR"]
+ Persist -->|"Работа осталась"| Discover
+ Persist -->|"Готово или заблокировано"| Inbox["Отправить в ваш входящий обзор"]
+ end
+ Inbox -->|"Вам нужно только принимать решения"| You["Вы"]
+```
+
+Вы больше не вводите инструкции. Система, которую вы спроектировали, обнаруживает работу, распределяет её, проверяет результаты, записывает состояние и решает следующий шаг. Ваша работа сводится к трём вещам: **определить цель и условие остановки до запуска, проверить вывод после завершения и корректировать правила, когда система сбивается с курса.** Рычаг смещается с «написания правильного запроса» на «проектирования правильного цикла».
+
+> Османи: «Год назад, если вам нужен был цикл, вы писали кучу bash и поддерживали эту кучу вечно, и она была ваша и только ваша. Теперь эти части просто поставляются внутри продуктов.» Вам не нужно строить с нуля. Вам нужно понять, как части сочетаются друг с другом.
+
+## Основные понятия
+
+- **Loop Engineering**: Проектирование системы, которая автоматически делает запросы к вашему агенту, заменяя ручной пошаговый ввод человеком. Человек перемещается изнутри цикла наружу, а рычаг смещается с «написания правильного запроса» на «проектирования правильного цикла».
+- **Режим `/goal`**: Простейший возможный цикл — предоставьте цель, метод верификации и условие остановки; агент циклически повторяет до достижения. Мост от ручных запросов к автономным циклам.
+- **Разделение генератора и оценщика**: Агент, который пишет код, и агент, который его проверяет, должны быть разделены. Модель, оценивающая свою собственную работу, ненадёжна; независимый верификатор — иногда использующий совершенно другую модель — это базовая гарантия надёжности любого цикла.
+- **Изоляция worktree**: Каждый параллельный агент работает в независимом git worktree, физически предотвращая конфликты файлов. Инфраструктурная предпосылка для параллельного выполнения множества агентов.
+- **Внешнее состояние**: Память, существующая вне одного разговора — markdown-файлы, трекеры задач, канбан-доски. Модели всё забывают между запусками; память должна жить на диске.
+- **Четыре тихих издержки**: Четыре скрытые издержки, которые становятся острее, чем дольше работает цикл — долг верификации, деградация понимания, когнитивная капитуляция, раздувание токенов. Циклы ускоряют не только вывод, но и риск.
+
+## Шесть примитивов цикла
+
+Османи разложил цикл на пять основных строительных блоков плюс один слой памяти, который пронизывает их все — всего шесть вещей, но слой памяти занимает особое положение: это не компонент на том же уровне, что и остальные; это позвоночник, от которого зависит всё остальное.
+
+На диаграмме ниже все шесть нарисованы в виде кольца, чтобы вы могли видеть полную картину с одного взгляда. Но помните: внешнее состояние — это не просто ещё одна остановка на цикле — это фундамент, на котором покоится весь цикл.
+
+```mermaid
+flowchart LR
+ A["Автоматизации<br/>Запланированные триггеры"] --> W["Worktrees<br/>Параллельная изоляция"]
+ W --> S["Навыки (Skills)<br/>Кодифицированные знания о проекте"]
+ S --> C["Коннекторы<br/>Доступ к внешним инструментам"]
+ C --> SA["Суб-агенты<br/>Разделение maker / checker"]
+ SA --> ES["Внешнее состояние<br/>Память между итерациями"]
+ ES --> A
+```
+
+### 1. Автоматизации — Сердцебиение
+
+Без автоматизации цикл — не цикл; это разовый запуск, который вы сделали вручную.
+
+И Claude Code, и Codex имеют полные системы планирования, но используют разные названия и слои. Примерно соответствие от самого лёгкого к самому тяжёлому:
+
+| Слой | Claude Code | Codex | Примечания |
+|-------|-------------|-------|-------|
+| Опрос внутри сессии | `/loop` | Thread automation | Привязан к текущей сессии, умирает при закрытии сессии |
+| Локальные запланированные задачи | Desktop scheduled tasks | Standalone automation (local mode) | Работает, пока машина включена, может обращаться к локальным файлам |
+| Облачные запланированные задачи | Cloud Routines | — (нет собственного облачного планировщика) | Работает, пока машина выключена |
+| Событийные триггеры | Routines (API / GitHub Webhook) | Standalone automation + plugins | Запускаются внешними событиями |
+| Полностью самохостные | GitHub Actions / самохостный cron | `codex exec` + cron | Полный контроль |
+
+**Вкладка Automations в Codex** — это точка входа для планирования. Выберите проект, запрос, частоту и то, будет ли он запускаться на вашей локальной копии или в фоновом worktree. Запуски, которые что-то находят, попадают во входящие Triage; запуски, которые ничего не находят, автоматически архивируются. OpenAI использует их внутри для ежедневной сортировки issues, сводок сбоев CI, брифингов по коммитам и поиска багов, введённых на прошлой неделе.
+
+Автоматизации Codex бывают двух видов:
+- **Thread automation** — повторяющиеся пробуждения в стиле heartbeat, привязанные к треду, с сохранением контекста. Хорошо для непрерывного сопровождения одной вещи, например мониторинга долго выполняющейся команды или опроса статуса PR. Аналог в Claude Code — `/loop`.
+- **Standalone automation** — каждый запуск начинается заново, результаты идут в Triage. Хорошо для ежедневных/еженедельных независимых задач, таких как брифинги или сканирование зависимостей. Аналог в Claude Code — Desktop scheduled tasks.
+
+Система Claude Code слоиста более детально:
+
+- **`/loop`** — лёгкое запланированное повторение внутри сессии. Работает, пока открыт ваш терминал, умирает при закрытии сессии, автоматически истекает через 7 дней. Хорошо для временного мониторинга во время вашей текущей рабочей сессии.
+- **Desktop scheduled tasks** — работает, пока ваша машина включена, переживает перезапуск сессии, интервалы на уровне минут. Хорошо для повторяющейся работы, требующей доступа к локальным файлам.
+- **Cloud Routines** — работает на облачной инфраструктуре Anthropic, переживает выключение вашей машины, минимальный интервал 1 час. Поддерживает три типа триггеров: запланированный, вызов API, GitHub webhook. Хорошо для ежедневных задач, не требующих вашего локального окружения.
+- **GitHub Actions / самохостный cron** — полностью под вашим контролем, работает как угодно. Хорошо для сценариев со специальными требованиями к окружению или безопасности.
+
+```bash
+# Claude Code: запускать тесты каждые 30 мин, исправлять падения (в текущей сессии)
+/goal 30m Run the test suite and fix any failing tests
+
+# Claude Code: проверять статус деплоя каждые 15 минут
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Автоматизации — это сердцебиение. Без них цикл — это чертёж, который никогда не просыпается.
+
+### 2. Worktrees — Изоляция в масштабе
+
+Как только вы запускаете более одного агента, конфликты файлов становятся неизбежным режимом отказа. Два агента, пишущие в один и тот же файл — это та же головная боль, что и два инженера, коммитящих в одни и те же строки без согласования друг с другом.
+
+`git worktree` решает это: каждый агент работает в своей собственной ветке в своей собственной директории. Они физически не могут затронуть рабочую копию друг друга.
+
+И Claude Code, и Codex поставляются с поддержкой worktree. Когда вы используете `--worktree` или `isolation: worktree` на суб-агенте, каждый помощник получает чистую независимую рабочую копию, которая сама себя очищает. Worktrees убирают механическую проблему коллизий — но помните: **ваша пропускная способность на рецензирование всё ещё является потолком.** Сколько параллельных агентов вы можете курировать, определяет, сколько worktree вы можете реально запустить.
+
+### 3. Навыки (Skills) — Перестаньте заново объяснять ваш проект
+
+Навык — это то, как вы перестаёте заново объяснять один и тот же контекст проекта каждую сессию. Это папка, содержащая `SKILL.md` с инструкциями и метаданными, а также опциональные скрипты, ссылки и активы.
+
+Codex и Claude Code поддерживают один и тот же формат. Навыки вызываются напрямую через `/skill-name` (Codex также поддерживает `$skill-name`), или запускаются неявно, когда задача соответствует описанию навыка.
+
+Навыки в фундаменте — это оплата вашего долга намерения. Агент начинает каждую сессию холодным — он заполняет любой пробел в вашем намерении уверенным предположением. Навык — это это намерение, записанное снаружи: соглашения, шаги сборки, «мы не делаем это так из-за того одного инцидента» — записано один раз, читается каждый запуск.
+
+### 4. Коннекторы — Ваш цикл касается настоящих инструментов
+
+Цикл, который может видеть только файловую систему — это маленький цикл. Коннекторы (построенные на протоколе MCP) позволяют агенту читать ваш трекер задач, запрашивать базу данных, обращаться к staging API, оставлять сообщение в Slack.
+
+И Codex, и Claude Code работают с MCP, поэтому коннектор, который вы написали для одного, обычно работает и в другом. Коннекторы — это разница между «вот исправление» и циклом, который открывает PR, связывает тикет Linear и пингует канал, как только CI позеленеет — сам, внутри вашей реальной среды, а не просто в терминале.
+
+### 5. Суб-агенты — Держите maker подальше от checker
+
+Самая структурно ценная дизайнерская опция в цикле — это разделение того, кто пишет, от того, кто проверяет. Модель, которая написала код, слишком щедро оценивает свою домашнюю работу. Второй агент, с другими инструкциями и иногда другой моделью, ловит то, во что первый агент сам себя убедил.
+
+Классическое разделение на три роли:
+
+```mermaid
+flowchart LR
+ Explorer["Агент-исследователь<br/>Прочитать кодовую базу, найти проблемы"] --> Implementer["Агент-реализатор<br/>Написать исправление, написать тесты"]
+ Implementer --> Verifier["Агент-верификатор<br/>Независимая проверка, запуск верификации"]
+ Verifier -->|"Не проходит"| Implementer
+ Verifier -->|"Проходит"| Output["Вывод"]
+```
+
+`/goal` в Claude Code запускает это под капотом — новая независимая сессия оценивает, должен ли цикл остановиться, а не сессия, которая выполняла работу. Это называется **разделением генератора и оценщика**, и это единственная самая важная гарантия надёжности в дизайне циклов.
+
+### 6. Внешнее состояние — Память цикла
+
+Модели всё забывают между запусками. Память должна жить на диске, а не в окне контекста.
+
+Это звучит слишком просто, чтобы иметь значение, но это тот же трюк, на котором зависит каждый долго работающий агент. Markdown-файл, доска Linear — что угодно, что живёт вне одного разговора и хранит, что сделано, что в работе и что дальше. Агент забывает. Репозиторий — нет.
+
+Эти шесть примитивов — ваш набор инструментов для дизайна циклов. Вам не нужны все они для каждого цикла. Но вам нужно знать, когда доставать какой.
+
+## Полный цикл, анатомированный
+
+Соедините все шесть вместе, и вот как выглядит реальный утренний цикл сортировки:
+
+```mermaid
+flowchart TD
+ Trigger["Каждое утро в 9:00<br/>Срабатывает автоматизация"] --> Read["Прочитать внешнее состояние<br/>Вчерашний claude-progress.md<br/>Открытые GitHub issues"]
+ Read --> Triage["Включается навык сортировки<br/>Классифицировать и приоритизировать находки"]
+ Triage --> Fork["Для каждой исполняемой задачи<br/>Ответвить изолированный Worktree"]
+ Fork --> Implement["Суб-агент-реализатор<br/>Написать исправление + тесты"]
+ Implement --> Verify["Суб-агент-верификатор<br/>Независимо запустить тесты + линтер + ревью"]
+ Verify -->|"Не проходит"| Retry["Очередь повторов<br/>Попробовать другой подход"]
+ Retry --> Implement
+ Verify -->|"Проходит"| PR["Коннектор: Открыть PR<br/>Связать issue, обновить файл прогресса"]
+ PR --> Memory["Записать во внешнее состояние<br/>Обновить claude-progress.md<br/>Записать результаты этого раунда"]
+ Memory -->|"Работа осталась"| Fork
+ Memory -->|"Всё готово или заблокировано"| Inbox["Результаты попадают во входящие Triage<br/>Ждут вашего обзора"]
+```
+
+Это уже не один запуск агента. Это непрерывно работающая система, которая просыпается каждое утро, сама убирает пол и ставит то, что требует вашего внимания, перед вами. Ваша роль становится такой: **проверять содержимое входящих, принимать решения и, когда вы замечаете закономерность, с которой система не может справиться, уточнять навыки и правила.**
+
+Черный использовал этот паттерн, чтобы слить 259 PR за 30 дней, ни разу не открыв IDE. Инженеры OpenAI использовали тот же паттерн, чтобы построить бета-продукт примерно на миллион строк — без написания ни одной строки кода самими.
+
+## Разделение генератора и оценщика: Почему нельзя позволять модели проверять свою собственную работу
+
+Это самый трудный урок в loop engineering.
+
+Ваш самый умный агент пишет прекрасный кусок кода. Логика ясная, комментарии подробные, и у каждой функции есть тест. Вы удовлетворены.
+
+Но вот вопрос: **если вы позволите агенту, который написал этот код, оценить, хорошо ли он справился, что он скажет?**
+
+Ответ снова и снова подтверждается опытом: он поставит себе высокую оценку. Не потому, что он нечестный, а потому, что он — автор; он убедил себя в правильности этого пути во время генерации. Когда он оглядывается назад, он не видит ошибок; он видит свой собственный процесс рассуждения.
+
+Это не проблема Claude. Это не проблема GPT. Это свойство всех генеративных моделей. **Модель — лучший адвокат по защите своего собственного вывода.**
+
+Исправление: никогда не позволяйте одной и той же сущности (одной и той же модели, одному и тому же запросу) делать и работу, и ревью.
+
+- `/goal` в Claude Code использует независимую супервайзорскую сессию для оценки, достигнута ли цель — а не сессия, которая её пыталась достичь.
+- Система суб-агентов в Codex позволяет вам определить агента-верификатора, использующего другую модель с другими усилиями рассуждения.
+- Общественная практика «adversarial verify» порождает N независимых скептиков на каждую находку, каждый из которых настроен опровергать — большинство отклонений убивает находку.
+
+Одно предложение для запоминания: **кто-то в вашей команде не должен вам верить.**
+
+## autoresearch Карпати: Образцовый цикл
+
+Если вы хотите увидеть, как выглядит хорошо спроектированный, реально работающий цикл — [autoresearch Карпати](https://github.com/karpathy/autoresearch) это учебный пример.
+
+В марте 2026 года Карпати выпустил 630-строчный Python-проект. Дайте ему один GPU и направление исследований, и он работает всю ночь — выполняя сотни экспериментов ML-обучения, сохраняя только те, которые действительно улучшают результат. Проект набрал 66 000+ звёзд в течение дней после релиза.
+
+### Три файла, три роли
+
+Во всей системе всего три основных файла, но разделение труда бритвенно-острое:
+
+| Файл | Кто редактирует | Что он делает |
+|------|-------------|-------------|
+| `prepare.py` | Никто (только чтение) | Подготовка данных, токенизатор, оценочный harness. Фиксированная инфраструктура. |
+| `train.py` (~630 строк) | **AI-агент** | Определение модели, оптимизатор, цикл обучения. Площадка для агента — можно менять что угодно. |
+| `program.md` | **Вы** | Методология исследований, написанная на естественном языке. Вы редактируете только это. Скажите агенту, как исследовать, как оценивать, чего не трогать. |
+
+Это трёхстороннее разделение — душа дизайна: **люди не трогают код, они трогают направление; агенты не трогают направление, они трогают код.** Ваша работа смещается с написания Python на «написание культуры исследовательской организации».
+
+### Вход: Как выглядит program.md
+
+`program.md` — это мозг цикла. Это не код — это руководство по исследованию, написанное на Markdown. Примерно содержит:
+
+- **Цель**: оптимизировать `val_bpb` (валидационные биты на байт, чем ниже, тем лучше)
+- **Ограничения**: не трогать `prepare.py`, оставаться в бюджете VRAM, фиксированное 5-минутное обучение
+- **Направления поиска**: попробовать разные архитектуры, оптимизаторы, расписания LR
+- **Правила оценки**: что считается улучшением, как логировать результаты, что делать при неудаче
+- **Железное правило**: никогда не останавливаться. Как только цикл запустился — продолжать вечно
+
+Ваш стартовый запрос к агенту может быть коротким, как одно предложение:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Остальное — на усмотрение агента, читающего документ и принимающего собственные решения.
+
+### Девятишаговый цикл-рассчёска
+
+В центре autoresearch — **рассчёска** (ratchet): она движется только вперёд, никогда назад. Каждая итерация строго следует девяти шагам:
+
+```mermaid
+flowchart TD
+ 1["1. Прочитать направление<br/>Загрузить program.md"] --> 2["2. Обследовать текущее состояние<br/>Прочитать train.py + прошлые результаты"]
+ 2 --> 3["3. Предложить гипотезу<br/>Придумать изменение для пробы"]
+ 3 --> 4["4. Изменить код<br/>Отредактировать train.py"]
+ 4 --> 5["5. Снимок<br/>git commit"]
+ 5 --> 6["6. Запустить обучение<br/>Фиксированные 5 минут реального времени"]
+ 6 --> 7{"7. Оценить<br/>Улучшился ли val_bpb?"}
+ 7 -->|Да| 8a["8a. Оставить<br/>Коммит остаётся<br/>Записать в results.tsv"]
+ 7 -->|Нет| 8b["8b. Откатить<br/>git reset HEAD~1<br/>Залогировать неудачу"]
+ 8a --> 9["9. Следующий раунд<br/>Вернуться к шагу 1"]
+ 8b --> 9
+```
+
+Он выполняет примерно 12 экспериментов в час. Ночная сессия (8 часов) — это около 100 экспериментов. Сам Карпати запускал его 2 дня — ~700 экспериментов.
+
+Фиксированный 5-минутный бюджет реального времени — ключевой дизайнерский выбор: независимо от того, что агент меняет, каждый эксперимент занимает ровно столько же времени. Это означает, что все результаты напрямую сравнимы при одинаковом бюджете времени — без споров о «этот запускался дольше, поэтому он лучше».
+
+### Вывод: Что вы видите, когда просыпаетесь
+
+После ночи циклической работы вы утром садитесь и находите три вещи:
+
+**1. История Git (движущаяся вперёд рассчёска)**
+
+На основной ветке остаются только коммиты, которые действительно улучшили результат. Всё, что не сработало, было откачено. `git log` — это проверенный исследовательский журнал.
+
+**2. results.tsv (полная запись экспериментов)**
+
+Каждый отдельный эксперимент — успех или неудача — логируется:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Исследовательский журнал (собственное резюме агента)**
+
+Агент пишет понятные комментарии к коммитам о том, что он пробовал, что сработало, что нет и что он планирует попробовать дальше. Вы их читаете — вам не нужно читать диффы кода.
+
+### Что он реально нашёл
+
+Результаты начального 2-дневного запуска Карпати с ~700 экспериментами:
+
+- Из ~700 попыток было найдено примерно **20 складывающихся реальных улучшений**
+- Время обучения nanochat на уровне GPT-2 на 8×H100 сократилось с **2,02 часа → 1,80 часа**, примерно **на 11% быстрее**
+- Находки включали: корректировки скорости обучения, тюнинг оптимизатора, замены активации, оптимизации паттернов внимания и т.д.
+
+Все ли улучшения были потрясающими открытиями? Нет. Большинство были небольшими оптимизациями, которые складывались вместе. Но эти 20 действительных улучшений заняли бы у человеческого исследователя недели ручной работы — агент сделал это за 48 часов.
+
+### Самый говорящий деталь: Цикл написан на английском, а не на коде.
+
+`program.md` — это документ Markdown, а не скрипт Python. Он описывает методологию исследования — что изменять, что оставлять в покое, как оценивать, как обрабатывать случаи неудачи и одно железное правило: **никогда не просить человеческой помощи, просто продолжать.** Кодовый агент читает этот документ и выполняет его бесконечно.
+
+Это шаблон для loop engineering: не давайте агенту задачу. Дайте ему **методологию**. Пусть методология будет циклом. Один `program.md`, 630 строк клеевого кода, и всё остальное — агент, запускающий сам себя.
+
+## Четыре тихих издержки
+
+Когда цикл начинает работать, вы не увидите проблем сразу. Следующие четыре издержки накапливаются тихо, и к тому времени, как вы заметите, вы, возможно, уже заплатили дорого.
+
+### 1. Долг верификации
+
+Быстрые циклы соблазняют вас пропустить верификацию. «Выглядит нормально» — это не то же самое, что «подтверждено правильным». Чем больше кода генерирует цикл без присмотра, тем быстрее накапливается долг верификации. Исправление: **условия остановки должны быть машинно-проверяемыми, никогда «кажется примерно правильным».**
+
+### 2. Деградация понимания
+
+Чем быстрее цикл поставляет код, тем дальше ваше понимание собственной кодовой базы уходит от реальности. У команды Черного 80% кода было написано агентами — что означает, что большая часть кода команды не была написана человеком. Если вы не читаете и не используете то, что производит цикл, ваше понимание непрерывно деградирует. **Быстрые циклы требуют быстрого чтения.**
+
+### 3. Когнитивная капитуляция
+
+Когда цикл работает гладко, самая комфортная поза — перестать иметь мнение. Берите то, что он возвращает, не думайте о выводе. Но именно здесь начинается опасность — вы используете цикл, чтобы избежать мышления, а не чтобы усилить мышление. Предупреждение Османи: «Два человека могут построить абсолютно одинаковый цикл и получить противоположные результаты. Один использует его, чтобы быстрее идти в работе, которую он понимает; другой использует его, чтобы избежать понимания работы. Цикл не знает разницы. Вы знаете.»
+
+### 4. Раздувание токенов
+
+Каждая итерация цикла накапливает больше контекста: написанный код, встреченные ошибки, принятые решения. Без управления контекстом размер запроса растёт примерно квадратично с количеством шагов. Codex решает это с помощью автоматического уплотнения контекста — специальное API сжимает старые повороты разговора в зашифрованные сводки содержания, сохраняя существенные знания при отбрасывании избыточных деталей. Это инженерный вопрос, который вы должны решить с самого первого цикла, а не прикручивать позже.
+
+## Построение вашего первого цикла
+
+Вам не нужно начинать с конвейера масштаба Stripe, сливающего 1300 PR в неделю. Начните с самой маленькой вещи, которая работает.
+
+### Шаг 1: Выберите одну повторяющуюся задачу
+
+Найдите то, что вы делаете вручную как минимум два раза в неделю. Примеры:
+- Открывать GitHub утром, проверять новые issues, сортировать и отвечать
+- Запускать линтер и тесты перед каждым ревью PR
+- Обновлять документацию по прогрессу в конце каждого дня
+
+### Шаг 2: Напишите цель и условие остановки
+
+Превратите задачу в то, что может понять `/goal`:
+
+```markdown
+Goal: Check the 10 most recent issues in the repo.
+For each issue:
+ - If it already has clear labels and an assignee, skip
+ - If untagged, add appropriate labels based on content
+ - If fixable in under 10 minutes, create a branch and attempt a fix
+Stop when: All qualifying issues have been processed, or an issue requires human decision.
+```
+
+### Шаг 3: Разделите maker и checker
+
+Не позволяйте одному и тому же агенту и писать код, и оценивать его. Разделите ваш цикл на две роли:
+- Реализатор: читает issue, пишет исправление, пишет тесты
+- Верификатор: независимо запускает тесты, проверяет дифф, оценивает, действительно ли исправление решает проблему
+
+### Шаг 4: Добавьте память
+
+Используйте markdown-файл, чтобы записывать, что случилось в каждом запуске цикла. Следующий запуск начинается с чтения этого файла — он знает, что было сделано, что в ожидании, что было заблокировано. Это лучше любой сложной базы данных.
+
+### Шаг 5: Установите таймер
+
+Используйте `/loop` или cron вашей ОС, чтобы цикл запускался без вас. Начните с одного раза в день. Наблюдайте неделю.
+
+### Лестница зрелости
+
+Вам не нужно достигать вершины одним прыжком. Внедрение циклов — это лестница:
+
+1. **Уровень 1: Исполнитель целей** — Вы можете использовать `/goal`, чтобы дать задачу с условием остановки; агент циклически повторяет до достижения.
+2. **Уровень 2: Запланированная одна задача** — Одна автоматизация выполняет одну задачу по таймеру (например, утренняя проверка CI).
+3. **Уровень 3: Мульти-агентный цикл** — Разделение maker и checker; каждая находка ответвляет изолированный worktree.
+4. **Уровень 4: Самоподдерживающийся цикл** — Цикл автоматически обнаруживает следующую задачу из внешнего состояния; он решает, что делать дальше.
+5. **Уровень 5: Оркестрация флота** — Несколько циклов работают параллельно, независимо, но разделяют слой памяти.
+
+Большинство команд сейчас находятся между Уровнем 2 и Уровнем 3. Уровень 1 — самый быстрый путь к получению отдачи.
+
+## Ключевые выводы
+
+- **Loop Engineering не заменяет Harness Engineering — он строит этаж выше.** Harness делает одиночные запуски надёжными. Цикл делает непрерывные запуски автономными.
+- **`/goal` — это простейший возможный цикл:** цель + верификация + условие остановки. Эти три вещи переносят вас изнутри цикла наружу.
+- **Шесть примитивов (Автоматизации / Worktrees / Навыки / Коннекторы / Суб-агенты / Внешнее состояние) — это строительные блоки цикла.** Не все они каждый раз, но вам нужно знать, когда доставать какой.
+- **Maker и checker должны быть разделены.** Модель, оценивающая свою собственную работу, ненадёжна. Независимый верификатор — иногда совершенно другая модель — это базовая гарантия надёжности любого цикла.
+- **Циклы делают генерацию почти бесплатной и оставляют суждение как дефицитный ресурс.** Время, которое вы сэкономили, — не для отдыха. Оно для принятия большего количества суждений.
+- **Четыре тихих издержки становятся острее, чем дольше работают циклы:** долг верификации, деградация понимания, когнитивная капитуляция, раздувание токенов. Циклы ускоряют вывод — и риск.
+- **Начинайте с малого.** Один `/goal`, один cron, один markdown-файл памяти. Увидьте отдачу, затем стройте вверх.
+
+## Дополнительная литература
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — общедоступный корпус из 50 реальных циклов
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Лекция 12: [Leave a Clean Handoff at the End of Every Session](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Предпосылка для циклов: каждая сессия оставляет чистое состояние, чтобы следующий раунд мог запуститься автоматически
+- Лекция 5: [Keep Long-Running Tasks Continuous Across Sessions](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Предварительные знания о внешнем состоянии и памяти
+- Лекция 11: [Why Observability Belongs Inside the Harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Чем быстрее работает цикл, тем больше вам нужна наблюдаемость, чтобы ловить проблемы
+- Лекция 8: [Why Feature Lists Are Harness Primitives](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Списки функций — естественный источник данных для самоподдерживающегося цикла, чтобы обнаруживать следующую задачу
+
+## Упражнения
+
+1. **Превратите повторяющуюся задачу в `/goal`:** Найдите то, что вы вручную делаете как минимум дважды в неделю. Запишите её цель, метод верификации и условие остановки. Запустите один раз с `/goal` и сравните время и качество с ручным выполнением. Это ваш первый шаг от Harness к Loop.
+
+2. **Разделите maker и checker:** Выберите задачу, которую вы ранее поручали агенту выполнить. На этот раз напишите два разных запроса: один для агента-реализатора и один для агента-верификатора (используйте разные модели — например, Claude для реализации, GPT для верификации, или наоборот). Верификатор должен указывать на конкретные проблемы с цитируемыми доказательствами. Запишите количество и тип проблем, найденных в каждом режиме.
+
+3. **Дайте вашему циклу память:** Создайте markdown-файл состояния для вашего цикла. В каждой итерации записывайте: что было сделано в этом раунде, результаты верификации, статус (прошло/не прошло/заблокировано) и что делать дальше. Запустите три раунда и наблюдайте разницу в поведении между наличием и отсутствием файла памяти.
+
+4. **Аудитируйте тихие издержки вашего цикла:** После того как цикл проработал час, оцените эти четыре метрики:
+ - Сколько верификации было «кажется правильным» вместо «машинно подтверждено»? (Долг верификации)
+ - Насколько хорошо вы можете объяснить код, который ваш цикл создал совсем недавно? (Деградация понимания)
+ - Сколько раз вы подумали «я посмотрю позже» и так и не посмотрели? (Когнитивная капитуляция)
+ - Как меняется размер контекста цикла? Повторяет ли он избыточную информацию? (Раздувание токенов)
diff --git a/docs/ru/projects/project-07-loop-engineering-first-loop/index.md b/docs/ru/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..f467134
--- /dev/null
+++ b/docs/ru/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Проект 07. Постройте свой первый автоматизированный цикл
+
+> Связанная лекция: [L13. Why You Need to Stop Prompting Your Agent](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Что вы будете делать
+
+Это переходный проект от «Harness» к «Loop». Вы уже знаете, как настроить агента с правильным окружением, инструкциями и обратной связью — теперь вы превратите эту настройку в цикл, который работает сам по себе.
+
+Вы проведёте три прогрессивных эксперимента: сначала превратите задачу из ручной в `/goal`, затем превратите задачу мониторинга в таймер `/loop`, и наконец построите полный цикл maker-checker, чтобы ощутить, что это такое, когда **вы выходите за рамки цикла.**
+
+## Файлы проекта
+
+Путь в репозитории: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Директория | Что внутри | Что вы делаете |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Небольшой проект базы знаний с полным комплектом harness (финальное состояние P06), включая AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Превратите этот комплект harness в тот, что может циклически работать автоматически. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Полные реализации трёх циклов: целевой цикл, таймерный цикл, цикл maker-checker, плюс файлы состояния цикла и скрипты верификации. | Справочный материал по паттернам дизайна циклов и управлению состоянием. |
+
+## Инструменты, которые вы будете использовать
+
+- Claude Code или Codex
+- Git
+- Ваш полный комплект harness из P06
+- Терминальный мультиплексор (tmux или screen, для наблюдения за долго работающими циклами)
+- Опционально: GitHub Actions или cron (для продвинутых событийно-ориентированных / запланированных экспериментов)
+
+## Шаги
+
+### Подготовка
+
+1. Начните с того же коммита, на котором вы закончили P06.
+2. Создайте три ветки: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Подтвердите, что ваш harness работает: запустите init.sh, проверьте, что файл состояния, список функций и документы передачи на месте.
+4. Выберите **целевую задачу**, над которой цикл будет работать повторно. Выберите что-то среднего размера с чёткими критериями завершения — например, «добавить модульные тесты ко всем модулям, достигнув 80% покрытия» или «добавить валидацию входных данных ко всем API-точкам».
+
+### Эксперимент 1: Целевой цикл — от ручного запуска к автозапуску
+
+Переключитесь на ветку `p07-goal-loop`.
+
+1. **Напишите описание цели**: Превратите выбранную задачу в файл `goal.md`, содержащий:
+ - Чёткая цель («что считается готовым»)
+ - Метод верификации («как подтвердить, что готово» — запустить тесты? запустить линтер? проверить покрытие?)
+ - Условие остановки («когда следует остановиться» — максимальное количество шагов? лимит времени? лимит бюджета?)
+ - Ограничения («чего не трогать» — производственная конфигурация, схема базы данных и т.д.)
+
+2. **Первый ручной запуск**: Дайте задачу агенту вручную, сами. Запишите, сколько шагов потребовалось, сколько раз вы вмешались, и качество результата. Это ваша базовая линия.
+
+3. **Запуск с `/goal`**: Используйте тот же `goal.md` как вход и запустите его в режиме `/goal`. Агент циклически повторяет сам, пока цель не будет достигнута или не сработает условие остановки.
+
+4. **Сравните результаты**:
+ - Разница в количестве шагов
+ - Разница в количестве ваших вмешательств
+ - Разница в качестве результата (используя тот же стандарт верификации)
+ - Разница в потраченном вами времени
+
+5. **Итерируйте над goal.md**: Если результаты плохие, пересмотрите описание цели и запустите снова. Продолжайте, пока не будете удовлетворены результатами, или пока не подтвердите предел того, что может сделать целевой цикл с этой задачей.
+
+### Эксперимент 2: Таймерный цикл — Превратите мониторинг в сердцебиение
+
+Переключитесь на ветку `p07-timer-loop`.
+
+1. **Выберите задачу мониторинга**: Найдите повторяющуюся проверку, которую вы обычно делаете вручную. Например:
+ - Запускать набор тестов каждый час, исправлять падения
+ - Проверять обновления безопасности зависимостей каждое утро
+ - Проверять нарушения стиля кодирования после каждого коммита
+ - Периодически сканировать комментарии TODO, чтобы увидеть, какие из них устарели
+
+2. **Напишите запрос/скрипт мониторинга**: Чётко изложите шаги мониторинга — что проверять, что делать при обнаружении проблем и когда вызывать человека.
+
+3. **Запуск с `/loop` (или Thread automation в Codex)**:
+ - Установите разумный интервал (рекомендуется 10-30 минут — слишком коротко и вы будете раздражены, слишком долго и вы не увидите эффекта)
+ - Дайте ему работать как минимум 2 часа (или займитесь чем-то другим и вернитесь позже)
+
+4. **Запишите результаты**:
+ - Сколько проблем он нашёл?
+ - Сколько он исправил сам?
+ - Сколько было ложных срабатываний?
+ - Сколько он усугубил?
+ - Сколько времени вы потратили на сопровождение его результатов?
+
+5. **Размышление**: Стоит ли автоматизировать эту задачу мониторинга? Сравните сэкономленное время против времени, потраченного на сопровождение. Если не стоит — вы выбрали не ту задачу, или цикл плохо спроектирован?
+
+### Эксперимент 3: Цикл Maker-Checker — Выйдите из цикла
+
+Переключитесь на ветку `p07-maker-checker`.
+
+Это самый важный из трёх экспериментов. Вы построите **полный цикл, которому не нужно, чтобы вы были рядом:**
+
+1. **Спроектируйте структуру цикла**:
+ - **Maker-агент**: реализует, пишет код, изменяет файлы
+ - **Checker-агент**: верифицирует, запускает тесты, делает ревью кода, проходит / не проходит
+ - **Файл состояния** (`loop-state.md`): записывает текущий раунд, что было сделано, результаты верификации, что дальше
+ - **Условие остановки**: N последовательных прохождений, или достигнуто максимальное количество раундов
+
+2. **Напишите три запроса**:
+ - Инструкции для maker (что делать, как делать, чего не трогать)
+ - Инструкции для checker (что верифицировать, как верифицировать, что считается проходом, как давать обратную связь)
+ - Логика управления циклом (кто ходит первым, как работает передача, как запустить следующий раунд)
+
+3. **Запустите как минимум 5 раундов**:
+ - Раунд 1: Maker реализует → Checker верифицирует → Не прошло → Обратная связь maker'у
+ - Раунд 2: Maker дорабатывает на основе обратной связи → Checker верифицирует → ...
+ - ...
+ - До последовательного прохода, или пока вы не остановите
+
+4. **Запишите состояние каждого раунда**:
+ - Номер раунда
+ - Что сделал Maker
+ - Какие проблемы нашёл Checker
+ - Прошло / не прошло
+ - Вмешались ли вы? (если да — почему?)
+
+5. **Финальный ретроспектив**:
+ - Сколько раз вы вмешались? Почему?
+ - Что бы случилось, если бы вы не вмешались?
+ - Пропустил ли Checker какие-то проблемы?
+ - Продолжал ли Maker делать одну и ту же ошибку?
+ - Где потолок качества этого цикла? Возможности maker, или возможности checker?
+
+## Как измерять результаты
+
+| Метрика | Эксп 1 (Цель) | Эксп 2 (Таймер) | Эксп 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Скорость завершения задачи | Была ли достигнута цель? | Сколько циклов мониторинга отработало? | Сколько раундов до прохода? |
+| Человеческие вмешательства | Сколько раз вы вмешались? | Сколько времени вы потратили на сопровождение? | Сколько раз вы вмешались? |
+| Качество результата | Как это сравнивается с ручным? | Уровень ложных срабатываний? Пропущенные проблемы? | Сколько проблем нашёл Checker, которые вы бы не нашли? |
+| Экономия времени | Сколько времени вы сэкономили? | Стоит ли автоматизировать? | Время, потраченное на проектирование цикла против сэкономленного времени |
+| Надёжность | Было ли условие остановки доверительным? | Убежало ли оно? | Может ли цикл застрять на одном месте? |
+
+## Что сдавать
+
+- `goal.md` (описание цели эксперимента 1, как минимум две итерации)
+- Заметки со сравнением эксперимента 1: ручной режим против целевого цикла
+- Запрос мониторинга эксперимента 2 + журнал 2-часового запуска
+- Три запроса эксперимента 3 (Maker / Checker / Управление циклом)
+- `loop-state.md` эксперимента 3 (записано как минимум 5 раундов)
+- Финальный ретроспектив: выводы из всех трёх экспериментов, как изменилось ваше понимание loop engineering, что хорошие кандидаты для циклизации, а что — нет
+
+## Связанные лекции
+
+- [Лекция 13 — Why You Need to Stop Prompting Your Agent](../../lectures/lecture-13-loop-engineering/index.md)
+- [Лекция 12 — Why Every Session Must Leave a Clean State](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (каждый раунд цикла нуждается в чистом состоянии)
+- [Лекция 11 — Why Observability Belongs Inside the Harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (вам нужно видеть, что происходит внутри цикла)
+- [Лекция 05 — Why State Files Are the Backbone of Continuity](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (файлы состояния цикла — это расширение файлов состояния)
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/tr/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/tr/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/code/index.md b/docs/tr/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/tr/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/tr/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/tr/lectures/lecture-13-loop-engineering/index.md b/docs/tr/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..d77ca97
--- /dev/null
+++ b/docs/tr/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Kod örnekleri: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Uygulama projesi: [Proje 07. İlk otomatik loop'unuzu oluşturun](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Ders 13. Manuel Prompting'den Otonom Loop'lara
+
+İlk on iki derste öğrendiklerinizin hepsi tek bir varsayıma dayanıyor: **klavyenin başında oturup teker teker talimatlar yazıyorsunuz.**
+
+`AGENTS.md` yazdınız (Ders 1–4), durum yönetimi oluşturdunuz (Ders 5–6), özellik listeleriyle kapsamı kısıtladınız (Ders 7–8), oturum sonunda temiz devirler bıraktınız (Ders 9, 12) ve runtime'ı gözlemlenebilir kıldınız (Ders 10–11). Ama tüm bunların tetikleyicisi her zaman siz oldunuz. Ajan ne zaman çalışmaya başlayacağına kendi kendine karar vermedi — çünkü kimse "başlat" tuşuna basmadı.
+
+Bu ders, başlat düğmesini sisteme teslim etmekle ilgili. Kontrolü bırakmak değil — bir sonraki katmana yükseltmek.
+
+## /goal: Mümkün olan en basit loop
+
+Loop mühendisliğine en iyi giriş, karmaşık bir mimari diyagramı değil — tek bir komuttur.
+
+2026 başlarında Claude Code ve OpenAI Codex bağımsız olarak aynı özelliği yayınladı: `/goal`. Terminal'e şunu yazarsınız:
+
+```
+/goal "Tüm testler geçsin, sıfır lint uyarısı olsun, main'e merge edilsin"
+```
+
+Sonra dizüstü bilgisayarınızı kapatıp uyumaya gidersiniz. Sekiz saat sonra ajan analiz etmiş, kodlamış, test etmiş, düzeltmiş ve kendi kendine merge etmiştir. Başarısızlıkta yeniden dener, takıldığında yaklaşımı değiştirir ve bittiğinde durur — omzunda durup "tekrar dene" demenize gerek kalmadan.
+
+`/goal` ile geleneksel bir prompt arasındaki tek fark bir şeydir. Ama o bir şey her şeyi değiştirir:
+
+| | Geleneksel Prompt | `/goal` |
+|---|---|---|
+| Ne sağlarsınız | Sırada ne yapılacağı | Son durumun neye benzeyeceği |
+| Ajan ne yapar | Bir kez yürütür | Ulaşılana kadar döner |
+| Biten kim tarafından yargılanır | Siz | Doğrulanabilir bir durdurma koşulu |
+| Ne zaman uzaklaşabilirsiniz | Uzaklaşamazsınız | `/goal` yazdığınız anda |
+
+`/goal` aslında bir loop'tur. Tam olarak üç parçası vardır: **bir hedef, bir doğrulama yöntemi ve bir durdurma koşulu.** Sadece bu üç şey sizi loop'un içinden dışına taşır.
+
+### `/goal` organik olarak nasıl büyüdü
+
+`/goal` sıfırdan bir anda ortaya çıkmadı. Gündelik iş akışlarından kademeli olarak büyüdü ve kabaca dört aşamadan geçti:
+
+**Aşama 1: Manuel teker teker prompting.** En erken çalışma yöntemi ileri geriydi: "bir fonksiyon yaz", "test ekle", "bu mantığı düzelt." Ajan her adımdan sonra durur ve sırada ne olduğunu söylemenizi beklerdi. Tüm pipeline'ın zamanlayıcısı sizdiniz.
+
+**Aşama 2: Birden fazla adım içeren uzun prompt'lar.** Sonra insanlar adımları üst üste koyan daha uzun prompt'lar yazmaya başladı: "önce kodu analiz et, sonra uygulamayı yaz, sonra testleri çalıştır, eğer başarısız olursa düzelt." Ajan tek seferde birkaç adım çalıştırabiliyordu, ama yine de izlemeniz gerekiyordu — çünkü yolun ortasında sapabilir veya bir adımı bitirip sırada ne yapacağını bilemeyebilirdi.
+
+**Aşama 3: Ajan öz-yansıtma ve öz-yönlendirme.** Ondan sonra ajanlar "iç gözlem" kazandı — her adımdan sonra sonuca bakıp sırada ne yapacaklarına karar verirlerdi. Bir hedef verirdiniz, kendileri parçalara ayırır ve kendi kendilerine yeniden denerlerdi. Ama bir sorun ortaya çıktı: ne zaman dururlar? Ajanın kendisinden gelen "bitti" sayılır mı? Pratik sürekli aynı cevabı verdi — hayır. Ajanlar zaferi çok kolay ilan eder.
+
+**Aşama 4: Bağımsız durdurma yargısı — `/goal`.** Son adım, "bitip bitmediğini yargılamayı" işi yapan ajanın elinden alıp bağımsız bir yargıcı teslim etmekti. Farklı bir model, bir betik veya bir test komutu olabilirdi — ama kural aynıydı: kodu yazan kişi ödevini kendi notlandıramaz. Bu noktada `/goal` gerçekten çalıştı: hedefi verirsiniz, döner, bağımsız bir yargıcı ne zaman duracağına karar verir ve siz uzaklaşabilirsiniz.
+
+Bu dört aşama hiçbir şirketin planladığı bir yol haritası değildi. Ajanlarla kod yazan herkesin aynı acı noktaları tarafından iterek bağımsız olarak vardığı yoldur. Claude Code ve Codex'in `/goal`'ı 2026 başlarında neredeyse eş zamanlı olarak yayınlaması tesadüf değildi — zamanı gelmişti.
+
+### Birden fazla loop türü var
+
+`/goal` anlaşılması en kolay loop'tur, ama tek tür değildir. Loop'lar nasıl tetiklendiklerine ve nasıl durduklarına göre kategorilere ayrılır:
+
+| Tür | Tetikleyici | Durdurma Koşulu | Claude Code | Codex | En İyi Kullanım |
+|------|---------|----------------|-------------|-------|----------|
+| **Sıra tabanlı loop** | Her prompt'u manuel olarak yazarsınız | Ajan bittiğini düşünür veya siz müdahale edersiniz | Normal sohbet | Normal sohbet | Küçük görevler, keşif çalışması |
+| **Hedef tabanlı loop** | Bir hedef verirsiniz | Bağımsız değerlendirici bittiğini onaylar veya maksimum tur sayısına ulaşılır | `/goal` | `/goal` (manuel etkinleştirme gerekli) | Net tamamlama kriterleri olan karmaşık görevler |
+| **Zaman tabanlı loop** | Planlanan aralık (her N dakika/saat) | Manuel olarak durdurursunuz veya işi tamamladıktan sonra çıkar | `/loop` | Thread otomasyonu | Durum yoklama, periyodik kontroller, tekrarlayan işler |
+| **Olay odaklı loop** | Dış olay (PR açıldı, CI başarısız oldu, yeni issue) | Olayı işledikten sonra durur veya yeniden deneme sınırına ulaşır | Routines (API / GitHub Webhook) | Standalone otomasyon + eklentiler | Reaktif iş akışları, CI/CD entegrasyonu |
+
+Bunlar birbiriyle yarışan şeyler değil — farklı işler için farklı araçlar. Sıra tabanlı küçük şeyler için iyidir. Net bir bitiş çizgisi olduğunda `/goal` kullanın. Bir şeyi izlemeniz gerektiğinde `/loop` kullanın. Dış sistemlerle entegre olduğunuzda olay odaklı kullanın.
+
+### `/goal` ve `/loop`'u karıştırmayın
+
+İkisinin de adında "loop" var ama tamamen farklı sorunları çözerler:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Ne olduğu** | Büyük bir görev, bitene kadar çalışır | Küçük bir eylem, aralıkla tekrarlar |
+| **Durdurma koşulu** | Hedefe ulaşılır veya bütçe tükenir | Manuel olarak durdurursunuz veya görev kendi kendine çıkar |
+| **Zaman profili** | Bir uzun çalışma, saatler veya günler sürebilir | Periyodik kısa patlamalar, her çalışma birkaç dakika olabilir |
+| **İlerleme** | Her iterasyonda bitiş çizgisine yaklaşır | Her çalışma bağımsızdır, kümülatif ilerleme yoktur |
+| **Benzetme** | Maraton koşmak — başlangıç silahı ateşlenir, bitiş çizgisinde durursunuz | Çalar saat — programa göre çalar, kapatırsınız |
+| **Tipik kullanım** | "Ödeme sistemini test kapsamıyla tam olarak uygula" | "Her 15 dakikada bir CI bozuldu mu kontrol et" |
+
+Yaygın bir hata: `/goal` olması gereken bir şeyi `/loop`'a sokmak. `/loop 10m "ödeme sistemini uygulamaya devam et"` yazmak gibi — bu yanlıştır. `/loop` aynı talimatı her seferinde bağımsız olarak çalıştırır, kaldığı yerden devam etmez. Sadece aynı başlangıç noktasını tekrar tekrar alırsınız.
+
+**Hangisini kullanacağınıza dair tek cümlelik test: bu şeyin sonu var mı?**
+- Sonu var → `/goal`
+- Sonu yok, sadece izlemeniz gerekiyor → `/loop`
+
+Bu dersin konusu olan Loop Mühendisliği, tek bir komutla ilgili değildir. **Tüm bu türleri içeren sistemler tasarlayabilmekle ilgilidir — böylece ajanınız orada olmasanız bile çalışmaya devam edebilir.**
+
+Her seferinde `/goal` yazmak zorunda değilsiniz. Ama nereden geldiğini ve neden göründüğü gibi olduğunu anlamak — loop mühendisliğinin özünü anlamaktır. Daha karmaşık loop'lar sadece zamanlama, paralellik, izolasyon ve bellek gibi parçaları aynı üç temel üzerine ekler: hedef, doğrulama, durdurma koşulu.
+
+## Haziran 2026: Üç kişi aynı haftada aynı sigortayı yaktı
+
+2026 Haziran'ın ilk haftasında, kodlama ajan altyapısı inşa eden üç pratisyen — notlar karşılaştırmadan — farklı kelimelerle aynı şeyi söyledi.
+
+**Peter Steinberger** (OpenClaw yaratıcısı, [yazısı 8 milyon görüntüleme ulaştı](https://x.com/steipete/status/2063697162748260627)): "Artık kodlama ajanlarını prompt etmemelisiniz. Ajanlarınızı prompt eden loop'lar tasarlamalısınız."
+
+**Boris Cherny** (Anthropic'te Claude Code başkanı, [Acquired podcast'te](https://x.com/rohanpaul_ai/status/2063289804708835412)): "Artık Claude'ı prompt etmiyorum. Claude'ı prompt eden ve ne yapacağını çözen loop'larım var. Benim işim loop yazmak."
+
+**Addy Osmani** (Google Chrome mühendislik lideri) [7 Haziran 2026'da kavramı adlandırdı](https://addyosmani.com/blog/loop-engineering/) ve tek satırlık bir tanım verdi:
+
+> **Loop mühendisliği, ajanı prompt eden kişi olarak kendinizi değiştirmektir. Onun yerine bunu yapan sistemi tasarlarsınız.**
+
+Cherny sayıları açıkladı: art arda 30 günden fazla, Claude Code'a tüm kod katkıları AI tarafından özerk olarak yapıldı — 259 merge edilmiş PR, üretim kodunun %80'inden fazlası Claude tarafından yazıldı ve açık uçlu yazılım görevlerinde %76 başarı oranı.
+
+Üç kişi. Bir hafta. Aynı sonuç. Koordine oldukları için değil — altyapı sessizce bir eşiği aştığı için. Ajanlar önemsiz olmayan görevleri denetimsiz bitirecek kadar güvenilir hale gelmişti. Zamanlama ilkelleri (`/loop`, `/goal`, cron) artık araçlara yerleşmişti. Tek bir ajan çalıştırmanın maliyeti, bir zamanlayıcıda tekrar tekrar çalıştırmanın israfçı görünmemesini sağlayacak kadar düşmüştü. Tüm parçalar mevcut olduğunda, onları birleştiren hareket herkes için aynı anda açık hale gelir.
+
+> Kaynak: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Loop'un içi vs. dışı
+
+İki somut senaryoyu karşılaştıralım.
+
+**Senaryo A: Loop'un içindesiniz (Ders 1–12).**
+
+```mermaid
+flowchart TD
+ You["Siz"] -->|"Talimatı manuel yaz"| Agent["AI Ajanı"]
+ Agent -->|"Çıktı üretir"| Result["Kod / testler / dokümanlar"]
+ Result -->|"Siz incelersiniz"| You
+ You -->|"Memnun kalmadınız, talimatı değiştirin"| Agent
+ You -->|"Memnun kaldınız, sonraki göreve geçin"| You
+```
+
+Tam bir harness'ınız var: `AGENTS.md` ajana proje kurallarını söyler, `feature_list.json` kapsamı kısıtlar, `init.sh` tutarlı ortam sağlar, `claude-progress.md` ilerlemeyi kaydeder. **Ama her adım hala sizin manuel başlatmanızı gerektirir.** Bir özelliği bitirin, ilerleme dosyasını okuyun, sırada ne olduğunu düşünün, talimatı yazın. Tüm iş akışının motoru sizsiniz.
+
+**Senaryo B: Loop'un dışındasınız (Loop Mühendisliği).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Tasarladığınız loop sistemi"]
+ Trigger["Otomatik tetikleyici<br/>Program / Olay / Önceki görev tamamlandı"] --> Discover["İşi keşfet<br/>İlerleme dosyasını oku / issue takipçisi"]
+ Discover --> Dispatch["Gönder<br/>Alt ajan oluştur"]
+ Dispatch --> Verify["Doğrula<br/>Testler / lint / Bağımsız inceleyici ajan"]
+ Verify --> Persist["Durumu kalıcı hale getir<br/>İlerlemeyi güncelle / Commit / PR aç"]
+ Persist -->|"İş kaldı"| Discover
+ Persist -->|"Bitti veya bloke oldu"| Inbox["İnceleme gelen kutunuza gönder"]
+ end
+ Inbox -->|"Sadece karar vermeniz gerekiyor"| You["Siz"]
+```
+
+Artık talimat yazmıyorsunuz. Tasarladığınız sistemi işi keşfeder, gönderir, sonuçları doğrular, durumu kaydeder ve bir sonraki adıma karar verir. İşiniz üç şeye küçülür: **başlamadan önce hedefi ve durdurma koşulunu tanımlamak, bittikten sonra çıktıyı gözden geçirmek ve sistem yoldan çıktığında kuralları ayarlamak.** Kaldıraç "doğru prompt yazmaktan" "doğru loop tasarlamaya" kayar.
+
+> Osmani: "Bir yıl önce bir loop istiyorsanız bir yığın bash yazarsınız ve o yığını sonsuza kadar bakımını yapardınız ve size aitti ve sadece size aitti. Şimdi parçalar doğrudan ürünlerin içinde geliyor." Sıfırdan inşa etmenize gerek yok. Parçaların nasıl bir araya geldiğini anlamanız gerekiyor.
+
+## Çekirdek Kavramlar
+
+- **Loop Mühendisliği**: Ajanınızı otomatik olarak prompt eden bir sistem tasarlamak, manuel adım adım insan girdisinin yerini almak. İnsan loop'un içinden dışına çıkar ve kaldıraç "doğru prompt yazmaktan" "doğru loop tasarlamaya" kayar.
+- **`/goal` modu**: Mümkün olan en basit loop — bir hedef, doğrulama yöntemi ve durdurma koşulu sağlayın; ajan ulaşılana kadar döner. Manuel prompting'den otonom loop'lara köprü.
+- **Üretici/Değerlendirici Ayrımı**: Kodu yazan ajan ile kontrol eden ajan ayrılmalıdır. Kendi çalışmasını notlandıran bir model güvenilmezdir; bazen tamamen farklı bir model kullanan bağımsız bir doğrulayıcı, herhangi bir loop'un temel güvenilirlik garantisidir.
+- **Worktree İzolasyonu**: Her paralel ajan bağımsız bir git worktree'de çalışır ve dosya çarpışmalarını fiziksel olarak önler. Çoklu ajan paralel yürütme için altyapı ön koşulu.
+- **Dış Durum**: Tek bir konuşmanın dışında yaşayan bellek — markdown dosyaları, issue takipçileri, kanban tahtaları. Modeller çalıştırmalar arasında her şeyi unutur; bellek diskte yaşamalıdır.
+- **Dört Sessiz Maliyet**: Bir loop ne kadar uzun süre çalışırsa o kadar belirginleşen dört gizli maliyet — doğrulama borcu, anlama çürümesi, bilişsel teslimiyet, token patlaması. Loop'lar sadece çıktıyı değil, riski de hızlandırır.
+
+## Loop'un Altı İlkeli
+
+Osmani bir loop'u beş çekirdek yapı taşına ayırdı, ayrıca hepsinden geçen bir bellek katmanı — toplam altı şey, ama bellek katmanı özel bir statüye sahiptir: diğerleriyle aynı seviyede bir bileşen değil; diğer her şeyin bağlı olduğu omurgadır.
+
+Aşağıdaki diyagram tüm altısını bir halka olarak çizer, böylece tam resmi bir bakışta görebilirsiniz. Ama unutmayın: Dış Durum sadece loop'daki bir durak değil — tüm loop'un dayandığı temeldir.
+
+```mermaid
+flowchart LR
+ A["Otomasyonlar<br/>Planlanan tetikleyiciler"] --> W["Worktree'ler<br/>Paralel izolasyon"]
+ W --> S["Beceriler<br/>Kodlanmış proje bilgisi"]
+ S --> C["Bağlayıcılar<br/>Dış araç erişimi"]
+ C --> SA["Alt ajanlar<br/>Maker / checker ayrımı"]
+ SA --> ES["Dış Durum<br/>Çapraz iterasyon belleği"]
+ ES --> A
+```
+
+### 1. Otomasyonlar — Kalp Atışı
+
+Otomasyon olmadan bir loop loop değildir — manuel olarak yaptığınız tek seferlik bir çalışmadır.
+
+Hem Claude Code hem de Codex tam zamanlama sistemlerine sahiptir, ama farklı isimler ve katmanlar kullanırlar. Kabaca en hafiften en ağıra doğru eşleme:
+
+| Katman | Claude Code | Codex | Notlar |
+|-------|-------------|-------|-------|
+| Oturum içi yoklama | `/loop` | Thread otomasyonu | Mevcut oturuma bağlı, oturum kapandığında ölür |
+| Yerel planlanan görevler | Masaüstü planlanan görevleri | Standalone otomasyon (yerel mod) | Makine açıkken çalışır, yerel dosyalara erişebilir |
+| Bulut planlanan görevler | Cloud Routines | — (yerel bulut zamanlayıcısı yok) | Makine kapalıyken çalışır |
+| Olay tetikleyicileri | Routines (API / GitHub Webhook) | Standalone otomasyon + eklentiler | Dış olaylar tarafından tetiklenir |
+| Tamamen kendi kendine barındırılan | GitHub Actions / kendi kendine barındırılan cron | `codex exec` + cron | Tam kontrol |
+
+**Codex'in Otomasyonlar sekmesi** zamanlama giriş noktasıdır. Projeyi, prompt'u, temposu ve yerel ödemeinizde mi yoksa arka plan worktree'sinde mi çalışacağını seçin. Bir şey bulan çalışmalar Triage gelen kutusuna düşer; hiçbir şey bulamayan çalışmalar otomatik olarak arşivlenir. OpenAI bunları dahili olarak günlük issue triajı, CI başarısızlık özetleri, commit brifingleri ve geçen hafta tanıtılan hataları avlamak için kullanır.
+
+Codex otomasyonları iki çeşittir:
+- **Thread otomasyonu** — Bir threade bağlı, bağlamı koruyan, kalp atışı tarzı tekrarlayan uyandırma çağrıları. Uzun süren bir komutu izlemek veya PR durumunu yoklamak gibi tek bir şey üzerinde sürekli takip için iyidir. Claude Code'daki karşılığı `/loop`.
+- **Standalone otomasyon** — Her çalışma taze başlar, sonuçlar Triage'a gider. Brifingler veya bağımlılık taramaları gibi günlük/haftalık bağımsız görevler için iyidir. Claude Code'daki karşılığı Masaüstü planlanan görevleri.
+
+Claude Code'un sistemi daha ayrıntılı katmanlıdır:
+
+- **`/loop`** — Hafif oturum içi planlanan tekrar. Terminaliniz açıkken çalışır, oturum kapandığında ölür, 7 gün sonra otomatik olarak sona erer. Mevcut çalışma oturumunuz sırasında geçici izleme için iyidir.
+- **Masaüstü planlanan görevler** — Makineniz açıkken çalışır, oturum yeniden başlatmalardan sağ çıkar, dakika seviyesi aralıklar. Yerel dosya erişimi gerektiren tekrarlayan işler için iyidir.
+- **Cloud Routines** — Anthropic'in bulut altyapısında çalışır, makinenizin kapalı olmasından sağ çıkar, 1 saat minimum aralık. Üç tetikleyici türünü destekler: planlanan, API çağrısı, GitHub webhook. Yerel ortamınıza ihtiyaç duymayan günlük görevler için iyidir.
+- **GitHub Actions / kendi kendine barındırılan cron** — Tamamen sizin kontrolünüzde, istediğiniz gibi çalışır. Özel ortam veya güvenlik gereksinimleri olan senaryolar için iyidir.
+
+```bash
+# Claude Code: her 30 dakikada bir testleri çalıştır, başarısız olanları düzelt (mevcut oturum içinde)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: her 15 dakikada bir deploy durumunu kontrol et
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Otomasyonlar kalp atışıdır. Onlar olmadan loop, asla uyanan bir plandır.
+
+### 2. Worktree'ler — Ölçekte İzolasyon
+
+Birden fazla ajan çalıştırır çalıştırmaz, dosya çarpışmaları kaçınılmaz hata modu haline gelir. Aynı dosyaya yazan iki ajan, birbirine danışmadan aynı satırlara commit eden iki mühendisin baş ağrısıyla tamamen aynıdır.
+
+`git worktree` bunu çözer: her ajan kendi şubesinde kendi dizininde çalışır. Birbirlerinin ödemeine fiziksel olarak dokunamazlar.
+
+Claude Code ve Codex ikisi de worktree desteğiyle birlikte gelir. Bir alt ajan üzerinde `--worktree` veya `isolation: worktree` kullandığınızda, her yardımcı temiz, bağımsız bir ödeme alır ve kendinden sonra temizlik yapar. Worktree'ler mekanik çarpışma sorununu ortadan kaldırır — ama unutmayın: **gözden geçirme bant genişliğiniz hala tavandır.** Kaç tane paralel ajanı denetleyebildiğiniz, gerçekten kaç tane worktree çalıştırabileceğinizi belirler.
+
+### 3. Beceriler — Projenizi yeniden açıklamayı bırakın
+
+Bir beceri, her oturum aynı proje bağlamını yeniden açıklamayı nasıl bırakacağınızdır. Talimatlar ve meta veriler içeren bir `SKILL.md`, artı isteğe bağlı betikler, referanslar ve varlıklar içeren bir klasördür.
+
+Codex ve Claude Code aynı formatı destekler. Beceriler doğrudan `/skill-name` ile çağrılır (Codex ayrıca `$skill-name` destekler) veya görev beceri açıklamasıyla eşleştiğinde örtük olarak tetiklenir.
+
+Beceriler temelde niyet borcunuzu ödemekle ilgilidir. Bir ajan her oturuma soğuk başlar — niyetinizdeki her boşluğu kendinden emin bir tahminle doldurur. Bir beceri, dışarıya yazılmış o niyettir: kurallar, derleme adımları, "bunu yapmayız çünkü şu olay oldu" — bir kez yazılır, her çalışmada okunur.
+
+### 4. Bağlayıcılar — Loop'unuz gerçek araçlara dokunur
+
+Sadece dosya sistemini görebilen bir loop küçük bir loop'dur. Bağlayıcılar (MCP protokolü üzerine kurulu) ajanın issue takipçinizi okumasını, bir veritabanı sorgulamasını, bir staging API'sine istek atmasını, Slack'e mesaj bırakmasını sağlar.
+
+Codex ve Claude Code ikisi de MCP konuşur, bu yüzden biri için yazdığınız bağlayıcı genellikle diğerinde de çalışır. Bağlayıcılar "düzeltme burada" ile PR açan, Linear biletini bağlayan ve CI yeşil olunca kanalı pingleyen bir loop arasındaki farktır — kendi kendine, gerçek ortamınızda, sadece terminalde değil.
+
+### 5. Alt ajanlar — Maker'ı checker'dan uzak tutun
+
+Bir loop'ta yapısal olarak en değerli tasarım seçimi, yazanı kontrol edenden ayırmaktır. Kodu yazan model kendi ödevini notlandırmak konusunda çok fazla cömerttir. Farklı talimatları ve bazen farklı bir modeli olan ikinci bir ajan, ilk ajanın kendini ikna ettiği şeyleri yakalar.
+
+Klasik üç rol ayrımı:
+
+```mermaid
+flowchart LR
+ Explorer["Explorer Ajanı<br/>Kod tabanını oku, sorunları bul"] --> Implementer["Implementer Ajanı<br/>Düzeltme yaz, testler yaz"]
+ Implementer --> Verifier["Verifier Ajanı<br/>Bağımsız inceleme, doğrulamayı çalıştır"]
+ Verifier -->|"Başarısız"| Implementer
+ Verifier -->|"Geçer"| Output["Çıktı"]
+```
+
+Claude Code'un `/goal`'u bunu kapalı olarak çalıştırır — taze, bağımsız bir oturum loop'un durup durmayacağını yargılar, işi yapan oturum değil. Buna **üretici/değerlendirici ayrımı** denir ve loop tasarımındaki en önemli tek güvenilirlik garantisidir.
+
+### 6. Dış Durum — Loop'un belleği
+
+Modeller çalıştırmalar arasında her şeyi unutur. Bellek bağlam penceresinde değil, diskte yaşamalıdır.
+
+Bu çok basit görünebilir, ama her uzun süreli ajanın güvendiği aynı hiledir. Bir markdown dosyası, bir Linear panosu — tek bir konuşmanın dışında yaşayan ve neyin yapıldığını, neyin devam ettiğini ve neyin sırada olduğunu tutan herhangi bir şey. Ajan unutur. Depo unutmaz.
+
+Bu altı ilke sizin loop tasarım araç setinizdir. Her loop için hepsine ihtiyacınız yok. Ama hangisine ne zaman ulaşacağınızı bilmeniz gerekir.
+
+## Tam Bir Loop, Anatomize Edilmiş
+
+Altısını da birbirine bağlayın ve gerçek bir sabah triaj loop'unun nasıl göründüğü işte:
+
+```mermaid
+flowchart TD
+ Trigger["Her sabah 9:00'da<br/>Otomasyon ateşlenir"] --> Read["Dış durumu oku<br/>Dünkü claude-progress.md<br/>Açık GitHub issue'ları"]
+ Read --> Triage["Triage Becerisi devreye girer<br/>Bulguları sınıflandır ve öncelikli tut"]
+ Triage --> Fork["Her eyleme geçilebilir öğe için<br/>İzole bir Worktree çatallayın"]
+ Fork --> Implement["Implementer Alt ajanı<br/>Düzeltme + testler yaz"]
+ Implement --> Verify["Verifier Alt ajanı<br/>Bağımsız olarak testleri + lint + inceleme çalıştır"]
+ Verify -->|"Başarısız"| Retry["Yeniden deneme kuyruğu<br/>Farklı yaklaşım dene"]
+ Retry --> Implement
+ Verify -->|"Geçer"| PR["Bağlayıcı: PR aç<br/>Issue'yu bağla, ilerleme dosyasını güncelle"]
+ PR --> Memory["Dış Duruma yaz<br/>claude-progress.md'yi güncelle<br/>Bu turun sonuçlarını kaydet"]
+ Memory -->|"İş kaldı"| Fork
+ Memory -->|"Hepsi bitti veya bloke oldu"| Inbox["Sonuçlar Triage gelen kutusuna düşer<br/>İncelemenizi bekliyor"]
+```
+
+Bu artık tek bir ajan çalışması değil. Her sabah uyanan, kendi kendine yeri süpüren ve dikkatinizi gerektiren şeyleri önünüze koyan sürekli çalışan bir sistemdir. Rolünüz şu hale gelir: **gelen kutusu içeriğini gözden geçirin, kararlar verin ve sistemin kaldıramayacağı bir desen gördüğünüzde becerileri ve kuralları iyileştirin.**
+
+Cherny bu deseni kullanarak 30 günde 259 PR'ı tek bir IDE açmadan merge etti. OpenAI mühendisleri aynı deseni kullanarak kabaca bir milyon satırlık bir beta ürünü elle — tek bir satır kod kendileri yazmadan — inşa ettiler.
+
+## Üretici/Değerlendirici Ayrımı: Neden Modelin Kendi Çalışmasını Notlandırmasına İzin Veremezsiniz
+
+Bu loop mühendisliğindeki en zor derstir.
+
+En akıllı ajanınız güzel bir kod parçası yazar. Mantık net, yorumlar kapsamlı ve her fonksiyonun bir testi var. Memnunsunuz.
+
+Ama şu soru var: **o kodu yazan ajana iyi bir iş yapıp yapmadığını yargılamasına izin verirseniz, ne diyecektir?**
+
+Cevap defalarca deneyimle doğrulandı: kendine yüksek bir not verecektir. Dürüst olmadığı için değil, yazarı olduğu için — üretim sırasında bu yolun doğru olduğuna kendini ikna etmiştir. Geriye baktığında hatalar görmez; kendi muhakeme sürecini görür.
+
+Bu bir Claude sorunu değil. Bu bir GPT sorunu değil. Bu tüm üretken modellerin bir özelliğidir. **Bir model kendi çıktısının en iyi savunma avukatıdır.**
+
+Düzeltme: aynı varlığın (aynı model, aynı prompt) hem işi hem de incelemeyi yapmasına asla izin vermeyin.
+
+- Claude Code'un `/goal`'u hedefin karşılanıp karşılanmadığını yargılamak için bağımsız bir denetçi oturumu kullanır — deneyen oturumu değil.
+- Codex'in alt ajan sistemi, farklı bir modelle farklı bir muhakeme çabası kullanan bir doğrulayıcı ajan tanımlamanıza olanak tanır.
+- "Düşmanca doğrulama" topluluk pratiği, her bulgu için N bağımsız şüpheci oluşturur, her biri çürütmek için prompt edilir — çoğunluk reddi bulguyu öldürür.
+
+Hatırlanacak tek cümle: **ekibinizdeki biri size inanmamalıdır.**
+
+## Karpathy'nin autoresearch'ı: Loop örneği
+
+İyi tasarlanmış, gerçekten çalışan bir loop'un neye benzediğini görmek istiyorsanız, [Karpathy'nin autoresearch'ı](https://github.com/karpathy/autoresearch) ders kitabı örneğidir.
+
+Mart 2026'da Karpathy 630 satırlık bir Python projesi yayınladı. Ona bir GPU ve bir araştırma yönü verin ve bütün gece çalışır — yüzlerce ML eğitim deneyi tamamlar, sadece gerçekten iyileştirenleri tutar. Proje yayınlanmasından birkaç gün içinde 66.000+ yıldıza ulaştı.
+
+### Üç Dosya, Üç Rol
+
+Tüm sistemin sadece üç çekirdek dosyası var, ama iş bölümü son derece keskindir:
+
+| Dosya | Kim Düzenler | Ne Yapar |
+|------|-------------|-------------|
+| `prepare.py` | Hiç kimse (salt okunur) | Veri hazırlığı, tokenizer, eval harness. Sabit altyapı. |
+| `train.py` (~630 satır) | **AI Ajanı** | Model tanımı, optimize edici, eğitim döngüsü. Ajanın oyun alanı — her şeyi değiştirebilir. |
+| `program.md` | **Siz** | Doğal dilde yazılmış araştırma metodolojisi. Sadece bunu düzenlersiniz. Ajana nasıl keşfedeceğini, nasıl değerlendireceğini, neye dokunmayacağını söyleyin. |
+
+Bu üç yönlü ayrım tasarımın ruhudur: **insanlar koda dokunmaz, yöne dokunur; ajanlar yöne dokunmaz, koda dokunur.** İşiniz Python yazmaktan "araştırma kurumu kültürünü yazmaya" kayar.
+
+### Girdi: program.md nasıl görünür
+
+`program.md` loop'un beynidir. Kod değil — Markdown'da yazılmış bir araştırma talimat kılavuzudur. Kabaca şunları içerir:
+
+- **Hedef**: `val_bpb`'yi optimize et (bayt başına doğrulama bitleri, daha düşük daha iyidir)
+- **Kısıtlamalar**: `prepare.py`'ye dokunma, VRAM bütçesi içinde kal, sabit 5 dakikalık eğitim
+- **Keşif yönleri**: farklı mimariler, optimize ediciler, LR programları dene
+- **Değerlendirme kuralları**: iyileştirme ne sayılır, sonuçlar nasıl günlüklenir, başarısızlıkta ne yapılır
+- **Demir kural**: asla durma. Loop başladığında, sonsuza kadar devam et
+
+Ajana başlangıç prompt'unuz tek bir cümle kadar kısa olabilir:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Geri kalanı, belgeyi okuyan ve kendi kararlarını veren ajana kalmış.
+
+### Dokuz Adımlı Mıknatıs Loop (Ratchet)
+
+autoresearch'ın kalbinde bir **mıknatıs** (ratchet) vardır — sadece ileri gider, asla geri gitmez. Her iterasyon kesinlikle dokuz adımı izler:
+
+```mermaid
+flowchart TD
+ 1["1. Yönü oku<br/>program.md'yi yükle"] --> 2["2. Mevcut durumu araştır<br/>train.py + geçmiş sonuçları oku"]
+ 2 --> 3["3. Hipotez öner<br/>Denenecek bir değişiklik düşün"]
+ 3 --> 4["4. Kodu değiştir<br/>train.py'yi düzenle"]
+ 4 --> 5["5. Anlık görüntü<br/>git commit"]
+ 5 --> 6["6. Eğitimi çalıştır<br/>Sabit 5 dakika duvar saati"]
+ 6 --> 7{"7. Değerlendir<br/>val_bpb iyileşti mi?"}
+ 7 -->|Evet| 8a["8a. Tut<br/>Commit kalır<br/>results.tsv'ye yaz"]
+ 7 -->|Hayır| 8b["8b. Geri al<br/>git reset HEAD~1<br/>Başarısızlığı günlüğe kaydet"]
+ 8a --> 9["9. Sonraki tur<br/>Adım 1'e geri dön"]
+ 8b --> 9
+```
+
+Saatte kabaca 12 deney çalıştırır. Bir gecelik çalışma (8 saat) yaklaşık 100 deneydir. Karpathy kendisi 2 gün çalıştırdı — ~700 deney.
+
+Sabit 5 dakikalık duvar saati bütçesi önemli bir tasarım seçimidir — ajan ne değiştirirse değiştirsin, her deney tam olarak aynı zamanı alır. Bu, tüm sonuçların aynı zaman bütçesi altında doğrudan karşılaştırılabilir olduğu anlamına gelir — "bunun daha uzun süre çalıştığı için daha iyi" tartışması yok.
+
+### Çıktı: Uyandığınızda ne görürsünüz
+
+Bir gece döngüden sonra sabah oturur ve üç şey bulursunuz:
+
+**1. Git geçmişi (ileri hareket eden mıknatıs)**
+
+Sadece gerçekten iyileştiren commit'ler ana dalda kalır. Başarısız olan her şey geri alındı. `git log` doğrulanmış bir araştırma günlüğüdür.
+
+**2. results.tsv (tam deney kaydı)**
+
+Her tek deney — başarılı veya başarısız — günlüğe kaydedilir:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Bir araştırma günlüğü (ajanın kendi özeti)**
+
+Ajan ne denediğini, neyin işe yaradığını, neyin yaramadığını ve sırada neyi denemeyi planladığını açık commit mesajları yazar. Bunları okursunuz — kod farklarını okumak zorunda değilsiniz.
+
+### Gerçekte ne buldu
+
+Karpathy'nin ilk 2 günlük ~700 deney çalışmasının sonuçları:
+
+- ~700 denemeden yaklaşık **20 yığılabilir gerçek iyileştirme** bulundu
+- nanochat'ın GPT-2 seviyesi eğitim süresini 8×H100'de **2,02 saat → 1,80 saat** olarak azalttı, yaklaşık **%11 daha hızlı**
+- Bulgular şunları içeriyordu: öğrenme oranı ayarlamaları, optimize edici ayarı, aktivasyon değişimleri, dikkat deseni optimizasyonları vb.
+
+Tüm iyileştirmeler yer sarsıcı keşifler miydi? Hayır. Çoğu yığılan küçük optimizasyonlardı. Ama bu 20 geçerli iyileştirme bir insan araştırmacının haftalarca manuel çalışmasını alırdı — ajan 48 saatte yaptı.
+
+### En anlatıcı detay: Loop İngilizce yazılır, kodla değil.
+
+`program.md` bir Python betiği değil, bir Markdown belgesidir. Bir araştırma metodolojisini tanımlar — neyi değiştirmek, neyi olduğu gibi bırakmak, nasıl değerlendirmek, başarısızlık durumlarını nasıl ele almak ve bir demir kural: **asla insan yardım isteme, sadece devam et.** Bir kodlama ajanı bu belgeyi okur ve süresiz olarak yürütür.
+
+Bu loop mühendisliğinin şablonudur: ajana bir görev verme. Ona bir **metodoloji** ver. Metodolojinin loop olmasına izin ver. Bir `program.md`, 630 satır tutkal kod ve geriye kalan her şey kendi kendini çalıştıran ajandır.
+
+## Dört Sessiz Maliyet
+
+Bir loop çalışmaya başladığında, sorunları hemen görmezsiniz. Aşağıdaki dört maliyet sessizce birikir ve fark ettiğinizde, zaten ağır bir şekilde ödeme yapmış olabilirsiniz.
+
+### 1. Doğrulama Borcu
+
+Hızlı loop'lar sizi doğrulamayı atlamaya kışkırtır. "Güzel görünüyor" ile "doğru olduğu onaylandı" aynı şey değildir. Bir loop denetimsiz ne kadar çok kod üretirse, doğrulama borcu o kadar hızlı yığılır. Düzeltme: **durdurma koşulları makine tarafından kontrol edilebilir olmalı, asla "doğru hissettiriyor" olmamalıdır.**
+
+### 2. Anlama Çürümesi
+
+Bir loop kod o kadar hızlı gönderir ki, kendi kod tabanınıza dair anlayışınız gerçeklikten o kadar uzaklaşır. Cherny'nin ekibinin kodunun %80'i ajanlar tarafından yazıldı — yani bir ekibin kodunun çoğu bir kişi tarafından yazılmadı. Loop'un ürettiğini okumaz ve kullanmazsanız, anlayışınız sürekli olarak çürür. **Hızlı loop'lar hızlı okuma gerektirir.**
+
+### 3. Bilişsel Teslimiyet
+
+Loop sorunsuz çalıştığında, en rahat duruş fikir sahibi olmayı bırakmaktır. Geri verdiği her şeyi alın, çıktı hakkında düşünmeyin. Ama tehlike tam olarak orada başlar — loop'u düşünmeyi güçlendirmek yerine düşünmekten kaçınmak için kullanıyorsunuz. Osmani'nin uyarısı: "İki kişi aynı loop'u kurabilir ve zıt sonuçlar alabilir. Biri anladığı işte daha hızlı gitmek için kullanır; diğeri işi anlamaktan kaçınmak için kullanır. Loop farkı bilmez. Siz bilirsiniz."
+
+### 4. Token Patlaması
+
+Bir loop'un her iterasyonu daha fazla bağlam biriktirir: yazılan kod, karşılaşılan hatalar, verilen kararlar. Bağlam yönetimi olmadan, prompt boyutu tur sayısıyla kabaca ikinci dereceden büyür. Codex bunu otomatik bağlam sıkıştırmasıyla ele alır — özel bir API eski konuşma turlarını şifreli içerik özetlerine sıkıştırır, temel bilgiyi korurken gereksiz detayı atar. Bu, ilk loop'tan ele almanız gereken bir mühendislik endişesidir, sonradan takılan bir ek değil.
+
+## İlk Loop'unuzu Oluşturmak
+
+Haftada 1.300 PR merge eden Stripe ölçeğinde bir pipeline ile başlamak zorunda değilsiniz. Çalışan en küçük şeyle başlayın.
+
+### Adım 1: Tekrarlayan Bir Görev Seçin
+
+Haftada en az iki kez manuel olarak yaptığınız bir şey bulun. Örnekler:
+- Sabah GitHub'ı aç, yeni issue'ları kontrol et, triaj yap ve yanıt ver
+- Her PR incelemesinden önce lint ve testleri çalıştır
+- Her günün sonunda ilerleme dokümanlarını güncelle
+
+### Adım 2: Bir Hedef ve Durdurma Koşulu Yazın
+
+Görevi `/goal`'un anlayabileceği bir şeye dönüştürün:
+
+```markdown
+Hedef: Depodaki en yeni 10 issue'yu kontrol et.
+Her issue için:
+ - Zaten net etiketleri ve atanmış bir kişisi varsa, atla
+ - Etiketlenmemişse, içeriğe göre uygun etiketleri ekle
+ - 10 dakikadan kısa sürede düzeltilebilirse, bir dal oluştur ve düzeltmeyi dene
+Ne zaman dur: Uygun tüm issue'lar işlendiğinde veya bir issue insan kararı gerektirdiğinde.
+```
+
+### Adım 3: Maker ve Checker'ı Ayırın
+
+Aynı ajana hem kodu yazıp hem de yargılamasına izin vermeyin. Loop'unuzu iki role ayırın:
+- Implementer: issue'yu okur, düzeltmeyi yazar, testleri yazar
+- Verifier: bağımsız olarak testleri çalıştırır, farkı inceler, düzeltmenin sorunu gerçekten çözüp çözmediğini yargılar
+
+### Adım 4: Bellek Ekleyin
+
+Her loop çalışmasında ne olduğunu kaydetmek için bir markdown dosyası kullanın. Bir sonraki çalışma bu dosyayı okuyarak başlar — neyin yapıldığını, neyin beklemede olduğunu, neyin bloke olduğunu bilir. Bu herhangi bir karmaşık veritabanından daha iyidir.
+
+### Adım 5: Bir Zamanlayıcı Ayarlayın
+
+Loop'un siz olmadan başlamasına izin vermek için `/loop` veya işletim sistemi cron'unuzu kullanın. Günde bir kez ile başlayın. Bir hafta boyunca gözlemleyin.
+
+### Olgunluk Merdiveni
+
+En üste bir sıçrayışta ulaşmak zorunda değilsiniz. Loop benimsemesi bir merdivendir:
+
+1. **Seviye 1: Hedef Çalıştırıcı** — Durdurma koşulu olan bir görev vermek için `/goal` kullanabilirsiniz; ajan ulaşılana kadar döner.
+2. **Seviye 2: Planlanan Tek Görev** — Bir otomasyon bir zamanlayıcı üzerinde bir görev çalıştırır (örneğin sabah CI kontrolü).
+3. **Seviye 3: Çoklu Ajan Loop'u** — Maker ve checker ayrımı; her bulgu izole bir worktree çatalları.
+4. **Seviye 4: Kendini Besleyen Loop** — Loop bir sonraki görevini dış durumdan otomatik olarak keşfeder; sırada ne yapacağına kendi karar verir.
+5. **Seviye 5: Filo Orkestrasyonu** — Birden fazla loop paralel olarak çalışır, bağımsız ama bir bellek katmanını paylaşır.
+
+Çoğu ekip şu anda Seviye 2 ile Seviye 3 arasındadır. Seviye 1, getiri görmek için en hızlı yoldur.
+
+## Ana Çıkarımlar
+
+- **Loop Mühendisliği Harness Mühendisliği'nin yerini almaz — onun üzerine bir kat inşa eder.** Harness tek çalışmaları güvenilir kılar. Loop sürekli çalışmaları özerk kılar.
+- **`/goal` mümkün olan en basit loop'tur:** hedef + doğrulama + durdurma koşulu. Bu üç şey sizi loop'un içinden dışına taşır.
+- **Altı ilke (Otomasyonlar / Worktree'ler / Beceriler / Bağlayıcılar / Alt ajanlar / Dış Durum) loop'un yapı taşlarıdır.** Her seferinde hepsine ihtiyacınız yok, ama hangisine ne zaman ulaşacağınızı bilmeniz gerekir.
+- **Maker ve checker ayrılmalıdır.** Kendi çalışmasını notlandıran bir model güvenilmezdir. Bazen tamamen farklı bir model olan bağımsız bir doğrulayıcı, herhangi bir loop'un temel güvenilirlik garantisidir.
+- **Loop'lar üretimi neredeyse ücretsiz kılar ve yargıyı kıt kaynak olarak bırakır.** Kazandığınız zaman dinlenmek için değildir. Daha fazla yargı yapmak içindir.
+- **Dört sessiz maliyet loop'lar daha uzun süre çalıştıkça belirginleşir:** doğrulama borcu, anlama çürümesi, bilişsel teslimiyet, token patlaması. Loop'lar çıktıyı — ve riski — hızlandırır.
+- **Küçük başlayın.** Bir `/goal`, bir cron, bir markdown bellek dosyası. Getiriyi görün, sonra yukarı doğru yığın.
+
+## Daha Fazla Okuma
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — 50 gerçek loop'un kamu korpusu
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Ders 12: [Her oturumun sonunda temiz devir](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Loop'lar için ön koşul: her oturum temiz durum bırakır ki bir sonraki tur otomatik başlayabilsin
+- Ders 5: [Uzun süreli görevleri oturumlar arasında sürekli tutun](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Dış durum ve bellek için ön bilgi
+- Ders 11: [Gözlemlenebilirlik neden harness'ın içinde olmalı](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Bir loop ne kadar hızlı çalışırsa, sorunları yakalamak için o kadar fazla gözlemlenebilirliğe ihtiyacınız olur
+- Ders 8: [Özellik listeleri neden harness ilkelleridir](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Özellik listeleri, kendini besleyen bir loop'un bir sonraki görevini keşfetmesi için doğal veri kaynağıdır
+
+## Alıştırmalar
+
+1. **Tekrarlayan bir görevi `/goal`'a dönüştürün:** Haftada en az iki kez manuel olarak yaptığınız bir şey bulun. Hedefini, doğrulama yöntemini ve durdurma koşulunu yazın. `/goal` ile bir kez çalıştırın ve zamanını ve kalitesini manuel yapmakla karşılaştırın. Bu, Harness'ten Loop'a ilk adımınız.
+
+2. **Maker ve checker'ı ayırın:** Daha önce bir ajanın yürüttüğü bir görev seçin. Bu sefer iki farklı prompt yazın: biri implementer ajanı için, diğeri verifier ajanı için (farklı modeller kullanın — örneğin uygulama için Claude, doğrulama için GPT veya tam tersi). Doğrulayıcı, kanıtlanmış belirli sorunları işaret etmelidir. Her modda bulunan sorun sayısını ve türünü kaydedin.
+
+3. **Loop'unuza bir bellek verin:** Loop'unuz için bir markdown durum dosyası oluşturun. Her iterasyonda şunları yazın: bu tur ne yapıldı, doğrulama sonuçları, durum (geçti/başarısız/bloke) ve sırada ne yapılacak. Üç tur çalıştırın ve bir bellek dosyası olması ile olmaması arasındaki davranışsal farkı gözlemleyin.
+
+4. **Loop'unuzun sessiz maliyetlerini denetleyin:** Loop'unuz bir saat çalıştıktan sonra, bu dört metriği değerlendirin:
+ - Ne kadar doğrulama "makine tarafından onaylandı" yerine "doğru hissettiriyordu"? (Doğrulama borcu)
+ - Loop'unuzun en son ürettiği kodu ne kadar iyi açıklayabilirsiniz? (Anlama çürümesi)
+ - Kaç kez "sonra bakarım" düşünüp hiç bakmadınız? (Bilişsel teslimiyet)
+ - Loop'un bağlam boyutu nasıl ilerliyor? Gereksiz bilgileri tekrar ediyor mu? (Token patlaması)
diff --git a/docs/tr/projects/project-07-loop-engineering-first-loop/index.md b/docs/tr/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..11962a1
--- /dev/null
+++ b/docs/tr/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+> İlgili Ders: [L13. Ajanınızı prompt etmeyi neden bırakmanız gerekir](./../../lectures/lecture-13-loop-engineering/index.md)
+
+# Proje 07. İlk Otomatik Loop'unuzu Oluşturun
+
+## Ne Yapacaksınız
+
+Bu, "Harness"tan "Loop"a geçiş projesidir. Bir ajanı uygun ortam, talimatlar ve geri bildirimle nasıl kuracağınızı zaten biliyorsunuz — şimdi o kurulumu kendi kendine çalışan bir loop'a dönüştüreceksiniz.
+
+Üç ilerici deney yapacaksınız: önce bir görevi manuelden `/goal`'a dönüştüreceksiniz, sonra bir izleme görevini `/loop` zamanlayıcısına dönüştüreceksiniz ve son olarak **loop'un dışına çıktığınızda** ne hissettiğini deneyimlemek için tam bir maker-checker loop'u oluşturacaksınız.
+
+## Proje Dosyaları
+
+Depo yolu: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Dizin | İçerik | Ne Yaparsınız |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Tam bir harness (P06 son durumu) içeren küçük bir bilgi tabanı projesi, AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md dahil. | Bu harness'i otomatik olarak dönebilen bir hale getirin. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Üç loop'un tam uygulamaları: hedef loop'u, zamanlayıcı loop'u, maker-checker loop'u, artı loop durum dosyaları ve doğrulama betikleri. | Loop tasarım desenleri ve durum yönetimi için referans. |
+
+## Kullanacağınız Araçlar
+
+- Claude Code veya Codex
+- Git
+- P06'dan tamamlanmış harness'ınız
+- Bir terminal çoklayıcı (uzun süreli loop'ları izlemek için tmux veya screen)
+- İsteğe bağlı: GitHub Actions veya cron (gelişmiş olay odaklı / planlanan deneyler için)
+
+## Adımlar
+
+### Hazırlık
+
+1. P06'ı bitirdiğiniz aynı commit'ten başlayın.
+2. Üç dal oluşturun: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Harness'ınızın çalıştığını doğrulayın: init.sh'ı çalıştırın, durum dosyası, özellik listesi ve devir dokümanlarının hepsinin yerinde olduğunu doğrulayın.
+4. Loop'un tekrar tekrar çalışacağı bir **hedef görev** seçin. Net tamamlama kriterleri olan orta ölçekli bir şey seçin — örneğin "tüm modüllere birim testleri ekle, %80 kapsama ulaş" veya "tüm API uç noktalarına giriş doğrulaması ekle."
+
+### Deney 1: Hedef Loop'u — Manuel Çalıştırmadan Otomatik Çalıştırmaya
+
+`p07-goal-loop` dalına geçin.
+
+1. **Hedef açıklamasını yazın**: Seçtiğiniz görevi şunları içeren bir `goal.md` dosyasına dönüştürün:
+ - Açık hedef ("bitti olarak ne sayılır")
+ - Doğrulama yöntemi ("bittiğini nasıl onaylarsınız" — testleri çalıştırmak mı? lint çalıştırmak mı? kapsamayı kontrol etmek mi?)
+ - Durdurma koşulu ("ne zaman durmalı" — maksimum tur sayısı mı? süre sınırı mı? bütçe sınırı mı?)
+ - Kısıtlamalar ("neye dokunulmamalı" — üretim yapılandırması, veritabanı şeması vb.)
+
+2. **İlk manuel çalıştırma**: Görevi ajana kendiniz manuel olarak verin. Kaç tur sürdüğünü, kaç kez müdahale ettiğinizi ve sonuç kalitesini kaydedin. Bu sizin taban çizginiz.
+
+3. **`/goal` ile çalıştırın**: Aynı `goal.md`'yi girdi olarak kullanın ve `/goal` modunda çalıştırın. Ajan hedefe ulaşılana veya durdurma koşulu tetiklenene kadar kendi kendine döner.
+
+4. **Sonuçları karşılaştırın**:
+ - Tur sayısındaki fark
+ - Müdahale sayınızdaki fark
+ - Sonuç kalitesindeki fark (aynı doğrulama standardını kullanarak)
+ - Harcadığınız zamandaki fark
+
+5. **goal.md üzerinde yineleme yapın**: Sonuçlar zayıfsa, hedef açıklamasını revize edin ve tekrar çalıştırın. Sonuçlardan memnun kalana kadar veya bir hedef loop'un bu görevde yapabileceklerinin sınırını doğrulayana kadar devam edin.
+
+### Deney 2: Zamanlayıcı Loop'u — İzlemeyi Kalp Atışına Dönüştürün
+
+`p07-timer-loop` dalına geçin.
+
+1. **Bir izleme görevi seçin**: Normalde manuel olarak yaptığınız tekrarlayan bir kontrol bulun. Örneğin:
+ - Her saatte test paketini çalıştır, başarısızlıkları düzelt
+ - Her sabah bağımlılık güvenlik güncellemelerini kontrol et
+ - Her commit'ten sonra kodlama stili ihlallerini kontrol et
+ - Periyodik olarak TODO yorumlarını tara, hangilerinin bayat olduğunu gör
+
+2. **İzleme prompt'unu/betiğini yazın**: İzleme adımlarını net bir şekilde ortaya koyun — ne kontrol edilecek, sorunlar bulunduğunda ne yapılacak ve ne zaman bir insan çağrılacak.
+
+3. **`/loop` (veya Codex Thread otomasyonu) ile çalıştırın**:
+ - Mantıklı bir aralık ayarlayın (10-30 dakika önerilir — çok kısa olursa rahatsız olursunuz, çok uzun olursa etkiyi görmezsiniz)
+ - En az 2 saat çalışmasına izin verin (veya başka bir şey yapıp sonra geri dönün)
+
+4. **Sonuçları kaydedin**:
+ - Kaç sorun buldu?
+ - Kaç tanesini kendi kendine düzeltti?
+ - Kaç tanesi yanlış pozitifti?
+ - Kaç tanesini daha da kötüleştirdi?
+ - Sonuçlarını takip etmek için ne kadar zaman harcadınız?
+
+5. **Düşünün**: Bu izleme görevi otomatikleştirilmeye değer mi? Kazandığınız zaman ile takip etmek için harcadığınız zamanı karşılaştırın. Değerli değilse, yanlış mı görev seçtiniz yoksa loop mu kötü tasarlandı?
+
+### Deney 3: Maker-Checker Loop'u — Kendinizi Loop'un Dışına Çıkarın
+
+`p07-maker-checker` dalına geçin.
+
+Bu, üç deneyin en önemlisidir. **Orada olmanıza gerek kalmayan tam bir loop** oluşturacaksınız:
+
+1. **Loop yapısını tasarlayın**:
+ - **Maker ajanı**: uygular, kod yazar, dosyaları değiştirir
+ - **Checker ajanı**: doğrular, testleri çalıştırır, kod incelemesi yapar, geçer / başarısız
+ - **Durum dosyası** (`loop-state.md`): mevcut turu, ne yapıldığını, doğrulama sonuçlarını, sırada ne olduğunu kaydeder
+ - **Durdurma koşulu**: N ardışık geçiş veya maksimum tur sayısına ulaşma
+
+2. **Üç prompt yazın**:
+ - Maker talimatları (ne yapmak, nasıl yapmak, neye dokunmamak)
+ - Checker talimatları (ne doğrulamak, nasıl doğrulamak, geçer ne sayılır, nasıl geri bildirim vermek)
+ - Loop kontrol mantığı (kim önce gider, devir nasıl çalışır, bir sonraki tura nasıl başlanır)
+
+3. **En az 5 tur çalıştırın**:
+ - Tur 1: Maker uygular → Checker doğrular → Başarısız → Maker'a geri bildirim
+ - Tur 2: Maker geri bildirime göre revize eder → Checker doğrular → ...
+ - ...
+ - Ardışık geçişe kadar veya siz durdurana kadar
+
+4. **Her turun durumunu kaydedin**:
+ - Tur numarası
+ - Maker ne yaptı
+ - Checker hangi sorunları buldu
+ - Geçer / başarısız
+ - Müdahale ettiniz mi? (eğer evetse, neden?)
+
+5. **Nihai retro**:
+ - Kaç kez müdahale ettiniz? Neden?
+ - Müdahale etmeseydiniz ne olurdu?
+ - Checker herhangi bir sorunu kaçırdı mı?
+ - Maker aynı hatayı yapmaya devam etti mi?
+ - Bu loop'un kalite tavanı nerede? Maker yeteneği mi, yoksa Checker yeteneği mi?
+
+## Sonuçlar Nasıl Ölçülür
+
+| Metrik | Deney 1 (Hedef) | Deney 2 (Zamanlayıcı) | Deney 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Görev tamamlama oranı | Hedefinize ulaşıldı mı? | Kaç izleme döngüsü çalıştı? | Geçene kadar kaç tur? |
+| İnsan müdahaleleri | Kaç kez araya girdiniz? | Sonuçları takip etmek için ne kadar zaman harcadınız? | Kaç kez müdahale ettiniz? |
+| Sonuç kalitesi | Manuel olana göre nasıl? | Yanlış pozitif oranı? Kaçırılan sorunlar? | Checker sizin bulamayacağınız kaç sorun buldu? |
+| Kazanılan zaman | Ne kadar zaman kazandınız? | Otomatikleştirmeye değer mi? | Loop'u tasarlamak için harcanan zaman vs. kazanılan zaman |
+| Güvenilirlik | Durdurma koşulu güvenilir miydi? | Kontrolden çıktı mı? | Loop aynı yerde takılıp kalabilir mi? |
+
+## Neler Teslim Edilecek
+
+- `goal.md` (Deney 1'in hedef açıklaması, en az iki yineleme)
+- Deney 1 karşılaştırma notları: manuel vs hedef loop'u
+- Deney 2 izleme prompt'u + 2 saatlik çalışma günlüğü
+- Deney 3'ün üç prompt'u (Maker / Checker / Loop kontrolü)
+- Deney 3'ün `loop-state.md` (en az 5 tur kaydedilmiş)
+- Nihai retro: tüm üç deneyden çıkarımlar, loop mühendisliği anlayışınız nasıl değişti, hangi şeyler loop-laştırma için iyi adaylar ve hangileri değil
+
+## İlgili Dersler
+
+- [Ders 13 — Ajanınızı prompt etmeyi neden bırakmanız gerekir](../../lectures/lecture-13-loop-engineering/index.md)
+- [Ders 12 — Her oturum neden temiz bir durumla bitmeli](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (bir loop'un her turu temiz durum gerekir)
+- [Ders 11 — Gözlemlenebilirlik neden harness'ın içinde olmalı](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (loop'un içinde ne olduğunu görmeniz gerekir)
+- [Ders 05 — Durum dosyaları neden sürekliliğin omurgasıdır](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (loop durum dosyaları durum dosyalarının bir uzantısıdır)
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/uk/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..c8c402e
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Промпт агента Checker
+
+> Для агента перевірки.
+> Фокусуйтесь на «пошуку проблем» — чим суворіше, тим краще.
+
+## Ваша роль
+
+Ви — Checker. Ваша робота — перевіряти те, що створив Maker. Ваша мета — знайти проблеми, а не говорити приємні речі.
+
+Коли ви отримуєте реалізацію від Maker, ваша робота —:
+
+1. Прочитати всі зміни
+2. Перевірити пункт за пунктом за чек-листом
+3. Запустити повні команди перевірки
+4. Перерахувати кожну знайдену проблему — кожну з доказами
+
+**Пам'ятайте: ви тут не для того, щоб хвалити, ви тут для того, щоб знаходити вади.** Не знайти проблем — це ваша невдача.
+
+## Чек-лист
+
+### Функціональна правильність
+- [ ] Чи відповідає реалізація вимогам?
+- [ ] Чи пропущено якісь граничні випадки?
+- [ ] Чи наявна обробка помилок?
+
+### Якість коду
+- [ ] Чи зрозумілий код? Чи зрозумілі назви?
+- [ ] Чи є дубльований код?
+- [ ] Чи відповідає він стандартам кодування проекту?
+- [ ] Чи є очевидні проблеми з продуктивністю?
+
+### Тестування
+- [ ] Чи покривають тести основні сценарії?
+- [ ] Чи протестовані граничні випадки?
+- [ ] Чи тести дійсно перевіряють щось значуще, чи вони просто відпрацьовують?
+
+### Команди перевірки
+- [ ] Чи повністю проходить `npm test`?
+- [ ] Чи має `npm run lint` нульових помилок?
+- [ ] Чи проходить перевірка типів TypeScript?
+- [ ] Чи покриття відповідає нормі?
+
+### Безпека та вплив
+- [ ] Чи вплине ця зміна на щось інше?
+- [ ] Чи введено нові залежності? Чи вони виправдані?
+- [ ] Чи правильні зміни файлів конфігурації?
+
+## Вимоги до виводу
+
+Кожна проблема має включати:
+1. **Опис**
+2. **Де** (файл та номер рядка)
+3. **Докази** (що саме неправильно, чому це проблема)
+4. **Серйозність** (Критична / Середня / Незначна)
+
+Завершіть загальним вердиктом: Проходить / Не проходить / Незначні проблеми, прийнятно
+
+Формат виводу:
+
+```
+## Загальний вердикт
+✅ Проходить / ❌ Не проходить / ⚠️ Незначні проблеми, прийнятно
+
+## Знайдені проблеми
+
+### 1. [Критична] Назва проблеми
+- Розташування: файл:рядок
+- Опис: ...
+- Докази: ...
+- Пропозиція: ...
+
+### 2. [Середня] Назва проблеми
+...
+
+## Результати команд перевірки
+- Модульні тести: X пройшло / Y всього
+- Lint: проходить / не проходить (X помилок)
+- Перевірка типів: проходить / не проходить
+- Покриття: XX%
+```
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/uk/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..7b07f04
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Шаблон циклу мети
+
+> Напишіть вашу мету як документ ось так, потім передайте його `/goal` або агенту maker.
+> Чим конкретніше і перевіреніше, тим вища якість циклу.
+
+## Мета
+
+<!-- Одне речення, що описує, що робити -->
+
+Реалізувати функцію XX з повним покриттям модульними тестами.
+
+## Критерії прийняття
+
+<!-- Умови завершення, що перевіряються машиною — кожну можна перевірити командою -->
+
+- [ ] `npm test` проходить повністю
+- [ ] Звіт про покриття показує покриття модуля XX ≥ 80%
+- [ ] `npm run lint` має нульових помилок
+- [ ] Перевірка типів TypeScript проходить (`npx tsc --noEmit`)
+- [ ] Увесь новий код відповідає стандартам кодування проекту
+
+## Обсяг
+
+<!-- Чітко вкажіть, чого НЕ чіпати -->
+
+### Можна чіпати
+
+- Усі файли в `src/xx/`
+- Тестові файли в `tests/`
+- Пов'язані файли визначення типів
+
+### Не чіпати
+
+- Вхідний файл `src/main.ts`
+- Міграції схеми бази даних
+- Версії залежностей у `package.json` (крім випадків явної необхідності)
+- Файли конфігурації CI/CD
+
+## Метод перевірки
+
+<!-- Як перевіряти після кожного кроку -->
+
+1. Після реалізації запустіть ці команди по порядку:
+ 1. `npx tsc --noEmit` — перевірка типів
+ 2. `npm run lint` — стиль коду
+ 3. `npm test` — модульні тести
+ 4. `npx vitest --coverage` — перевірка покриття
+
+2. Виправте будь-які невдачі перед переходом до наступного кроку.
+3. Коли все проходить, запустіть повний набір e2e-тестів (якщо доступний).
+
+## Умови зупинки
+
+- Усі критерії прийняття проходять ✅
+- Досягнуто максимальну кількість ходів: 20
+- Немає прогресу протягом 3 послідовних раундів (одна й та ж помилка з'являється знову і знову)
+- Блокуюча проблема, яку не можна вирішити самостійно (наприклад, відсутня залежність, проблеми з середовищем)
+
+## Як працювати
+
+1. Спочатку прочитайте `AGENTS.md` та `feature_list.json`, щоб зрозуміти структуру проекту та наявні функції.
+2. Напишіть дизайн-підхід перед тим, як чіпати код.
+3. Перевіряйте після завершення кожного підзавдання.
+4. Якщо застрягли більше ніж на 2 раунди, змініть підхід або спростіть.
+5. Оновлюйте прогрес наприкінці кожного раунду.
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/code/index.md b/docs/uk/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..8da0266
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Приклади коду до Лекції 13
+
+Використовуйте цю папку для прикладів:
+
+- Шаблон опису мети goal.md
+- Шаблон стану циклу loop-state.md
+- Шаблони промптів ролей Maker / Checker
+- Приклади скриптів керування циклом
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/uk/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..4044818
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Шаблон стану циклу
+
+> Кожен цикл повинен мати файл стану, що відстежує поточний прогрес.
+> Оновлюйте наприкінці кожного раунду; читайте на початку наступного раунду.
+
+## Основна інформація
+
+- **Назва циклу**: <!-- наприклад, "Цикл завершення модульних тестів" -->
+- **Розпочато**: 2026-07-09 10:00
+- **Поточний раунд**: Раунд 1 / N всього
+- **Поточний статус**: В процесі <!-- В процесі / Завершено / Заблоковано / Не вдалося -->
+- **Загальний витрачений час**: 0г 0хв
+
+## Мета
+
+<!-- Чого намагається досягти цей цикл -->
+
+## Журнал раундів
+
+### Раунд 1
+
+- **Розпочато**:
+- **Що зробив Maker**:
+- **Результат перевірки**: ✅ Прошло / ❌ Не прошло / ⚠️ Частково
+- **Знайдені проблеми**:
+ -
+- **План наступного раунду**:
+- **Потрібне втручання людини**: Так / Ні
+
+### Раунд 2
+
+- **Розпочато**:
+- **Що зробив Maker**:
+- **Результат перевірки**: ✅ Прошло / ❌ Не прошло / ⚠️ Частково
+- **Знайдені проблеми**:
+ -
+- **План наступного раунду**:
+- **Потрібне втручання людини**: Так / Ні
+
+<!-- Скопіюйте формат вище і продовжуйте додавати -->
+
+## Накопичена статистика
+
+| Метрика | Значення |
+|--------|-------|
+| Завершено раундів | 0 |
+| Пройдено раундів | 0 |
+| Провалено раундів | 0 |
+| Усього знайдено проблем | 0 |
+| Втручань людини | 0 |
+| Змінено файлів | 0 |
+
+## Список блокувань
+
+<!-- Записуйте повторювані проблеми, щоб наступний раунд був у курсі -->
+
+-
+
+## Кінцевий результат
+
+<!-- Заповніть, коли цикл закінчиться -->
+
+- **Кінцевий статус**: Завершено / Не вдалося / Зупинено вручну
+- **Закінчено о**:
+- **Підсумок**:
+ - Що було зроблено
+ - Як пройшло
+ - Що було вивчено
+ - Як поліпшити наступного разу
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/uk/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..de9fe00
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Промпт агента Maker
+
+> Для агента реалізації.
+> Фокусуйтесь на «змусити це працювати.»
+
+## Ваша роль
+
+Ви — Maker. Ваша робота — реалізовувати функції та писати код.
+
+Коли ви отримуєте завдання, ваша робота —:
+
+1. Розуміти вимоги
+2. Спроектувати підхід
+3. Написати код
+4. Запустити базову перевірку (збірка, lint, модульні тести)
+5. Передати результат на розгляд Checker
+
+## Правила роботи
+
+- Спочатку прочитайте AGENTS.md та відповідну документацію, щоб зрозуміти структуру проекту.
+- Поясніть ваш план перед внесенням змін.
+- Після написання самостійно запустіть базову перевірку — переконайтеся, що це принаймні запускається.
+- Якщо ви чогось не знаєте, скажіть, що не знаєте. Не вигадуйте речі.
+- Записуйте прогрес на кожному кроці.
+
+## Результати
+
+- Список змінених файлів
+- Короткий підсумок реалізації
+- Результати базової перевірки (збірка / lint / тести)
+- Області, у яких ви не впевнені (для фокусу Checker)
+
+## Формат виводу
+
+```
+## Підсумок реалізації
+...
+
+## Змінені файли
+- ...
+
+## Базова перевірка
+- Збірка: проходить / не проходить
+- Lint: проходить / не проходить
+- Модульні тести: X пройшло, Y провалено
+
+## Відомі проблеми та ризики
+- ...
+```
diff --git a/docs/uk/lectures/lecture-13-loop-engineering/index.md b/docs/uk/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..e5f096e
--- /dev/null
+++ b/docs/uk/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Приклади коду: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Практичний проект: [Проект 07. Побудова вашого першого автоматизованого циклу](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Лекція 13. Від ручного введення промптів до автономних циклів
+
+Все, що ви вивчили у перших дванадцяти лекціях, спирається на одному припущенні: **ви сидите за клавіатурою і вводите інструкції одну за одною.**
+
+Ви написали `AGENTS.md` (Лекції 1–4), створили управління станом (Лекції 5–6), обмежили обсяг за допомогою списків функцій (Лекції 7–8), залишали чисті передачі наприкінці сесій (Лекції 9, 12) та зробили середовище виконання спостережуваним (Лекції 10–11). Але тригером для всього цього завжди були ви. Агент ніколи сам не вирішував, коли почати роботу — бо ніхто не натиснув «старт».
+
+Ця лекція про те, щоб передати кнопку запуску системі. Не віддаючи контроль — а піднімаючи його на наступний рівень.
+
+## /goal: Найпростіший можливий цикл
+
+Найкращий вхід до loop engineering — не складна архітектурна діаграма, а одна команда.
+
+На початку 2026 року Claude Code та OpenAI Codex незалежно один від одного випустили однакову функцію: `/goal`. Ви вводите в терміналі:
+
+```
+/goal "Усі тести проходять, нульових попереджень lint, злиття в main"
+```
+
+Потім ви закриваєте ноутбук і йдете спати. Вісім годин потім агент самостійно проаналізував, написав код, протестував, виправив і злив. Він повторює спроби при невдачі, змінює підхід, якщо застряг, і зупиняється, коли готово — без того, щоб ви стояли над душою й казали «спробуй ще раз».
+
+Єдина різниця між `/goal` та традиційним промптом — одна річ. Але ця одна річ змінює все:
+
+| | Традиційний промпт | `/goal` |
+|---|---|---|
+| Що ви надаєте | Що робити далі | Як виглядає кінцевий стан |
+| Що робить агент | Виконує один раз | Циклічно повторює, поки не досягне |
+| Хто визначає готовність | Ви | Перевірена умова зупинки |
+| Коли ви можете відійти | Не можете | У момент введення `/goal` |
+
+`/goal` — це, по суті, цикл. У нього є рівно три частини: **мета, метод перевірки та умова зупинки.** Лише ці три речі переміщують вас ізсередини циклу назовні.
+
+### Як `/goal` зростав органічно
+
+`/goal` не з'явився з ніде. Він поступово виріс із повсякденних робочих процесів, пройшовши приблизно чотири етапи:
+
+**Етап 1: Ручне введення промптів один за одним.** Найраніший спосіб роботи був взаємодія «запит-відповідь»: «напиши функцію», «додай тест», «виправ цю логіку». Агент зупинявся після кожного кроку і чекав, поки ви скажете, що далі. Ви були планувальником усього конвеєра.
+
+**Етап 2: Довгі промпти з кількома кроками.** Потім люди почали писати довші промпти, що складають кроки разом: «спочатку проаналізуй код, потім напиши реалізацію, потім запусти тести, і якщо вони проваляться, виправ їх». Агент міг виконати кілька кроків за один раз, але вам все ще доводилося спостерігати — бо він може зійти з курсу посередині, або завершити крок і не знати, що робити далі.
+
+**Етап 3: Саморефлексія та самоврядування агента.** Після цього агенти отримали «інтроспекцію» — після кожного кроку вони дивилися на результат і вирішували, що робити далі. Ви ставали мету, і вони самі розбивали її на частини та самостійно повторювали спроби. Але виникла проблема: коли вони зупиняються? Чи рахується «я готовий», що звучить від самого агента? Практика постійно відповідала — ні. Агенти оголошують перемогу занадто легко.
+
+**Етап 4: Незалежне судження про зупинку — `/goal`.** Останнім кроком було вилучення «оцінки готовності» з рук агента, який виконує роботу, і передача її незалежному судді. Це може бути інша модель, скрипт або команда тестування — але правило було тим самим: людина, що пише код, не може оцінювати власну домашню роботу. На цьому етапі `/goal` справді запрацював: ви ставите мету, цикл працює, незалежний суддя вирішує, коли зупинитися, і ви можете відійти.
+
+Ці чотири етапи не були дорожньою картою, запланованою якоюсь компанією. Це був шлях, до якого незалежно дійшли усі, хто програмував з агентами, підштовхнувшись однаковими болями. Те, що Claude Code та Codex випустили `/goal` майже одночасно на початку 2026 року — не збіг; час настав.
+
+### Існує більше одного виду циклів
+
+`/goal` — найпростіший для розуміння цикл, але він не єдиний. Цикли поділяються на категорії залежно від того, як вони запускаються і як зупиняються:
+
+| Тип | Тригер | Умова зупинки | Claude Code | Codex | Найкраще для |
+|------|---------|----------------|-------------|-------|----------|
+| **Цикл на основі ходів** | Ви вручну вводите кожен промпт | Агент вважає, що готовий, або ви перериваєте | Звичайний чат | Звичайний чат | Невеликі завдання, дослідницька робота |
+| **Цикл на основі мети** | Ви ставите мету | Незалежний оцінювач підтверджує готовність, або досягнуто максимальну кількість ходів | `/goal` | `/goal` (потрібне ручне увімкнення) | Складні завдання з чіткими критеріями завершення |
+| **Часовий цикл** | Запланований інтервал (кожні N хвилин/годин) | Ви зупиняєте вручну, або він виходить після завершення роботи | `/loop` | Автоматизація потоків | Опитування статусу, періодичні перевірки, повторювана робота |
+| **Цикл на основі подій** | Зовнішня подія (відкрито PR, впав CI, нова проблема) | Зупиняється після обробки події, або досягає ліміту повторень | Routines (API / GitHub Webhook) | Автономна автоматизація + плагіни | Реактивні робочі процеси, інтеграція CI/CD |
+
+Це не конкуренти — це різні інструменти для різних завдань. На основі ходів добре для дрібниць. Використовуйте `/goal`, коли є чітка фінішна пряма. Використовуйте `/loop`, коли потрібно за чимось спостерігати. Використовуйте на основі подій, коли інтегруєтеся із зовнішніми системами.
+
+### Не плутайте `/goal` та `/loop`
+
+Обидва мають «loop» в назві, але вирішують абсолютно різні проблеми:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Що це** | Одне велике завдання, працює, поки не буде виконане | Одна мала дія, повторюється з інтервалом |
+| **Умова зупинки** | Мета досягнута, або бюджет вичерпано | Ви зупиняєте вручну, або завдання виходить самостійно |
+| **Часовий профіль** | Один довгий запуск, може тривати години або дні | Періодичні короткі спалахи, кожен запуск може тривати кілька хвилин |
+| **Прогрес** | Кожна ітерація наближає до фінішної прямої | Кожен запуск незалежний, немає кумулятивного прогресу |
+| **Аналогія** | Біг марафону — дають старт, ви зупиняєтеся на фініші | Будильник — дзвонить за розкладом, ви його вимикаєте |
+| **Типове використання** | «Реалізуй повну платіжну систему з покриттям тестами» | «Перевіряй, чи зламано CI, кожні 15 хвилин» |
+
+Поширена помилка: заштовхнути те, що має бути `/goal`, у `/loop`. Наприклад, написати `/loop 10m "продовжуй реалізовувати платіжну систему"` — це неправильно. `/loop` запускає однакову інструкцію незалежно кожного разу, він не пам'ятає, де зупинився минулого разу. Ви просто отримаєте одну й ту ж точку початку знову і знову.
+
+**Одне речення для перевірки, що використати: чи має ця річ кінець?**
+- Має кінець → `/goal`
+- Немає кінця, просто потрібно продовжувати спостерігати → `/loop`
+
+Loop Engineering, тема цієї лекції — не про якусь одну команду. Це про **здатність проектувати системи, що включають усі ці типи — щоб ваш агент міг продовжувати працювати, навіть коли вас немає.**
+
+Вам не потрібно вводити `/goal` кожного разу. Але розуміння, звідки воно взялося і чому воно виглядає саме так — це розуміння суті loop engineering. Більш складні цикли просто додають такі частини, як планування, паралелізм, ізоляція та пам'ять поверх цих самих трьох основ: мета, перевірка, умова зупинки.
+
+## Червень 2026: Троє людей запалили той самий запал за один тиждень
+
+У перший тиждень червня 2026 року троє практиків, що будували інфраструктуру агентів кодування — не порівнюючи нотатки — сказали те ж саме різними словами.
+
+**Пітер Штайнбергер** (творець OpenClaw, [його допис набрав 8 мільйонів переглядів](https://x.com/steipete/status/2063697162748260627)): «Ви більше не повинні писати промпти для агентів кодування. Ви повинні проектувати цикли, які пишуть промпти для ваших агентів.»
+
+**Борис Черний** (керівник Claude Code в Anthropic, [на підкасті Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): «Я більше не пишу промпти для Claude. У мене працюють цикли, які пишуть промпти для Claude і вирішують, що робити. Моя робота — писати цикли.»
+
+**Едді Османі** (інженерний лід у Google Chrome) [ввів назву концепції](https://addyosmani.com/blog/loop-engineering/) 7 червня 2026 року і дав їй визначення в одній строці:
+
+> **Loop engineering — це заміна себе як людини, яка пише промпти для агента. Ви проектуєте систему, яка робить це замість вас.**
+
+Черний розкрив цифри: протягом понад 30 послідовних днів усі внески коду в Claude Code були зроблені автономно ШІ — 259 злитих PR, понад 80% продуктивного коду, написаного Claude, і 76% успішності у відкритих програмних завданнях.
+
+Троє людей. Один тиждень. Однаковий висновок. Не тому що вони координувалися — а тому що інфраструктура тихо перетнула поріг. Агенти стали достатньо надійними, щоб виконувати нетривіальні завдання без нагляду. Примітиви планування (`/loop`, `/goal`, cron) тепер вбудовані в інструменти. Вартість одного запуску агента впала достатньо низько, щоб запускати його повторно за таймером і не вважати це марнотратством. Коли всі частини на місці, хід, який їх поєднує, стає очевидним для всіх одночасно.
+
+> Джерело: [Едді Османі: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Всередині циклу проти поза циклом
+
+Порівняємо два конкретних сценарії.
+
+**Сценарій А: Ви всередині циклу (Лекції 1–12).**
+
+```mermaid
+flowchart TD
+ You["Ви"] -->|"Вручну вводите інструкцію"| Agent["AI Агент"]
+ Agent -->|"Створює результат"| Result["Код / тести / документація"]
+ Result -->|"Ви перевіряєте"| You
+ You -->|"Не задоволені, змінюєте інструкцію"| Agent
+ You -->|"Задоволені, переходите до наступного завдання"| You
+```
+
+У вас є повний hарнес: `AGENTS.md` розповідає агенту правила проекту, `feature_list.json` обмежує обсяг, `init.sh` забезпечує послідовне середовище, `claude-progress.md` записує прогрес. **Але кожен крок все ще вимагає вашого ручного ініціювання.** Завершили одну функцію, прочитали файл прогресу, подумали, що далі, ввели інструкцію. Ви є двигуном усього робочого процесу.
+
+**Сценарій Б: Ви поза циклом (Loop Engineering).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Система циклів, яку ви спроектували"]
+ Trigger["Автоматичний тригер<br/>Розклад / Подія / Попереднє завдання завершено"] --> Discover["Виявлення роботи<br/>Читання файлу прогресу / трекера проблем"]
+ Discover --> Dispatch["Відправка<br/>Запуск під-агента"]
+ Dispatch --> Verify["Перевірка<br/>Тести / lint / Незалежний агент-рев'юер"]
+ Verify --> Persist["Збереження стану<br/>Оновлення прогресу / Коміт / Відкриття PR"]
+ Persist -->|"Робота залишається"| Discover
+ Persist -->|"Готово або заблоковано"| Inbox["Надіслати до вашого вхідного для перегляду"]
+ end
+ Inbox -->|"Вам потрібно лише приймати рішення"| You["Ви"]
+```
+
+Ви більше не вводите інструкції. Система, яку ви спроектували, виявляє роботу, відправляє її, перевіряє результати, записує стан і вирішує наступний крок. Ваша робота зменшується до трьох речей: **визначити мету та умову зупинки перед початком, переглянути результат після завершення та коригувати правила, коли система збиває з курсу.** Плече переміщується з «написання правильного промпту» на «проектування правильного циклу».
+
+> Османі: «Рік тому, якщо вам потрібен був цикл, ви писали купу bash і підтримували цю купу вічно, і вона була вашою і лише вашою. Тепер частини просто поставляються всередині продуктів.» Вам не потрібно будувати з нуля. Вам потрібно розуміти, як частини підходять одна до одної.
+
+## Основні концепції
+
+- **Loop Engineering**: Проектування системи, яка автоматично пише промпти для вашого агента, замінюючи ручний покроковий людський ввід. Людина переміщується ізсередини циклу назовні, і плече зміщується з «написання правильного промпту» на «проектування правильного циклу».
+- **Режим `/goal`**: Найпростіший можливий цикл — надайте мету, метод перевірки та умову зупинки; агент циклічно працює, поки не досягне. Міст від ручного введення промптів до автономних циклів.
+- **Розділення генератора/оцінювача**: Агент, який пише код, і агент, який його перевіряє, мають бути розділені. Модель, що оцінює власну роботу, ненадійна; незалежний перевіряючий — іноді з використанням зовсім іншої моделі — це базова гарантія надійності будь-якого циклу.
+- **Ізоляція worktree**: Кожен паралельний агент працює в незалежному git worktree, фізично запобігаючи зіткненням файлів. Інфраструктурна передумова для багатоагентного паралельного виконання.
+- **Зовнішній стан**: Пам'ять, що живе поза одним розмовою — markdown-файли, трекери проблем, канбан-дошки. Моделі забувають все між запусками; пам'ять має жити на диску.
+- **Чотири тихі вартості**: Чотири приховані витрати, які стають гострішими, чим довше працює цикл — борг перевірки, розуміннява гниль, когнітивна здача, вибух токенів. Цикли прискорюють не лише виведення, а й ризик.
+
+## Шість примітивів циклу
+
+Османі розклав цикл на п'ять основних будівельних блоків, плюс один шар пам'яті, який пронизує усі їх — усього шість речей, але шар пам'яті займає особливий статус: це не компонент на тому ж рівні, що й інші; це хребет, на якому все інше спирається.
+
+На діаграмі нижче усі шість намальовані кільцем, щоб ви могли побачити повну картину з першого погляду. Але пам'ятайте: Зовнішній стан — це не просто ще одна зупинка на циклі — це фундамент, на якому спирається весь цикл.
+
+```mermaid
+flowchart LR
+ A["Автоматизації<br/>Заплановані тригери"] --> W["Worktrees<br/>Паралельна ізоляція"]
+ W --> S["Навички (Skills)<br/>Кодифіковані знання про проект"]
+ S --> C["Конектори<br/>Доступ до зовнішніх інструментів"]
+ C --> SA["Під-агенти<br/>Розділення maker / checker"]
+ SA --> ES["Зовнішній стан<br/>Пам'ять між ітераціями"]
+ ES --> A
+```
+
+### 1. Автоматизації — серцебиття
+
+Без автоматизації цикл — не цикл; це одноразовий запуск, який ви зробили вручну.
+
+І Claude Code, і Codex мають повні системи планування, але вони використовують різні назви та рівні. Приблизне відображення від найлегшого до найважчого:
+
+| Рівень | Claude Code | Codex | Примітки |
+|-------|-------------|-------|-------|
+| Опитування всередині сесії | `/loop` | Автоматизація потоків | Пов'язано з поточною сесією, вмирає при закритті сесії |
+| Локальні заплановані завдання | Заплановані завдання на робочому столі | Автономна автоматизація (локальний режим) | Працює, коли машина увімкнена, може отримувати доступ до локальних файлів |
+| Хмарні заплановані завдання | Cloud Routines | — (немає вбудованого хмарного планувальника) | Працює, коли машина вимкнена |
+| Тригери подій | Routines (API / GitHub Webhook) | Автономна автоматизація + плагіни | Запускаються зовнішніми подіями |
+| Повністю самохостовані | GitHub Actions / самохостований cron | `codex exec` + cron | Повний контроль |
+
+**Вкладка Automations у Codex** — точка входу для планування. Виберіть проект, промпт, частоту і чи запускати його на вашій локальній копії або у фоновому worktree. Запуски, які щось знаходять, потрапляють у вхідну скриньку Triage; запуски, що нічого не знайшли, автоматично архівуються. OpenAI використовує їх внутрішньо для щоденного розбору проблем, підсумків збоїв CI, брифінгів комітів та пошуку помилок, введених минулого тижня.
+
+Автоматизації Codex бувають двох видів:
+- **Автоматизація потоку** — повторювані дзвінки будильникового стилю, прикріплені до потоку, що зберігають контекст. Добре для безперервного слідкування за однією річчю, як-от моніторинг довготривалої команди або опитування статусу PR. Еквівалент у Claude Code — `/loop`.
+- **Автономна автоматизація** — Кожен запуск починається заново, результати надходять до Triage. Добре для щоденних/тижневих незалежних завдань, як-от брифінги або сканування залежностей. Еквівалент у Claude Code — заплановані завдання на робочому столі.
+
+Система Claude Code розшарована більш детально:
+
+- **`/loop`** — Легковажна повторюваність за розкладом всередині сесії. Працює, поки ваш термінал відкритий, вмирає при закритті сесії, автоматично завершується через 7 днів. Добре для тимчасового моніторингу під час поточної робочої сесії.
+- **Заплановані завдання на робочому столі** — Працює, коли ваша машина увімкнена, переживає перезапуск сесій, інтервали на рівні хвилин. Добре для повторюваної роботи, якій потрібен доступ до локальних файлів.
+- **Cloud Routines** — Працює на хмарній інфраструктурі Anthropic, переживає вимкнення вашої машини, мінімальний інтервал 1 година. Підтримує три типи тригерів: запланований, виклик API, GitHub webhook. Добре для щоденних завдань, яким не потрібне ваше локальне середовище.
+- **GitHub Actions / самохостований cron** — Повністю під вашим контролем, працює як завгодно. Добре для сценаріїв із спеціальними вимогами до середовища або безпеки.
+
+```bash
+# Claude Code: запускати тести кожні 30 хвилин, виправляти невдачі (в межах поточної сесії)
+/loop 30m Запускай набір тестів і виправляй будь-які тести, що провалюються
+
+# Claude Code: перевіряти статус деплою кожні 15 хвилин
+/loop 15m Перевіряй, чи вдалося деплоїти в продакшн, і повідомляй статус
+```
+
+Автоматизації — це серцебиття. Без них цикл — це креслення, яке ніколи не прокинеться.
+
+### 2. Worktrees — ізоляція у масштабі
+
+Як тільки ви запускаєте більше одного агента, зіткнення файлів стають неминучим режимом відмови. Два агенти, що пишуть у той самий файл — це та сама головна біль, що й два інженери, які комітять ті самі рядки, не радлячись один з одним.
+
+`git worktree` вирішує це: кожен агент працює на своїй гілці у своєму каталозі. Вони фізично не можуть торкатися чужого оточення.
+
+І Claude Code, і Codex мають підтримку worktree. Коли ви використовуєте `--worktree` або `isolation: worktree` для під-агента, кожен помічник отримує чисте, незалежне оточення, яке самостійно очищається після себе. Worktrees прибирають механічну проблему зіткнень — але пам'ятайте: **ваша пропускна здатність на перегляд все ще є стелею.** Скільки паралельних агентів ви можете контролювати, визначає, скільки worktree ви реально можете запустити.
+
+### 3. Навички (Skills) — припніть перерозповідати свій проект
+
+Навичка — це те, як ви припиняєте перерозповідати один і той самий контекст проекту кожну сесію. Це папка, що містить `SKILL.md` з інструкціями та метаданими, плюс додаткові скрипти, довідники та активи.
+
+Codex та Claude Code підтримують однаковий формат. Навички викликаються безпосередньо за допомогою `/skill-name` (Codex також підтримує `$skill-name`), або запускаються неявно, коли завдання відповідає опису навички.
+
+Навички, по суті, про сплату вашого боргу наміру. Агент починає кожну сесію холодним — він заповнює будь-які прогалини у вашому намірі впевненими здогадками. Навичка — це цей намір, записаний ззовні: конвенції, кроки збірки, «ми не робимо це так через той один інцидент» — написано один раз, читається при кожному запуску.
+
+### 4. Конектори — ваш цикл торкається реальних інструментів
+
+Цикл, який може бачити лише файлову систему — це маленький цикл. Конектори (побудовані на протоколі MCP) дозволяють агенту читати ваш трекер проблем, запитувати базу даних, звертатися до стейджінгового API, залишати повідомлення у Slack.
+
+І Codex, і Claude Code підтримують MCP, тому конектор, який ви написали для одного, зазвичай працює в іншому. Конектори — це різниця між «ось виправлення» і циклом, який сам відкриває PR, пов'язує квиток Linear і повідомляє канал, коли CI стане зеленим — у вашому реальному середовищі, а не просто в терміналі.
+
+### 5. Під-агенти — тримайте Maker подалі від Checker
+
+Найцінніша конструктивна вибір у циклі — розділити того, хто пише, від того, хто перевіряє. Модель, яка написала код, надто щедро оцінює власну домашню роботу. Другий агент з іншими інструкціями, а іноді й іншою моделлю, знаходить те, у що переконаний перший агент.
+
+Класичне розділення на три ролі:
+
+```mermaid
+flowchart LR
+ Explorer["Агенти-дослідник<br/>Читати кодову базу, знаходити проблеми"] --> Implementer["Агенти-реалізувач<br/>Написати виправлення, написати тести"]
+ Implementer --> Verifier["Агенти-перевіряючий<br/>Незалежний огляд, запуск перевірки"]
+ Verifier -->|"Провал"| Implementer
+ Verifier -->|"Проходить"| Output["Результат"]
+```
+
+`/goal` у Claude Code працює так під капотом — нова, незалежна сесія оцінює, чи має цикл зупинитися, а не сесія, яка виконувала роботу. Це називається **розділенням генератора/оцінювача**, і це є найважливішою гарантією надійності у проектуванні циклів.
+
+### 6. Зовнішній стан — пам'ять циклу
+
+Моделі забувають все між запусками. Пам'ять має жити на диску, а не у вікні контексту.
+
+Це звучить надто просто, щоб мати значення, але це та сама хитрість, на якій побудований кожен довгоживучий агент. Markdown-файл, дошка Linear — що завгодно, що живе поза однією розмовою і зберігає те, що зроблено, що в процесі і що далі. Агент забуває. Репозиторій — ні.
+
+Ці шість примітивів — це ваш набір інструментів для проєктування циклів. Вам не потрібні усі для кожного циклу. Але вам потрібно знати, коли до якого звертатися.
+
+## Повний цикл, анатомізований
+
+З'єднайте всі шість разом, і ось як виглядає реальний ранковий цикл розбору:
+
+```mermaid
+flowchart TD
+ Trigger["Кожного ранку о 9:00 ранку<br/>Запускається автоматизація"] --> Read["Читати зовнішній стан<br/>Вчорашній claude-progress.md<br/>Відкриті проблеми GitHub"]
+ Read --> Triage["Увімкнення навички розбору<br/>Класифікація та пріоритизація знахідок"]
+ Triage --> Fork["Для кожного завдання, що виконується<br/>Створити ізольований Worktree"]
+ Fork --> Implement["Під-агент-реалізувач<br/>Написати виправлення + тести"]
+ Implement --> Verify["Під-агент-перевіряючий<br/>Самостійно запускати тести + lint + огляд"]
+ Verify -->|"Провал"| Retry["Черга повторних спроб<br/>Спробувати інший підхід"]
+ Retry --> Implement
+ Verify -->|"Проходить"| PR["Конектор: Відкрити PR<br/>Пов'язати проблему, оновити файл прогресу"]
+ PR --> Memory["Записати у Зовнішній стан<br/>Оновити claude-progress.md<br/>Записати результати цього раунду"]
+ Memory -->|"Робота залишається"| Fork
+ Memory -->|"Усе готово або заблоковано"| Inbox["Результати потрапляють у вхідну Triage<br/>Чекають на ваш перегляд"]
+```
+
+Це вже не один запуск агента. Це безперервно працююча система, яка прокидається кожного ранку, самостійно прибирає на робочому місці і ставить те, що потребує вашої уваги, перед вами. Ваша роль стає такою: **переглядати вміст вхідної скриньки, приймати рішення, і коли ви помічаєте патерн, з яким система не може впоратися, уточнювати навички та правила.**
+
+Черний використав цей патерн, щоб злити 259 PR за 30 днів, жодного разу не відкриваючи IDE. Інженери OpenAI використали той самий патерн, щоб вручну побудувати бета-продукт приблизно на мільйон рядків — жодного разу не написавши рядок коду самостійно.
+
+## Розділення генератора/оцінювача: чому ви не можете дозволити моделі оцінювати власну роботу
+
+Це найважчий урок у loop engineering.
+
+Ваш найрозумніший агент пише чудовий фрагмент коду. Логіка зрозуміла, коментарі ретельні, і кожна функція має тест. Ви задоволені.
+
+Але ось питання: **якщо ви дозволите агенту, який написав цей код, оцінити, чи добре він справився, що він скаже?**
+
+Відповідь знову і знову підтверджується досвідом: він поставить собі високу оцінку. Не тому, що він нечесний, а тому, що він автор — він переконав себе, що цей шлях правильний під час генерації. Коли він дивиться назад, він не бачить помилок; він бачить власний процес міркування.
+
+Це не проблема Claude. Це не проблема GPT. Це властивість усіх генеративних моделей. **Модель — найкращий захисний адвокат власного виводу.**
+
+Виправлення: ніколи не дозволяйте тій самій сутності (тій самій моделі, тому самому промпту) робити і роботу, і перевірку.
+
+- `/goal` у Claude Code використовує незалежну сесію супервизора, щоб оцінити, чи досягнута мета — а не сесія, яка намагалася це зробити.
+- Система під-агентів Codex дозволяє визначити агента-перевіряючого з використанням іншої моделі з іншими зусиллями міркування.
+- Спільнотна практика «adversarial verify» породжує N незалежних скептиків на кожну знахідку, кожному з яких дається завдання спростувати — більшість відмов знищує знахідку.
+
+Одне речення для запам'ятовування: **хтось у вашій команді має вам не вірити.**
+
+## autoresearch Карпатського: взірець циклу
+
+Якщо ви хочете побачити, як виглядає добре спроектований, реально працюючий цикл, [autoresearch Karpathy](https://github.com/karpathy/autoresearch) — це підручниковий приклад.
+
+У березні 2026 року Карпатський випустив Python-проект на 630 рядків. Дайте йому один GPU і напрямок досліджень, і він працює всю ніч — виконуючи сотні експериментів навчання ML, залишаючи лише ті, які дійсно покращують результат. Проект набрав 66 000+ зірок протягом кількох днів після випуску.
+
+### Три файли, три ролі
+
+У всій системі є лише три основні файли, але розподіл праці вкрай чіткий:
+
+| Файл | Хто редагує | Що робить |
+|------|-------------|-------------|
+| `prepare.py` | Ніхто (тільки для читання) | Підготовка даних, токенізатор, eval harness. Фіксована інфраструктура. |
+| `train.py` (~630 рядків) | **AI Агент** | Визначення моделі, оптимізатор, цикл навчання. Майданчик агента — змінюй що завгодно. |
+| `program.md` | **Ви** | Методологія дослідження, написана природною мовою. Ви редагуєте лише це. Розкажіть агенту, як досліджувати, як оцінювати, чого не чіпати. |
+
+Цей тристоронній розділ — душа дизайну: **люди не чіпають код, вони чіпають напрямок; агенти не чіпають напрямок, вони чіпають код.** Ваша робота зміщується з написання Python на «написання культури дослідницької організації.»
+
+### Вхід: як виглядає program.md
+
+`program.md` — це мозок циклу. Це не код — це посібник з досліджень, написаний Markdown. Він приблизно містить:
+
+- **Мета**: оптимізувати `val_bpb` (валідаційні біти на байт, чим нижче, тим краще)
+- **Обмеження**: не чіпати `prepare.py`, залишатися в межах бюджету VRAM, фіксоване 5-хвилинне навчання
+- **Напрямки досліджень**: спробувати різні архітектури, оптимізатори, розклади LR
+- **Правила оцінки**: що рахувати поліпшенням, як реєструвати результати, що робити при невдачі
+- **Залізне правило**: ніколи не зупинятися. Як тільки цикл запущено, продовжуй вічно
+
+Ваш стартовий промпт для агента може бути коротким, як одне речення:
+
+```
+Подивися на program.md і почнемо новий експеримент!
+```
+
+Решта — на розсуд агента, який читає документ і приймає власні рішення.
+
+### Дев'ятикроковий цикл ручної гребінки
+
+У центрі autoresearch лежить **ручна гребінка (ratchet)** — вона рухається лише вперед, ніколи назад. Кожна ітерація суворо відповідає дев'яти крокам:
+
+```mermaid
+flowchart TD
+ 1["1. Читати напрямок<br/>Завантажити program.md"] --> 2["2. Обстежити поточний стан<br/>Читати train.py + минулі результати"]
+ 2 --> 3["3. Запропонувати гіпотезу<br/>Придумати зміну для спроби"]
+ 3 --> 4["4. Модифікувати код<br/>Редагувати train.py"]
+ 4 --> 5["5. Знімок<br/>git commit"]
+ 5 --> 6["6. Запустити навчання<br/>Фіксовані 5 хвилин реального часу"]
+ 6 --> 7{"7. Оцінити<br/>Чи покращився val_bpb?"}
+ 7 -->|Так| 8a["8a. Залишити<br/>Коміт залишається<br/>Записати в results.tsv"]
+ 7 -->|Ні| 8b["8b. Відмінити<br/>git reset HEAD~1<br/>Залогувати невдачу"]
+ 8a --> 9["9. Наступний раунд<br/>Повернутися до кроку 1"]
+ 8b --> 9
+```
+
+Він виконує приблизно 12 експериментів на годину. Нічний запуск (8 годин) — це близько 100 експериментів. Сам Карпатський запускав його протягом 2 днів — ~700 експериментів.
+
+Фіксований 5-хвилинний бюджет реального часу — ключовий дизайнерський вибір — незалежно від того, що агент змінює, кожен експеримент займає рівно стільки ж часу. Це означає, що усі результати можна безпосередньо порівнювати за однакового бюджету часу — жодних суперечок про «цей працював довше, тому він кращий».
+
+### Вивід: що ви бачите, коли прокидаєтеся
+
+Після ночі роботи циклу ви сідаєте вранці і знаходить три речі:
+
+**1. Історія Git (ручна гребінка, що рухається вперед)**
+
+На основній гілці залишаються лише коміти, які дійсно покращили результат. Усе, що провалилося, було відкотено. `git log` — це перевірений дослідницький журнал.
+
+**2. results.tsv (повний запис експериментів)**
+
+Кожен окремий експеримент — успішний чи невдалий — логується:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 базовий
+08:06:15 d4e5f6g 1.228 22400 збільшено швидкість навчання на 10%
+08:11:20 (відмінено) 1.241 21800 перехід на активацію GELU
+08:16:08 h7i8j9k 1.219 23000 додано ваговий спад 0.01
+...
+```
+
+**3. Дослідницький журнал (власний підсумок агента)**
+
+Агент пише зрозумілі повідомлення комітів про те, що він спробував, що спрацювало, що ні, і що він планує спробувати далі. Ви читаєте їх — вам не потрібно читати дифи коду.
+
+### Що він насправді знайшов
+
+Результати початкового 2-денного запуску Карпатського з ~700 експериментами:
+
+- З ~700 спроб знайдено приблизно **20 дійсних поліпшень, що складаються**
+- Час навчання nanochat на рівні GPT-2 на 8×H100 зменшився з **2,02 години → 1,80 години**, приблизно **на 11% швидше**
+- Знахідки включали: корекції швидкості навчання, налаштування оптимізатора, заміни активації, оптимізації патернів уваги тощо.
+
+Чи були усі поліпшення земними відкриттями? Ні. Більшість були малими оптимізаціями, що складалися разом. Але ці 20 дійсних поліпшень зайняли б у людського дослідника тижні ручної роботи — агент зробив це за 48 годин.
+
+### Найпоказовіша деталь: цикл написано англійською, а не кодом.
+
+`program.md` — це документ Markdown, а не скрипт Python. Він описує методологію дослідження — що модифікувати, що залишати без змін, як оцінювати, як обробляти випадки невдачі, і одне залізне правило: **ніколи не просити людської допомоги, просто продовжуй.** Агент кодування читає цей документ і виконує його нескінченно.
+
+Це шаблон для loop engineering: не давайте агенту завдання. Дайте йому **методологію**. Нехай методологія буде циклом. Один `program.md`, 630 рядків коду-склеювача, і все інше — це агент, який керує собою сам.
+
+## Чотири тихі вартості
+
+Коли цикл починає працювати, ви не побачите проблем відразу. Наступні чотири вартості накопичуються тихо, і до того часу, коли ви помітите, ви, можливо, вже сильно заплатили.
+
+### 1. Борг перевірки
+
+Швидкі цикли спокушають вас пропустити перевірку. «Виглядає добре» — це не те саме, що «підтверджено правильність». Чим більше коду генерує цикл без нагляду, тим швидше накопичується борг перевірки. Виправлення: **умови зупинки повинні перевірятися машиною, ніколи не «відчуває, що приблизно правильно».**
+
+### 2. Розуміннява гниль
+
+Чим швидше цикл випускає код, тим далі ваше розуміння власної кодової бази відходить від реальності. У команди Черного 80% коду було написано агентами — що означає, що більша частина коду команди не була написана людиною. Якщо ви не читаєте і не використовуєте те, що виробляє цикл, ваше розуміння постійно погіршується. **Швидкі цикли вимагають швидкого читання.**
+
+### 3. Когнітивна здача
+
+Коли цикл працює гладко, найзатишніша поза — припинити мати думки. Беріть, що він дає, не думайте про результат. Але саме тут починається небезпека — ви використовуєте цикл, щоб уникнути думання, а не щоб посилити думання. Попередження Османі: «Дві людини можуть побудувати той самий цикл і отримати протилежні результати. Один використовує його, щоб швидше рухатися по роботі, яку він розуміє; інший використовує його, щоб уникнути розуміння роботи. Цикл не знає різниці. Ви знаєте.»
+
+### 4. Вибух токенів
+
+Кожна ітерація циклу накопичує більше контексту: написаний код, зустрічені помилки, прийняті рішення. Без управління контекстом розмір промпту зростає приблизно квадратично залежно від кількості ходів. Codex вирішує це за допомогою автоматичного стиснення контексту — спеціалізований API стискає старі ходи розмови в зашифровані зведення вмісту, зберігаючи важливі знання, відкидаючи зайві деталі. Це інженерне питання, яке ви повинні вирішити з першого циклу, а не додавати пізніше.
+
+## Побудова вашого першого циклу
+
+Вам не потрібно починати з конвеєра масштабу Stripe, що зливає 1300 PR на тиждень. Почніть з найменшої речі, яка працює.
+
+### Крок 1: Виберіть одне повторюване завдання
+
+Знайдіть те, що ви робите вручну принаймні двічі на тиждень. Приклади:
+- Вранці відкривати GitHub, перевіряти нові проблеми, розбирати і відповідати
+- Перед кожним переглядом PR запускати lint та тести
+- Наприкінці кожного дня оновлювати документацію прогресу
+
+### Крок 2: Напишіть мету та умову зупинки
+
+Перетворіть завдання на те, що може зрозуміти `/goal`:
+
+```markdown
+Мета: Перевірити 10 останніх проблем у репозиторії.
+Для кожної проблеми:
+ - Якщо вже має чіткі мітки та відповідального, пропустити
+ - Якщо без міток, додати відповідні мітки за змістом
+ - Якщо можна виправити менш ніж за 10 хвилин, створити гілку та спробувати виправити
+Зупинитися коли: Усі відповідні проблеми оброблено, або проблема вимагає людського рішення.
+```
+
+### Крок 3: Розділіть Maker та Checker
+
+Не дозволяйте тому самому агенту і писати код, і оцінювати його. Розділіть ваш цикл на дві ролі:
+- Реалізувач: читає проблему, пише виправлення, пише тести
+- Перевіряючий: самостійно запускає тести, переглядає диф, оцінює, чи виправлення дійсно вирішує проблему
+
+### Крок 4: Додайте пам'ять
+
+Використовуйте markdown-файл, щоб записувати, що сталося під час кожного запуску циклу. Наступний запуск починається з читання цього файлу — він знає, що було зроблено, що очікує, що було заблоковано. Це краще будь-якої складної бази даних.
+
+### Крок 5: Встановіть таймер
+
+Використовуйте `/loop` або cron вашої ОС, щоб цикл запускався без вас. Почніть з разу на день. Спостерігайте протягом тижня.
+
+### Драблина зрілості
+
+Вам не потрібно досягати вершини одним стрибком. Впровадження циклів — це драблина:
+
+1. **Рівень 1: Виконавець мети** — Ви можете використовувати `/goal`, щоб поставити завдання з умовою зупинки; агент циклічно працює, поки не досягне.
+2. **Рівень 2: Заплановане одне завдання** — Одна автоматизація виконує одне завдання за таймером (наприклад, ранкова перевірка CI).
+3. **Рівень 3: Багатоагентний цикл** — Розділення maker та checker; кожна знахідка породжує ізольований worktree.
+4. **Рівень 4: Самопостачальний цикл** — Цикл автоматично виявляє наступне завдання із зовнішнього стану; він сам вирішує, що робити далі.
+5. **Рівень 5: Оркестрація флоту** — Кілька циклів працюють паралельно, незалежно, але спільно використовують шар пам'яті.
+
+Більшість команд зараз знаходяться між Рівнем 2 та Рівнем 3. Рівень 1 — найшвидший шлях до отримання віддачі.
+
+## Основні висновки
+
+- **Loop Engineering не замінює Harness Engineering — він будує поверх нього.** Harness робить окремі запуски надійними. Цикл робить безперервні запуски автономними.
+- **`/goal` — найпростіший можливий цикл:** мета + перевірка + умова зупинки. Ці три речі переміщують вас ізсередини циклу назовні.
+- **Шість примітивів (Автоматизації / Worktrees / Навички / Конектори / Під-агенти / Зовнішній стан) — будівельні блоки циклу.** Не усі кожного разу, але вам потрібно знати, коли до якого звертатися.
+- **Maker та checker мають бути розділені.** Модель, що оцінює власну роботу, ненадійна. Незалежний перевіряючий — іноді зовсім інша модель — це базова гарантія надійності будь-якого циклу.
+- **Цикли роблять генерацію майже безкоштовною і залишають судження дефіцитним ресурсом.** Час, який ви заощаджуєте, — не для відпочинку. Він для прийняття більшої кількості рішень.
+- **Чотири тихі вартості стають гострішими, чим довше працюють цикли:** борг перевірки, розуміннява гниль, когнітивна здача, вибух токенів. Цикли прискорюють виведення — і ризик.
+- **Почніть з малих.** Один `/goal`, один cron, один markdown-файл пам'яті. Побачте віддачу, потім нарощуйте вгору.
+
+## Подальше читання
+
+- [Едді Османі: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Едді Османі: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Саймон Віллісон: Проектування агентних циклів (вер 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Карпатський: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Динамічні робочі процеси та оркестрація](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Бібліотека циклів (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Публічний корпус з 50 реальних циклів
+- [The Neuron: Творці Claude Code про агентні цикли](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Лекція 12: [Залишайте чисту передачу наприкінці кожної сесії](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Передумова для циклів: кожна сесія залишає чистий стан, щоб наступний раунд міг автоматично початися
+- Лекція 5: [Зберігайте безперервність довготривалих завдань між сесіями](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Передумова для зовнішнього стану та пам'яті
+- Лекція 11: [Чому спостережуваність належить всередині hарнесу](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Чим швидше працює цикл, тим більше вам потрібна спостережуваність, щоб помічати проблеми
+- Лекція 8: [Чому списки функцій є примитивами hарнесу](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Списки функцій — це природне джерело даних для самопостачального циклу, щоб виявляти наступне завдання
+
+## Вправи
+
+1. **Перетворіть повторюване завдання на `/goal`:** Знайдіть те, що ви робите вручну принаймні двічі на тиждень. Запишіть його мету, метод перевірки та умову зупинки. Запустіть один раз з `/goal` і порівняйте час та якість з ручним виконанням. Це ваш перший крок від Harness до Loop.
+
+2. **Розділіть maker та checker:** Виберіть завдання, яке ви раніше мали агент виконувати. Цього разу напишіть два різних промпти: один для агента-реалізувача, а інший для агента-перевіряючого (використовуйте різні моделі — наприклад, Claude для реалізації, GPT для перевірки, або навпаки). Перевіряючий повинен вказати на конкретні проблеми з доказами. Запишіть кількість та тип знайдених проблем у кожному режимі.
+
+3. **Надайте вашому циклу пам'ять:** Створіть markdown-файл стану для вашого циклу. Під час кожної ітерації пишіть: що було зроблено у цьому раунді, результати перевірки, статус (прошло/не прошло/заблоковано) і що робити далі. Запустіть три раунди і спостерігайте за поведінковою різницею між наявністю та відсутністю файлу пам'яті.
+
+4. **Перевірте тихі вартості вашого циклу:** Після того, як цикл пропрацює годину, оцініть чотири показники:
+ - Скільки перевірки було «відчуває, що правильно», а не «підтверджено машиною»? (Борг перевірки)
+ - Наскільки добре ви можете пояснити код, який ваш цикл нещодавно виробив? (Розуміннява гниль)
+ - Скільки разів ви подумали «я подивлюся пізніше» і ніколи не подивилися? (Когнітивна здача)
+ - Який тренд розміру контексту циклу? Чи повторює він зайву інформацію? (Вибух токенів)
diff --git a/docs/uk/projects/project-07-loop-engineering-first-loop/index.md b/docs/uk/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..ce8a49d
--- /dev/null
+++ b/docs/uk/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Проект 07. Побудова вашого першого автоматизованого циклу
+
+> Пов'язана лекція: [L13. Чому вам потрібно припинити писати промпти для свого агента](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Що ви зробите
+
+Це перехідний проект від «Harness» до «Loop». Ви вже знаєте, як налаштувати агента належним середовищем, інструкціями та зворотним зв'язком — тепер ви перетворите це налаштування на цикл, який працює самостійно.
+
+Ви проведете три поступових експерименти: спочатку перетворите завдання з ручного на `/goal`, потім перетворите завдання моніторингу на таймер `/loop`, і нарешті побудуєте повний цикл maker-checker, щоб відчути, що це коли **ви виходите за межі циклу.**
+
+## Файли проекту
+
+Шлях до репозиторію: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Директорія | Що всередині | Що ви робите |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Невеликий проект бази знань із повним hарнесом (кінцевий стан P06), включаючи AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Перетворіть цей hарнес на такий, що може циклічно працювати автоматично. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Повні реалізації трьох циклів: цикл мети, цикл таймера, цикл maker-checker, плюс файли стану циклу та скрипти перевірки. | Довідник з патернів проєктування циклів та управління станом. |
+
+## Інструменти, які ви використовуватимете
+
+- Claude Code або Codex
+- Git
+- Ваш повний hарнес з P06
+- Термінальний мультиплексор (tmux або screen, для спостереження за довготривалими циклами)
+- Опціонально: GitHub Actions або cron (для розширених експериментів на основі подій / запланованих)
+
+## Кроки
+
+### Підготовка
+
+1. Почніть з того ж коміту, де ви закінчили P06.
+2. Створіть три гілки: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Підтвердіть, що ваш hарнес працює: запустіть init.sh, перевірте, що файл стану, список функцій та документи передачі на місці.
+4. Виберіть **цільове завдання**, над яким цикл буде працювати повторно. Виберіть щось середнього розміру з чіткими критеріями завершення — наприклад, «додати модульні тести до всіх модулів, досягнувши 80% покриття» або «додати валідацію введення до всіх API-кінцевих точок».
+
+### Експеримент 1: Цикл мети — від ручного запуску до автоматичного
+
+Перейдіть на гілку `p07-goal-loop`.
+
+1. **Напишіть опис мети**: Перетворіть вибране завдання у файл `goal.md`, що містить:
+ - Чітку мету («що рахувати готовим»)
+ - Метод перевірки («як підтвердити, що готово» — запустити тести? запустити lint? перевірити покриття?)
+ - Умову зупинки («коли має зупинитися» — максимальна кількість ходів? обмеження часу? обмеження бюджету?)
+ - Обмеження («чого не чіпати» — продуктивна конфігурація, схема бази даних тощо)
+
+2. **Перший ручний запуск**: Надайте завдання агенту вручну самі. Запишіть, скільки ходів знадобилося, скільки разів ви втрутилися, та якість результату. Це ваш базовий рівень.
+
+3. **Запуск з `/goal`**: Використовуйте той самий `goal.md` як вхідні дані і запустіть у режимі `/goal`. Агент самостійно циклічно працює, поки мета не буде досягнута або не спрацює умова зупинки.
+
+4. **Порівняйте результати**:
+ - Різниця у кількості ходів
+ - Різниця у кількості ваших втручань
+ - Різниця у якості результату (за тим самим стандартом перевірки)
+ - Різниця у витраченому вами часі
+
+5. **Ітеруйте над goal.md**: Якщо результати погані, перегляньте опис мети і запустіть знову. Продовжуйте, поки не задовольнитеся результатами, або поки не підтверджите межі того, що може зробити цикл мети для цього завдання.
+
+### Експеримент 2: Цикл таймера — перетворіть моніторинг на серцебиття
+
+Перейдіть на гілку `p07-timer-loop`.
+
+1. **Виберіть завдання моніторингу**: Знайдіть повторювану перевірку, яку ви зазвичай робите вручну. Наприклад:
+ - Запускати набір тестів кожну годину, виправляти невдачі
+ - Перевіряти оновлення безпеки залежностей кожного ранку
+ - Перевіряти порушення стилю кодування після кожного коміту
+ - Періодично сканувати коментарі TODO, щоб побачити, які з них застарілі
+
+2. **Напишіть промпт/скрипт моніторингу**: Чітко викладіть кроки моніторингу — що перевіряти, що робити, коли знайдено проблеми, і коли викликати людину.
+
+3. **Запуск з `/loop` (або автоматизація потоку Codex)**:
+ - Встановіть розумний інтервал (рекомендується 10-30 хвилин — занадто коротко і ви будете роздратовані, занадто довго і ви не побачите ефекту)
+ - Дайте йому пропрацювати принаймні 2 години (або займіться чимось іншим і поверніться пізніше)
+
+4. **Запишіть результати**:
+ - Скільки проблем він знайшов?
+ - Скільки він виправив самостійно?
+ - Скільки було помилкових спрацьовувань?
+ - Скільки він погіршив?
+ - Скільки часу ви витратили на подальшу роботу з його результатами?
+
+5. **Роздуми**: Чи варто автоматизувати це завдання моніторингу? Порівняйте заощаджений час проти часу, витраченого на подальшу роботу. Якщо не варто — ви вибрали неправильне завдання, чи цикл погано спроектований?
+
+### Експеримент 3: Цикл Maker-Checker — вийдіть за межі циклу
+
+Перейдіть на гілку `p07-maker-checker`.
+
+Це найважливіший із трьох експериментів. Ви побудуєте **повний цикл, якому не потрібно, щоб ви були поруч:**
+
+1. **Спроектуйте структуру циклу**:
+ - **Агент-maker**: реалізовує, пише код, модифікує файли
+ - **Агент-checker**: перевіряє, запускає тести, робить огляд коду, проходить / не проходить
+ - **Файл стану** (`loop-state.md`): записує поточний раунд, що було зроблено, результати перевірки, що далі
+ - **Умова зупинки**: N послідовних проходжень, або досягнуто максимальну кількість раундів
+
+2. **Напишіть три промпти**:
+ - Інструкції maker (що робити, як робити, чого не чіпати)
+ - Інструкції checker (що перевіряти, як перевіряти, що рахувати проходом, як давати зворотний зв'язок)
+ - Логіка керування циклом (хто ходить перший, як працює передача, як запустити наступний раунд)
+
+3. **Запустіть принаймні 5 раундів**:
+ - Раунд 1: Maker реалізовує → Checker перевіряє → Невдача → Зворотний зв'язок для Maker
+ - Раунд 2: Maker перегляд на основі зворотного зв'язку → Checker перевіряє → ...
+ - ...
+ - До послідовного проходження, або доки ви не скажете стоп
+
+4. **Запишіть стан кожного раунду**:
+ - Номер раунду
+ - Що зробив Maker
+ - Які проблеми знайшов Checker
+ - Прошло / не прошло
+ - Чи втрутилися ви? (якщо так, чому?)
+
+5. **Фінальний ретро**:
+ - Скільки разів ви втрутилися? Чому?
+ - Що сталося б, якби ви не втручалися?
+ - Чи пропустив Checker якісь проблеми?
+ - Чи продовжував Maker робити одну й ту саму помилку?
+ - Де знаходиться стеля якості цього циклу? Можливості Maker, чи можливості Checker?
+
+## Як вимірювати результати
+
+| Метрика | Експ 1 (Мета) | Експ 2 (Таймер) | Експ 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Швидкість виконання завдання | Чи була досягнута мета? | Скілько циклів моніторингу пройшло? | Скілько раундів до проходження? |
+| Людські втручання | Скілько разів ви втрутилися? | Скілько часу ви витратили на подальшу роботу? | Скілько разів ви втрутилися? |
+| Якість результату | Як це порівнюється з ручним? | Рівень помилкових спрацьовувань? Пропущені проблеми? | Скілько проблем знайшов Checker, яких ви б не знайшли? |
+| Заощаджений час | Скілько часу ви заощадили? | Чи варто автоматизувати? | Час, витрачений на проєктування циклу проти заощадженого часу |
+| Надійність | Чи була умова зупинки довірчивою? | Чи він розбігся? | Чи може цикл застрягти на одному місці? |
+
+## Що надати
+
+- `goal.md` (опис мети Експерименту 1, принаймні дві ітерації)
+- Примітки до порівняння Експерименту 1: ручний проти цикл мети
+- Промпт моніторингу Експерименту 2 + журнал 2-годинного запуску
+- Три промпти Експерименту 3 (Maker / Checker / Керування циклом)
+- `loop-state.md` Експерименту 3 (записано принаймні 5 раундів)
+- Фінальний ретро: висновки з усіх трьох експериментів, як змінилося ваше розуміння loop engineering, які речі є хорошими кандидатами на циклізацію, а які ні
+
+## Пов'язані лекції
+
+- [Лекція 13 — Чому вам потрібно припинити писати промпти для свого агента](../../lectures/lecture-13-loop-engineering/index.md)
+- [Лекція 12 — Чому кожна сесія має залишати чистий стан](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (кожен раунд циклу потребує чистого стану)
+- [Лекція 11 — Чому спостережуваність належить всередині hарнесу](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (вам потрібно бачити, що відбувається всередині циклу)
+- [Лекція 05 — Чому файли стану є хребтом безперервності](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (файли стану циклу — це розширення файлів стану)
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/uz/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/uz/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/code/index.md b/docs/uz/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/uz/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/uz/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/uz/lectures/lecture-13-loop-engineering/index.md b/docs/uz/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..fe6be2e
--- /dev/null
+++ b/docs/uz/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Kod misollari: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/en/lectures/lecture-13-loop-engineering/code/)
+> Amaliy loyiha: [Loyiha 07. Birinchi avtomatlashtirilgan loop'ingizni qurish](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# 13-maʼruza. Qoʻlda prompt yozishdan avtonom loop'largacha
+
+Birinchi oʻn ikki maʼruzada oʻrgangan hamma narsa bir taxminga tayanadi: **siz klaviatura oldida oʻtirib, birma-bir koʻrsatmalar terasiz.**
+
+Siz `AGENTS.md` ni yozdingiz (1–4-maʼruzalar), holat boshqaruvini qurdingiz (5–6-maʼruzalar), funksiyalar roʻyxati bilan skopni chekladingiz (7–8-maʼruzalar), sessiya oxirida toza topshirish qoldirdingiz (9, 12-maʼruzalar) va runtime ni kuzatuvchan qildingiz (10–11-maʼruzalar). Lekin bularning barchasi uchun har doim siz trigger edingiz. Agent hech qachon oʻzi ish boshlashga qaror qilmagan — chunki hech kim "boshlash" tugmasini bosmagan.
+
+Ushbu maʼruza boshlash tugmasini tizimga topshirish haqida. Nazoratni yoʻqotish emas — uni keyingi qavatga koʻtarish.
+
+## /goal: Eng oddiy mumkin boʻlgan loop
+
+Loop muhandisligiga kirishning eng yaxshi usuli murakkab arxitektura diagrammasi emas — bitta buyruq.
+
+2026-yil boshida Claude Code va OpenAI Codex mustaqil ravishda bir xil funksiyani chiqardi: `/goal`. Siz terminalga yozasiz:
+
+```
+/goal "Barcha testlar oʻtsin, zero lint ogohlantirishlari boʻlsin, main'ga merge qiling"
+```
+
+Keyin siz noutbukni yopib, uxlashga borasiz. Sakkiz soatdan keyin agent oʻzi tahlil qiladi, kod yozadi, test qiladi, tuzatadi va merge qiladi. U muvaffaqiyatsizlikda qayta urinadi, tiqilib qolganda yondashuvni almashtiradi va tayyor boʻlganda toʻxtaydi — siz uning yelkasiga suyanib "qayta urinib koʻring" demasdan ham.
+
+`/goal` va anʼanaviy prompt orasidagi yagona farq bitta narsada. Ammo bu bir narsa hamma narsani oʻzgartiradi:
+
+| | Anʼanaviy Prompt | `/goal` |
+|---|---|---|
+| Nima berasiz | Keyin nima qilish kerak | Yakuniy holat qanday boʻlishi kerak |
+| Agent nima qiladi | Bir marta bajaradi | Erishgunga qadar loop qiladi |
+| Tugalligini kim baholaydi | Siz | Tekshirilishi mumkin boʻlgan toʻxtash sharti |
+| Qachon uzoqlasangiz boʻladi | Boʻlmaydi | `/goal` ni tergan paytingizdan |
+
+`/goal` mohiyatan bir loop. Uning atigi uchta qismi bor: **maqsad, tekshirish usuli va toʻxtash sharti.** Aynan shu uchta narsa sizni loop ichidan tashqariga olib chiqadi.
+
+### `/goal` qanday qilib organik oʻsdi
+
+`/goal` birdan 0 dan 1 ga sakrab chiqmadi. U kundalik ish jarayonlaridan asta-sekin oʻsib, taxminan toʻrt bosqichdan oʻtdi:
+
+**1-bosqich: Qoʻlda birma-bir prompt yozish.** Eng dastlabki ish usuli qarama-qarshi edi: "funksiya yozing", "test qoʻshing", "bu mantiqni tuzating". Agent har bir qadamdan keyin toʻxtab, keyin nima qilishni aytishingizni kutardi. Siz butun pipeline ning rejalashtiruvchisi edingiz.
+
+**2-bosqich: Bir nechta qadamlarni oʻz ichiga olgan uzoq promptlar.** Keyin odamlar qadamlarni bir-biriga ulab yozadigan uzoqroq promptlar yozishni boshladilar: "avval kodni tahlil qiling, keyin implementatsiyani yozing, keyin testlarni ishga tushiring, va agar ular yiqilsa, tuzating". Agent bir zumda bir nechta qadamni bajarishi mumkin edi, lekin siz hali ham kuzatib turishingiz kerak edi — chunki u oʻrtada buzilishi yoki bir qadamni tugatib keyin nima qilishni bilmasligi mumkin edi.
+
+**3-bosqich: Agentning oʻz-oʻzini fikr qilishi va yoʻnaltirilishi.** Shundan soʻng agentlarga "oʻzini oʻzi tekshirish" qobiliyati qoʻshildi — har bir qadamdan keyin u natijaga qarab, keyin nima qilishga qaror qilar edi. Siz maqsad berasiz, u oʻzi parchalab, oʻzi qayta urinadi. Ammo bir muammo paydo boʻldi: ular qachon toʻxtaydi? Agentning oʻzidan kelgan "men tugattim" deb hisoblashimi? Amaliyot doim javob berdi — yoʻq. Agentlar gʻalabani juda oson eʼlon qiladilar.
+
+**4-bosqich: Mustaqil toʻxtash bahosi — `/goal`.** Oxirgi qadam "tugalligini baholash" ni ishlayotgan agentning qoʻlidan olib, mustaqil sudyaga topshirish edi. Bu boshqa model, skript yoki test buyrugʻi boʻlishi mumkin — ammo qoida bir xil edi: kod yozgan odam oʻz uy ishisini baholay olmaydi. Bu nuqtada `/goal` haqiqatan ham ishladi: siz maqsad berasiz, u loop qiladi, mustaqil sudya qachon toʻxtashga qaror qiladi va siz uzoqlasangiz boʻladi.
+
+Bu toʻrt bosqich hech bir kompaniya tomonidan rejalashtirilgan yoʻl emas edi. Bu agentlar bilan kod yozgan hamma kishi mustaqil ravishda, bir xil ogʻriq nuqtalar tufayli kelib chiqqan yoʻl edi. Claude Code va Codex ning 2026-yil boshida deyarli bir vaqtning oʻzida `/goal` ni chiqarishi tasodif emas edi — vaqt keldi.
+
+### Loopʼning bir turi emas
+
+`/goal` tushunish uchun eng oson loop, ammo bu yagona turi emas. Loopʼlar qanday ishga tushirilishi va qanday toʻxtashi asosida turkumlarga boʻlinadi:
+
+| Turi | Trigger | Toʻxtash sharti | Claude Code | Codex | Eng yaxshi... uchun |
+|------|---------|----------------|-------------|-------|---------------------|
+| **Turn-based loop** | Siz har bir promptni qoʻlda terasiz | Agent oʻzi tugadi deb hisoblasa, yoki siz toʻxtatasiz | Oddiy chat | Oddiy chat | Kichik vazifalar, tadqiqot ishi |
+| **Goal-based loop** | Siz maqsad berasiz | Mustaqil baholovchi tugalligini tasdiqlasa, yoki maksimal turnlar soniga yetganda | `/goal` | `/goal` (qoʻlda yoqish kerak) | Tugallik mezonlari aniq boʻlgan murakkab vazifalar |
+| **Time-based loop** | Rejalashtirilgan interval (har N daqiqa/soat) | Siz qoʻlda toʻxtatasiz, yoki ishni tugatgandan keyin chiqadi | `/loop` | Thread automation | Holatni polling qilish, davriy tekshiruvlar, takrorlanuvchi ish |
+| **Event-driven loop** | Tashqi hodisa (PR ochildi, CI yiqildi, yangi issue) | Hodisani ishlov berishdan keyin toʻxtaydi, yoki qayta urinish chegarasiga yetadi | Routines (API / GitHub Webhook) | Standalone automation + plugins | Reaktiv ish jarayonlari, CI/CD integratsiyasi |
+
+Bular bir-biriga raqobatchi emas — ular turli ishlar uchun turli vositalar. Kichik narsalar uchun turn-based yetarli. Tugallik chizigʻi aniq boʻlganda `/goal` ishlating. Bir narsani kuzatib turish kerak boʻlganda `/loop` ishlating. Tashqi tizimlar bilan integratsiya qilayotganda event-driven ishlating.
+
+### `/goal` va `/loop` ni aralashmang
+
+Ikkalasining ham nomida "loop" bor, lekin ular butunlay turli muammolarni hal qiladi:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Nima** | Bir katta vazifa, tugagunga qadar ishlaydi | Bir kichik harakat, intervalda takrorlanadi |
+| **Toʻxtash sharti** | Maqsadga erishilgan, yoki byudjet tugagan | Siz qoʻlda toʻxtatasiz, yoki vazifa oʻzi chiqib ketadi |
+| **Vaqt profili** | Bir uzoq ishlash, soatlar yoki kunlar davom etishi mumkin | Davriy qisqa portlashlar, har bir ishlash bir necha daqiqa boʻlishi mumkin |
+| **Rivojlanish** | Har bir iteratsiya finish chizigʻiga yaqinlashadi | Har bir ishlash mustaqil, jamlangan rivojlanish yoʻq |
+| **Oʻxshatma** | Marafon yugurish — start quroli otiladi, siz finish chizigʻida toʻxtaysiz | Signal soati — jadvalda jiringlaydi, siz uni oʻchirib qoʻyasiz |
+| **Odatiy foydalanish** | "Toʻliq toʻlov tizimini test qamrov bilan implement qiling" | "Har 15 daqiqada CI buzildimi, tekshiring" |
+
+Keng tarqalgan xato: `/goal` boʻlishi kerak boʻlgan narsani `/loop` ga solishtirish. Masalan, `/loop 10m "toʻlov tizimini implement qilishda davom eting" deb yozish — bu notoʻgʻri. `/loop` har safar bir xil koʻrsatmani mustaqil ishga tushiradi, u oʻtgan safar qayerda qolganini eslamaydi. Siz shunchaki bir xil boshlangʻich nuqtadan qayta-qayta boshlanasiz.
+
+**Qaysi birini ishlatish haqida bir jumlik test: bu narsaning oxiri bormi?**
+- Oxiri bor → `/goal`
+- Oxiri yoʻq, shunchaki kuzatib turishingiz kerak → `/loop`
+
+Ushbu maʼruza mavzusi boʻlgan Loop Engineering (Loop muhandisligi) hech qanday bitta buyruq haqida emas. Bu **barcha turlarni oʻz ichiga olgan tizimlarni loyihalash qobiliyati haqida — shunda agent siz yoʻqligingizda ham ishlashda davom etishi mumkin.**
+
+Siz har safar `/goal` terishingiz shart emas. Lekin u qayerdan kelganini va nima uchun shunday koʻrinishini tushunish — bu loop muhandisligining yadrosini tushunishdir. Murakkabroq loopʼlar shunchaki rejalashtirish, parallelizm, izolyatsiya va xotira kabi qismlarni shu uchta asos: maqsad, tekshirish, toʻxtash sharti ustiga qoʻshadi.
+
+## 2026-yil iyun: Bir haftada uchta odam bir xil gʻoyani oldi
+
+2026-yil iyun oyining birinchi haftasida kodlash agentlari infratuzilmasini qurgan uchta amaliyotchilar — bir-birlari bilan maslahatlashmasdan — turli soʻzlar bilan bir xil narsani aytdilar.
+
+**Peter Steinberger** (OpenClaw yaratuvchisi, [uning postʼi 8 million marta koʻrildi](https://x.com/steipete/status/2063697162748260627)): "Siz endi kodlash agentlariga prompt yozmasligingiz kerak. Siz agentlaringizga prompt yozadigan loopʼlarni loyihalashingiz kerak."
+
+**Boris Cherny** (Anthropicʼda Claude Code boshligʻi, [Acquired podkastida](https://x.com/rohanpaul_ai/status/2063289804708835412)): "Men endi Claudeʼga prompt yozmayman. Claudeʼga prompt yozadigan va nima qilishni aniqlaydigan loopʼlarim bor. Mening ishim loopʼlar yozishdan iborat."
+
+**Addy Osmani** (Google Chrome muhandislik yetakchisi) [ushbu kontseptsiyani nomladi](https://addyosmani.com/blog/loop-engineering/) 2026-yil 7-iyun kuni va bitta satrlik taʼrif berdi:
+
+> **Loop muhandisligi — agentga prompt yozuvchi odam oʻrnini egallashdir. Buning oʻrniga qiluvchi tizimni siz loyihalasiz.**
+
+Cherny raqamlarni oshkor qildi: 30 dan ortiq ketma-ket kun davomida Claude Codeʼga barcha kod hissalari AI tomonidan mustaqil ravishda kiritildi — 259 ta merge qilingan PR, production kodining 80% dan ortigʻi Cloude tomonidan yozildi va ochiq dasturiy vazifalarda 76% muvaffaqiyat darajasi.
+
+Uchta odam. Bir hafta. Bir xil xulosa. Bu ular kelishganligi uchun emas — infratuzilma jim qorindi oʻtdi. Agentlar no trivial vazifalarni kuzatuvsiz tugatish uchun etarlicha ishonchli holga keldi. Rejalashtirish primitivlari (`/loop`, `/goal`, cron) endi vositalarga oʻrnatilgan edi. Bitta agent ishlashining narxi shunchalik pastlashganki, taymerda qayta-qayta ishlatish isrofgarchi koʻrinishdan chiqdi. Barcha qismlar mavjud boʻlganda, ularni birlashtiruvchi harakat hamma uchun bir zumda aniq boʻladi.
+
+> Manba: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Loop ichida va tashqarisida
+
+Ikka aniq stsenariyni solishtiraylik.
+
+**A stsenariy: Siz loop ichidasiz (1–12-maʼruzalar).**
+
+```mermaid
+flowchart TD
+ You["Siz"] -->|"Qoʻlda koʻrsatma terish"| Agent["AI Agent"]
+ Agent -->"Natija chiqarish"| Result["Kod / testlar / hujjatlar"]
+ Result -->"Siz tekshirib koʻrasiz"| You
+ You -->"Qoniqmangizda, koʻrsatmani oʻzgartiring"| Agent
+ You -->"Qoniqganingizda, keyingi vazifaga oʻting"| You
+```
+
+Sizda toʻliq harness bor: `AGENTS.md` agentga loyiha qoidalarini aytadi, `feature_list.json` skopni cheklaydi, `init.sh` mos keluvchi muhitni taʼminlaydi, `claude-progress.md` jarayonni yozib boradi. **Ammo har bir qadam hali ham sizning qoʻlda boshlashingizni talab qiladi.** Bir funksiyani tugating, jarayon faylini oʻqing, keyin nima qilishni oʻylang, koʻrsatmani tering. Siz butun ish jarayonining dvigatelisiz.
+
+**B stsenariy: Siz loop tashqarisida (Loop muhandisligi).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Siz loyihalagan loop tizimi"]
+ Trigger["Avto trigger<br/>Jadval / Hodisa / Oldingi vazifa tugadi"] --> Discover["Ishni aniqlash<br/>Jarayon faylini oʻqish / issue trakkeri"]
+ Discover --> Dispatch["Tayinlash<br/>Sub-agentni ishga tushirish"]
+ Dispatch --> Verify["Tekshirish<br/>Testlar / lint / Mustaqil koʻzguvchi agent"]
+ Verify --> Persist["Holatni saqlash<br/>Jarayonni yangilash / Commit / PR ochish"]
+ Persist -->"Ish qolgan"| Discover
+ Persist -->"Tugadi yoki tiqilib qoldi"| Inbox["Koʻrib chiqish qutingizga yuborish"]
+ end
+ Inbox -->"Siz faqat qarorlar qabul qilasiz"| You["Siz"]
+```
+
+Siz endi koʻrsatmalar teramaysiz. Siz loyihalagan tizim ishni topadi, uni joʻnatadi, natijalarni tekshiradi, holatni yozadi va keyingi qadamga qaror qiladi. Sizning ishingiz uchta narsaga qisqaradi: **boshlashdan oldin maqsad va toʻxtash shartini belgilash, tugagandan keyin natijani koʻrib chiqish va tizim yoʻldan chiqganda qoidalarni tuzatish.** Qulay "toʻgʻri prompt yozish" dan "toʻgʻri loop loyihalash" ga oʻtadi.
+
+> Osmani: "Bir yil oldin agar siz loop xohlasangiz, bir toʻda bash yozar edingiz va oʻsha toʻdani abadiy saqlab turar edingiz va u faqat sizniki edi. Endi esa bu qismlar mahsulotlar ichida tayyor keladi." Siz noldan qurishingiz shart emas. Qismlar qanday bogʻlanishini tushunishingiz kerak.
+
+## Asosiy tushunchalar
+
+- **Loop muhandisligi**: Agentga avtomatik ravishda prompt yozuvchi tizimni loyihalash, qoʻlda qadam-bashorat inson kiritmasini almashtirish. Inson loop ichidan tashqariga chiqadi va qulay "toʻgʻri prompt yozish" dan "toʻgʻri loop loyihalash" ga oʻtadi.
+- **`/goal` rejimi**: Eng oddiy mumkin boʻlgan loop — maqsad, tekshirish usuli va toʻxtash shartini bering; agent ular bajarilgunga qadar loop qiladi. Qoʻlda prompt yozishdan avtonom loopʼlargacha koʻprik.
+- **Generator/Evaluator boʻlinishi**: Kod yozuvchi agent va uni tekshiruvchi agent ajratilishi kerak. Oʻz ishlari baholaydigan model ishonchsizdir; mustaqil tekshiruvchi — baʼzan butunlay boshqa model ishlatiladi — har qanday loop ning asosiy ishonchlilik kafolati.
+- **Worktree izolyatsiyasi**: Har bir parallel agent mustaqil git worktree da ishlaydi, fizik ravishda fayl toʻqnashuvlarining oldini oladi. Koʻp agentli parallel bajarish uchun infratuzilma sharti.
+- **Tashqi holat (External State)**: Bitta suhbatdan tashqarida yashovchi xotira — markdown fayllar, issue trackerlari, kanban doskalar. Modellar ishlashlar orasida hamma narsani unutadi; xotira diskda yashashi kerak.
+- **Toʻrtta jim turdagi xarajat**: Loop uzoqroq ishlaganda keskinroq oʻsadigan toʻrtta yashirin xarajat — verification debt (tekshiruvi qarz), comprehension rot (tushunish parchalanishi), cognitive surrender (kognitiv taslim boʻlish), token blowout (token portlashi). Loopʼlar nafaqat ishlab chiqarishni, balki xavfni ham tezlashtiradi.
+
+## Loop ning oltita primativi
+
+Osmani loopʼni beshta asosiy qurilish blokiga, ularning barchasidan oʻtadigan bitta xotira qavatiga boʻldi — jami olta narsa, lekin xotira qavati alohida holat egallaydi: u boshqalari bilan bir darajadagi komponent emas; boshqa hamma narsa tayanadigan umurtqa.
+
+Quyidagi diagramma barcha oltitasini halqa shaklida chizadi, shunda siz butun rasmini bir zumda koʻrasiz. Lekin eslang: Tashqi holat bu loop dagi yana bir toʻxtash nuqtasi emas — butun loop tayanadigan poydevor.
+
+```mermaid
+flowchart LR
+ A["Avtomatlashtirishlar<br/>Rejalashtirilgan triggerlar"] --> W["Worktreeʼlar<br/>Parallel izolyatsiya"]
+ W --> S["Skillʼlar<br/>Kodlangan loyiha bilimi"]
+ S --> C["Konnektorlar<br/>Tashqi vosita kirishi"]
+ C --> SA["Sub-agentlar<br/>Maker / checker boʻlinishi"]
+ SA --> ES["Tashqi holat<br/>Iteratsiyalararo xotira"]
+ ES --> A
+```
+
+### 1. Avtomatlashtirishlar — Yurak urishi
+
+Avtomatlashtirishsiz loop loop emas — bu siz qoʻlda qilgan bir martalik ishlash.
+
+Ham Claude Code, ham Codex toʻliq rejalashtirish tizimlariga ega, lekin ular turli nomlar va qavatlardan foydalanadilar. Eng engildan eng ogʻirigacha taxminan moslashuv:
+
+| Qavat | Claude Code | Codex | Eslatmalar |
+|-------|-------------|-------|-----------|
+| Sessiya ichidagi polling | `/loop` | Thread automation | Joriy sessiyaga bogʻliq, sessiya yopilganda oʻladi |
+| Mahalliy rejalashtirilgan vazifalar | Desktop rejalashtirilgan vazifalar | Standalone automation (local mode) | Mashina yoqilganda ishlaydi, mahalliy fayllarga kirishi mumkin |
+| Bulutli rejalashtirilgan vazifalar | Cloud Routines | — (tugʻma bulutli rejalashtiruvchi yoʻq) | Mashina oʻchirilgan holda ham ishlaydi |
+| Hodisa triggerlari | Routines (API / GitHub Webhook) | Standalone automation + plaginlar | Tashqi hodisalar bilan triggerlanadi |
+| Toʻliq oʻz hostingida | GitHub Actions / oʻz hostingidagi cron | `codex exec` + cron | Toʻliq nazorat |
+
+**Codex avtomatlashtirishlar oynasi** rejalashtirish kirish nuqtasi. Loyihani, prompt’ni, chastotani va mahalliy kassada yoki fon worktree da ishlashini tanlang. Biror narsa topadigan ishlashlar Triage qutingizga tushadi; hech narsa topmaganlar avtomatik arxivlanadi. OpenAI ularni ichida kunlik issue triage, CI xato xulosalari, commit briefllari va oʻtgan hafta kiritilgan xatolarni qidirish uchun ishlatadi.
+
+Codex avtomatlashtirishlari ikki turda boʻladi:
+- **Thread automation** — ipga bogʻlangan, kontekstni saqlab turuvchi heartbeat uslubidagi takrorlanuvchi uygʻatishlar. Bir narsada davriy kuzatish uchun yaxshi, masalan, uzoq davom etayotgan buyruqni monitoring qilish yoki PR holatini polling qilish. Claude Code da ekvivalenti `/loop`.
+- **Standalone automation** — Har bir ishlash yangidan boshlanadi, natijalar Triageʼga boradi. Kunlik/haftalik mustaqil vazifalar, masalan, briefllar yoki bogʻliqlik skanerlari uchun yaxshi. Claude Code da ekvivalenti Desktop rejalashtirilgan vazifalar.
+
+Claude Code tizimi yanada maydalangan qavatlarga ega:
+
+- **`/loop`** — Engil sessiya ichidagi rejalashtirilgan takrorlash. Terminalingiz ochik ishlaydi, sessiya yopilganda oʻladi, 7 kundan keyin avtomatik tugaydi. Joriy ish sessiyangizda vaqtinchalik monitoring uchun yaxshi.
+- **Desktop rejalashtirilgan vazifalar** — Mashinangiz yoqilganda ishlaydi, sessiya qayta ishga tushirishdan omon qoladi, daqiqa darajasidagi intervallar. Mahalliy fayl kirishi kerak boʻlgan takrorlanuvchi ishlar uchun yaxshi.
+- **Cloud Routines** — Anthropicʼning bulutli infratuzilmasida ishlaydi, mashinangiz oʻchirilgan holda omon qoladi, 1 soat minimal interval. Uchta trigger turini qoʻllab-quvvatlaydi: rejalashtirilgan, API chaqiruv, GitHub webhook. Mahalliy muhitingizga muhtoj boʻlmagan kunlik vazifalar uchun yaxshi.
+- **GitHub Actions / oʻz hostingidagi cron** — Toʻliq nazoratingizda, qanday ishlatsangiz ham ishlaydi. Maxsus muhit yoki xavfsizlik talablari boʻlgan stsenariylar uchun yaxshi.
+
+```bash
+# Claude Code: har 30 daqiqada testlarni ishga tushiring, xatolarni tuzating (joriy sessiya ichida)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: har 15 daqiqada deploy holatini tekshiring
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Avtomatlashtirishlar bu yurak urishi. Ularsiz loop bu hech qachon uygʻonmaydigan loyiha.
+
+### 2. Worktreeʼlar — Miqyosda izolyatsiya
+
+Bir nechta agentni ishga tushirishi bilan, fayl toʻqnashuvlari muqarrar muvaffaqiyatsizlik rejimiga aylanadi. Ikki agentning bir xil faylga yozishi — ikki muhandisning bir-birlariga maslahatlashmasdan bir xil satrlarga commit qilishdagi bosh ogʻrigʻi bilan bir xil.
+
+`git worktree` buni hal qiladi: har bir agent oʻz novdasida oʻz katalogida ishlaydi. Ular fizik ravishda bir-birining kassasiga tegga olmaydi.
+
+Claude Code ham, Codex ham worktree qoʻllab-quvvatlash bilan keladi. Sub-agentda `--worktree` yoki `isolation: worktree` ishlatganingizda, har bir yordamchiga oʻzi tozalab ketadigan toza, mustaqil kassa beriladi. Worktreeʼlar mexanik toʻqnashuv muammosini olib tashlaydi — lekin eslang: **sizning koʻrib chiqish kengligingiz hali ham shifondir.** Qancha parallel agentni nazorat qila olasiz, shuncha worktree ni haqiqatan ham ishga tushira olasiz.
+
+### 3. Skillʼlar — Loyihangizni qayta-qayta tushuntirishni bas qiling
+
+Skill bu sessiyadan sessiyaga bir xil loyiha kontekstini qayta-qayta tushuntirishni bas qilishingizdir. Bu `SKILL.md` yoʻriqnoma va meta-maʼlumotlar, ixtiyoriy skriptlar, mos yozuvlar va aktivlarni oʻz ichiga olgan papka.
+
+Codex va Claude Code bir xil formatni qoʻllab-quvvatlaydi. Skillʼlar toʻgʻridan-toʻgʻri `/skill-name` bilan chaqiriladi (Codex shuningdek `$skill-name` ni qoʻllab-quvvatlaydi), yoki vazifa skill tavsifiga mos kelganda bilvosita ishga tushiriladi.
+
+Skillʼlar mohiyatan intentingiz qarzini toʻlashdan iborat. Agent har bir sessiyani sovuqqan boshlaydi — u niyatidagi har bir boʻshliqni ishonchli taxmin bilan toʻldiradi. Skill bu tashqariga yozilgan niyatdir: konventsiyalar, build qadamlari, "biz shunday qilmaymiz, chunki oʻsha bir voqea bor" — bir marta yoziladi, har bir ishlashda oʻqiladi.
+
+### 4. Konnektorlar — Loopʼingiz haqiqiy vositalarga tegadi
+
+Faqat fayl tizimini koʻra oladigan loop kichik loop. Konnektorlar (MCP protokoliga asoslangan) agentga issue tracker’ingizni oʻqishiga, maʼlumotlar bazasini soʻrashiga, staging API ga joylashishiga, Slack da xabar tashlashiga imkon beradi.
+
+Codex ham, Claude Code ham MCP ni tushunadi, shuning uchun biringiz uchun yozgan konnektor odatda ikkinchisida ham ishlaydi. Konnektorlar "mana tuzatish" va PR ochadigan, Linear chiptasini bogʻlaydigan va CI yashil boʻlgunga qadar kanalni pingslaydigan loop orasidagi farqdir — oʻzi, haqiqiy muhitingiz ichida, nafaqat terminalda.
+
+### 5. Sub-agentlar — Maker ni checkerdan uzoqroq ushlang
+
+Loop da eng tizimli qiymatli dizayn tanlovi — yozuvchini tekshiruvchidan ajratishdir. Kod yozgan model oʻz uy ishisini baholashda juda mehribon. Ikkinchi agent, boshqa koʻrsatmalar va baʼzan boshqa model bilan, birinchi agent oʻzini ishontirgan narsani topadi.
+
+Klassik uchta role boʻlinishi:
+
+```mermaid
+flowchart LR
+ Explorer["Explorer Agent<br/>Kod bazasini oʻqish, muammolarni aniqlash"] --> Implementer["Implementer Agent<br/>Tuzatish yozish, testlar yozish"]
+ Implementer --> Verifier["Verifier Agent<br/>Mustaqil koʻrib chiqish, tekshirishni ishga tushirish"]
+ Verifier -->"Muvaffaqiyatsizlik"| Implementer
+ Verifier -->"Muvaffaqiyat"| Output["Natija"]
+```
+
+Claude Codeʼning `/goal` ini kapotylda bu ishlaydi — yangi, mustaqil sessiya loop ni toʻxtatish kerak yoki yoʻqligiga qaror qiladi, ishni qilgan sessiya emas. Bu **generator/evaluator separation (generator/evaluator boʻlinishi)** deb ataladi va bu loop dizaynidagi yagona eng muhim ishonchlilik kafolati.
+
+### 6. Tashqi holat — Loop xotirasi
+
+Modellar ishlashlar orasida hamma narsani unutadi. Xotira diskda yashashi kerak, kontekst oynasida emas.
+
+Bu juda oddiygina tuyulishi mumkin, lekin bu har bir uzoq davom etuvchi agent tayanadigan bir xil hiyla. Markdown fayli, Linear doskasi — bitta suhbatdan tashqarida yashovchi va nima qilingan, nima jarayonda va nima navbatda ekanligini saqlovchi har qanday narsa. Agent unutadi. Repozitoriy unitmaydi.
+
+Bu oltita primitiv sizning loop dizayn asboblar toʻplamingiz. Har bir loop uchun barchasiga muhtoj emasziz. Lekin qaysi biriga qachon qoʻl choʻzishni bilishingiz kerak.
+
+## Toʻliq loop, anatomiyasi
+
+Oltitasini bir-biriga ulang va haqiqiy ertalabki triage loop shunday koʻrinadi:
+
+```mermaid
+flowchart TD
+ Trigger["Har kuni ertalab 9:00 da<br/>Avtomatlashtirish ishga tushadi"] --> Read["Tashqi holatni oʻqish<br/>Kechaagi claude-progress.md<br/>Ochiq GitHub issue'lar"]
+ Read --> Triage["Triage Skill ishga tushadi<br/>Topilmalarni tasniflash va ustuvorliklarni belgilash"]
+ Triage --> Fork["Har bir amalga oshiriladigan element uchun<br/>Izolyatsiyalangan Worktree ni fork qiling"]
+ Fork --> Implement["Implementer sub-agent<br/>Tuzatish + testlarni yozish"]
+ Implement --> Verify["Verifier sub-agent<br/>Mustqil testlar + lint + koʻrib chiqish"]
+ Verify -->"Muvaffaqiyatsizlik"| Retry["Qayta urinish navbati<br/>Boshqa usul sinab koʻring"]
+ Retry --> Implement
+ Verify -->"Muvaffaqiyat"| PR["Konnektor: PR oching<br/>Issue'ni bogʻlash, jarayon faylini yangilash"]
+ PR --> Memory["Tashqi holatga yozish<br/>claude-progress.md ni yangilash<br/>Ushbu raund natijalarini yozish"]
+ Memory -->"Ish qolgan"| Fork
+ Memory -->"Hammasi tugadi yoki tiqilib qoldi"| Inbox["Natijalar Triage qutingizga tushadi<br/>Koʻrib chiqishingizni kutmoqda"]
+```
+
+Bu endi bitta agent ishlash emas. Bu har ertalab uygʻonib, oʻzi yerni supurib, eʼtiboringizga chiqadigan narsalarni oldingizga qoʻyadigan doimiy ishlaydigan tizim. Sizning rolingiz quyidagicha boʻladi: **qutik tarkibini koʻrib chiqish, qarorlar qabul qilish va tizim qila olmaydigan naqshni koʻrganingizda, skill va qoidalarni takomillashtirish.**
+
+Cherny bu naqshni ishlatib, 30 kunda hech qachon IDE ochmasdan 259 PR ni merge qildi. OpenAI muhandislari xuddi shu naqshni ishlatib, qoʻlda million qatorda beta mahsulotini qurdilar — hech bir qator kodni oʻzlari yozmasdan.
+
+## Generator/Evaluator boʻlinishi: Nega modelni oʻz ishlari baholashiga yoʻl qoʻymaslik kerak
+
+Bu loop muhandisligidagi eng ogʻriq dars.
+
+Sizning aqlli agentingiz chiroyli kod yozadi. Mantiq aniq, izohlar toʻliq va har bir funktsiyaning testi bor. Siz qoniqasiz.
+
+Ammo savol shundan: **agar siz oʻsha kodni yozgan agentga oʻzi yaxshi ishladimi yoʻqmi deb baholashga yoʻl qoʻysangiz, u nima deydi?**
+
+Javob tajribada qayta-qayta tasdiqlangan: u oʻziga balʼli baho beradi. Bu uning halol emasligi uchun emas, balki u muallifligi uchun — u generatsiya paytida bu yoʻl toʻgʻri ekanligiga oʻzini ishontirgan. U orqaga qaraganda, xatolarni koʻrmaydi; u oʻzining fikrlash jarayonini koʻradi.
+
+Bu Claude muammosi emas. Bu GPT muammosi emas. Bu barcha generativ modellar xususiyati. **Model oʻz chiqishining eng yaxshi mudofaa advokatidir.**
+
+Tuzatish: hech qachon bir xil sub’ekt (bir xil model, bir xil prompt) ham ishni, ham koʻrib chiqishni bajarmasin.
+
+- Claude Codeʼning `/goal` ini maqsadga erishilganmi yoki yoʻqligini baholash uchun mustaqil supervisor sessiya ishlatiladi — urinib koʻrgan sessiya emas.
+- Codex ning sub-agent tizimi sizga boshqa model va boshqa fikrlash harakati bilan tekshiruvchi agentni aniqlash imkonini beradi.
+- "Adversarial verify" jamoat amaliyoti har bir topilma uchun N ta mustaqil shubhali chiqaradi, ularning har biri rad etishga promptlanadi — aksariyat rad etsa topilma oʻlimiga uchraydi.
+
+Esda tutish uchun bir jumla: **ekipajingizda bir kishi sizga ishonmasligi kerak.**
+
+## Karpathy autoresearch: Loop namunasi
+
+Agar siz yaxshi loyihalangan, haqiqatan ishlayotgan loop nima koʻrinishini koʻrmoqchi boʻlsangiz, [Karpathy autoresearch](https://github.com/karpathy/autoresearch) oʻquv qoʻllanma misolidir.
+
+2026-yil martida Karpathy 630 qatordan iborat Python loyihasini chiqardi. Bunga bitta GPU va tadqiqot yoʻnalishini bering, u tun boʻyi ishlaydi — yuzlab ML trening eksperimentlarini bajaradi, faqat haqiqatan yaxshilaydiganlarini saqlab turadi. Loyiha chiqqandan keyin bir necha kun ichida 66,000+ yulduzga erishdi.
+
+### Uchta fayl, uchta rol
+
+Butun tizimda atigi uchta asosiy fayl bor, lekin mehnat boʻlinishi oʻtkir:
+
+| Fayl | Kim tahrirlaydi | Nima qiladi |
+|------|----------------|-------------|
+| `prepare.py` | Hech kim (faqat oʻqish uchun) | Maʼlumotlarni tayyorlash, tokenizer, eval harness. Qatʼiy infratuzilma. |
+| `train.py` (~630 qator) | **AI Agent** | Modelni aniqlash, optimizator, trening loop. Agentning oʻynash maydoni — hech narsani oʻzgartiring. |
+| `program.md` | **Siz** | Tabiiy tilda yozilgan tadqiqot metodologiyasi. Siz faqat buni tahrirlaysiz. Agentga qanday oʻrganishni, qanday baholashni, nimaga tegmamaslikni aytasiz. |
+
+Bu uch tomonlama boʻlinish dizaynning ruhidir: **insonlarga code tegmaydi, ularga yoʻnalish tegadi; agentlarga yoʻnalish tegmaydi, ularga code tegadi.** Sizning ishingiz Python yozishdan "tadqiqot tashkiloti madaniyatini yozish"ga oʻzgaradi.
+
+### Kirish: program.md qanday koʻrinadi
+
+`program.md` bu loop ning miyasi. Bu kod emas — bu Markdown da yozilgan tadqiqot yoʻriqnomasi. U taxminan quyidagilarni oʻz ichiga oladi:
+
+- **Maqsad**: `val_bpb` ni optimallashtirish (baytiga tasdiqlash bitsi, pastroq = yaxshiroq)
+- **Cheklovlar**: `prepare.py` ga tegmang, VRAM byudjetida qoling, sobit 5-daqiqalik trening
+- **Oʻrganish yoʻnalishlari**: turli arxitekturalarni, optimizatorlarni, LR jadvalini sinab koʻring
+- **Baholash qoidalari**: nima yaxshilash hisoblanadi, natijalarni qanday yozish kerak, muvaffaqiyatsizlikda nima qilish kerak
+- **Temir qoida**: hech qachon toʻxtamang. Loop boshlangandan keyin, abadiy davom eting
+
+Agentga boshlash promptʼi bitta jumladek qisqa boʻlishi mumkin:
+
+```
+program.md ga qarang va keling, yangi eksperimentni boshlaylik!
+```
+
+Qolgani dokumentni oʻqib, oʻz qarorlarini qabul qiluvchi agentga qoladi.
+
+### Toʻqqiz qadamli ratchet loop
+
+autoresearchning yuragida **ratchet** bor — u faqat oldinga siljiydi, hech qachon orqaga. Har bir iteratsiya qatʼiy besh qadamni amalga oshiradi:
+
+```mermaid
+flowchart TD
+ 1["1. Yoʻnalishni oʻqish<br/>program.md ni yuklash"] --> 2["2. Joriy holatni koʻrib chiqish<br/>train.py + oʻtgan natijalarni oʻqish"]
+ 2 --> 3["3. Gipotazani taklif qilish<br/>Sinab koʻrish uchun oʻzgarish oʻylash"]
+ 3 --> 4["4. Kodni oʻzgartirish<br/>train.py ni tahrirlash"]
+ 4 --> 5["5. Snapshot<br/>git commit"]
+ 5 --> 6["6. Treningni ishga tushirish<br/>Sobiq 5 daqiqalik vaqt"]
+ 6 --> 7{"7. Baholash<br/>val_bpb yaxshilanganmi?"}
+ 7 -->|Ha| 8a["8a. Saqlash<br/>Commit qoladi<br/>results.tsv ga yozish"]
+ 7 -->|Yoʻq| 8b["8b. Qaytish<br/>git reset HEAD~1<br/>Muvaffaqiyatsizlikni yozish"]
+ 8a --> 9["9. Keyingi raund<br/>1-qadamga qaytish"]
+ 8b --> 9
+```
+
+U soatiga taxminan 12 ta eksperiment ishlatadi. Tunda ishlash (8 soat) taxminan 100 ta eksperiment. Karpathy oʻzi 2 kun davom ettirdi — ~700 ta eksperiment.
+
+Sobiq 5-daqiqalik vaqt byudjeti muhim dizayn tanlovidir — agent nima oʻzgartirishi qatʼiy nazar, har bir eksperiment bir xil vaqtni oladi. Bu barcha natijalar bir xil vaqt byudjeti ostida bevosita solishtirilishi mumkinligini anglatadi — "buning ishlash vaqti uzoqroq, shuning uchun yaxshiroq" degan bahs yoʻq.
+
+### Chiqish: Uyqudan uygʻonganda nima koʻrasiz
+
+Bir tun loop ishlagandan keyin, ertalab oʻtirib, uchta narsani topasiz:
+
+**1. Git tarixi (oldinga siljigan ratchet)**
+
+Faqat haqiqatan yaxshilagan commitlar main novdasida qoladi. Barcha muvaffaqiyatsizliklar qaytarilgan. `git log` tasdiqlangan tadqiqot jurnalidir.
+
+**2. results.tsv (toʻliq eksperiment yozuvi)**
+
+Har bir eksperiment — muvaffaqiyatli yoki muvaffaqiyatsiz — yozib boriladi:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Tadqiqot jurnali (agentning oʻz xulosasi)**
+
+Agent nima sinaganini, nima ishlaganini, nima ishlamaganini va keyin nima sinashni rejalashtirganini toʻliq xabarnomalar yozadi. Siz ularni oʻqiysiz — kod farqlarini oʻqish shart emas.
+
+### Haqiqatan nima topdi
+
+Karpathyʼning dastlabki 2 kunlik, ~700 eksperimentlik ishlashidan olingan natijalar:
+
+- ~700 ta urinish ichidan, taxminan **20 ta yonma-yon ishlaydigan haqiqiy yaxshilash** topildi
+- nanochatʼning GPT-2 darajasidagi trening vaqtini 8×H100 da **2.02 soat → 1.80 soat** ga qisqartirdi, taxminan **11% tezroq**
+- Topilmalar orasida: oʻrganish darajasi sozlamalari, optimizator sozlash, aktivatsiyani almashtirish, diqqat naqshlari optimallashtirish va boshqalar
+
+Barcha yaxshilanmalar yer sakraydigan kashfiyotlar edimi? Yoʻq. Koʻpchiligi yonma-yon ishlaydigan kichik optimallashtirishlar edi. Lekin bu 20 ta haqiqiy yaxshilash inson tadqiqotchisiga haftalar qoʻlda ish olib kelgan boʻlar edi — agent buni 48 soatda bajardi.
+
+### Eng koʻrsatuvchi batafsil: loop ingliz tilida yozilgan, kodda emas.
+
+`program.md` Markdown dokumenti, Python skripti emas. U tadqiqot metodologiyasini tasvirlaydi — nimani oʻzgartirish, nimaga tegmang, qanday baholash, muvaffaqiyatsizlik holatlarini qanday boshqarish va bitta temir qoida: **hech qachon inson yordamini soʻramang, shunchaki davom eting.** Kod yozuvchi agent ushbu dokumentni oʻqiydi va uni cheksiz amalga oshiradi.
+
+Bu loop muhandisligi uchun shablondir: agentga vazifa bermang. Unga **metodologiya** bering. Metodologiya loop boʻlsin. Bitta `program.md`, 630 qator li-kod va qolgan hamma narsa agentning oʻzi ishlashidir.
+
+## Toʻrtta jim turdagi xarajat
+
+Loop ishga tushganda, muammolarni darhol koʻrmaysiz. Quyidagi toʻrtta xarajat jim toʻplanadi va siz sezganingizda, balki allaqachon koʻp pul sarflagan boʻlasiz.
+
+### 1. Tekshiruv qarzi (Verification debt)
+
+Tez loopʼlar sizni tekshirishni oʻtkazib yuborishga vasvasilaydi. "Yaxshi koʻrinadi" va "toʻgʻriligi tasdiqlangan" bir narsa emas. Loop qancha koʻp kodni kuzatuvsiz ishlab chiqarsa, tekshiruv qarzi shunchalik tez yigʻilib boradi. Tuzatish: **toʻxtash shartlari mashina tekshirishi mumkin boʻlishi kerak, hech qachon "taxminan toʻgʻri" emas.**
+
+### 2. Tushunish parchalanishi (Comprehension rot)
+
+Loop qancha tez code joʻnatsa, sizning oʻz kod bazangizni tushunishingiz haqiqatdan shunchalik uzoqlashadi. Chernyning jamoasida kodning 80% i agentlar tomonidan yozilgan — yaʼni jamoaning aksariyat kodi odam tomonidan yozilmagan. Agar siz loop ishlab chiqargan narsani oʻqmasangiz va ishlatmasangiz, tushunishingiz doimiy ravishda pasayadi. **Tez loopʼlar tez oʻqishni talab qiladi.**
+
+### 3. Kognitiv taslim boʻlish (Cognitive surrender)
+
+Loop silliq ishlaganda, eng qulay holat — fikr bildirishni bas qilishdir. U qaytargan narsani oling, chiqish haqida oʻylamang. Ammo xavf aynan shu yerda boshlanadi — siz fikr kuchaytirish emas, balki fikrdan qochish uchun loop dan foydalanayapsiz. Osmani ogohlantirishi: "Ikki kishi bir xil loop ni qura oladi va qarama-qarshi natijalar oladi. Biri tushunadigan ishlarda tezroq borish uchun ishlatadi; ikkinchisi ishni tushunmaslik uchun ishlatadi. Loop farqni bilmaydi. Siz bilasiz."
+
+### 4. Token portlashi (Token blowout)
+
+Loop ning har bir iteratsiyasi koʻproq kontekst toʻplaydi: yozilgan kod, duch kelgan xatolar, qabul qilingan qarorlar. Kontekst boshqaruvisiz, prompt kattaligi turnlar soniga taxminan kvadratik oʻsadi. Codex buni avtomatik kontekst siqish bilan hal qiladi — maxsus API eski suhbat burilishlarini shifrlangan mazmuni xulosalarga siqib, kerakli bilimni saqlab, ortiqcha detallarni tashlaydi. Bu siz birinchi loopʼdan boshlab hal qilishingiz kerak boʻlgan muhandislik muammosi, keyinroq qoʻshiladigan narsa emas.
+
+## Birinchi loopʼingizni qurish
+
+Siz Stripe miqyosidagi pipeline haftasiga 1300 PR merge qilishdan boshlashingiz shart emas. Ishlaydigan eng kichik narsadan boshlang.
+
+### 1-qadam: Bir takrorlanuvchi vazifani tanlang
+
+Haftasida kamida ikki marta qoʻlda qilgan narsangizni toping. Misollar:
+- Ertalab GitHub ni ochish, yangi issue larni tekshirish, triage qilish va javob qaytarish
+- Har bir PR koʻrib chiqishdan oldin lint va testlarni ishga tushirish
+- Har bir kun oxirida jarayon hujjatlarini yangilash
+
+### 2-qadam: Maqsad va toʻxtash shartini yozing
+
+Vazifani `/goal` tushuna oladigan narsaga aylantiring:
+
+```markdown
+Maqsad: repodagi 10 ta eng yangi issue'ni tekshiring.
+Har bir issue uchun:
+ - Agar uning allaqachon aniq label'lari va javobgar shaxsi boʻlsa, oʻtkazing
+ - Agar taglanmagan boʻlsa, mazmuni asosida tegishli label'larni qoʻshing
+ - Agar 10 daqiqada tuzatish mumkin boʻlsa, branch oching va tuzatishga urinib koʻring
+Toʻxtash sharti: Barcha mos keluvchi issueʼlar koʻrib chiqilgan, yoki issue inson qarorini talab qiladi.
+```
+
+### 3-qadam: Maker va checker ni ajrating
+
+Bir xil agent ham kod yozsin, ham baholasin — qilmayman. Loopʼingizni ikki rolga ajrating:
+- Implementer: issue’ni oʻqiydi, tuzatishni yozadi, testlarni yozadi
+- Tekshiruvchi: mustaqil testlarni ishga tushiradi, farqni koʻrib chiqadi, tuzatish haqiqatan ham muammoni hal qiladimi yoki yoʻqligini baholaydi
+
+### 4-qadam: Xotira qoʻshing
+
+Har bir loop ishlashida nima sodir boʻlganini yozib borish uchun markdown fayldan foydalaning. Keyingi ishlash ushbu faylni oʻqishdan boshlaydi — u nima qilinganini, nima kutilayotganini, nima tiqilib qolganini biladi. Bu har qanday murakkab maʼlumotlar bazasidan yaxshiroq.
+
+### 5-qadam: Taymer oʻrnating
+
+Loopʼning sizsiz boshlashiga yoʻl qoʻyish uchun `/loop` yoki OS cron dan foydalaning. Kuniga bir martadan boshlang. Bir hafta kuzating.
+
+### Yetuklik zinapoyasi
+
+Siz eng yuqori nuqtaga bir sakrashda yetishingiz shart emas. Loop qabul qilishi zinapoyadir:
+
+1. **1-daraja: Maqsad bajaruvisi** — Siz `/goal` dan foydalanib, toʻxtash sharti boʻlgan vazifa berishingiz mumkin; agent ular bajarilgunga qadar loop qiladi.
+2. **2-daraja: Rejalashtirilgan bitta vazifa** — Bitta avtomatlashtirish taymerda bitta vazifani bajaradi (masalan, ertalabki CI tekshiruvi).
+3. **3-daraja: Koʻp agentli loop** — Maker va checker boʻlingan; har bir topilma izolyatsiyalangan worktree ni fork qiladi.
+4. **4-daraja: Oʻz-oʻzini oziqlantiruvchi loop** — loop keyingi vazifani tashqi holatdan avtomatik ravishda topadi; keyin nima qilishga oʻzi qaror qiladi.
+5. **5-daraja: Flot orkestratsiyasi** — Bir nechta loop parallel ishlaydi, mustaqil lekin xotira qavatini baham koʻradi.
+
+Koʻpchilik jamoalar hozir 2-daraja va 3-daraja orasida. 1-daraja daromad koʻrishning eng tez yoʻli.
+
+## Asosiy xulosalar
+
+- **Loop muhandisligi Harness muhandisligini almashtirmaydi — u bir qavat yuqoriga qurilgan.** Harness bitta ishlashni ishonchli qiladi. Loop esa doimiy ishlashni avtonom qiladi.
+- **`/goal` eng oddiy mumkin boʻlgan loop:** maqsad + tekshirish + toʻxtash sharti. Bu uchta narsa sizni loop ichidan tashqariga olib chiqadi.
+- **Oltita primitiv (Avtomatlashtirishlar / Worktreeʼlar / Skillʼlar / Konnektorlar / Sub-agentlar / Tashqi holat) loop’ning qurilish bloklari hisoblanadi.** Har safar barchasiga emas, lekin qaysi biriga qachon qoʻl choʻzishni bilishingiz kerak.
+- **Maker va checker ajratilishi kerak.** Oʻz ishlari baholaydigan model ishonchsizdir. Mustaqil tekshiruvchi — baʼzan butunlay boshqa model — har qanday loop’ning asosiy ishonchlilik kafolati.
+- **Loop’lar generatsiyani deyarli bepul qiladi va bahoni kam resurs sifatida qoldiradi.** Sertaratgan vaqtingiz dam olish uchun emas. Bu koʻproq baholar berish uchun.
+- **Loop uzoqroq ishlaganda toʻrtta jim xarajat keskinroq oʻsadigan:** tekshiruv qarzı, tushunish parchalanishi, kognitiv taslim boʻlish, token portlashi. Loop’lar ishlab chiqarishni — va xavfni ham tezlashtiradi.
+- **Kichikdan boshlang.** Bitta `/goal`, bitta cron, bitta markdown xotira fayli. Daromadni koʻring, keyin yuqoriga qiling.
+
+## Qoʻshimcha oʻqish
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — 50 ta haqiqiy loopʼning ommaviy korpusi
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- 12-maʼruza: [Har bir sessiya oxirida toza holat topshiring](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Loop uchun zarur shart: har bir sessiya toza holat qoldiradi, shunda keyingi raund avtomatik boshlanishi mumkin
+- 5-maʼruza: [Uzoq davom etadigan vazifalarni sessiyalar orasida uzluksiz saqlash](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Tashqi holat va xotira uchun bilim
+- 11-maʼruza: [Nima uchun kuzatuvchanlik harness ichida boʻlishi kerak](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Loop qancha tez ishlasa, muammolarni aniqlash uchun kuzatuvchanlik shunchalik kerak boʻladi
+- 8-maʼruza: [Nima uchun funksiyalar roʻyxati harness primitividir](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Funksiyalar roʻyxati oʻz-oʻzini oziqlantiruvchi loopʼning keyingi vazifani topishi uchun tabiiy maʼlumot manbai
+
+## Mashqlar
+
+1. **Takrorlanuvchi vazifani `/goal` ga aylantiring:** Haftasida kamida ikki marta qoʻlda qilgan narsangizni toping. Uning maqsadini, tekshirish usulini va toʻxtash shartini yozing. Buni bir marta `/goal` bilan ishga tushiring va vaqt va sifatni qoʻlda qilish bilan solishtiring. Bu Harness dan Loopʼga birinchi qadamingiz.
+
+2. **Maker va checker ni ajrating:** Ilgari agentni bajargan vazifani tanlang. Bu safar, ikki xil prompt yozing: biri implementer agent uchun, ikkinchisi tekshiruvchi agent uchun (turli modellardan foydalaning — masalan, implementatsiya uchun Claude, tekshirish uchun GPT yoki aksincha). Tekshiruvchi aniq dalillar bilan aniq muammolarni koʻrsatishi kerak. Har bir rejimda topilgan muammolar sonini va turini yozib oling.
+
+3. **Loopʼingizga xotira bering:** Loop uchun markdown holat faylini yarating. Har bir iteratsiyada yozing: bu raundda nima qilingan, tekshiruv natijalari, holat (oʻtdi/yiqildi/tiqilib qoldi) va keyin nima qilish kerak. Uchta raund ishlating va xotira fayli bor va yoʻq holatlaridagi xatti-harakat farqini kuzating.
+
+4. **Loopʼingizning jim xarajatlarini audit qiling:** Loop bir soat ishlagandan keyin, bu toʻrtta metrikani baholang:
+ - Qancha tekshirish "mashina tasdiqlagan" emas, balki "toʻgʻri tuyuldi" edi? (Tekshiruv qarzı)
+ - Loop eng yaqin ishlab chiqargan kodini qanchalik tushunib izohlaysiz? (Tushunish parchalanishi)
+ - Nechi marta "keyinroq qarayman" deb oʻyladingiz va hech qachon qaraedingiz? (Kognitiv taslim boʻlish)
+ - Loop’ning kontekst kattalishi qanday tendentsiyada? U ortiqcha maʼlumotni takrorlayaptimi? (Token portlashi)
diff --git a/docs/uz/projects/project-07-loop-engineering-first-loop/index.md b/docs/uz/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..8719c13
--- /dev/null
+++ b/docs/uz/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Loyiha 07. Birinchi avtomatlashtirilgan loop'ingizni qurish
+
+> Bogʻliq maʼruza: [L13. Nega agentingizga prompt yozishni bas qilishingiz kerak](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Nima qilasiz
+
+Bu "Harness" dan "Loop" ga oʻtish loyihasi. Siz allaqachon agentni toʻgʻri muhit, koʻrsatmalar va fikr-mulohaza bilan oʻrnatishni bilasiz — endi siz oʻsha oʻrnatishni oʻzi ishlaydigan loopʼga aylantirasiz.
+
+Siz uchta progressiv eksperiment qilasiz: avval vazifani qoʻldan `/goal` ga aylantirasiz, keyin kuzatuv vazifasini `/loop` taymeriga aylantirasiz va nihoyat toʻliq maker-checker loopʼini qurib, **siz loop tashqarisiga chiqsangiz** nima his qilishni boshdan kechirasiz.
+
+## Loyiha fayllari
+
+Repo yoʻli: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Katalog | Ichida nima bor | Nima qilasiz |
+|---------|----------------|--------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Toʻliq harness (P06 oxirgi holati) bilan kichik bilim bazasi loyihasi, jumladan AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Ushbu harnessni avtomatik loop qilishi mumkin boʻlgan holatga keltiring. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Uchta loopʼning toʻliq implementatsiyasi: goal loop, timer loop, maker-checker loop, plus loop holat fayllari va tekshirish skriptlari. | Loop dizayn naqshlari va holat boshqaruvi uchun mos yozuv. |
+
+## Foydalanadigan vositalar
+
+- Claude Code yoki Codex
+- Git
+- P06 dan sizning toʻliq harnessʼingiz
+- Terminal multiplaksatori (tmux yoki screen, uzoq davom etadigan loopʼlarni kuzatish uchun)
+- Ixtiyoriy: GitHub Actions yoki cron (rivojlangan event-driven / rejalashtirilgan eksperimentlar uchun)
+
+## Qadamlar
+
+### Tayyorgarlik
+
+1. P06 ni tugatgan xuddi shu commit dan boshlang.
+2. Uchta branch yarating: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Harnessʼingiz ishlashini tasdiqlang: init.sh ni ishga tushiring, holat fayli, funksiyalar roʻyxati va topshirish hujjatlari borligini tekshiring.
+4. Loopʼning takroran ishlashi kerak boʻlgan **maqsadli vazifa** ni tanlang. Tugallik mezonlari aniq boʻlgan oʻrtacha kattalikdagi narsani tanlang — masalan, "barcha modullarga unit testlar qoʻshish, 80% qamrovga erishish" yoki "barcha API endpointʼlariga kirishni tekshirishni qoʻshish".
+
+### 1-eksperiment: Goal Loop — Qoʻlda ishlatishdan avtomatik ishlashga
+
+`p07-goal-loop` branchʼiga oʻting.
+
+1. **Maqsad tavsifini yozing**: Tanlagan vazifangizni `goal.md` fayliga aylantiring, quyidagilarni oʻz ichiga olgan holda:
+ - Aniq maqsad ("nima tugallangan hisoblanadi")
+ - Tekshirish usuli ("tugalligini qanday tasdiqlash kerak" — testlarni ishga tushirishmi? lint ni ishga tushirishmi? qamrovni tekshirishmi?)
+ - Toʻxtash sharti ("qachon toʻxtashi kerak" — maksimal turnlar soni? vaqt chegarasi? byudjet chegarasi?)
+ - Cheklovlar ("nimaga tegmang" — production konfiguratsiyasi, maʼlumotlar bazasi sxemasi va boshqalar)
+
+2. **Birinchi qoʻlda ishlatish**: Vazifani agentga oʻzingiz qoʻlda bering. Necha turn oʻtganini, necha marta aralashganingizni va natija sifatini yozib oling. Bu sizning bazangiz.
+
+3. **`/goal` bilan ishlatish**: Xuddi shu `goal.md` ni kirish sifatida ishlating va uni `/goal` rejimida ishga tushiring. Agent maqsadga erishgunga qadar yoki toʻxtash sharti ishga tushgunga qadar oʻzi loop qiladi.
+
+4. **Natijalarni solishtiring**:
+ - Turnlar sonidagi farq
+ - Sizning aralashish soningizdagi farq
+ - Natija sifatidagi farq (bir xil tekshirish standartidan foydalanib)
+ - Sarflagan vaqtingizdagi farq
+
+5. **goal.md ustida takrorlang**: Agar natijalar yomon boʻlsa, maqsad tavsifini qayta koʻrib chiqing va yana ishlating. Natijalardan qoniqmaganingizgacha yoki goal loop ushbu vazifada qila oladigan chegarasini tasdiqlaguningizgacha davom eting.
+
+### 2-eksperiment: Taymer Loop — Kuzatuvni yurak urishiga aylantiring
+
+`p07-timer-loop` branchʼiga oʻting.
+
+1. **Kuzatuv vazifasini tanlang**: Odatda qoʻlda qilgan takroriy tekshiruvni toping. Masalan:
+ - Har soat test toʻplamini ishga tushiring, xatolarni tuzating
+ - Har ertalab bogʻliqlik xavfsizlik yangilanishlarini tekshiring
+ - Har bir commit dan keyin kodlash uslubi buzilishlarini tekshiring
+ - Vaqti-vaqti bilan TODO izohlarini skanerlab, qaysilari eskirganini koʻring
+
+2. **Kuzatuv prompt/skriptini yozing**: Kuzatuv qadamlari aniq belgilang — nima tekshirilishi kerak, muammolar topilsa nima qilish kerak va qachon insonga murojaat qilish kerak.
+
+3. **`/loop` (yoki Codex Thread automation) bilan ishlatish**:
+ - Oʻrtacha interval oʻrnating (10-30 daqiqa tavsiya etiladi — juda qisqa boʻlsa bezovta qilasiz, juda uzoq boʻlsa taʼsirini koʻrmaysiz)
+ - Kamida 2 soat davom ettiring (yoki boshqa narsa qilib, keyinroq qayting)
+
+4. **Natijalarni yozing**:
+ - Necha muammo topdi?
+ - Nechtasini oʻzi tuzatdi?
+ - Nechtasi notoʻgʻri musbat edi?
+ - Nechtasini yomonlashtirdi?
+ - Natijalarini kuzatib qancha vaqt sarfladingiz?
+
+5. **Oʻylab koʻring**: Ushbu kuzatuv vazifasini avtomatlashtirish arzimaydimi? Sertaratgan vaqtni kuzatib sarflagan vaqt bilan solishtiring. Agar arziymasa — notoʻgʻri vazifani tanladingizmi, yoki loop yomon loyihalanganmi?
+
+### 3-eksperiment: Maker-Checker Loop — Oʻzingizni loop dan tashqariga chiqaring
+
+`p07-maker-checker` branchʼiga oʻting.
+
+Bu uchta eksperimentning eng muhimi. Siz **sizning ishtirokingizni talab qilmaydigan toʻliq loop** qurishingiz kerak:
+
+1. **Loop tuzilishini loyihalang**:
+ - **Maker agent**: implement qiladi, kod yozadi, fayllarni oʻzgartiradi
+ - **Checker agent**: tekshiradi, testlarni ishga tushiradi, kod koʻrib chiqishni amalga oshiradi, oʻtkazadi / muvaffaqiyatsizlikka uchratadi
+ - **Holat fayli** (`loop-state.md`): joriy raund, nima qilingan, tekshiruv natijalari, keyin nima qilish kerakligini yozib boradi
+ - **Toʻxtash sharti**: N ta ketma-ket oʻtish yoki maksimal raundlar soniga yetish
+
+2. **Uchta prompt yozing**:
+ - Maker yoʻriqnomalari (nima qilish kerak, qanday qilish kerak, nimaga tegmang)
+ - Checker yoʻriqnomalari (nima tekshirilishi kerak, qanday tekshirilishi kerak, nima oʻtish hisoblanadi, qanday fikr-mulohaza berish kerak)
+ - Loop boshqaruv mantiqi (kim birinchi boʻladi, topshirish qanday ishlaydi, keyingi raundni qanday boshlash kerak)
+
+3. **Kamida 5 ta raund ishlating**:
+ - 1-raund: Maker implement qiladi → Checker tekshiradi → Muvaffaqiyatsizlik → Makerʼga fikr-mulohaza
+ - 2-raund: Maker fikr-mulohaza asosida qayta ishlaydi → Checker tekshiradi → ...
+ - ...
+ - Ketma-ket oʻtgunga qadar yoki siz chaqirgunga qadar
+
+4. **Har bir raund holatini yozing**:
+ - Raund raqami
+ - Maker nima qildi
+ - Checker qanday muammolar topdi
+ - Oʻtdi / yiqildi
+ - Siz aralashdingizmi? (agar ha, nega?)
+
+5. **Yakuniy retro**:
+ - Nechi marta aralashdingiz? Nega?
+ - Agar aralashmasangiz nima boʻlar edi?
+ - Checker hech qanday muammoni oʻtkazib yubordimi?
+ - Maker bir xil xatoni qayta-qayta qildimi?
+ - Ushbu loop ning sifat shifoni qayerda? Maker qobiliyati yoki Checker qobiliyati?
+
+## Natijalarni qanday oʻlchash kerak
+
+| Metrika | 1-eksperiment (Goal) | 2-eksperiment (Taymer) | 3-eksperiment (Maker-Checker) |
+|---------|---------------------|----------------------|-------------------------------|
+| Vazifani bajarish darajasi | Maqsadga erishildimi? | Necha kuzatuv davri ishladi? | Oʻtguncha necha raund? |
+| Inson aralashuvi | Nechi marta aralashdingiz? | Kuzatib qancha vaqt sarfladingiz? | Nechi marta aralashdingiz? |
+| Natija sifati | Qoʻlda qilish bilan qanday solishtiriladi? | Notoʻgʻri musbat darajasi? Oʻtkazilgan muammolar? | Checker siz topmaganingizda necha muammo topdi? |
+| Sertaratgan vaqt | Necha vaqt sertaradingiz? | Avtomatlashtirish arzimaydimi? | Loop loyihalashga sarflangan vaqt sertaratgan vaqtga nisbatan |
+| Ishonchlilik | Toʻxtash sharti ishonchli edi? | U qochib kettdimi? | Loop bir joyda tiqilib qolishi mumkinmi? |
+
+## Nima topshirish kerak
+
+- `goal.md` (1-eksperimentning maqsad tavsifi, kamida ikki iteratsiya)
+- 1-eksperimentning taqqoslash eslatmalari: qoʻlda vs goal loop
+- 2-eksperimentning kuzatuv promptʼi + 2 soatlik ishlash jurnali
+- 3-eksperimentning uchta promptʼi (Maker / Checker / Loop boshqaruv)
+- 3-eksperimentning `loop-state.md` (kamida 5 ta raund yozilgan)
+- Yakuniy retro: barcha uchta eksperimentdan olingan darsliklar, loop muhandisligi haqidagi tushunchangiz qanday oʻzgardi, qanday narsalar loopʼlashtirish uchun yaxshi nomzod va qaysilari emas
+
+## Bogʻliq maʼruzalar
+
+- [13-maʼruza — Nega agentingizga prompt yozishni bas qilishingiz kerak](../../lectures/lecture-13-loop-engineering/index.md)
+- [12-maʼruza — Nega har bir sessiya toza holat qoldirishishi kerak](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (loop ning har bir raundi toza holatni talab qiladi)
+- [11-maʼruza — Nega kuzatuvchanlik harness ichida boʻlishi kerak](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (loop ichida nima boʻlayotganini koʻrish kerak)
+- [5-maʼruza — Nega holat fayllari uzluksizlikning umurtqasi hisoblanadi](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (loop holat fayllari holat fayllarining kengaytmasidir)
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/vi/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..61695be
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt
+
+> For the verification agent.
+> Focus on "finding problems" — the stricter, the better.
+
+## Your Role
+
+You are the Checker. Your job is to verify what the Maker produced. Your goal is to find problems, not say nice things.
+
+When you get an implementation from the Maker, your job is to:
+
+1. Read through all changes
+2. Verify item by item against the checklist
+3. Run the full verification commands
+4. List every problem you find — each with evidence
+
+**Remember: you're not here to praise, you're here to find fault.** Not finding problems is your failure.
+
+## Checklist
+
+### Functional Correctness
+- [ ] Does the implementation match the requirements?
+- [ ] Are there any edge cases missed?
+- [ ] Is error handling in place?
+
+### Code Quality
+- [ ] Is the code clear? Are names clear?
+- [ ] Is there duplicate code?
+- [ ] Does it follow project coding standards?
+- [ ] Are there obvious performance issues?
+
+### Testing
+- [ ] Do tests cover the main scenarios?
+- [ ] Are edge cases tested?
+- [ ] Are the tests actually testing something meaningful, or are they just going through the motions?
+
+### Verification Commands
+- [ ] Does `npm test` pass fully?
+- [ ] Does `npm run lint` have zero errors?
+- [ ] Does TypeScript type check pass?
+- [ ] Does coverage meet the bar?
+
+### Safety and Impact
+- [ ] Will this change affect anything else?
+- [ ] Are any new dependencies introduced? Are they justified?
+- [ ] Are config file changes correct?
+
+## Output Requirements
+
+Each issue must include:
+1. **Description**
+2. **Where** (file and line number)
+3. **Evidence** (what exactly is wrong, why it's a problem)
+4. **Severity** (Critical / Medium / Minor)
+
+End with an overall verdict: Pass / Fail / Minor issues, acceptable
+
+Output format:
+
+```
+## Overall Verdict
+✅ Pass / ❌ Fail / ⚠️ Minor issues, acceptable
+
+## Issues Found
+
+### 1. [Critical] Issue title
+- Location: file:line
+- Description: ...
+- Evidence: ...
+- Suggestion: ...
+
+### 2. [Medium] Issue title
+...
+
+## Verification Command Results
+- Unit tests: X passed / Y total
+- Lint: pass / fail (X errors)
+- Type check: pass / fail
+- Coverage: XX%
+```
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/vi/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..5e8e0ed
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop Template
+
+> Write your goal as a document like this, then hand it to `/goal` or a maker agent.
+> The more specific and verifiable, the higher the loop quality.
+
+## Goal
+
+<!-- One sentence describing what to do -->
+
+Implement the XX feature with complete unit test coverage.
+
+## Acceptance Criteria
+
+<!-- Machine-verifiable completion conditions — each one can be checked with a command -->
+
+- [ ] `npm test` passes fully
+- [ ] Coverage report shows XX module coverage ≥ 80%
+- [ ] `npm run lint` has zero errors
+- [ ] TypeScript type check passes (`npx tsc --noEmit`)
+- [ ] All new code follows project coding standards
+
+## Scope
+
+<!-- Be explicit about what NOT to touch -->
+
+### Fair game
+
+- All files under `src/xx/`
+- Test files under `tests/`
+- Related type definition files
+
+### Hands off
+
+- `src/main.ts` entry file
+- Database schema migrations
+- Dependency versions in `package.json` (unless explicitly needed)
+- CI/CD config files
+
+## Verification Method
+
+<!-- How to verify after each step -->
+
+1. After implementation, run these commands in order:
+ 1. `npx tsc --noEmit` — type check
+ 2. `npm run lint` — code style
+ 3. `npm test` — unit tests
+ 4. `npx vitest --coverage` — coverage check
+
+2. Fix any failures before moving to the next step.
+3. When everything passes, run the full end-to-end test suite (if available).
+
+## Stop Conditions
+
+- All acceptance criteria pass ✅
+- Max turns reached: 20
+- No progress for 3 consecutive rounds (same error keeps appearing)
+- Blocking issue that cannot be resolved independently (e.g., missing dependency, environment problem)
+
+## How to Work
+
+1. Read `AGENTS.md` and `feature_list.json` first to understand the project structure and existing features.
+2. Write out the design approach before touching code.
+3. Verify after each sub-task is done.
+4. If stuck for more than 2 rounds, switch approach or simplify.
+5. Update progress at the end of each round.
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/code/index.md b/docs/vi/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..3fcaea7
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# Lecture 13 Code Examples
+
+Use this folder for examples of:
+
+- goal.md goal description template
+- loop-state.md loop state template
+- Maker / Checker role prompt templates
+- Loop control script examples
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/vi/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..5884ef5
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State Template
+
+> Every loop should have a state file tracking current progress.
+> Update at the end of each round; read at the start of the next round.
+
+## Basic Info
+
+- **Loop name**: <!-- e.g. "Unit test completion loop" -->
+- **Started**: 2026-07-09 10:00
+- **Current round**: Round 1 / N total
+- **Current status**: In progress <!-- In progress / Completed / Blocked / Failed -->
+- **Total elapsed**: 0h 0m
+
+## Goal
+
+<!-- What this loop is trying to achieve -->
+
+## Round Log
+
+### Round 1
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+### Round 2
+
+- **Started**:
+- **What the Maker did**:
+- **Verification result**: ✅ Pass / ❌ Fail / ⚠️ Partial
+- **Issues found**:
+ -
+- **Next round plan**:
+- **Human intervention needed**: Yes / No
+
+<!-- Copy the format above and keep adding -->
+
+## Cumulative Stats
+
+| Metric | Value |
+|--------|-------|
+| Rounds completed | 0 |
+| Passed rounds | 0 |
+| Failed rounds | 0 |
+| Total issues found | 0 |
+| Human interventions | 0 |
+| Files changed | 0 |
+
+## Blocker List
+
+<!-- Record recurring issues so the next round is aware -->
+
+-
+
+## Final Result
+
+<!-- Fill in when loop ends -->
+
+- **Final status**: Completed / Failed / Manually stopped
+- **Finished at**:
+- **Summary**:
+ - What was done
+ - How it went
+ - What was learned
+ - How to improve next time
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/vi/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..fa035c5
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt
+
+> For the implementation agent.
+> Focus on "making it work."
+
+## Your Role
+
+You are the Maker. Your job is to implement features and write code.
+
+When you get a task, your job is to:
+
+1. Understand the requirements
+2. Design the approach
+3. Write the code
+4. Run basic verification (build, lint, unit tests)
+5. Hand the result to the Checker for review
+
+## Working Rules
+
+- Read AGENTS.md and relevant docs first to understand the project structure.
+- Explain your plan before making changes.
+- Run basic verification on your own after writing — make sure it at least runs.
+- If you don't know something, say you don't know. Don't make things up.
+- Record progress at each step.
+
+## Deliverables
+
+- List of files modified
+- Brief implementation summary
+- Basic verification results (build / lint / tests)
+- Areas you're unsure about (for the Checker to focus on)
+
+## Output Format
+
+```
+## Implementation Summary
+...
+
+## Modified Files
+- ...
+
+## Basic Verification
+- Build: pass / fail
+- Lint: pass / fail
+- Unit tests: X passed, Y failed
+
+## Known Issues and Risks
+- ...
+```
diff --git a/docs/vi/lectures/lecture-13-loop-engineering/index.md b/docs/vi/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..19b214e
--- /dev/null
+++ b/docs/vi/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> Ví dụ code: [code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/vi/lectures/lecture-13-loop-engineering/code/)
+> Dự án thực hành: [Dự án 07. Xây dựng Vòng lặp Tự động Đầu tiên](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# Bài 13. Từ Nhắc lệnh Thủ công đến Vòng lặp Tự chủ
+
+Tất cả những gì bạn đã học trong mười hai bài đầu tiên đều dựa trên một giả định: **bạn đang ngồi trước bàn phím, gõ các chỉ dẫn từng cái một.**
+
+Bạn đã viết `AGENTS.md` (Bài 1–4), xây dựng quản lý trạng thái (Bài 5–6), giới hạn phạm vi với danh sách tính năng (Bài 7–8), để lại bàn giao sạch ở cuối phiên (Bài 9, 12), và làm cho runtime có thể quan sát được (Bài 10–11). Nhưng tác nhân kích hoạt tất cả mọi thứ luôn là bạn. Agent không bao giờ tự quyết định khi nào bắt đầu làm việc — vì không ai nhấn nút "bắt đầu".
+
+Bài giảng này là về việc trao nút bắt đầu cho hệ thống. Không phải từ bỏ quyền kiểm soát — mà là nâng nó lên tầng tiếp theo.
+
+## /goal: Vòng lặp Đơn giản Nhất
+
+Cách tốt nhất để bắt đầu loop engineering không phải là một sơ đồ kiến trúc phức tạp — mà là một lệnh duy nhất.
+
+Vào đầu năm 2026, Claude Code và OpenAI Codex độc lập phát hành cùng một tính năng: `/goal`. Bạn gõ vào terminal:
+
+```
+/goal "All tests pass, zero lint warnings, merge to main"
+```
+
+Sau đó bạn đóng máy tính và đi ngủ. Tám giờ sau, agent đã tự phân tích, code, test, sửa lỗi, và merge. Nó thử lại khi thất bại, đổi cách tiếp cận khi bị kẹt, và dừng lại khi xong — mà không cần bạn đứng sau lưng nói "thử lại đi."
+
+Sự khác biệt duy nhất giữa `/goal` và một prompt truyền thống là một điều. Nhưng điều đó thay đổi mọi thứ:
+
+| | Prompt truyền thống | `/goal` |
+|---|---|---|
+| Bạn cung cấp gì | Phải làm gì tiếp theo | Trạng thái cuối trông như thế nào |
+| Agent làm gì | Thực thi một lần | Lặp lại cho đến khi đạt được |
+| Ai quyết định xong | Bạn | Một điều kiện dừng có thể kiểm chứng |
+| Khi nào bạn có thể rời đi | Bạn không thể | Ngay khi bạn gõ `/goal` |
+
+`/goal` về cơ bản là một vòng lặp. Nó có đúng ba phần: **một mục tiêu, một phương pháp xác minh, và một điều kiện dừng.** Chỉ ba thứ đó đã dịch chuyển bạn từ bên trong vòng lặp ra bên ngoài nó.
+
+### Làm sao `/goal` Phát triển Tự nhiên
+
+`/goal` không phải nhảy từ 0 lên 1 bất ngờ. Nó lớn dần từ các quy trình làm việc hàng ngày, đi qua khoảng bốn giai đoạn:
+
+**Giai đoạn 1: Nhắc lệnh thủ công từng cái một.** Cách làm việc sớm nhất là qua lại: "viết một hàm," "thêm test," "sửa logic này." Agent dừng lại sau mỗi bước và chờ bạn nói tiếp theo là gì. Bạn là người lên lịch cho toàn bộ đường ống.
+
+**Giai đoạn 2: Prompt dài với nhiều bước.** Sau đó mọi người bắt đầu viết các prompt dài hơn xếp chồng các bước lại với nhau: "đầu tiên phân tích code, sau đó viết triển khai, sau đó chạy test, và nếu chúng thất bại thì sửa chúng." Agent có thể chạy nhiều bước trong một lần, nhưng bạn vẫn phải theo dõi — vì nó có thể trôi dạt giữa chừng, hoặc hoàn thành một bước và không biết phải làm gì tiếp theo.
+
+**Giai đoạn 3: Agent tự phản ánh và tự định hướng.** Sau đó, các agent có được "sự nội quan" — sau mỗi bước chúng nhìn kết quả và quyết định phải làm gì tiếp theo. Bạn đưa ra mục tiêu, và chúng tự chia nhỏ và tự thử lại. Nhưng một vấn đề nảy sinh: khi nào chúng dừng lại? Việc "tôi xong rồi" từ chính agent có đáng tin không? Thực tế liên tục trả lời — không. Các agent tuyên bố chiến thắng quá dễ dàng.
+
+**Giai đoạn 4: Phán đoán dừng độc lập — `/goal`.** Bước cuối cùng là lấy "việc phán đoán xem có xong không" ra khỏi tay agent đang làm việc, và trao nó cho một thẩm phán độc lập. Đó có thể là một mô hình khác, một script, hoặc một lệnh test — nhưng quy tắc là như nhau: người viết code không thể chấm điểm bài tập về nhà của chính mình. Tại thời điểm này, `/goal` mới thực sự hoạt động: bạn đưa ra mục tiêu, nó lặp lại, một thẩm phán độc lập quyết định khi nào dừng, và bạn có thể rời đi.
+
+Bốn giai đoạn này không phải là lộ trình được bất kỳ công ty nào lên kế hoạch. Đó là con đường mà mọi người code với agent đều đến được, một cách độc lập, bị đẩy bởi những điểm đau giống nhau. Claude Code và Codex phát hành `/goal` gần như đồng thời vào đầu năm 2026 không phải là ngẫu nhiên — thời điểm đã đến.
+
+### Không Chỉ Một Loại Vòng lặp
+
+`/goal` là vòng lặp dễ hiểu nhất, nhưng nó không phải loại duy nhất. Các vòng lặp được phân loại dựa trên cách chúng được kích hoạt và cách chúng dừng lại:
+
+| Loại | Kích hoạt | Điều kiện dừng | Claude Code | Codex | Tốt nhất cho |
+|------|---------|----------------|-------------|-------|----------|
+| **Vòng lặp theo lượt** | Bạn gõ từng prompt thủ công | Agent nghĩ nó xong, hoặc bạn ngắt | Chat bình thường | Chat bình thường | Nhiệm vụ nhỏ, khám phá |
+| **Vòng lặp theo mục tiêu** | Bạn đưa ra mục tiêu | Đánh giá độc lập xác nhận xong, hoặc đạt lượt tối đa | `/goal` | `/goal` (cần bật thủ công) | Nhiệm vụ phức tạp có tiêu chí hoàn thành rõ ràng |
+| **Vòng lặp theo thời gian** | Khoảng thời gian theo lịch (mỗi N phút/giờ) | Bạn dừng thủ công, hoặc nó thoát sau khi hoàn thành công việc | `/loop` | Thread automation | Kiểm tra trạng thái định kỳ, kiểm tra định kỳ, công việc lặp lại |
+| **Vòng lặp theo sự kiện** | Sự kiện bên ngoài (PR được mở, CI thất bại, issue mới) | Dừng sau khi xử lý sự kiện, hoặc đạt giới hạn thử lại | Routines (API / GitHub Webhook) | Standalone automation + plugins | Quy trình phản ứng, tích hợp CI/CD |
+
+Chúng không cạnh tranh — chúng là những công cụ khác nhau cho những công việc khác nhau. Turn-based thì ổn cho những việc nhỏ. Dùng `/goal` khi có đường đích rõ ràng. Dùng `/loop` khi bạn cần theo dõi gì đó. Dùng event-driven khi bạn tích hợp với các hệ thống bên ngoài.
+
+### Đừng Nhầm Lẫn `/goal` và `/loop`
+
+Cả hai đều có "loop" trong tên, nhưng chúng giải quyết các vấn đề hoàn toàn khác nhau:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **Nó là gì** | Một nhiệm vụ lớn, chạy cho đến khi xong | Một hành động nhỏ, lặp lại theo khoảng thời gian |
+| **Điều kiện dừng** | Đạt mục tiêu, hoặc hết ngân sách | Bạn dừng thủ công, hoặc nhiệm vụ tự thoát |
+| **Phổ thời gian** | Một lần chạy dài, có thể mất vài giờ hoặc vài ngày | Các đợt ngắn định kỳ, mỗi lần chạy có thể vài phút |
+| **Tiến độ** | Mỗi vòng lặp lại gần hơn với đường đích | Mỗi lần chạy độc lập, không có tiến độ tích lũy |
+| **Giống với** | Chạy marathon — súng bắn bắt đầu, bạn dừng ở đường đích | Đồng hồ báo thức — kêu theo lịch, bạn tắt nó |
+| **Sử dụng điển hình** | "Triển khai toàn bộ hệ thống thanh toán với độ phủ test" | "Kiểm tra CI có bị hỏng không mỗi 15 phút" |
+
+Một sai lầm phổ biến: ép thứ gì đó đáng lẽ là `/goal` vào một `/loop`. Như viết `/loop 10m "tiếp tục triển khai hệ thống thanh toán"` — sai rồi. `/loop` chạy cùng một chỉ dẫn độc lập mỗi lần, nó không nhớ nơi nó dừng lại lần trước. Bạn chỉ sẽ nhận được cùng một điểm khởi đầu lặp đi lặp lại.
+
+**Câu hỏi một câu để chọn cái nào: thứ này có kết thúc không?**
+- Có kết thúc → `/goal`
+- Không kết thúc, bạn chỉ cần tiếp tục theo dõi → `/loop`
+
+Loop Engineering, chủ đề của bài giảng này, không phải về một lệnh nào đó. Nó là về **khả năng thiết kế các hệ thống bao gồm tất cả các loại này — để agent của bạn có thể tiếp tục làm việc ngay cả khi bạn không ở đó.**
+
+Bạn không cần phải gõ `/goal` mỗi lần. Nhưng hiểu nó đến từ đâu và tại sao nó trông như thế nào — đó là hiểu cốt lõi của loop engineering. Các vòng lặp phức tạp hơn chỉ thêm các phần như lập lịch, song song, cô lập, và bộ nhớ lên trên ba nguyên tắc cơ bản giống nhau: mục tiêu, xác minh, điều kiện dừng.
+
+## Tháng Sáu 2026: Ba Người Đốt Cùng Một Que Diêm Trong Một Tuần
+
+Trong tuần đầu tiên của tháng 6 năm 2026, ba người thực hành xây dựng cơ sở hạ tầng agent coding — mà không so sánh ghi chú — đã nói cùng một điều bằng những lời khác nhau.
+
+**Peter Steinberger** (người tạo ra OpenClaw, [bài đăng của ông đạt 8 triệu lượt xem](https://x.com/steipete/status/2063697162748260627)): "Bạn không nên còn đang nhắc lệnh các agent coding nữa. Bạn nên thiết kế các vòng lặp nhắc lệnh agent của bạn."
+
+**Boris Cherny** (trưởng phòng Claude Code tại Anthropic, [trên podcast Acquired](https://x.com/rohanpaul_ai/status/2063289804708835412)): "Tôi không còn nhắc lệnh Claude nữa. Tôi có các vòng lặp chạy nhắc lệnh Claude và tìm ra phải làm gì. Công việc của tôi là viết các vòng lặp."
+
+**Addy Osmani** (trưởng nhóm kỹ thuật tại Google Chrome) [đặt tên cho khái niệm](https://addyosmani.com/blog/loop-engineering/) vào ngày 7 tháng 6 năm 2026, và đưa ra định nghĩa một dòng:
+
+> **Loop engineering là thay thế bản thân bạn với tư cách là người nhắc lệnh agent. Bạn thiết kế hệ thống làm việc đó thay thế.**
+
+Cherny tiết lộ con số: trong hơn 30 ngày liên tiếp, tất cả các đóng góp code cho Claude Code đều được thực hiện tự chủ bởi AI — 259 PR đã được merge, hơn 80% code sản xuất được viết bởi Claude, và tỷ lệ thành công 76% đối với các nhiệm vụ phần mềm mở.
+
+Ba người. Một tuần. Cùng một kết luận. Không phải vì họ phối hợp — mà vì cơ sở hạ tầng đã lặng lẽ vượt qua một ngưỡng. Các agent đã trở nên đủ tin cậy để hoàn thành các nhiệm vụ không tầm thường mà không cần giám sát. Các nguyên thủy lập lịch (`/loop`, `/goal`, cron) giờ đã được tích hợp sẵn trong các công cụ. Chi phí của một lần chạy agent đã giảm đủ thấp để việc chạy một cách lặp đi lặp lại theo bộ hẹn giờ trông không còn lãng phí. Khi tất cả các bộ phận đều có mặt, bước di chuyển kết hợp chúng trở nên hiển nhiên với mọi người cùng một lúc.
+
+> Nguồn: [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## Bên Trong Vòng lặp vs. Bên Ngoài Vòng lặp
+
+Hãy đối chiếu hai kịch bản cụ thể.
+
+**Kịch bản A: Bạn ở bên trong vòng lặp (Bài 1–12).**
+
+```mermaid
+flowchart TD
+ You["Bạn"] -->|"Gõ chỉ dẫn thủ công"| Agent["AI Agent"]
+ Agent -->|"Đưa ra kết quả"| Result["Code / test / tài liệu"]
+ Result -->|"Bạn kiểm tra"| You
+ You -->|"Không hài lòng, sửa chỉ dẫn"| Agent
+ You -->|"Hài lòng, chuyển nhiệm vụ tiếp theo"| You
+```
+
+Bạn có một bộ harness hoàn chỉnh: `AGENTS.md` nói với agent các quy tắc dự án, `feature_list.json` giới hạn phạm vi, `init.sh` đảm bảo môi trường nhất quán, `claude-progress.md` ghi lại tiến độ. **Nhưng mỗi bước vẫn đòi hỏi bạn khởi tạo thủ công.** Hoàn thành một tính năng, đọc file tiến độ, suy nghĩ về tiếp theo là gì, gõ chỉ dẫn. Bạn là động cơ của toàn bộ quy trình làm việc.
+
+**Kịch bản B: Bạn ở bên ngoài vòng lặp (Loop Engineering).**
+
+```mermaid
+flowchart TD
+ subgraph Loop["Hệ thống vòng lặp bạn đã thiết kế"]
+ Trigger["Tự động kích hoạt<br/>Lịch / Sự kiện / Nhiệm vụ trước hoàn thành"] --> Discover["Khám phá công việc<br/>Đọc file tiến độ / trình theo dõi issue"]
+ Discover --> Dispatch["Phân công<br/>Tạo sub-agent"]
+ Dispatch --> Verify["Xác minh<br/>Test / lint / Agent đánh giá độc lập"]
+ Verify --> Persist["Lưu trạng thái<br/>Cập nhật tiến độ / Commit / Mở PR"]
+ Persist -->|"Còn việc"| Discover
+ Persist -->|"Xong hoặc bị chặn"| Inbox["Đẩy vào hộp thư review của bạn"]
+ end
+ Inbox -->|"Bạn chỉ cần đưa ra quyết định"| You["Bạn"]
+```
+
+Bạn không còn gõ chỉ dẫn nữa. Hệ thống bạn đã thiết kế khám phá công việc, phân công nó, xác minh kết quả, ghi lại trạng thái, và quyết định bước tiếp theo. Công việc của bạn thu hẹp còn ba điều: **định nghĩa mục tiêu và điều kiện dừng trước khi nó bắt đầu, review kết quả sau khi nó hoàn thành, và điều chỉnh các quy tắc khi hệ thống đi lạc hướng.** Đòn bẩy dịch chuyển từ "viết prompt đúng" sang "thiết kế vòng lặp đúng."
+
+> Osmani: "Một năm trước nếu bạn muốn một vòng lặp bạn viết một đống bash và bạn duy trì đống đó mãi mãi và nó là của bạn và chỉ của bạn. Bây giờ các mảnh ghép chỉ được giao bên trong các sản phẩm." Bạn không cần xây dựng từ đầu. Bạn cần hiểu các mảnh ghép khớp với nhau như thế nào.
+
+## Các Khái niệm Cốt lõi
+
+- **Loop Engineering**: Thiết kế một hệ thống tự động nhắc lệnh agent của bạn, thay thế đầu vào của con người từng bước thủ công. Con người di chuyển từ bên trong vòng lặp ra bên ngoài nó, và đòn bẩy chuyển từ "viết prompt đúng" sang "thiết kế vòng lặp đúng."
+- **Chế độ `/goal`**: Vòng lặp đơn giản nhất — đưa ra mục tiêu, phương pháp xác minh, và điều kiện dừng; agent lặp lại cho đến khi đạt được. Cầu nối từ nhắc lệnh thủ công đến các vòng lặp tự chủ.
+- **Phân tách Generator/Evaluator**: Agent viết code và agent kiểm tra code phải được tách riêng. Một mô hình chấm điểm công việc của chính mình là không đáng tin cậy; một trình xác minh độc lập — đôi khi sử dụng hoàn toàn một mô hình khác — là đảm bảo độ tin cậy cơ bản của bất kỳ vòng lặp nào.
+- **Cô lập Worktree**: Mỗi agent song song làm việc trong một git worktree độc lập, ngăn chặn vật lý các va chạm tệp. Điều kiện tiên quyết về cơ sở hạ tầng cho thực thi song song đa agent.
+- **Trạng thái bên ngoài**: Bộ nhớ sống bên ngoài một cuộc trò chuyện đơn lẻ — các file markdown, trình theo dõi issue, bảng kanban. Các mô hình quên mọi thứ giữa các lần chạy; bộ nhớ phải sống trên đĩa.
+- **Bốn chi phí thầm lặng**: Bốn chi phí ẩn trở nên gay gắt hơn vòng lặp chạy càng lâu — nợ xác minh, sự thối rữa hiểu biết, sự đầu hàng nhận thức, bùng nổ token. Các vòng lặp không chỉ tăng tốc đầu ra, mà còn tăng tốc rủi ro.
+
+## Sáu Nguyên thủy của Một Vòng lặp
+
+Osmani phân rã một vòng lặp thành năm khối xây dựng cốt lõi, cộng với một lớp bộ nhớ xuyên suốt tất cả chúng — tổng cộng sáu thứ, nhưng lớp bộ nhớ chiếm một vị trí đặc biệt: nó không phải là một thành phần ở cùng cấp độ với những cái khác; nó là xương sống mà mọi thứ khác phụ thuộc vào.
+
+Sơ đồ dưới đây vẽ tất cả sáu thành một vòng để bạn có thể thấy toàn bộ bức tranh trong nháy mắt. Nhưng hãy nhớ: Trạng thái bên ngoài không chỉ là một điểm dừng khác trên vòng lặp — nó là nền tảng mà toàn bộ vòng lặp dựa vào.
+
+```mermaid
+flowchart LR
+ A["Automations<br/>Trình kích hoạt theo lịch"] --> W["Worktrees<br/>Cô lập song song"]
+ W --> S["Skills<br/>Kiến thức dự án được mã hóa"]
+ S --> C["Connectors<br/>Truy cập công cụ bên ngoài"]
+ C --> SA["Sub-agents<br/>Phân chia Maker / Checker"]
+ SA --> ES["Trạng thái bên ngoài<br/>Bộ nhớ xuyên vòng lặp"]
+ ES --> A
+```
+
+### 1. Automations — Nhịp Tim
+
+Nếu không có automation, một vòng lặp không phải là vòng lặp — đó là một lần chạy một lần bạn đã làm thủ công.
+
+Cả Claude Code và Codex đều có hệ thống lập lịch đầy đủ, nhưng chúng sử dụng tên và các lớp khác nhau. Ánh xạ sơ bộ từ nhẹ nhàng nhất đến nặng nhọc nhất:
+
+| Lớp | Claude Code | Codex | Ghi chú |
+|-------|-------------|-------|-------|
+| Polling trong phiên | `/loop` | Thread automation | Gắn với phiên hiện tại, chết khi phiên đóng |
+| Nhiệm vụ theo lịch cục bộ | Desktop scheduled tasks | Standalone automation (local mode) | Chạy khi máy bật, có thể truy cập file cục bộ |
+| Nhiệm vụ theo lịch đám mây | Cloud Routines | — (không có trình lập lịch đám mây gốc) | Chạy khi máy tắt |
+| Trình kích hoạt sự kiện | Routines (API / GitHub Webhook) | Standalone automation + plugins | Được kích hoạt bởi các sự kiện bên ngoài |
+| Tự hoàn toàn tự lưu trữ | GitHub Actions / cron tự lưu trữ | `codex exec` + cron | Kiểm soát đầy đủ |
+
+**Tab Automations của Codex** là điểm vào lập lịch. Chọn dự án, prompt, nhịp độ, và liệu nó chạy trên bản checkout cục bộ của bạn hay một worktree nền. Các lần chạy tìm thấy thứ gì đó sẽ vào hộp thư Triage; các lần chạy không tìm thấy gì sẽ tự động lưu trữ. OpenAI sử dụng chúng nội bộ cho việc phân loại issue hàng ngày, tóm tắt lỗi CI, bản tin commit, và tìm kiếm các lỗi được giới thiệu tuần trước.
+
+Các automation của Codex có hai hương vị:
+- **Thread automation** — Các cuộc gọi thức dậy định kỳ kiểu nhịp tim gắn với một luồng, giữ lại ngữ cảnh. Tốt cho việc theo dõi liên tục trên một thứ duy nhất, như giám sát một lệnh chạy lâu hoặc kiểm tra trạng thái PR. Tương đương trong Claude Code là `/loop`.
+- **Standalone automation** — Mỗi lần chạy bắt đầu mới, kết quả đi đến Triage. Tốt cho các tác vụ độc lập hàng ngày/hàng tuần như bản tin hoặc quét phụ thuộc. Tương đương trong Claude Code là Desktop scheduled tasks.
+
+Hệ thống của Claude Code được phân lớp chi tiết hơn:
+
+- **`/loop`** — Lặp lại theo lịch nhẹ nhàng trong phiên. Hoạt động khi terminal của bạn đang mở, chết khi phiên đóng, tự động hết hạn sau 7 ngày. Tốt cho việc giám sát tạm thời trong phiên làm việc hiện tại của bạn.
+- **Desktop scheduled tasks** — Chạy khi máy của bạn đang bật, sống sót qua các lần khởi động lại phiên, khoảng thời gian cấp phút. Tốt cho các công việc lặp lại cần truy cập file cục bộ.
+- **Cloud Routines** — Chạy trên cơ sở hạ tầng đám mây của Anthropic, sống sót khi máy của bạn tắt, khoảng thời gian tối thiểu 1 giờ. Hỗ trợ ba loại trình kích hoạt: theo lịch, gọi API, GitHub webhook. Tốt cho các tác vụ hàng ngày không cần môi trường cục bộ của bạn.
+- **GitHub Actions / cron tự lưu trữ** — Hoàn toàn dưới sự kiểm soát của bạn, chạy bất cứ cách nào bạn muốn. Tốt cho các kịch bản có yêu cầu môi trường hoặc bảo mật đặc biệt.
+
+```bash
+# Claude Code: chạy test mỗi 30 phút, sửa lỗi (trong phiên hiện tại)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code: kiểm tra trạng thái deploy mỗi 15 phút
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Automations là nhịp tim. Nếu không có chúng, vòng lặp là một bản thiết kế không bao giờ thức dậy.
+
+### 2. Worktrees — Cô lập ở Quy mô lớn
+
+Ngay khi bạn chạy nhiều hơn một agent, các va chạm tệp trở thành chế độ thất bại tất yếu. Hai agent viết vào cùng một tệp chính là cơn đau đầu của hai kỹ sư commit vào cùng một dòng mà không tham khảo ý kiến nhau.
+
+`git worktree` giải quyết vấn đề này: mỗi agent làm việc trên nhánh của riêng mình trong thư mục của riêng mình. Chúng vật lý không thể chạm vào bản checkout của nhau.
+
+Cả Claude Code và Codex đều hỗ trợ worktree. Khi bạn sử dụng `--worktree` hoặc `isolation: worktree` trên một sub-agent, mỗi trợ lý nhận được một bản checkout sạch, độc lập tự dọn dẹp sau khi xong. Worktrees loại bỏ vấn đề va chạm cơ học — nhưng hãy nhớ: **băng thông review của bạn vẫn là trần nhà.** Bạn có thể giám sát bao nhiêu agent song song quyết định bạn thực sự có thể chạy bao nhiêu worktree.
+
+### 3. Skills — Ngừng Giải thích Lại Dự án của Bạn
+
+Một skill là cách bạn ngừng giải thích lại cùng một ngữ cảnh dự án mỗi phiên. Đó là một thư mục chứa một `SKILL.md` với các chỉ dẫn và siêu dữ liệu, cộng với các script, tài liệu tham khảo, và tài sản tùy chọn.
+
+Cả Codex và Claude Code đều hỗ trợ cùng một định dạng. Các skill được gọi trực tiếp bằng `/skill-name` (Codex cũng hỗ trợ `$skill-name`), hoặc được kích hoạt ngầm khi nhiệm vụ khớp với mô tả skill.
+
+Skills về cơ bản là về việc trả nợ ý định của bạn. Một agent bắt đầu mỗi phiên lạnh lùng — nó lấp đầy bất kỳ khoảng trống nào trong ý định của bạn bằng một đoán tự tin. Một skill là ý định đó được viết ra bên ngoài: các quy ước, các bước build, "chúng ta không làm theo cách này vì một sự cố đó" — viết một lần, đọc mỗi lần chạy.
+
+### 4. Connectors — Vòng lặp của Bạn Chạm vào Các Công cụ Thực
+
+Một vòng lặp chỉ có thể xem hệ thống tệp là một vòng lặp nhỏ. Các connector (được xây dựng trên giao thức MCP) cho phép agent đọc trình theo dõi issue của bạn, truy vấn cơ sở dữ liệu, gọi một API staging, gửi tin nhắn trong Slack.
+
+Cả Codex và Claude Code đều nói MCP, vì vậy connector bạn viết cho cái này thường hoạt động ở cái kia. Connectors là sự khác biệt giữa "đây là bản sửa lỗi" và một vòng lặp mở PR, liên kết ticket Linear, và nhắc nhở kênh khi CI xanh — tự nó, bên trong môi trường thực tế của bạn, không chỉ trong terminal.
+
+### 5. Sub-agents — Giữ Maker Khỏi Checker
+
+Lựa chọn thiết kế có giá trị cấu trúc nhất trong một vòng lặp là tách người viết ra khỏi người kiểm tra. Mô hình đã viết code thì quá hào phóng khi chấm điểm bài tập về nhà của chính mình. Một agent thứ hai, với các chỉ dẫn khác nhau và đôi khi là một mô hình khác, sẽ bắt được những gì agent thứ nhất đã tự thuyết phục mình.
+
+Sự phân chia ba vai trò kinh điển:
+
+```mermaid
+flowchart LR
+ Explorer["Agent Khám phá<br/>Đọc codebase, xác định vấn đề"] --> Implementer["Agent Triển khai<br/>Viết sửa lỗi, viết test"]
+ Implementer --> Verifier["Agent Xác minh<br/>Review độc lập, chạy xác minh"]
+ Verifier -->|"Thất bại"| Implementer
+ Verifier -->|"Đạt"| Output["Kết quả"]
+```
+
+`/goal` của Claude Code chạy cái này dưới lớp — một phiên độc lập, mới mẻ phán đoán xem vòng lặp có nên dừng không, không phải phiên đã làm việc. Điều này được gọi là **phân tách generator/evaluator**, và nó là đảm bảo độ tin cậy quan trọng nhất trong thiết kế vòng lặp.
+
+### 6. Trạng thái Bên ngoài — Bộ nhớ của Vòng lặp
+
+Các mô hình quên mọi thứ giữa các lần chạy. Bộ nhớ phải sống trên đĩa, không phải trong cửa sổ ngữ cảnh.
+
+Điều này nghe có vẻ quá đơn giản để quan trọng, nhưng đó là cùng một thủ thuật mà mọi agent chạy lâu đều dựa vào. Một file markdown, một bảng Linear — bất cứ thứ gì sống bên ngoài một cuộc trò chuyện đơn lẻ và giữ những gì đã xong, gì đang tiến hành, và gì tiếp theo. Agent quên. Kho lưu trữ thì không.
+
+Sáu nguyên thủy này là bộ công cụ thiết kế vòng lặp của bạn. Bạn không cần tất cả chúng cho mọi vòng lặp. Nhưng bạn cần biết khi nào nên dùng cái nào.
+
+## Một Vòng lặp Hoàn chỉnh, Được Giải phẫu
+
+Nối tất cả sáu lại với nhau và đây là một vòng lặp phân loại buổi sáng thực tế trông như thế nào:
+
+```mermaid
+flowchart TD
+ Trigger["Mỗi buổi sáng lúc 9:00<br/>Automation kích hoạt"] --> Read["Đọc trạng thái bên ngoài<br/>claude-progress.md của hôm qua<br/>Các issue GitHub đang mở"]
+ Read --> Triage["Kỹ năng Triage kích hoạt<br/>Phân loại và ưu tiên các phát hiện"]
+ Triage --> Fork["Với mỗi mục có thể hành động<br/>Tạo một Worktree cô lập"]
+ Fork --> Implement["Sub-agent Triển khai<br/>Viết sửa lỗi + test"]
+ Implement --> Verify["Sub-agent Xác minh<br/>Độc lập chạy test + lint + review"]
+ Verify -->|"Thất bại"| Retry["Hàng đợi thử lại<br/>Thử cách tiếp cận khác"]
+ Retry --> Implement
+ Verify -->|"Đạt"| PR["Connector: Mở PR<br/>Liên kết issue, cập nhật file tiến độ"]
+ PR --> Memory["Ghi vào Trạng thái Bên ngoài<br/>Cập nhật claude-progress.md<br/>Ghi lại kết quả vòng này"]
+ Memory -->|"Còn việc"| Fork
+ Memory -->|"Tất cả xong hoặc bị chặn"| Inbox["Kết quả đến hộp thư Triage<br/>Chờ bạn review"]
+```
+
+Đây không còn là một lần chạy agent đơn lẻ nữa. Đó là một hệ thống vận hành liên tục thức dậy mỗi buổi sáng, tự quét dọn sàn nhà, và đặt những thứ cần sự chú ý của bạn ra trước mặt bạn. Vai trò của bạn trở thành: **review nội dung hộp thư, đưa ra quyết định, và khi bạn phát hiện một mẫu hệ thống không thể xử lý, tinh chỉnh các kỹ năng và quy tắc.**
+
+Cherny đã sử dụng mẫu này để merge 259 PR trong 30 ngày mà không cần mở IDE một lần nào. Các kỹ sư OpenAI đã sử dụng cùng một mẫu để xây dựng một sản phẩm beta khoảng một triệu dòng mã bằng tay — mà không cần tự viết một dòng mã nào.
+
+## Phân tách Generator/Evaluator: Tại sao Bạn Không thể Để Mô hình Chấm Điểm Công việc của Chính Mình
+
+Đây là bài học khó nhất trong loop engineering.
+
+Agent thông minh nhất của bạn viết một đoạn code đẹp đẽ. Logic rõ ràng, comment kỹ lưỡng, và mọi hàm đều có test. Bạn hài lòng.
+
+Nhưng câu hỏi là: **nếu bạn để agent viết code đó phán đoán xem nó có làm tốt không, nó sẽ nói gì?**
+
+Câu trả lời đã được kinh nghiệm xác nhận lặp đi lặp lại: nó sẽ tự cho mình điểm cao. Không phải vì nó không trung thực, mà vì nó là người tác giả — nó đã tự thuyết phục mình con đường này là đúng trong quá trình tạo ra. Khi nó nhìn lại, nó không thấy sai lầm; nó thấy chính quy trình suy luận của mình.
+
+Đây không phải là vấn đề của Claude. Đây không phải là vấn đề của GPT. Đây là một thuộc tính của tất cả các mô hình sinh tạo. **Một mô hình là luật sư bào chữa tốt nhất cho chính đầu ra của mình.**
+
+Cách sửa: không bao giờ để cùng một thực thể (cùng mô hình, cùng prompt) vừa làm việc vừa review.
+
+- `/goal` của Claude Code sử dụng một phiên giám sát độc lập để phán đoán xem mục tiêu có đạt được không — không phải phiên đã thử làm.
+- Hệ thống sub-agent của Codex cho phép bạn định nghĩa một agent xác minh sử dụng một mô hình khác với nỗ lực suy luận khác nhau.
+- Thực hành cộng đồng "adversarial verify" tạo ra N người hoài nghi độc lập cho mỗi phát hiện, mỗi người được nhắc lệnh để bác bỏ — đa số bác bỏ sẽ loại bỏ phát hiện đó.
+
+Một câu để nhớ: **ai đó trong đội của bạn phải không tin bạn.**
+
+## autoresearch của Karpathy: Mẫu Vòng lặp Điển hình
+
+Nếu bạn muốn xem một vòng lặp được thiết kế tốt, thực sự đang chạy trông như thế nào, [autoresearch của Karpathy](https://github.com/karpathy/autoresearch) là ví dụ sách giáo khoa.
+
+Vào tháng 3 năm 2026, Karpathy phát hành một dự án Python 630 dòng. Đưa cho nó một GPU và một hướng nghiên cứu, và nó chạy cả đêm — hoàn thành hàng trăm thí nghiệm huấn luyện ML, chỉ giữ lại những cái thực sự cải thiện. Dự án đạt 66.000+ sao trong vài ngày sau khi phát hành.
+
+### Ba Tệp, Ba Vai trò
+
+Toàn bộ hệ thống chỉ có ba tệp cốt lõi, nhưng sự phân chia công việc cực kỳ sắc bén:
+
+| Tệp | Ai Sửa nó | Nó làm gì |
+|------|-------------|-------------|
+| `prepare.py` | Không ai (chỉ đọc) | Chuẩn bị dữ liệu, tokenizer, bộ đánh giá. Cơ sở hạ tầng cố định. |
+| `train.py` (~630 dòng) | **AI Agent** | Định nghĩa mô hình, optimizer, vòng lặp huấn luyện. Sân chơi của agent — thay đổi bất cứ gì. |
+| `program.md` | **Bạn** | Phương pháp luận nghiên cứu được viết bằng ngôn ngữ tự nhiên. Bạn chỉ sửa cái này. Nói với agent cách khám phá, cách đánh giá, gì không được động. |
+
+Sự phân chia ba phía này là linh hồn của thiết kế: **con người không chạm vào code, họ chạm vào hướng; agent không chạm vào hướng, họ chạm vào code.** Công việc của bạn chuyển từ viết Python sang "viết văn hóa tổ chức nghiên cứu."
+
+### Đầu vào: program.md Trông Như Thế Nào
+
+`program.md` là bộ não của vòng lặp. Nó không phải code — đó là một hướng dẫn nghiên cứu được viết bằng Markdown. Nó khoảng bao gồm:
+
+- **Mục tiêu**: tối ưu hóa `val_bpb` (validation bits per byte, càng thấp càng tốt)
+- **Các ràng buộc**: đừng động vào `prepare.py`, giữ trong ngân sách VRAM, huấn luyện 5 phút cố định
+- **Các hướng khám phá**: thử các kiến trúc khác nhau, optimizer, lịch trình LR
+- **Các quy tắc đánh giá**: gì được tính là cải thiện, cách ghi kết quả, làm gì khi thất bại
+- **Quy tắc sắt đá**: không bao giờ dừng lại. Một khi vòng lặp bắt đầu, tiếp tục mãi mãi
+
+Prompt khởi đầu của bạn cho agent có thể ngắn như một câu:
+
+```
+Have a look at program.md and let's kick off a new experiment!
+```
+
+Phần còn lại tùy thuộc vào agent đọc tài liệu và tự đưa ra quyết định.
+
+### Vòng lặp Bàn chín Bước
+
+Trái tim của autoresearch là một **bàn đạp** — nó chỉ di chuyển về phía trước, không bao giờ lùi lại. Mỗi lần lặp lại nghiêm ngặt theo chín bước:
+
+```mermaid
+flowchart TD
+ 1["1. Đọc hướng<br/>Tải program.md"] --> 2["2. Khảo sát trạng thái hiện tại<br/>Đọc train.py + kết quả quá khứ"]
+ 2 --> 3["3. Đề xuất giả thuyết<br/>Nghĩ về một thay đổi để thử"]
+ 3 --> 4["4. Sửa code<br/>Chỉnh sửa train.py"]
+ 4 --> 5["5. Chụp nhanh<br/>git commit"]
+ 5 --> 6["6. Chạy huấn luyện<br/>5 phút thời gian thực cố định"]
+ 6 --> 7{"7. Đánh giá<br/>val_bpb có cải thiện không?"}
+ 7 -->|Có| 8a["8a. Giữ lại<br/>Commit giữ lại<br/>Ghi vào results.tsv"]
+ 7 -->|Không| 8b["8b. Hoàn tác<br/>git reset HEAD~1<br/>Ghi lại thất bại"]
+ 8a --> 9["9. Vòng tiếp theo<br/>Quay lại bước 1"]
+ 8b --> 9
+```
+
+Nó chạy khoảng 12 thí nghiệm mỗi giờ. Một lần chạy qua đêm (8 giờ) là khoảng 100 thí nghiệm. Bản thân Karpathy đã chạy nó trong 2 ngày — ~700 thí nghiệm.
+
+Ngân sách thời gian thực 5 phút cố định là một lựa chọn thiết kế quan trọng — bất kể agent thay đổi gì, mọi thí nghiệm đều mất đúng cùng một thời gian. Điều này có nghĩa là tất cả các kết quả đều có thể so sánh trực tiếp dưới cùng một ngân sách thời gian — không có tranh cãi về "cái này chạy lâu hơn nên nó tốt hơn."
+
+### Đầu ra: Bạn Nhìn Thấy Gì Khi Thức Dậy
+
+Sau một đêm lặp lại, bạn ngồi xuống vào buổi sáng và tìm thấy ba thứ:
+
+**1. Lịch sử Git (bàn đạp chỉ tiến về phía trước)**
+
+Chỉ các commit thực sự cải thiện mới được giữ trên nhánh chính. Tất cả những gì thất bại đã được hoàn tác. `git log` là một nhật ký nghiên cứu đã được xác minh.
+
+**2. results.tsv (bản ghi đầy đủ các thí nghiệm)**
+
+Mỗi thí nghiệm — thành công hay thất bại — đều được ghi lại:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. Một nhật ký nghiên cứu (tóm tắt của chính agent)**
+
+Agent viết các thông điệp commit rõ ràng về những gì nó đã thử, gì hiệu quả, gì không, và gì nó dự định thử tiếp theo. Bạn đọc những cái đó — bạn không cần đọc các diff code.
+
+### Nó Thực sự Tìm Thấy Gì
+
+Kết quả từ lần chạy 2 ngày, ~700 thí nghiệm ban đầu của Karpathy:
+
+- Trong khoảng ~700 lần thử, đã tìm thấy khoảng **20 cải thiện thực sự có thể xếp chồng lên nhau**
+- Giảm thời gian huấn luyện cấp GPT-2 của nanochat trên 8×H100 từ **2,02 giờ → 1,80 giờ**, nhanh hơn khoảng **11%**
+- Các phát hiện bao gồm: điều chỉnh learning rate, tinh chỉnh optimizer, hoán đổi hàm kích hoạt, tối ưu hóa mẫu attention, v.v.
+
+Tất cả các cải thiện có phải là những khám phá làm chấn động địa cầu không? Không. Hầu hết là các tối ưu nhỏ xếp chồng lên nhau. Nhưng 20 cải thiện hợp lệ đó sẽ mất một nhà nghiên cứu con người hàng tuần công việc thủ công — agent đã làm nó trong 48 giờ.
+
+### Chi tiết Nói lên Nhiều Nhất: Vòng lặp được Viết Bằng Tiếng Anh, Không Phải Code.
+
+`program.md` là một tài liệu Markdown, không phải một script Python. Nó mô tả một phương pháp luận nghiên cứu — gì nên sửa, gì nên để yên, cách đánh giá, cách xử lý các trường hợp thất bại, và một quy tắc sắt đá: **không bao giờ yêu cầu giúp đỡ con người, cứ tiếp tục đi.** Một agent coding đọc tài liệu này và thực thi nó vô thời hạn.
+
+Đây là khuôn mẫu cho loop engineering: đừng cho agent một nhiệm vụ. Hãy cho nó một **phương pháp luận**. Để phương pháp luận là vòng lặp. Một `program.md`, 630 dòng code kết dính, và mọi thứ còn lại là agent tự chạy chính nó.
+
+## Bốn Chi phí Thầm lặng
+
+Khi một vòng lặp bắt đầu chạy, bạn sẽ không thấy các vấn đề ngay lập tức. Bốn chi phí sau tích lũy một cách thầm lặng, và đến khi bạn nhận thấy, bạn có thể đã trả giá đắt.
+
+### 1. Nợ Xác minh
+
+Các vòng lặp nhanh cám dỗ bạn bỏ qua xác minh. "Trông ổn" không giống như "đã xác nhận đúng." Vòng lặp tạo ra càng nhiều code không được giám sát, nợ xác minh càng chất đống nhanh chóng. Cách sửa: **các điều kiện dừng phải có thể kiểm tra bằng máy, không bao giờ là "cảm thấy khoảng rồi."**
+
+### 2. Sự thối rữa Hiểu biết
+
+Vòng lặp giao code càng nhanh, sự hiểu biết của bạn về chính codebase của bạn càng trôi dạt xa khỏi thực tế. Đội của Cherny có 80% code được viết bởi agent — có nghĩa là hầu hết code của một đội không được viết bởi một con người. Nếu bạn không đọc và sử dụng những gì vòng lặp tạo ra, sự hiểu biết của bạn liên tục suy thoái. **Các vòng lặp nhanh đòi hỏi đọc nhanh.**
+
+### 3. Sự đầu hàng Nhận thức
+
+Khi vòng lặp chạy trơn tru, tư thế thoải mái nhất là ngừng có ý kiến. Nhận bất cứ gì nó trả lại, đừng nghĩ về đầu ra. Nhưng đó chính là nơi nguy hiểm bắt đầu — bạn đang sử dụng vòng lặp để tránh suy nghĩ, thay vì để khuếch đại suy nghĩ. Cảnh báo của Osmani: "Hai người có thể xây dựng chính xác cùng một vòng lặp và nhận được kết quả ngược lại. Người này sử dụng nó để đi nhanh hơn trên công việc họ hiểu; người kia sử dụng nó để tránh hiểu công việc. Vòng lặp không biết sự khác biệt. Bạn biết."
+
+### 4. Bùng nổ Token
+
+Mỗi lần lặp của một vòng lặp tích lũy thêm ngữ cảnh: code đã viết, lỗi đã gặp, quyết định đã đưa ra. Nếu không có quản lý ngữ cảnh, kích thước prompt tăng khoảng bậc hai theo số lượt. Codex giải quyết vấn đề này với nén ngữ cảnh tự động — một API chuyên dụng nén các lượt cuộc trò chuyện cũ thành các tóm tắt nội dung được mã hóa, giữ lại kiến thức thiết yếu trong khi loại bỏ chi tiết dư thừa. Đây là một mối quan tâm kỹ thuật bạn phải giải quyết từ vòng lặp đầu tiên, không phải thêm vào sau này.
+
+## Xây dựng Vòng lặp Đầu tiên của Bạn
+
+Bạn không cần bắt đầu với một đường ống quy mô Stripe merge 1.300 PR một tuần. Bắt đầu với thứ nhỏ nhất hoạt động được.
+
+### Bước 1: Chọn Một Nhiệm vụ Lặp lại
+
+Tìm thứ gì đó bạn làm thủ công ít nhất hai lần một tuần. Ví dụ:
+- Mở GitHub vào buổi sáng, kiểm tra các issue mới, phân loại và phản hồi
+- Chạy lint và test trước mỗi lần review PR
+- Cập nhật tài liệu tiến độ vào cuối mỗi ngày
+
+### Bước 2: Viết Mục tiêu và Điều kiện Dừng
+
+Biến nhiệm vụ thành thứ mà một `/goal` có thể hiểu:
+
+```markdown
+Mục tiêu: Kiểm tra 10 issue gần đây nhất trong repo.
+Với mỗi issue:
+ - Nếu nó đã có nhãn rõ ràng và người phụ trách, bỏ qua
+ - Nếu chưa được gắn thẻ, thêm các nhãn phù hợp dựa trên nội dung
+ - Nếu có thể sửa trong dưới 10 phút, tạo nhánh và thử sửa
+Dừng khi: Tất cả các issue đủ điều kiện đã được xử lý, hoặc một issue yêu cầu quyết định của con người.
+```
+
+### Bước 3: Phân chia Maker và Checker
+
+Đừng để cùng một agent vừa viết code vừa phán đoán nó. Chia vòng lặp của bạn thành hai vai trò:
+- Người triển khai (Implementer): đọc issue, viết sửa lỗi, viết test
+- Người xác minh (Verifier): độc lập chạy test, review diff, phán đoán xem sửa lỗi có thực sự giải quyết vấn đề không
+
+### Bước 4: Thêm Bộ nhớ
+
+Sử dụng một file markdown để ghi lại những gì đã xảy ra trong mỗi lần chạy vòng lặp. Lần chạy tiếp theo bắt đầu bằng cách đọc file này — nó biết gì đã làm, gì đang chờ xử lý, gì bị chặn. Điều này tốt hơn bất kỳ cơ sở dữ liệu phức tạp nào.
+
+### Bước 5: Đặt Bộ hẹn giờ
+
+Sử dụng `/loop` hoặc cron của hệ điều hành để vòng lặp bắt đầu mà không cần bạn. Bắt đầu với một lần một ngày. Quan sát trong một tuần.
+
+### Thang Độ Trưởng thành
+
+Bạn không cần đạt đến đỉnh trong một cú nhảy. Việc áp dụng vòng lặp là một cái thang:
+
+1. **Cấp độ 1: Người chạy Mục tiêu** — Bạn có thể sử dụng `/goal` để đưa ra một nhiệm vụ với điều kiện dừng; agent lặp lại cho đến khi đạt được.
+2. **Cấp độ 2: Nhiệm vụ Đơn theo Lịch** — Một automation chạy một nhiệm vụ theo bộ hẹn giờ (ví dụ: kiểm tra CI buổi sáng).
+3. **Cấp độ 3: Vòng lặp Đa agent** — Phân chia maker và checker; mỗi phát hiện tạo ra một worktree cô lập.
+4. **Cấp độ 4: Vòng lặp Tự nuôi** — Vòng lặp tự khám phá nhiệm vụ tiếp theo từ trạng thái bên ngoài; nó tự quyết định phải làm gì tiếp theo.
+5. **Cấp độ 5: Điều phối Hạm đội** — Nhiều vòng lặp chạy song song, độc lập nhưng chia sẻ một lớp bộ nhớ.
+
+Hầu hết các đội hiện đang ở giữa Cấp độ 2 và Cấp độ 3. Cấp độ 1 là con đường nhanh nhất để thấy lợi nhuận.
+
+## Những Điểm Chính
+
+- **Loop Engineering không thay thế Harness Engineering — nó xây dựng một tầng lên trên đó.** Harness làm cho các lần chạy đơn lẻ đáng tin cậy. Vòng lặp làm cho các lần chạy liên tục tự chủ.
+- **`/goal` là vòng lặp đơn giản nhất:** mục tiêu + xác minh + điều kiện dừng. Ba thứ đó dịch chuyển bạn từ bên trong vòng lặp ra bên ngoài nó.
+- **Sáu nguyên thủy (Automations / Worktrees / Skills / Connectors / Sub-agents / Trạng thái Bên ngoài) là các khối xây dựng của vòng lặp.** Không phải tất cả mọi lúc, nhưng bạn cần biết khi nào nên dùng cái nào.
+- **Maker và checker phải được tách riêng.** Một mô hình chấm điểm công việc của chính mình là không đáng tin cậy. Một trình xác minh độc lập — đôi khi là một mô hình hoàn toàn khác — là đảm bảo độ tin cậy cơ bản của bất kỳ vòng lặp nào.
+- **Các vòng lặp làm cho việc tạo ra gần như miễn phí và để lại phán đoán như là nguồn lực khan hiếm.** Thời gian bạn tiết kiệm không phải để nghỉ ngơi. Đó là để đưa ra nhiều phán đoán hơn.
+- **Bốn chi phí thầm lặng trở nên gay gắt hơn khi vòng lặp chạy càng lâu:** nợ xác minh, sự thối rữa hiểu biết, sự đầu hàng nhận thức, bùng nổ token. Các vòng lặp tăng tốc đầu ra — và rủi ro.
+- **Bắt đầu nhỏ.** Một `/goal`, một cron, một file bộ nhớ markdown. Nhận thấy lợi nhuận, sau đó xếp chồng lên nhau.
+
+## Đọc Thêm
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — Bộ sưu tập công cộng 50 vòng lặp thực tế
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- Bài 12: [Bàn giao sạch ở cuối mỗi phiên](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — Điều kiện tiên quyết cho các vòng lặp: mỗi phiên để lại trạng thái sạch để vòng tiếp theo có thể tự động bắt đầu
+- Bài 5: [Giữ các nhiệm vụ chạy lâu liên tục giữa các phiên](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — Kiến thức tiên quyết về trạng thái bên ngoài và bộ nhớ
+- Bài 11: [Tại sao tính quan sát được thuộc về bên trong Harness](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — Vòng lặp chạy càng nhanh, bạn càng cần tính quan sát được để bắt vấn đề
+- Bài 8: [Tại sao danh sách tính năng là các nguyên thủy của Harness](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — Danh sách tính năng là nguồn dữ liệu tự nhiên cho một vòng lặp tự nuôi để khám phá nhiệm vụ tiếp theo
+
+## Bài tập
+
+1. **Biến một nhiệm vụ lặp lại thành một `/goal`:** Tìm thứ gì đó bạn làm thủ công ít nhất hai lần một tuần. Viết xuống mục tiêu, phương pháp xác minh, và điều kiện dừng của nó. Chạy nó một lần với `/goal` và so sánh thời gian và chất lượng so với làm thủ công. Đây là bước đầu tiên của bạn từ Harness sang Loop.
+
+2. **Phân chia maker và checker:** Chọn một nhiệm vụ bạn trước đây đã cho agent thực hiện. Lần này, viết hai prompt khác nhau: một cho agent triển khai và một cho agent xác minh (sử dụng các mô hình khác nhau — ví dụ: Claude để triển khai, GPT để xác minh, hoặc ngược lại). Người xác minh phải chỉ ra các vấn đề cụ thể với bằng chứng được trích dẫn. Ghi lại số lượng và loại vấn đề được tìm thấy trong mỗi chế độ.
+
+3. **Cho vòng lặp của bạn một bộ nhớ:** Tạo một file trạng thái markdown cho vòng lặp của bạn. Trong mỗi lần lặp, viết: gì đã làm trong vòng này, kết quả xác minh, trạng thái (đạt/thất bại/bị chặn), và gì phải làm tiếp theo. Chạy ba vòng và quan sát sự khác biệt về hành vi giữa có và không có file bộ nhớ.
+
+4. **Kiểm toán các chi phí thầm lặng của vòng lặp của bạn:** Sau khi vòng lặp của bạn đã chạy trong một giờ, đánh giá bốn chỉ số này:
+ - Bao nhiêu phần xác minh là "cảm thấy đúng" thay vì "được máy xác nhận"? (Nợ xác minh)
+ - Bạn có thể giải thích code mà vòng lặp của bạn gần đây nhất tạo ra tốt đến đâu? (Sự thối rữa hiểu biết)
+ - Bạn đã nghĩ "sau này xem lại" và không bao giờ xem lại bao nhiêu lần? (Sự đầu hàng nhận thức)
+ - Kích thước ngữ cảnh của vòng lặp đang có xu hướng như thế nào? Nó có lặp lại thông tin dư thừa không? (Bùng nổ token)
diff --git a/docs/vi/projects/project-07-loop-engineering-first-loop/index.md b/docs/vi/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..34731ba
--- /dev/null
+++ b/docs/vi/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Dự án 07. Xây dựng Vòng lặp Tự động Đầu tiên
+
+> Bài giảng liên quan: [Bài 13. Tại sao bạn cần ngừng nhắc lệnh Agent của mình](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## Bạn Sẽ Làm Gì
+
+Đây là dự án chuyển tiếp từ "Harness" sang "Loop." Bạn đã biết cách thiết lập một agent với môi trường, chỉ dẫn, và phản hồi phù hợp — bây giờ bạn sẽ biến thiết lập đó thành một vòng lặp tự chạy.
+
+Bạn sẽ thực hiện ba thí nghiệm tiến triển: đầu tiên biến một nhiệm vụ từ thủ công thành `/goal`, sau đó biến một nhiệm vụ giám sát thành bộ hẹn giờ `/loop`, và cuối cùng xây dựng một vòng lặp maker-checker đầy đủ để trải nghiệm cảm giác khi **bạn bước ra khỏi vòng lặp.**
+
+## Các Tệp Dự án
+
+Đường dẫn repo: [`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| Thư mục | Nội dung | Bạn Làm Gì |
+|-----------|--------------|-------------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | Một dự án cơ sở kiến thức nhỏ với một bộ harness hoàn chỉnh (trạng thái cuối của P06), bao gồm AGENTS.md, feature_list.json, init.sh, session-handoff.md, clean-state-checklist.md. | Biến bộ harness này thành bộ có thể lặp tự động. |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | Triển khai đầy đủ của ba vòng lặp: goal loop, timer loop, maker-checker loop, cộng với các file trạng thái vòng lặp và các script xác minh. | Tham khảo cho các mẫu thiết kế vòng lặp và quản lý trạng thái. |
+
+## Công cụ Bạn Sẽ Dùng
+
+- Claude Code hoặc Codex
+- Git
+- Bộ harness hoàn chỉnh của bạn từ P06
+- Một trình đa hợp terminal (tmux hoặc screen, để quan sát các vòng lặp chạy lâu)
+- Tùy chọn: GitHub Actions hoặc cron (cho các thí nghiệm điều khiển theo sự kiện / theo lịch nâng cao)
+
+## Các Bước
+
+### Chuẩn bị
+
+1. Bắt đầu từ cùng commit nơi bạn đã hoàn thành P06.
+2. Tạo ba nhánh: `p07-goal-loop`, `p07-timer-loop`, `p07-maker-checker`.
+3. Xác minh harness của bạn hoạt động: chạy init.sh, xác minh file trạng thái, danh sách tính năng, và các tài liệu bàn giao đều đã sẵn sàng.
+4. Chọn một **nhiệm vụ mục tiêu** bạn muốn vòng lặp làm việc lặp đi lặp lại. Chọn thứ gì đó cỡ trung bình với các tiêu chí hoàn thành rõ ràng — ví dụ: "thêm unit test cho tất cả các module, đạt 80% độ phủ" hoặc "thêm xác minh đầu vào cho tất cả các endpoint API."
+
+### Thí nghiệm 1: Vòng lặp Mục tiêu — Từ Chạy Thủ công sang Chạy Tự động
+
+Chuyển sang nhánh `p07-goal-loop`.
+
+1. **Viết mô tả mục tiêu**: Biến nhiệm vụ bạn đã chọn thành một file `goal.md` chứa:
+ - Mục tiêu rõ ràng ("gì được tính là xong")
+ - Phương pháp xác minh ("làm sao để xác nhận nó xong" — chạy test? chạy lint? kiểm tra độ phủ?)
+ - Điều kiện dừng ("khi nào nó nên dừng" — lượt tối đa? giới hạn thời gian? giới hạn ngân sách?)
+ - Các ràng buộc ("gì không được động" — cấu hình sản xuất, schema cơ sở dữ liệu, v.v.)
+
+2. **Lần chạy thủ công đầu tiên**: Đưa nhiệm vụ cho agent thủ công, bằng chính bạn. Ghi lại nó đã mất bao nhiêu lượt, bạn đã can thiệp bao nhiêu lần, và chất lượng kết quả. Đây là đường cơ sở của bạn.
+
+3. **Chạy với `/goal`**: Sử dụng cùng `goal.md` làm đầu vào và chạy nó ở chế độ `/goal`. Agent tự lặp lại cho đến khi đạt được mục tiêu hoặc điều kiện dừng kích hoạt.
+
+4. **So sánh kết quả**:
+ - Sự khác biệt về số lượt
+ - Sự khác biệt về số lần can thiệp của bạn
+ - Sự khác biệt về chất lượng kết quả (sử dụng cùng tiêu chuẩn xác minh)
+ - Sự khác biệt về thời gian bạn đã dành
+
+5. **Lặp lại trên goal.md**: Nếu kết quả kém, sửa lại mô tả mục tiêu và chạy lại. Tiếp tục cho đến khi bạn hài lòng với kết quả, hoặc cho đến khi bạn đã xác nhận giới hạn của những gì một vòng lặp mục tiêu có thể làm trên nhiệm vụ này.
+
+### Thí nghiệm 2: Vòng lặp Bộ hẹn giờ — Biến Giám sát thành Nhịp Tim
+
+Chuyển sang nhánh `p07-timer-loop`.
+
+1. **Chọn một nhiệm vụ giám sát**: Tìm một kiểm tra lặp lại bạn thường làm thủ công. Ví dụ:
+ - Chạy bộ test mỗi giờ, sửa lỗi
+ - Kiểm tra các bản cập nhật bảo mật phụ thuộc mỗi buổi sáng
+ - Kiểm tra các vi phạm phong cách code sau mỗi commit
+ - Định kỳ quét các comment TODO để xem cái nào đã cũ
+
+2. **Viết prompt/script giám sát**: Trình bày rõ ràng các bước giám sát — kiểm tra gì, làm gì khi tìm thấy vấn đề, và khi nào gọi con người.
+
+3. **Chạy với `/loop` (hoặc Codex Thread automation)**:
+ - Đặt một khoảng thời gian hợp lý (khuyến nghị 10-30 phút — quá ngắn bạn sẽ bị phiền, quá dài bạn sẽ không thấy hiệu ứng)
+ - Để nó chạy ít nhất 2 giờ (hoặc đi làm gì đó khác và quay lại sau)
+
+4. **Ghi lại kết quả**:
+ - Nó đã tìm thấy bao nhiêu vấn đề?
+ - Nó đã tự sửa được bao nhiêu?
+ - Bao nhiêu là dương tính giả?
+ - Bao nhiêu cái nó làm tồi tệ hơn?
+ - Bạn đã dành bao nhiêu thời gian theo dõi kết quả của nó?
+
+5. **Suy ngẫm**: Nhiệm vụ giám sát này có đáng tự động hóa không? So sánh thời gian bạn tiết kiệm so với thời gian bạn dành để theo dõi. Nếu không đáng, bạn đã chọn sai nhiệm vụ, hay vòng lặp được thiết kế kém?
+
+### Thí nghiệm 3: Vòng lặp Maker-Checker — Đưa Bản thân Ra Khỏi Vòng lặp
+
+Chuyển sang nhánh `p07-maker-checker`.
+
+Đây là thí nghiệm quan trọng nhất trong ba thí nghiệm. Bạn sẽ xây dựng một **vòng lặp hoàn chỉnh không cần bạn ở đó:**
+
+1. **Thiết kế cấu trúc vòng lặp**:
+ - **Agent Maker**: triển khai, viết code, sửa đổi tệp
+ - **Agent Checker**: xác minh, chạy test, thực hiện review code, đạt / thất bại
+ - **File trạng thái** (`loop-state.md`): ghi lại vòng hiện tại, gì đã làm, kết quả xác minh, gì tiếp theo
+ - **Điều kiện dừng**: N lần đạt liên tiếp, hoặc đạt số vòng tối đa
+
+2. **Viết ba prompt**:
+ - Hướng dẫn của Maker (phải làm gì, làm sao để làm, gì không được động)
+ - Hướng dẫn của Checker (phải xác minh gì, làm sao để xác minh, gì được tính là đạt, làm sao để đưa ra phản hồi)
+ - Logic điều khiển vòng lặp (ai đi trước, bàn giao hoạt động như thế nào, làm sao để bắt đầu vòng tiếp theo)
+
+3. **Chạy ít nhất 5 vòng**:
+ - Vòng 1: Maker triển khai → Checker xác minh → Thất bại → Phản hồi cho Maker
+ - Vòng 2: Maker sửa đổi dựa trên phản hồi → Checker xác minh → ...
+ - ...
+ - Cho đến khi đạt liên tiếp, hoặc bạn dừng lại
+
+4. **Ghi lại trạng thái của mỗi vòng**:
+ - Số thứ tự vòng
+ - Maker đã làm gì
+ - Checker đã tìm thấy những vấn đề gì
+ - Đạt / thất bại
+ - Bạn có can thiệp không? (nếu có, tại sao?)
+
+5. **Tổng kết cuối cùng**:
+ - Bạn đã can thiệp bao nhiêu lần? Tại sao?
+ - Điều gì sẽ xảy ra nếu bạn không can thiệp?
+ - Checker có bỏ lỡ bất kỳ vấn đề nào không?
+ - Maker có tiếp tục mắc cùng một lỗi không?
+ - Trần chất lượng của vòng lặp này ở đâu? Năng lực của Maker, hay năng lực của Checker?
+
+## Cách Đo lường Kết quả
+
+| Chỉ số | Thí nghiệm 1 (Mục tiêu) | Thí nghiệm 2 (Bộ hẹn giờ) | Thí nghiệm 3 (Maker-Checker) |
+|--------|-------------|--------------|----------------------|
+| Tỷ lệ hoàn thành nhiệm vụ | Mục tiêu có đạt được không? | Bao nhiêu chu kỳ giám sát đã chạy? | Bao nhiêu vòng cho đến khi đạt? |
+| Sự can thiệp của con người | Bạn đã can thiệp bao nhiêu lần? | Bạn đã dành bao nhiêu thời gian theo dõi? | Bạn đã can thiệp bao nhiêu lần? |
+| Chất lượng kết quả | Nó so với thủ công như thế nào? | Tỷ lệ dương tính giả? Bỏ lỡ vấn đề? | Checker đã tìm thấy bao nhiêu vấn đề mà bạn sẽ không tìm thấy? |
+| Thời gian tiết kiệm | Bạn đã tiết kiệm được bao nhiêu thời gian? | Có đáng để tự động hóa không? | Thời gian dành để thiết kế vòng lặp so với thời gian tiết kiệm |
+| Độ tin cậy | Điều kiện dừng có đáng tin không? | Nó có chạy失控 không? | Vòng lặp có thể bị kẹt ở cùng một chỗ không? |
+
+## Nộp Gì
+
+- `goal.md` (mô tả mục tiêu của Thí nghiệm 1, ít nhất hai lần lặp)
+- Ghi chú so sánh Thí nghiệm 1: thủ công so với vòng lặp mục tiêu
+- Prompt giám sát Thí nghiệm 2 + nhật ký chạy 2 giờ
+- Ba prompt của Thí nghiệm 3 (Maker / Checker / Điều khiển vòng lặp)
+- `loop-state.md` của Thí nghiệm 3 (ít nhất 5 vòng được ghi lại)
+- Tổng kết cuối cùng: những bài học rút ra từ cả ba thí nghiệm, sự hiểu biết của bạn về loop engineering đã thay đổi như thế nào, những thứ gì là ứng viên tốt để vòng lặp hóa và những thứ gì không
+
+## Các Bài giảng Liên quan
+
+- [Bài 13 — Tại sao bạn cần ngừng nhắc lệnh Agent của mình](../../lectures/lecture-13-loop-engineering/index.md)
+- [Bài 12 — Tại sao mỗi phiên phải để lại trạng thái sạch](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md) (mỗi vòng của một vòng lặp cần trạng thái sạch)
+- [Bài 11 — Tại sao tính quan sát được thuộc về bên trong Harness](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md) (bạn cần thấy những gì đang xảy ra bên trong vòng lặp)
+- [Bài 05 — Tại sao các file trạng thái là xương sống của tính liên tục](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md) (các file trạng thái vòng lặp là một phần mở rộng của các file trạng thái)
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/code/checker-prompt.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/checker-prompt.md
new file mode 100644
index 0000000..dd36609
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/checker-prompt.md
@@ -0,0 +1,80 @@
+# Checker Agent Prompt(检查者)
+
+> 给验证 agent 用的 prompt。
+> 专注于"挑毛病",越严格越好。
+
+## 你的角色
+
+你是 Checker,负责验证 Maker 的产出。你的目标是找到问题,不是说好听的。
+
+拿到 Maker 会给你一份实现,你的工作是:
+
+1. 通读所有改动
+2. 按检查清单逐项验证
+3. 跑完整的验证命令
+4. 逐条列出所有发现的问题,每条都要有证据
+
+**记住:你不是来点赞的,是来挑毛病的。** 找不到问题是你的失职。
+
+## 检查清单
+
+### 功能正确性
+- [ ] 实现是否符合需求描述?
+- [ ] 有没有漏掉什么边界情况?
+- [ ] 错误处理到位了吗?
+
+### 代码质量
+- [ ] 代码清晰吗?命名清楚吗?
+- [ ] 有没有重复代码?
+- [ ] 符合项目编码规范吗?
+- [ ] 有没有明显的性能问题?
+
+### 测试
+- [ ] 测试覆盖了主要场景吗?
+- [ ] 有没有 edge case 没有测到?
+- [ ] 测试真的在测对东西,而不是走过场?
+
+### 验证命令
+- [ ] `npm test` 全部通过了吗?
+- [ ] `npm run lint` 无错误?
+- [ ] TypeScript 类型检查通过?
+- [ ] 覆盖率达标?
+
+### 安全和影响
+- [ ] 改动会不会影响其他地方?
+- [ ] 有没有引入新的依赖?合理吗?
+- [ ] 配置文件改得对吗?
+
+## 输出要求
+
+每条问题都必须包含:
+1. **问题描述**
+2. **在哪**(文件和行号
+3. **证据**(具体错在哪里、为什么是问题
+4. **严重程度**(严重 / 中等 / 轻微
+
+最后给一个总体结论:通过 / 不通过 / 有小问题可过
+
+输出格式:
+
+```
+## 总体结论
+✅ 通过 / ❌ 不通过 / ⚠️ 小问题可过
+
+## 发现的问题
+
+### 1. [严重] 问题标题
+- 位置:文件:行号
+- 描述:...
+- 证据:...
+- 建议:...
+
+### 2. [中等] 问题标题
+...
+
+## 验证命令结果
+- 单元测试:通过 X / Y
+- lint:通过 / 失败(X 个错误)
+- 类型检查:通过 / 失败
+- 覆盖率:XX%
+```
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/code/goal-template.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/goal-template.md
new file mode 100644
index 0000000..6bf1430
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/goal-template.md
@@ -0,0 +1,65 @@
+# Goal Loop 目标描述模板
+
+> 把你的目标写成这样一份文档,交给 `/goal` 或 maker agent 用。
+> 越具体、越可验证,loop 的质量越高。
+
+## 目标
+
+<!-- 一句话说清楚要做什么 -->
+
+完成 XX 功能,包含完整的单元测试覆盖。
+
+## 验收标准
+
+<!-- 机器可验证的完成条件,每条都能跑命令或检查 -->
+
+- [ ] `npm test` 全部通过
+- [ ] 覆盖率报告显示 XX 模块覆盖率 ≥ 80%
+- [ ] `npm run lint` 无错误
+- [ ] TypeScript 类型检查通过(`npx tsc --noEmit`)
+- [ ] 所有新增代码符合项目编码规范
+
+## 范围
+
+<!-- 明确说清楚不能碰什么 -->
+
+### 可以改的
+
+- `src/xx/` 目录下的所有文件
+- `tests/` 目录下的测试文件
+- 相关的类型定义文件
+
+### 不能改的
+
+- `src/main.ts` 入口文件
+- 数据库 schema 迁移文件
+- `package.json` 里的依赖版本(除非明确需要新增)
+- CI/CD 配置文件
+
+## 验证方式
+
+<!-- 每做一步怎么验证 -->
+
+1. 实现完成后,按顺序跑以下命令:
+ 1. `npx tsc --noEmit` — 类型检查
+ 2. `npm run lint` — 代码规范
+ 3. `npm test` — 单元测试
+ 4. `npx vitest --coverage` — 覆盖率检查
+
+2. 任何一步失败都先修,修完再跑下一个。
+3. 全部通过后,运行一次完整的端到端测试(如果有)。
+
+## 停止条件
+
+- 所有验收标准全部通过 ✅
+- 达到最大回合数:20 轮
+- 连续 3 轮没有进展(同样的错误反复出现)
+- 遇到无法自行解决的阻塞问题(比如需要的依赖不存在、环境问题)
+
+## 工作方式
+
+1. 先读 `AGENTS.md` 和 `feature_list.json`,理解项目结构和现有功能。
+2. 先写设计思路,再动手改代码。
+3. 每完成一个子任务就验证一次。
+4. 遇到卡住超过 2 轮,换个思路或简化方案。
+5. 每一轮结束后更新进度。
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/code/index.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/index.md
new file mode 100644
index 0000000..a4f61b8
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/index.md
@@ -0,0 +1,8 @@
+# 第 13 讲代码
+
+使用此文件夹存放以下方面的示例:
+
+- goal.md 目标描述模板
+- loop-state.md 循环状态模板
+- Maker / Checker 角色 prompt 模板
+- 循环控制脚本示例
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/code/loop-state-template.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/loop-state-template.md
new file mode 100644
index 0000000..9b6714c
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/loop-state-template.md
@@ -0,0 +1,69 @@
+# Loop State 循环状态模板
+
+> 每个 loop 都应该有一个状态文件,记录当前进度。
+> 每一轮结束时更新,下一轮开始时读取。
+
+## 基本信息
+
+- **循环名称**:<!-- 比如 "单元测试补全循环" -->
+- **启动时间**:2026-07-09 10:00
+- **当前轮次**:第 1 轮 / 共 N 轮
+- **当前状态**:进行中 <!-- 进行中 / 已完成 / 已阻塞 / 已失败 -->
+- **总耗时**:0 小时 0 分钟
+
+## 目标
+
+<!-- 这个 loop 要达成什么 -->
+
+## 轮次记录
+
+### 第 1 轮
+
+- **开始时间**:
+- **Maker 做了什么**:
+- **验证结果**:✅ 通过 / ❌ 失败 / ⚠️ 部分通过
+- **发现的问题**:
+ -
+- **下一轮要做什么**:
+- **是否需要人类介入**:是 / 否
+
+### 第 2 轮
+
+- **开始时间**:
+- **Maker 做了什么**:
+- **验证结果**:✅ 通过 / ❌ 失败 / ⚠️ 部分通过
+- **发现的问题**:
+ -
+- **下一轮要做什么**:
+- **是否需要人类介入**:是 / 否
+
+<!-- 复制上面的格式继续加 -->
+
+## 累积统计
+
+| 指标 | 数值 |
+|------|------|
+| 已完成轮次 | 0 |
+| 通过轮次 | 0 |
+| 失败轮次 | 0 |
+| 发现的总问题数 | 0 |
+| 人类介入次数 | 0 |
+| 代码改动文件数 | 0 |
+
+## 阻塞问题列表
+
+<!-- 把反复出现的问题记在这里,避免下一轮注意 -->
+
+-
+
+## 最终结果
+
+<!-- loop 结束后填写 -->
+
+- **最终状态**:完成 / 失败 / 人工终止
+- **完成时间**:
+- **总结**:
+ - 做了什么
+ - 结果如何
+ - 学到了什么
+ - 下次怎么改进
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/code/maker-prompt.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/maker-prompt.md
new file mode 100644
index 0000000..9c65eac
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/code/maker-prompt.md
@@ -0,0 +1,49 @@
+# Maker Agent Prompt(制作者)
+
+> 给实现 agent 用的 prompt。
+> 专注于"做出来"。
+
+## 你的角色
+
+你是 Maker,负责实现功能、写代码。
+
+你拿到一个任务,你的工作是:
+
+1. 理解需求
+2. 设计实现方案
+3. 写出代码
+4. 跑基础验证(编译、lint、单测)
+5. 把结果交给 Checker 审核
+
+## 工作规则
+
+- 先读 AGENTS.md 和相关文档,理解项目结构。
+- 改代码前先说清楚打算怎么改。
+- 写完自己先跑一遍基础验证,确保至少能跑通。
+- 不知道的东西老实说不知道,不要瞎编。
+- 每一步都有进展就记下来。
+
+## 交付物
+
+- 修改的文件列表
+- 实现思路简述
+- 基础验证结果(编译 / lint / 测试)
+- 你自己觉得可能有问题的地方(供 Checker 重点看)
+
+## 输出格式
+
+```
+## 实现概要
+...
+
+## 修改的文件
+- ...
+
+## 基础验证
+- 编译:通过 / 失败
+- lint:通过 / 失败
+- 单元测试:通过 X / 个,失败 Y 个
+
+## 已知问题和风险
+- ...
+```
diff --git a/docs/zh-TW/lectures/lecture-13-loop-engineering/index.md b/docs/zh-TW/lectures/lecture-13-loop-engineering/index.md
new file mode 100644
index 0000000..c60c2e0
--- /dev/null
+++ b/docs/zh-TW/lectures/lecture-13-loop-engineering/index.md
@@ -0,0 +1,498 @@
+[English Version →](../../../en/lectures/lecture-13-loop-engineering/)
+
+> 本篇程式碼範例:[code/](https://github.com/walkinglabs/learn-harness-engineering/blob/main/docs/zh/lectures/lecture-13-loop-engineering/code/)
+> 實戰練習:[Project 07. 搭建你的第一個自動循環](./../../projects/project-07-loop-engineering-first-loop/index.md)
+
+# 第十三講. 從手動驅動到自動循環
+
+前十二講,你做的事情始終有一個共同前提:**你坐在鍵盤前,一次一次地輸入指令。**
+
+你寫好了 `AGENTS.md`(第一到四講),建立了狀態管理(第五、六講),用功能清單約束範圍(第七、八講),讓 agent 在結束時留下乾淨交接(第九、十二講),讓運行過程可觀測(第十、十一講)——但所有這些工作的觸發者,始終是你。agent 不會自己決定什麼時候該幹活,因為沒有人按下「開始」按鈕。
+
+這一講要討論的,就是怎麼把「按按鈕」這件事也交給系統。不是放棄控制,而是把控制升到更高一層。
+
+## /goal:最簡形態的 loop
+
+理解 loop engineering,最好的入口不是一套複雜的架構圖,而是一個具體的指令。
+
+2026 年初,Claude Code 和 OpenAI Codex 不約而同地加入了同一個功能:`/goal`。你在終端裡敲:
+
+```
+/goal "所有測試通過,lint 零告警,合併到 main"
+```
+
+然後合上筆記本去睡覺。八小時後醒來,agent 已經自己完成了分析、編碼、測試、修復、合併的全過程。它失敗了就重試,方向錯了就換策略,通過了就結束——不需要你坐在旁邊說「再試一次試試」。
+
+`/goal` 和傳統 prompt 的區別只有一點,但這一點改變了一切:
+
+| | 傳統 prompt | `/goal` |
+|---|---|---|
+| 你給什麼 | 下一步具體做什麼 | 最終狀態是什麼 |
+| agent 做什麼 | 執行一次 | 循環直達成 |
+| 誰判斷做完了 | 你 | 一條可驗證的停止條件 |
+| 你什麼時候可以走 | 不能走 | 給完 `/goal` 就行 |
+
+`/goal` 本質上就是一個 loop。它的結構只有三樣東西:**一個目標,一種驗證方式,一條停止條件。** 但就是這三樣東西,讓你的位置從循環**裡面**移到了循環**外面**。
+
+### `/goal` 是怎麼長出來的
+
+`/goal` 不是某天突然從 0 跳到 1 的。它是從日常工作流裡一點一點長出來的,大致經歷了四個階段:
+
+**階段一:手動一條一條輸。** 最早的用法就是你一句我一句,「寫個函數」、「加個測試」、「改一下這個邏輯」。agent 每執行一步就停下來等你說下一步。你是整個流程的排程器。
+
+**階段二:長 prompt + 多步驟。** 後來大家開始寫更長的 prompt,把多個步驟寫在一起:「先分析程式碼,再寫實作,再跑測試,測試沒過就修。」agent 可以一口氣跑好幾步了,但你還是得盯著——因為它可能在某一步跑偏,或者跑完了不知道下一步該幹嘛。
+
+**階段三:agent 自己判斷要不要繼續。** 再往後,agent 有了「自省」能力——跑完一步自己看結果,決定下一步怎麼走。你給一個目標,它自己拆步驟、自己重試。但問題來了:它什麼時候停?它自己說「我做完了」算不算數?實踐反覆證明——不算數。agent 太容易宣告勝利了。
+
+**階段四:獨立的停止判斷——`/goal`。** 最後一步是把「判斷做完了沒有」這件事,從幹活的 agent 手裡拿出來,交給一個獨立的判斷者。可能是另一個模型、可能是一段腳本、可能是一條測試指令,但總之——不能讓寫程式碼的人自己批作業。到這一步,`/goal` 才真正成立:你給目標,它循環跑,獨立判斷停不停,你可以走人。
+
+這四個階段不是某家公司規劃好的路線圖,是全世界用 agent 寫程式碼的人,在各自的日常裡,被同一個痛點推著,一步一步走到了同一個地方。Claude Code 和 Codex 在 2026 年初幾乎同時上線 `/goal`,不是巧合——是時候到了。
+
+### Loop 不只有一種
+
+`/goal` 是最容易理解的 loop,但它不是唯一的一種。按觸發方式和停止方式的不同,loop 可以分成幾類:
+
+| 類型 | 觸發方式 | 停止方式 | Claude Code | Codex | 適用場景 |
+|------|---------|---------|------------|-------|---------|
+| **回合制 loop** | 你手動輸入每一條 prompt | agent 認為做完了,或者你打斷 | 普通對話 | 普通對話 | 小任務、探索性工作 |
+| **目標驅動 loop** | 你給一個目標 | 獨立判斷者確認達成,或達到最大回合數 | `/goal` | `/goal`(需手動開啟) | 有明確完成標準的複雜任務 |
+| **時間驅動 loop** | 定時觸發(每隔 N 分鐘/小時) | 你手動停止,或任務完成後自行退出 | `/loop` | 對話執行緒自動化(Thread automation) | 輪詢狀態、定期巡檢、重複性工作 |
+| **事件驅動 loop** | 外部事件觸發(PR 提交、CI 失敗、新 issue) | 處理完事件就停,或達到重試上限 | Routines (API / GitHub Webhook) | 獨立自動化任務 + 外掛 | 回應式工作流、CI/CD 整合 |
+
+這幾種 loop 不是互相取代的關係,而是工具箱裡的不同工具。小任務用回合制就夠了;有明確終點的用 `/goal`;需要盯著什麼東西的用 `/loop`;要和外部系統聯動的用事件驅動。
+
+### `/goal` 和 `/loop` 別搞混
+
+名字裡都帶 "loop",但它們解決的是完全不同的問題:
+
+| | `/goal` | `/loop` |
+|---|---------|---------|
+| **本質** | 一個大任務,跑到完為止 | 同一個小動作,按間隔重複跑 |
+| **停止條件** | 目標達成了,或者預算花完了 | 你手動停,或者任務做完自己退 |
+| **時間特徵** | 一次長跑,可能跑幾小時甚至幾天 | 週期性短跑,每次可能只跑幾分鐘 |
+| **狀態累積** | 任務越跑越接近終點 | 每次都是獨立的,不累積進度 |
+| **類比** | 跑馬拉松——發令槍響了就跑,撞線就停 | 鬧鐘——每隔一段時間響一次,你關了才停 |
+| **典型用法** | 「實作整個支付系統,有測試覆蓋」 | 「每 15 分鐘看一眼 CI 掛了沒」 |
+
+一個容易犯的錯:把該用 `/goal` 的事情塞進 `/loop` 裡。比如你寫 `/loop 10m "繼續實作支付系統"`——這是錯的。因為 `/loop` 每次都是獨立跑一遍指令,不會記得上次做到哪了,結果就是每次都從同一個地方重新開始。
+
+**判斷該用哪個的一句話標準:這件事有終點嗎?**
+- 有終點 → `/goal`
+- 沒終點,就是要一直盯著 → `/loop`
+
+本講講的 Loop Engineering,核心不是某一個指令,而是**當你需要的時候,能設計出包含以上所有類型的系統——讓 agent 在你不在場的時候也能自己跑。**
+
+你不必每次都寫 `/goal`。但理解它從哪來、為什麼長這樣,就理解了 loop engineering 的核心——更複雜的 loop 只是在三樣基礎(目標、驗證、停止)之上,加上了排程、平行、隔離、記憶這些零件。
+
+## 2026 年 6 月,三個人在同一週點了一把火
+
+2026 年 6 月第一週,三位構建 coding agent 基礎設施的核心人物,在沒有通氣的情況下,說了同一句話的不同版本。
+
+**Peter Steinberger**(OpenClaw 作者,[其推文收穫 800 萬瀏覽](https://x.com/steipete/status/2063697162748260627)):「你不應該再給 coding agent 寫 prompt 了。你應該設計循環去 prompt 你的 agent。」
+
+**Boris Cherny**(Anthropic Claude Code 負責人,[在 Acquired 播客上](https://x.com/rohanpaul_ai/status/2063289804708835412)):「我已經不手動 prompt Claude 了。我有一堆循環在跑,它們負責 prompt Claude、搞清楚要做什麼。我的工作變成了寫循環。」
+
+**Addy Osmani**(Google Chrome 工程負責人)在 6 月 7 日[撰文](https://addyosmani.com/blog/loop-engineering/)將這個概念命名為 **Loop Engineering**,並給了它一句話定義:
+
+> **Loop engineering 就是用系統取代你自己去 prompt agent。**
+
+Cherny 透露了一個數字:在連續 30 天裡,Claude Code 的所有程式碼貢獻全部由 AI 自主完成,累計合併 259 個 PR,其中超過 80% 的生產程式碼由 Claude 編寫,開放式軟體任務成功率達到 76%。
+
+三個人、同一週、同一個結論。不是因為商量好的,是因為基礎設施剛好跨過了一個門檻:agent 已經可靠到能獨立完成非 trivial 任務、排程原語(`/loop`、`/goal`、cron)已經內建於工具中、單次運行的 token 成本也低到值得反覆跑。當零件全部就定位,把零件拼在一起的動作,所有人在同一時間想到了。
+
+> 來源:[Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+
+## 你在循環裡面 vs 你在循環外面
+
+讓我們用兩個具體的場景對比。
+
+**場景 A:你在循環裡面(前十二講的模式)**
+
+```mermaid
+flowchart TD
+ You["你"] -->|"手動輸入指令"| Agent["AI Agent"]
+ Agent -->|"產出結果"| Result["程式碼 / 測試 / 文件"]
+ Result -->|"你檢查"| You
+ You -->|"不滿意,修改指令"| Agent
+ You -->|"滿意,進入下⼀任務"| You
+```
+
+你有完整的 harness:`AGENTS.md` 告訴 agent 專案規則,`feature_list.json` 約束了範圍,`init.sh` 保證環境一致,`claude-progress.md` 記錄進度。**但每一步仍需你手動發起。** 做完一個 feature,你要讀進度檔案,想一下下一個做什麼,再輸入指令。你是整個工作流的引擎。
+
+**場景 B:你在循環外面(Loop Engineering)**
+
+```mermaid
+flowchart TD
+ subgraph Loop["你設計的循環系統"]
+ Trigger["自動觸發<br/>定時 / 事件 / 上一個任務完成"] --> Discover["發現任務<br/>讀進度檔案 / issue tracker"]
+ Discover --> Dispatch["分發任務<br/>生成子 agent"]
+ Dispatch --> Verify["驗證結果<br/>測試 / lint / 獨立評審 agent"]
+ Verify --> Persist["記錄狀態<br/>更新進度 / 提交 / 打開 PR"]
+ Persist -->|"有剩餘任務"| Discover
+ Persist -->|"全部完成或遇到阻塞"| Inbox["推送到你的審閱佇列"]
+ end
+ Inbox -->|"你只需要做決策"| You["你"]
+```
+
+你不輸入指令了。你設計的系統去發現任務、分發任務、驗證結果、記錄狀態、決定下一步。你做的事情變成了三件:**在開始前定義目標和停止條件,在結束後審閱結果,在系統跑偏時調整規則。** 價值槓桿從「寫對 prompt」轉移到了「設計對的循環」。
+
+> Addy Osmani 的原話:「一年前如果你想搞一個 loop,你得寫一堆 bash 腳本然後永遠維護它。現在這些零件已經直接內建於產品中了。」你不需要重造輪子,你需要的是理解這些零件怎麼拼在一起。
+
+## 核心概念
+
+- **Loop Engineering**:設計一個系統來自動向 agent 發指令,取代人手動逐條輸入。人從循環裡面移到循環外面,價值槓桿從「寫對 prompt」轉移到「設計對的循環」。
+- **`/goal` 模式**:最簡形態的 loop——給出目標、驗證方式和停止條件,agent 循環直達成。是從手動驅動到自動循環的橋樑。
+- **Generator/Evaluator 分離**:寫程式碼的 agent 和檢查程式碼的 agent 必須分開。同一個模型給自己打分是不可信的;獨立的、有時甚至用不同模型的驗證者是 loop 可靠性的底線。
+- **Worktree 隔離**:每個平行 agent 在獨立的 git worktree 中工作,物理上避免檔案碰撞。是多 agent 平行運行的基礎設施前提。
+- **外部狀態(External State)**:活在單次對話之外的記憶載體——markdown 檔案、issue tracker、看板等。模型在會話之間什麼都不記得,記憶必須在磁碟上。
+- **六種沉默成本**:loop 跑得越久越尖銳的四類隱性成本——驗證負債、理解腐爛、認知投降、權杖爆炸。loop 加速的不僅是產出,也包括風險。
+
+## 一個 Loop 的六大原語
+
+Osmani 將構成 loop 的零件歸納為五個核心元件,外加一個貫穿始終的記憶層——一共六樣東西,但記憶層的地位是特殊的:它不是一個和其他零件平級的元件,而是其他所有零件都依賴的脊柱。
+
+下面這張圖把六樣東西畫成一個環,方便你一眼看全。但要記住:External State 不是環上的一站,它是整個環的地基。
+
+```mermaid
+flowchart LR
+ A["Automations<br/>自動觸發"] --> W["Worktrees<br/>平行隔離"]
+ W --> S["Skills<br/>專案知識"]
+ S --> C["Connectors<br/>連接外部工具"]
+ C --> SA["Sub-agents<br/>製作者/檢查者"]
+ SA --> ES["External State<br/>跨迭代持久記憶"]
+ ES --> A
+```
+
+### 1. Automations(自動觸發)
+
+沒有自動觸發,loop 就不是 loop,只是你手動跑了一次。
+
+Claude Code 和 Codex 都有完整的排程體系,但叫法和分層不太一樣。從輕到重大致可以這樣對應:
+
+| 層級 | Claude Code | Codex | 說明 |
+|------|------------|-------|------|
+| 會話內輪詢 | `/loop` | 對話執行緒自動化(Thread automation) | 跟著當前會話走,關了就沒了 |
+| 本機定時任務 | Desktop 定時任務 | 獨立自動化任務(本機模式) | 機器開著就跑,能讀本機檔案 |
+| 雲端定時任務 | Cloud Routines | —(Codex 無雲原生排程) | 機器關了也跑 |
+| 事件觸發 | Routines (API / GitHub Webhook) | 獨立自動化任務 + 外掛 | 外部事件觸發 |
+| 完全自建 | GitHub Actions / 自建 cron | `codex exec` + cron | 完全自己掌控 |
+
+**Codex 的 Automations 面板**是它的排程入口。在裡面選專案、寫好 prompt、設好頻率、選在本機工作區還是後台 worktree 跑。找到東西的結果進入 Triage 收件匣;沒找到東西的自動歸檔。OpenAI 內部用它做日常:issue 分類、CI 失敗總結、commit 簡報、追溯上週引入的 bug。
+
+Codex 的自動化分兩種:
+- **對話執行緒自動化(Thread automation)** — 心跳式重複喚醒同一個執行緒,保留上下文。適合盯著一件事持續跟進,比如監控一個長指令、輪詢 PR 狀態。對應 Claude Code 的 `/loop`。
+- **獨立自動化任務(Standalone automation)** — 每次啟動全新運行,結果進入 Triage。適合每天/每週獨立執行的任務,比如每日簡報、依賴掃描。對應 Claude Code 的 Desktop 定時任務。
+
+Claude Code 的體系分得更細:
+
+- **`/loop`** — 會話內的輕量定時循環。終端開著的時候有效,關了就沒了,7 天自動過期。適合當前工作 session 裡臨時需要盯著什麼東西的時候。
+- **Desktop 定時任務** — 機器開著就跑,會話關了也不受影響,間隔可以到分鐘級。適合需要存取本機檔案的重複性工作。
+- **Cloud Routines** — 跑在 Anthropic 的雲上,你的機器關了也不影響,最小間隔 1 小時。支援三種觸發器:定時、API 呼叫、GitHub Webhook。適合不需要本機環境的日常任務。
+- **GitHub Actions / 自建 cron** — 完全自己掌控,想怎麼跑怎麼跑。適合有特殊環境要求或安全限制的場景。
+
+```bash
+# Claude Code:每 30 分鐘跑一次測試並修復(當前會話內有效)
+/loop 30m Run the test suite and fix any failing tests
+
+# Claude Code:每 15 分鐘檢查一次部署狀態
+/loop 15m Check if the production deploy succeeded and report status
+```
+
+Automations 是這個系統的「心跳」。沒有它,loop 就只是個設計圖,從來不會自己運轉。
+
+### 2. Worktrees(平行隔離)
+
+一旦有超過一個 agent 同時跑,檔案碰撞就變成必然的失敗模式。兩個 agent 同時改同一個檔案,就像兩個工程師沒有溝通就提交了同一段程式碼。
+
+`git worktree` 解決的就是這個:每個 agent 在自己的獨立分支上工作,物理上不可能碰到別人的修改。
+
+Claude Code 和 Codex 都內建了 worktree 支援。當你用 `--worktree` 或 `isolation: worktree` 啟動子 agent 時,每個 helper 拿到一個乾淨的、獨立的 checkout,完成任務後自行清理。worktree 移除了碰撞的機械問題,但你要記住:**你的審閱頻寬仍然是天花板**,你能同時盯多少個平行 agent,決定了你能跑多少個 worktree。
+
+### 3. Skills(專案知識)
+
+Skill 讓你不再每次會話都重新解釋一遍你的專案。它是一個資料夾,裡面有 `SKILL.md` 存放指令和後設資料,外加可選的腳本、參考文件、資源檔案。
+
+Codex 和 Claude Code 都支援相同的格式。skill 透過 `/skill-name` 直接呼叫(Codex 也支援 `$skill-name`),也可以在 agent 判斷任務匹配時自動觸發。
+
+技能本質上是在 pay 你的 intent debt——一個 agent 每次啟動時都是「冷」的,你上下文裡沒寫的東西,它就用自信的猜測填補。skill 就是把你的意圖寫在外面,寫一次,每次運行都讀。
+
+### 4. Connectors(外掛與連接器)
+
+一個只能看到檔案系統的 loop 是個小 loop。Connectors(基於 MCP 協定)讓 agent 能讀 issue tracker、查資料庫、調 staging API、往 Slack 發訊息。
+
+Codex 和 Claude Code 都支援 MCP,你為一個工具寫的 connector 通常另一個也能直接用。Connectors 的區別在於:有了它,agent 不只是說「這是修復方案」,而是自動打開 PR、關聯 Linear ticket、在 CI 通過後 ping 頻道——loop 在你的真實環境裡行動,不只是在終端裡打字。
+
+### 5. Sub-agents(子 agent)
+
+loop 裡最有結構價值的設計,就是把「寫的人」和「檢查的人」分開。寫程式碼的模型對自己的作業評分太寬容了。第二個 agent,用不同的指令、有時用不同的模型,能抓住第一個 agent 自我說服的東西。
+
+典型的三人分工:
+
+```mermaid
+flowchart LR
+ Explorer["探索者 Agent<br/>讀程式碼庫、定位問題"] --> Implementer["實作者 Agent<br/>寫修改、寫測試"]
+ Implementer --> Verifier["驗證者 Agent<br/>獨立審查、運行驗證"]
+ Verifier -->|"未通過"| Implementer
+ Verifier -->|"通過"| Output["輸出結果"]
+```
+
+Claude Code 的 `/goal` 底層就是這麼幹的——一個獨立的小模型來判斷 loop 是否應該停止,而不是讓寫程式碼的那個模型自評。這被稱為 **generator/evaluator 分離**,是 loop 可靠性的核心保障。
+
+### 6. External State(外部狀態)
+
+模型在會話之間什麼都不記得。記憶必須在磁碟上,不能在上下文視窗裡。
+
+這聽起來太簡單而不值得提,但它是每個長時間運行的 agent 都依賴的同一個把戲。一個 markdown 檔案、一個 Linear 看板——任何活在單次對話之外的東西,記錄了什麼做完了、什麼正在做、什麼被阻塞了。agent 忘了一切,倉庫不會忘。
+
+這六個原語拼在一起,就是你的 loop 設計工具箱。你不需要每次都全用上,但你需要知道什麼時候該用哪一個。
+
+## 一個 Loop 的完整解剖
+
+把六個原語拼在一起,看一個真實的 morning triage loop:
+
+```mermaid
+flowchart TD
+ Trigger["每天早上 9:00<br/>Automation 自動觸發"] --> Read["讀外部狀態<br/>昨天的 claude-progress.md<br/>GitHub 上未讀 issue"]
+ Read --> Triage["Triage Skill 啟動<br/>對發現的問題分類、排優先順序"]
+ Triage --> Fork["每個可處理的問題<br/>fork 一個獨立 Worktree"]
+ Fork --> Implement["實作者 Sub-agent<br/>寫修復 + 測試"]
+ Implement --> Verify["驗證者 Sub-agent<br/>獨立運行測試 + lint + 審查"]
+ Verify -->|"未通過"| Retry["重試佇列<br/>換策略再試"]
+ Retry --> Implement
+ Verify -->|"通過"| PR["Connector: 打開 PR<br/>關聯 issue, 更新進度檔案"]
+ PR --> Memory["寫入 External State<br/>更新 claude-progress.md<br/>記錄本輪結果"]
+ Memory -->|"有剩餘問題"| Fork
+ Memory -->|"全部處理完畢<br/>或遇到無法處理的阻塞"| Inbox["結果推入 Triage 收件匣<br/>等你審閱"]
+```
+
+這不再是一個 agent 的一次運行。它是一個持續運轉的系統,每天早上自己醒來,自己掃地,自己把需要你關注的東西放到你面前。你的角色變成了:**審閱 inbox 的內容,做決策,遇到系統處理不了的模式就最佳化 skill 或規則。**
+
+Cherny 用這個模式讓 Claude Code 團隊在 30 天內合併了 259 個 PR,自己一次都沒有打開 IDE。OpenAI 的工程師用同樣的模式建立了約一百萬行程式碼的 beta 產品,一行都沒有手寫。
+
+## Generator/Evaluator 分離:為什麼不能讓自己批自己作業
+
+這是 loop engineering 中最硬核的一條教訓。
+
+你讓你最聰明的 agent 寫了一段漂亮的程式碼。程式碼邏輯清晰、註解完整、測試全覆蓋。你很滿意。
+
+但你有沒有想過一個問題:**如果讓那個寫了程式碼的 agent 自己來評判自己做得對不對,它會說什麼?**
+
+答案已經被實踐反覆驗證:它會給自己打高分。不是因為它不誠實,而是因為它就是這段程式碼的作者——它在生成的時候已經說服自己這條路是對的。你讓它回頭看,它看到的不是錯誤,而是自己的推理過程。
+
+這不是 Claude 的問題,不是 GPT 的問題,這是所有生成式模型的共同特性。**模型是它自己輸出最好的辯護律師。**
+
+解決方案就是:永遠不用同一個人(同一個模型、同一個 prompt)既幹活又檢查。
+
+- Claude Code 的 `/goal` 底層的 supervisor 是一個獨立的 session,獨立判斷是否達成目標
+- Codex 的 subagent 體系讓你定義驗證 agent 可以和實作 agent 用不同模型、不同 reasoning effort
+- 社群實踐裡的「adversarial verify」模式:每一個發現用 N 個獨立的質疑 agent 來反駁它,多數否決則丟棄
+
+這個原則用一句話總結:**你的人裡必須有一個不信你的。**
+
+## Karpathy 的 autoresearch:Loop 的最佳示範
+
+如果想看一個設計精良、真實跑通的 loop 長什麼樣,Andrej Karpathy 的 [autoresearch](https://github.com/karpathy/autoresearch) 是最好的教材。
+
+2026 年 3 月,Karpathy 發布了一個 630 行 Python 的專案。給它一張 GPU、一份研究方向,它能自己跑一整夜,完成上百個 ML 訓練實驗,只保留真正有改進的。專案上線幾天內獲得 66,000+ star。
+
+### 三個檔案,三種角色
+
+整個系統只有三個核心檔案,但分工極其清晰:
+
+| 檔案 | 誰來改 | 作用 |
+|------|--------|------|
+| `prepare.py` | 沒有人(唯讀) | 資料準備、tokenizer、評估函數。固定的基礎設施。 |
+| `train.py`(~630 行) | **AI Agent** | 模型定義、最佳化器、訓練循環。Agent 的實驗場,想改什麼改什麼。 |
+| `program.md` | **你** | 用自然語言寫的研究方法論。你只改這個,告訴 agent 怎麼探索、怎麼評估、什麼不能碰。 |
+
+這個三分法是整個設計的精髓:**人不動程式碼,動方向;agent 不動方向,動程式碼。** 你的工作從寫 Python 變成了「寫研究組織文化」。
+
+### 輸入:program.md 長什麼樣
+
+`program.md` 是 loop 的大腦。它不是程式碼,是一份用 Markdown 寫的研究指令。裡面大致包含:
+
+- **目標**:最佳化 `val_bpb`(驗證集 bits-per-byte,越低越好)
+- **約束**:不能改 `prepare.py`、VRAM 不能超、訓練時間固定 5 分鐘
+- **探索方向**:試試不同的架構、最佳化器、學習率排程
+- **評估規則**:怎麼算改進、怎麼記錄結果、失敗了怎麼辦
+- **鐵律**:永遠不要停。一旦開始循環,就一直跑下去
+
+你給 agent 的啟動 prompt 甚至可以短到一句話:
+
+```
+看看 program.md,然後開始實驗。
+```
+
+剩下的全靠 agent 自己讀文件、自己做決定。
+
+### 九步棘輪循環
+
+autoresearch 的核心是一個**棘輪(ratchet)**——只能往前走,不能後退。每一輪循環嚴格按九步走:
+
+```mermaid
+flowchart TD
+ 1["1. 讀方向<br/>讀取 program.md"] --> 2["2. 看現狀<br/>讀 train.py + 歷史結果"]
+ 2 --> 3["3. 提假設<br/>想一個要試的改動"]
+ 3 --> 4["4. 改程式碼<br/>修改 train.py"]
+ 4 --> 5["5. 提交快照<br/>git commit"]
+ 5 --> 6["6. 跑訓練<br/>固定 5 分鐘牆鐘"]
+ 6 --> 7{"7. 評估<br/>val_bpb 改進了嗎?"}
+ 7 -->|是| 8a["8a. 保留<br/>commit 留下<br/>結果寫入 results.tsv"]
+ 7 -->|否| 8b["8b. 回退<br/>git reset HEAD~1<br/>記錄失敗"]
+ 8a --> 9["9. 下一輪<br/>回到第 1 步"]
+ 8b --> 9
+```
+
+每小時大約跑 12 次實驗。睡一覺(8 小時)就是約 100 次。Karpathy 自己跑了 2 天,約 700 次實驗。
+
+固定 5 分鐘牆鐘是個關鍵設計——不管 agent 改了什麼,每次實驗時間完全一樣。這意味著所有結果在同一時間預算下直接可比,不會出現「這個跑久一點所以更好」的爭議。
+
+### 輸出:你早上起來看到什麼
+
+Loop 跑完一夜,你早上打開電腦會看到三樣東西:
+
+**1. git 歷史(前進的棘輪)**
+
+只有真正改進了的 commit 留在主分支上,失敗的全被回滾了。git log 就是一份經過驗證的研究日誌。
+
+**2. results.tsv(完整的實驗記錄)**
+
+每一次實驗——不管成功失敗——都記在裡面:
+
+```
+timestamp commit_hash val_bpb vram_mb description
+--------- ------------- ---------- ---------- ----------------------------
+08:01:12 a1b2c3d 1.234 22100 baseline
+08:06:15 d4e5f6g 1.228 22400 increased learning rate by 10%
+08:11:20 (reverted) 1.241 21800 switched to GELU activation
+08:16:08 h7i8j9k 1.219 23000 added weight decay 0.01
+...
+```
+
+**3. 一份研究日誌(agent 自己寫的總結)**
+
+Agent 會在 commit message 裡寫清楚它試了什麼、什麼有效、什麼無效、下一步打算試什麼。你讀這些就夠了,不用讀程式碼 diff。
+
+### 實際跑出了什麼結果
+
+Karpathy 首輪 2 天、約 700 次實驗的結果:
+
+- 從約 700 次嘗試中篩出了約 **20 個可堆疊的有效改進**
+- 將 nanochat 在 8×H100 上復現 GPT-2 水準的訓練時間從 **2.02 小時壓縮到 1.80 小時**,提速約 **11%**
+- 找到的改進包括:學習率調整、最佳化器微調、啟動函數替換、注意力模式最佳化等
+
+不是所有改進都是驚天動地的大發現嗎?不是。大部分是小最佳化堆疊出來的。但這 20 個有效改進,靠人手動做要花幾週——agent 用 48 小時跑完了。
+
+### 最值得注意的細節:loop 是用英文寫的,不是用程式碼。
+
+`program.md` 是一份 Markdown 文件,不是 Python 腳本。它描述了研究方法論——改什麼、不改什麼、怎麼評估、怎麼處理失敗、以及一條鐵律:**禁止向人類求助,一直跑。** 一個 coding agent 讀這份文件,然後無限循環執行下去。
+
+這就是 loop engineering 的核心模式:不給 agent 任務,給 agent **方法論**。讓方法論成為 loop。一份 `program.md`,630 行膠水程式碼,剩下的全部是 agent 自己跑。
+
+## 四種沉默成本
+
+loop 跑起來之後,你不會立刻看到問題。以下四種成本會沉默地累積,等到你發現的時候可能已經損失了很多。
+
+### 1. Verification Debt(驗證負債)
+
+loop 跑得快的時候,你很容易跳過驗證。「看起來沒問題」不等於「確實沒問題」。loop 裡自動生成的程式碼越多,驗證債務積累越快。解決方式是:**停止條件必須是可自動檢查的,不能是「感覺差不多」。**
+
+### 2. Comprehension Rot(理解腐爛)
+
+loop 出程式碼的速度越快,你對自己程式碼庫的理解就越跟不上。Cherny 的團隊 80% 的程式碼是 agent 寫的——這意味著一個團隊大部分程式碼不是人寫的。如果不讀不用,你對系統的理解會持續衰減。**快速跑 loop 的前提是快速讀結果。**
+
+### 3. Cognitive Surrender(認知投降)
+
+當 loop 跑得很順的時候,最舒服的姿勢就是不再有觀點。來什麼接什麼,不對結果動腦子。但這恰恰是危險的開始——你在用 loop 逃避思考,而不是用 loop 放大思考。Osmani 的警告:「兩個人可以造完全一樣的 loop,得到完全相反的結果。一個用它加深理解後加速,另一個用它代替理解。loop 不知道區別,你知道。」
+
+### 4. Token Blowout(權杖爆炸)
+
+loop 的每一次迭代都會積累更多上下文。程式碼寫過了,錯誤遇到了,決策做過了。如果不做上下文壓縮,prompt size 會隨著迭代次數近似平方成長。Codex 的解決方案是自動 context compaction——用一個專門的 API 將老的對話輪次壓縮成加密的內容摘要,保留關鍵知識,丟棄冗餘細節。這是每個 loop 設計之初就要考慮的工程問題。
+
+## 從零構建你的第一個 Loop
+
+不需要一上來就搭一個 Stripe 級別、每週合併 1,300 個 PR 的系統。從最小可行的版本開始。
+
+### 第一步:選一個重複發生的任務
+
+找一個你每週至少做兩次的事情。比如:
+- 早上打開 GitHub,看有沒有新 issue,分類和回覆
+- 每次 PR 審核前跑一遍 lint 和測試
+- 每天結束前更新進度文件
+
+### 第二步:寫一個 goal 和停止條件
+
+把任務變成一個 `/goal` 可以理解的描述:
+
+```markdown
+Goal: 檢查倉庫最新的 10 個 issue。
+對於每個 issue:
+ - 如果已經有明確標籤和負責人,跳過
+ - 如果沒有標籤,根據內容添加標籤
+ - 如果可以 10 分鐘內修復,建立分支並嘗試修復
+停止條件:所有符合條件的 issue 都已處理,或遇到需要人工決策的問題。
+```
+
+### 第三步:拆出 maker 和 checker
+
+不要讓同一個 agent 既改程式碼又判對錯。把你的 loop 拆成兩個角色:
+- 實作者:讀 issue、寫修復、寫測試
+- 驗證者:獨立運行測試、審查 diff、判斷這個修復是否真解決了問題
+
+### 第四步:加上記憶
+
+用一個 markdown 檔案記錄 loop 每次運行的結果。下一輪啟動時先讀這個檔案,知道上一輪做了什麼、什麼還沒做。這比任何複雜的資料庫都管用。
+
+### 第五步:設一個定時器
+
+用 `/loop` 指令或作業系統的 cron,讓這個 loop 在沒有你的時候也能啟動。先從每天一次開始,觀察一週。
+
+### 成熟度階梯
+
+你不需要一次到位。loop 的採用是一個階梯:
+
+1. **Level 1: Goal Runner** — 你會用 `/goal` 下達有停止條件的任務,agent 循環直達成
+2. **Level 2: Scheduled Single-Task** — 一個自動化定時跑一個任務(比如每天早上檢查 CI)
+3. **Level 3: Multi-Agent Loop** — 實作者和驗證者分離,每個發現 fork 一個獨立 worktree
+4. **Level 4: Self-Feeding Loop** — loop 從外部狀態中自動發現下一個任務,自己決定做什麼
+5. **Level 5: Fleet Orchestration** — 多個 loop 平行運行,彼此獨立、共享記憶
+
+絕大多數團隊目前卡在 Level 2 到 Level 3 之間。Level 1 是最快能看到回報的一步。
+
+## 核心要點
+
+- **Loop Engineering 不是取代 Harness Engineering,而是在它之上建一層。** harness 保證單次運行可靠,loop 保證持續運行不需要你守在旁邊。
+- **`/goal` 是最簡形態的 loop:** 目標 + 驗證方式 + 停止條件。這三樣東西讓你的位置從循環裡面移到循環外面。
+- **六個原語(Automations / Worktrees / Skills / Connectors / Sub-agents / External State)是 loop 的零件。** 不是每次都全用,但需要知道什麼時候該裝哪一個。
+- **寫程式碼的人和檢查程式碼的人必須分離。** 一個模型給自己打分是不可信的;獨立的、有時甚至用不同模型的驗證 agent 是 loop 可靠性的底線。
+- **loop 讓生成幾乎免費,判斷成為稀缺資源。** 你省下的時間不是用來歇的,是用來做更多判斷的。
+- **四種沉默成本會隨著 loop 跑得越久越尖銳:** 驗證負債、理解腐爛、認知投降、權杖爆炸。loop 加速的不僅是產出,也包括風險。
+- **從小開始。** 一個 `/goal`,一個 cron,一個 markdown 記憶檔案。看到回報之後再往上加。
+
+## 延伸閱讀
+
+- [Addy Osmani: Loop Engineering](https://addyosmani.com/blog/loop-engineering/)
+- [Addy Osmani: Agent Harness Engineering](https://addyosmani.com/blog/agent-harness-engineering/)
+- [Simon Willison: Designing Agentic Loops (Sep 2025)](https://simonw.substack.com/p/designing-agentic-loops)
+- [Karpathy: autoresearch](https://github.com/karpathy/autoresearch)
+- [Claude Code: Dynamic Workflows and Orchestration](https://kenhuangus.substack.com/p/claude-code-orchestration-dynamic)
+- [Loop Library (Forward Future)](https://signals.forwardfuture.ai/loop-library/) — 50 個真實 loop 的公開語料庫
+- [The Neuron: Claude Code Creators on Agent Loops](https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/)
+- 第十二講:[每次會話結束前都做好交接](./../lecture-12-why-every-session-must-leave-a-clean-state/index.md) — loop 的前提:每個會話留下乾淨狀態,下一輪才能自動啟動
+- 第五講:[讓跨會話的任務保持上下文連續](./../lecture-05-why-long-running-tasks-lose-continuity/index.md) — 外部狀態和記憶的前置知識
+- 第十一講:[讓 agent 的運行過程可觀測](./../lecture-11-why-observability-belongs-inside-the-harness/index.md) — loop 跑得越快,越需要可觀測性來發現問題
+- 第八講:[用功能清單約束 agent 該做什麼](./../lecture-08-why-feature-lists-are-harness-primitives/index.md) — 功能清單是 self-feeding loop 發現下一個任務的天然資料來源
+
+## 練習
+
+1. **把你的一個重複任務變成 `/goal`:** 找一個你每週至少手動做兩次的事情。寫下它的目標、驗證方式和停止條件。用 `/goal` 跑一次,比較和手動做的時間和結果品質。這是你從 Harness 到 Loop 的第一步。
+
+2. **分離 maker 和 checker:** 挑一個你之前讓 agent 執行過的任務。這一次,寫兩份不同的 prompt:一份給實作 agent,一份給驗證 agent(用不同模型,比如實作用 Claude,驗證用 GPT,或反過來)。驗證 agent 必須逐條指出問題並引用證據。記錄兩種模式下發現的問題數量和類型差異。
+
+3. **給 loop 加上記憶:** 為你的 loop 建立一個 markdown 狀態檔案。在 loop 的每一輪中寫入:本輪做了什麼、驗證結果、狀態(通過/失敗/阻塞)、下一輪該做什麼。跑三輪,觀察沒有記憶檔案和有記憶檔案的情況下,agent 的行為差異。
+
+4. **審計你的 loop 的沉默成本:** 你的 loop 跑一小時後,評估以下四個指標:
+ - 有多少驗證是「感覺通過了」而不是「機器確認通過了」?(驗證負債)
+ - 你對 loop 最新產出的程式碼能講清楚多少?(理解腐爛)
+ - 你有多少次「看看再說」但始終沒看?(認知投降)
+ - loop 的上下文成長趨勢如何?是否在重複冗餘資訊?(權杖爆炸)
diff --git a/docs/zh-TW/projects/project-07-loop-engineering-first-loop/index.md b/docs/zh-TW/projects/project-07-loop-engineering-first-loop/index.md
new file mode 100644
index 0000000..057eae6
--- /dev/null
+++ b/docs/zh-TW/projects/project-07-loop-engineering-first-loop/index.md
@@ -0,0 +1,147 @@
+[English Version →](../../../en/projects/project-07-loop-engineering-first-loop/)
+
+# Project 07. 搭建你的第一個自動循環
+
+> 相關講義:[L13. 從手動驅動到自動循環](./../../lectures/lecture-13-loop-engineering/index.md)
+
+## 你要做什麼
+
+這是從 "Harness" 到 "Loop" 的躍遷專案。你已經知道怎麼給 agent 配好一套環境、一套指令、一套回饋——現在你要把這套東西變成一個能自己跑的循環。
+
+你會做三個遞進的實驗:先把一個任務從手動跑變成 `/goal` 自動跑,再把一個巡檢任務變成 `/loop` 定時跑,最後做一個帶 maker-checker 分離的完整循環,體驗「人退到循環外面」是什麼感覺。
+
+## 使用倉庫裡的專案
+
+倉庫路徑:[`projects/project-07/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07)
+
+| 目錄 | 裡面有什麼 | 做什麼 |
+|------|----------|--------|
+| [`starter/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/starter) | 一個帶有完整 harness 的小型知識庫專案(P06 完成態),包含 AGENTS.md、feature_list.json、init.sh、session-handoff.md、clean-state-checklist.md。 | 把這套 harness 改造成能自動循環的版本。 |
+| [`solution/`](https://github.com/walkinglabs/learn-harness-engineering/tree/main/projects/project-07/solution) | 三個循環的完整實作:goal loop、loop timer loop、maker-checker loop,加上 loop 狀態檔案和驗證腳本。 | 參考 loop 的設計方式和狀態管理模式。 |
+
+## 用什麼工具
+
+- Claude Code 或 Codex
+- Git
+- 你在 P06 搭建好的完整 harness
+- 一個你常用的終端複用工具(tmux 或 screen,用於觀察長時間運行的 loop)
+- 可選:GitHub Actions 或 cron(用於事件驅動/定時驅動的進階實驗)
+
+## 具體步驟
+
+### 準備工作
+
+1. 基於 P06 完成後的程式碼,從同一個 commit 出發。
+2. 建立三個分支:`p07-goal-loop`、`p07-timer-loop`、`p07-maker-checker`。
+3. 確認你的 harness 是工作的:跑一次 init.sh,確認狀態檔案、feature list、交接文件都在。
+4. 選一個你要讓 loop 反覆做的**目標任務**。建議選一個中等大小、有明確完成標準的任務,比如:「給所有模組補充單元測試,覆蓋率達到 80%」或「把所有 API 端點加上輸入驗證」。
+
+### 實驗一:Goal Loop —— 從手動跑到自動跑
+
+切到 `p07-goal-loop` 分支。
+
+1. **寫目標描述**:把你選的任務寫成一份 `goal.md`,包含:
+ - 明確的目標(「完成什麼算做完」)
+ - 驗證方式(「怎麼確認做完了」——跑測試?跑 lint?檢查覆蓋率?)
+ - 停止條件(「什麼時候應該停下」——最大回合數?時間上限?預算上限?)
+ - 約束(「不能碰什麼」——生產設定、資料庫 schema 等)
+
+2. **第一次手動跑**:你自己手動給 agent 發指令,完成一次這個任務。記錄用了多少回合、你介入了多少次、結果品質如何。這是你的基線。
+
+3. **用 `/goal` 跑**:用同一份 `goal.md` 作為輸入,用 `/goal` 模式跑一次。agent 自己循環直達成目標或觸發停止條件。
+
+4. **對比結果**:
+ - 回合數差異
+ - 你介入的次數差異
+ - 結果品質差異(用同樣的驗證標準)
+ - 你花的時間差異
+
+5. **迭代 goal.md**:如果結果不好,改 goal 描述,再跑一次。直到你對結果滿意,或者確認 goal loop 在這個任務上的極限在哪裡。
+
+### 實驗二:Timer Loop —— 把巡檢變成心跳
+
+切到 `p07-timer-loop` 分支。
+
+1. **選一個巡檢任務**:找一個你平時手動做的、重複性的檢查工作。比如:
+ - 每小時跑一次測試,有失敗就修
+ - 每天早上檢查依賴有沒有安全更新
+ - 每次提交後檢查程式碼有沒有違反編碼規範
+ - 定期掃描 TODO 註解,看哪些已經過期了
+
+2. **寫巡檢腳本/prompt**:把巡檢的步驟寫清楚——檢查什麼、發現問題了怎麼辦、什麼時候需要叫人。
+
+3. **用 `/loop`(或 Codex 的對話執行緒自動化)跑**:
+ - 設定合理的間隔(建議 10-30 分鐘,太短你會被打擾,太長看不出效果)
+ - 讓它跑至少 2 小時(或者你去幹別的事,過一會兒回來看)
+
+4. **記錄結果**:
+ - 它發現了多少問題?
+ - 它自己修了多少?
+ - 有多少是誤報?
+ - 有多少是它修壞了的?
+ - 你花了多少時間跟進它的結果?
+
+5. **思考**:這個巡檢任務值得自動化嗎?節省的時間和你跟進它花的時間比,哪個多?如果不划算,是任務選錯了還是 loop 設計得不好?
+
+### 實驗三:Maker-Checker Loop —— 把你從循環裡拿出來
+
+切到 `p07-maker-checker` 分支。
+
+這是三個實驗裡最重要的一個。你要做一個**完整的、你不需要在場的循環**:
+
+1. **設計循環結構**:
+ - **Maker agent**:負責實作,寫程式碼,改檔案
+ - **Checker agent**:負責驗證,跑測試,做程式碼審查,打通過/不通過
+ - **狀態檔案**(`loop-state.md`):記錄當前輪次、做了什麼、驗證結果、下一輪要做什麼
+ - **停止條件**:連續 N 輪通過,或者達到最大輪次
+
+2. **寫三份 prompt**:
+ - Maker 的指令(做什麼、怎麼做、什麼不能碰)
+ - Checker 的指令(驗證什麼、怎麼驗證、什麼算通過、發現問題了怎麼回饋)
+ - 循環控制邏輯(誰先跑、跑完了怎麼交接、下一輪怎麼啟動)
+
+3. **跑至少 5 輪循環**:
+ - 第一輪:Maker 實作 → Checker 驗證 → 不通過 → 回饋給 Maker
+ - 第二輪:Maker 根據回饋修改 → Checker 再驗證 → ...
+ - ...
+ - 直到連續通過,或者你叫停
+
+4. **記錄每一輪的狀態**:
+ - 輪次
+ - Maker 做了什麼
+ - Checker 發現了什麼問題
+ - 通過/不通過
+ - 你有沒有介入(如果介入了,為什麼)
+
+5. **最後覆盤**:
+ - 你一共介入了幾次?為什麼介入?
+ - 如果沒有介入,結果會怎麼樣?
+ - Checker 有没有漏過問題?
+ - Maker 有没有在同一個問題上反覆犯錯?
+ - 這個循環的品質天花板在哪裡?是 Maker 的能力還是 Checker 的能力?
+
+## 怎麼衡量結果
+
+| 指標 | 實驗一(Goal) | 實驗二(Timer) | 實驗三(Maker-Checker) |
+|------|--------------|---------------|----------------------|
+| 任務完成率 | 目標達成了嗎? | 巡檢了多少次? | 多少輪後通過? |
+| 人類介入次數 | 你插手了幾次? | 你跟進花了多久? | 你介入了幾次? |
+| 結果品質 | 和手動比怎麼樣? | 誤報率多少?漏檢率多少? | Checker 發現了多少你沒發現的問題? |
+| 時間節省 | 你省了多少時間? | 值得自動化嗎? | 你花在設計循環上的時間 vs 你省下來的時間 |
+| 可靠性 | 停止條件靠譜嗎? | 有没有跑飛了? | 循環會不會卡死在同一個地方? |
+
+## 要交什麼
+
+- `goal.md`(實驗一的目標描述,至少迭代了兩個版本)
+- 實驗一的對比記錄:手動 vs goal loop
+- 實驗二的巡檢 prompt 和 2 小時運行日誌
+- 實驗三的三份 prompt(Maker / Checker / 循環控制)
+- 實驗三的 `loop-state.md`(至少 5 輪記錄)
+- 最終覆盤:三個實驗的收穫、你對 loop engineering 的理解變化、哪些事情適合 loop 化、哪些不適合
+
+## 對應講義
+
+- [Lecture 13 — 從手動驅動到自動循環](../../lectures/lecture-13-loop-engineering/index.md)
+- [Lecture 12 — 為什麼每次會話都必須留下乾淨狀態](../../lectures/lecture-12-why-every-session-must-leave-a-clean-state/index.md)(loop 的每一輪都需要 clean state)
+- [Lecture 11 — 為什麼可觀測性屬於 harness 的一部分](../../lectures/lecture-11-why-observability-belongs-inside-the-harness/index.md)(你需要看到 loop 內部在發生什麼)
+- [Lecture 05 — 為什麼狀態檔案是跨會話連續性的核心](../../lectures/lecture-05-why-state-files-are-the-backbone-of-continuity/index.md)(loop 狀態檔案是 state file 的延伸)