Eğitimler

Dokümantasyonu kod tabanınla senkronize tutma

IBM Bob'un init komutu ve özel bir Docs Architect modu kullanarak teknik dokümantasyonu gerçek geliştirme senaryolarında — özellik geliştirme, kod incelemeleri, işe alıştırma ve süregelen bakım — kod tabanınla senkronize nasıl tutacağını öğren.

Dokümantasyon, yazılım geliştirmede genellikle ikincil bir düşünce olarak ele alınır — kod "bitti" olduktan sonra yaptığın bir şey. Ancak pratikte, dokümantasyonun kodunla birlikte sürekli olarak evrilmesi gerekir. Bu tutorial, IBM Bob kullanarak pratik bir geliştirme iş akışında yapay zeka kod dokümantasyonunun nasıl çalıştığını gösterir.

Teoriye odaklanmak yerine, Bob'un dokümantasyon yeteneklerini günlük geliştirme sürecine nasıl entegre edeceğini göreceksin: ilk proje kurulumundan özellik geliştirmeye, kod incelemelerine ve sürümlere kadar. Yapay zeka tarafından okunabilir bağlam oluşturmak için /init komutunu kullanacak ve geliştirmenin her aşamasında insan tarafından okunabilir dokümantasyon oluşturan özel bir Docs Architect modu oluşturacaksın.

Ne başarırsın

Bu tutorialda şunları öğrenirsin:

  • Yapay zeka kod dokümantasyonunu geliştirme iş akışının bir parçası olarak kurma
  • Yapay zeka tarafından okunabilir proje bağlamı oluşturmak ve sürdürmek için /init kullanma
  • Kullanıcıya yönelik dokümantasyon oluşturmak için özel bir Docs Architect modu oluşturma
  • Dokümantasyon güncellemelerini özellik geliştirme döngülerine entegre etme
  • Dokümantasyonu kod incelemeleri ve pull request'ler aracılığıyla sürdürme
  • Dokümantasyonu sürüm kontrolündeki kod değişiklikleriyle senkronize tutma

Ön koşullar

Bu tutorialı tamamlamak için şunlara ihtiyacın var:

  • Kurulu Bob IDE.
  • Dokümante etmek istediğin bir Git deposu. Herhangi bir yerel proje veya açık kaynak deposu işe yarar.

Yapay zeka kod dokümantasyonu pratikte nasıl çalışır

Geleneksel dokümantasyon iş akışları kod yazmayı dokümantasyon yazmadan ayırır. Geliştiriciler kod yazar, sonra (belki) dokümantasyonu daha sonra günceller. Bu, dokümantasyonun geride kaldığı, yanlış olduğu ve sonunda görmezden gelindiği bir boşluk yaratır.

IBM Bob, yazılım geliştirmenin tüm yaşam döngüsünü desteklemek için oluşturulmuş bir IDE'dir — ve bu yapay zeka kod dokümantasyonunu içerir. Bob, dokümantasyon oluşturmayı kod değişiklikleriyle birlikte gerçekleşebilecek kadar hızlı yapar, böylece belgeler geride kalmak yerine güncel kalır. Pratikte nasıl çalıştığı şu şekilde:

Yapay zeka dokümantasyon iş akışı

  1. Yapay zeka kod tabanını öğrenir: /init komutu deponuzu tarar ve büyük dil modeli için bilgi tabanları olarak hizmet eden yapılandırılmış özetler olan AGENTS.md dosyaları oluşturur
  2. Yapay zeka dokümantasyon oluşturur: Docs Architect gibi özel modlar, kullanıcıya yönelik dokümantasyon (README'ler, kılavuzlar, API belgeleri) oluşturmak için bu bağlamı kullanır
  3. Gözden geçirir ve iyileştirirsin: Yapay zeka tarafından oluşturulan dokümantasyon bir başlangıç noktasıdır; doğrular, düzenler ve kodla birlikte commit'lersin
  4. Yapay zeka senkronize kalır: Kod değişikliklerinden sonra /init'i yeniden çalıştırmak yapay zekanın anlayışını günceller, hızlı dokümantasyon güncellemelerini mümkün kılar

Bu iş akışı, dokümantasyonu ayrı bir görev olarak ele almak yerine geliştirme sürecine entegre eder.

Gerçek dünya senaryoları

Bu tutorial karşılaşacağın pratik senaryoları ele alır:

  • Yeni bir proje başlatma: Sıfırdan dokümantasyon kurma
  • Özellik ekleme: Geliştirirken belgeleri güncelleme
  • Kod incelemesi: Pull request'lerde dokümantasyonu kontrol etme
  • İşe alıştırma: Yeni takım üyelerine yardımcı olmak için yapay zeka tarafından oluşturulan belgeleri kullanma
  • Bakım: Kod tabanı geliştikçe belgeleri güncel tutma

Senaryo 1: İlk proje dokümantasyonu

Minimal dokümantasyonla bir depo devraldın. Yeni takım üyeleri kod tabanını anlamakta güçlük çekiyor ve kapsamlı dokümantasyonu hızlı bir şekilde oluşturman gerekiyor.

Çalışma alanını kurma

  1. Depoyu IBM Bob IDE'de aç.
  2. Bob sohbet arayüzünü aç: Option + Command + B (macOS) veya Ctrl + Alt + B (Windows)

/init ile yapay zeka tarafından okunabilir bağlam oluşturma

İlk adım Bob'a projen hakkında bilgi vermektir. Agent moduna geç ve şunu çalıştır:

/init

Bob deponuzu tarar ve şunları oluşturur:

  • Deponun kök dizininde AGENTS.md (ana proje bağlamı)
  • .bob/rules-code/AGENTS-code.md (Agent moduna özgü bağlam)
  • .bob/rules-plan/AGENTS-plan.md (Plan moduna özgü bağlam)
  • .bob/rules-ask/AGENTS-ask.md (Ask moduna özgü bağlam)

Bu dosyalar şunları içerir:

  • Kod yapısı ve önemli dizinler
  • Teknoloji yığını ve bağımlılıklar
  • Build, test ve lint komutları
  • Kod kalıpları ve kurallar

Bu neden önemli: Bu AGENTS.md dosyaları, Bob'un her konuşmada başvurduğu bilgi tabanları olarak hizmet eder. Her seferinde tüm kod tabanını yeniden analiz etmek yerine Bob'un projen hakkında kalıcı bağlamı vardır.

Oluşturulan bağlamı inceleme

AGENTS.md'yi aç ve Bob'un ne keşfettiğini incele:

cat AGENTS.md

Projenin yapılandırılmış bir özetini göreceksin. Bob önemli ayrıntıları kaçırdıysa (iş kuralları, dağıtım kuralları, takım uygulamaları), AGENTS.md'yi düzenleyerek bunları ekle. Bu dosya özelleştirilmek üzere tasarlanmıştır.

Docs Architect modu oluşturma

Şimdi kullanıcıya yönelik dokümantasyon oluşturan özel bir mod oluştur. Bu mod, yapay zeka için değil insanlar için dokümantasyon oluşturmak üzere AGENTS.md bağlamını kullanacak.

  1. Ayarları açmak için Bob panelindeki settings simgesine tıkla.
  2. Modes sekmesini seç.
  3. Yeni bir mod oluşturmak için + simgesine tıkla.
  4. Aşağıdaki değerleri doldur:
AlanDeğer
NameDocs Architect
Slugdocs-architect
Role DefinitionYou are a documentation architect and writer who creates user-facing documentation. You work alongside AGENTS.md files (created by /init) which provide AI-readable technical context. Your role is to create human-readable documentation that complements, not duplicates, the AGENTS.md content. You focus on user needs: getting started guides, conceptual overviews, tutorials, and onboarding materials. Include code snippets with clear explanations. Add JSDoc comments (JavaScript) or Javadoc (Java) and docstrings where helpful to improve code quality.
When to useUse this mode for writing and maintaining user-facing documentation such as READMEs, onboarding guides, and API docs. Not for writing or modifying application code.
Available ToolsRead, Edit

Mode-specific Custom Instructions alanı için aşağıdakileri kopyalayıp yapıştır:

When documenting a project:
1. Review AGENTS.md files to understand project structure and technical details
2. Create user-facing documentation (READMEs, getting started guides, tutorials)
3. Avoid duplicating technical details from AGENTS.md (build commands, code patterns)
4. Focus on user workflows, conceptual overviews, and practical code examples
5. Include code blocks with clear explanations
6. Add docstrings and JSDoc comments to improve code quality

Generate:
- README.md explaining project purpose and navigation
- CONTRIBUTING.md with onboarding steps for new contributors
- Getting started guide with code snippets
- Conceptual documentation explaining architectural decisions

Kaydet'e tıkla.

Bob, .bob içinde Docs Architect mod yapılandırmasını içeren bir custom_modes.yaml dosyası oluşturur. Gelecekteki değişiklikleri yapmak için bu dosyayı doğrudan düzenleyebilirsin.

İlk dokümantasyonu oluşturma

Docs Architect moduna geç ve şunu yaz:

I've run /init to establish project context. Please create comprehensive documentation for this project:

1. Review AGENTS.md to understand the project structure
2. Create a README.md with:
   - Project overview and purpose
   - Quick start guide with code examples
   - Project structure explanation
   - Links to additional documentation
3. Create CONTRIBUTING.md with:
   - Development setup instructions
   - How to run tests
   - How to submit a pull request
   - Code style guidelines
4. Identify gaps in the codebase that need better documentation (missing docstrings, unclear functions)

Focus on making the technical details from AGENTS.md accessible to new developers.

Bob dokümantasyon dosyaları oluşturur. Doğruluk açısından incele, düzenlemeler yap, ardından commit'le:

git add AGENTS.md .bob/ README.md CONTRIBUTING.md
git commit -m "docs: initial project documentation with AI assistance"

Sonuç: Saatler değil dakikalar içinde minimal dokümantasyondan kapsamlı belgelere geçtin.

Senaryo 2: Yeni bir özelliği belgeleme

Az önce yeni bir özellik uyguladın. Kod çalışıyor, ancak README'n, katkı kılavuzun ve API belgeleriniz hâlâ projenin eski durumunu açıklıyor. Dokümantasyonun geride kaldığı en yaygın nokta budur — özellik hazır, ancak belgeler henüz yetişmedi.

Bob kullanarak bu boşluğu nasıl kapatacağın aşağıda gösterilmektedir.

Özelliği Bob'un yardımıyla yazma

Geliştirme sırasında Bob'un uygulamaya yardımcı olabilmesi için Agent moduna geç. Bob'un zaten Senaryo 1'de çalıştırdığın /init'ten proje bağlamı olduğu için, kod yapını, bağımlılıklarını ve kurallarını anlıyor — bu da önerilerini sıfırdan başlamaktan daha alakalı hale getiriyor.

Özelliği normalde yaptığın gibi yaz, kod tamamlama, yeniden düzenleme veya mevcut kod tabanı hakkında sorular sormak için Bob'u kullan.

Yapay zeka bağlamını güncellemek için /init'i yeniden çalıştırma

Özellik uygulandıktan sonra Bob'un bağlamı eskidir — yeni kodun var olmadan önce oluşturuldu. Güncelle:

/init

Bob depoyu yeniden tarar ve AGENTS.md'yi değişenleri yansıtacak şekilde günceller — yeni modüller, güncellenmiş bağımlılıklar ve algıladığı yeni kod kalıpları.

Güncellemenin değişikliklerini yakaladığını onayla:

git diff AGENTS.md .bob/

Diff yeni özelliğini gösteriyorsa Bob doğru dokümantasyon oluşturmaya hazırdır. Önemli bir şey eksikse devam etmeden önce AGENTS.md'yi manuel olarak düzenle.

Yeni özellik için dokümantasyon oluşturma

Şimdi Docs Architect moduna geç. AGENTS.md'yi yeni güncellediğin için Bob'un yeni özelliğin doğru bir resmini var ve gerçek uygulamayı yansıtan — tahmin değil — dokümantasyon oluşturabilir.

Bob'dan güncellenmesi gerekenleri iste:

I've added a new feature to the project. Please update the documentation:

1. Add a section to README.md explaining:
   - What the feature does
   - How to configure and use it
   - A code snippet showing basic usage
2. Update CONTRIBUTING.md if the development workflow has changed
3. Create a dedicated docs page that covers:
   - How the feature works
   - Relevant API endpoints or interfaces
   - Code examples for common use cases
   - Code explanations for non-obvious logic
   - Troubleshooting tips

Include code blocks with clear explanations. Add docstrings to any functions that lack them.

Oluşturulan dokümantasyonu doğruluk açısından incele — kod örneklerinin uygulamanla gerçekten eşleştiğini kontrol et — ardından her şeyi birlikte commit'le:

git add src/ AGENTS.md .bob/ README.md CONTRIBUTING.md docs/
git commit -m "feat: add [feature name] with documentation"

Sonuç: Özelliğin ve dokümantasyonu birlikte geliştirilir ve aynı pull request'te commit'lenir.

Senaryo 3: Dokümantasyon kontrolleriyle kod incelemesi

Bir takım üyesi yeni bir API endpoint'i ekleyen bir pull request gönderiyor. Dokümantasyonun güncellendiğinden emin olman gerekiyor.

Kod değişikliklerini inceleme

git diff main feature-branch

Yeni API endpoint'leri görüyorsun ama dokümantasyon güncellemesi yok.

/init'in çalıştırılıp çalıştırılmadığını kontrol etme

git diff main feature-branch -- AGENTS.md .bob/

AGENTS.md'de değişiklik yoksa geliştirici /init'i çalıştırmamıştır. Şunları yapmasını iste:

  1. Yapay zeka bağlamını güncellemek için /init çalıştırsın
  2. Kullanıcıya yönelik belgeleri güncellemek için Docs Architect'i kullansın

Eksik dokümantasyonu oluşturma

PR'yi inceliyorsan dokümantasyonu kendin oluşturabilirsin:

git checkout feature-branch

Bob'da /init çalıştır, ardından Docs Architect moduna geç:

I'm reviewing a pull request that adds new API endpoints. Please update the documentation:

1. Review the new endpoints in src/api/
2. Update README.md with a brief mention of the new endpoints
3. Update docs/api.md with:
   - Endpoint descriptions
   - Request/response examples with code blocks
   - Authentication requirements
   - Error codes
4. Add JSDoc comments to the endpoint handlers if missing

Focus on making the API easy to understand for other developers.

Dokümantasyon güncellemelerini commit'le:

git add AGENTS.md .bob/ README.md docs/api.md src/api/
git commit -m "docs: add documentation for new API endpoints"
git push

Sonuç: Dokümantasyon, kod inceleme sürecinin bir parçasıdır, sonradan düşünülen bir şey değil.

Senaryo 4: Yeni bir takım üyesini işe alıştırma

Takımına yeni bir geliştirici katılıyor. Kod tabanını hızla anlaması gerekiyor.

/init çalıştırmasını sağlama

Yeni geliştirici depoyu klonlar ve şunu çalıştırır:

/init

Bob, kod tabanının mevcut durumunu yansıtan yeni AGENTS.md dosyaları oluşturur. Yeni geliştirici artık şunları yapabilir:

  1. Proje yapısını anlamak için AGENTS.md'yi okur
  2. Başlangıç talimatları için README.md'yi okur
  3. Geliştirme iş akışı için CONTRIBUTING.md'yi okur

Keşif için Ask modunu kullanma

Yeni geliştirici kod tabanını keşfetmek için Bob'un Ask modunu kullanabilir:

@src/auth Explain how authentication works in this project
@src/api What API endpoints are available and what do they do?
@tests How do I run tests for a specific module?

Bob, AGENTS.md'deki bağlamı ve gerçek kaynak kodunu kullanarak yanıt verir.

Kişiselleştirilmiş işe alıştırma belgeleri oluşturma

Projenin işe alıştırma dokümantasyonu yoksa Docs Architect'i kullan:

Create an onboarding guide for new developers joining this project:

1. Prerequisites (tools, accounts, access)
2. Initial setup steps with code blocks
3. How to run the project locally
4. How to run tests
5. Overview of the codebase structure
6. Common development tasks with examples
7. Where to find help

Make it practical and include code snippets for each step.

Sonuç: Yeni takım üyeleri günler yerine saatler içinde hız kazanabilir.

Senaryo 5: Zaman içinde dokümantasyonu sürdürme

Projen aylardır geliştirilmektedir. Kod önemli ölçüde değişti ve dokümantasyon sapmaya başladı.

Dokümantasyon sapmasını tespit etme

Neyin değiştiğini görmek için /init'i çalıştır:

/init

Diff'i incele:

git diff AGENTS.md .bob/

Büyük değişiklikler önemli bir kod evrimi olduğuna işaret eder. Bu, kullanıcıya yönelik dokümantasyonun güncellemelere ihtiyaç duyduğunun sinyalidir.

Dokümantasyonu sistematik olarak güncelleme

Dokümantasyonu yenilemek için Docs Architect'i kullan:

I've run /init and noticed significant changes to the project structure. Please review and update the documentation:

1. Review AGENTS.md changes to understand what's different
2. Update README.md to reflect current project structure
3. Update CONTRIBUTING.md if development workflow has changed
4. Identify any new features that lack documentation
5. Remove documentation for deprecated features
6. Update code examples to match current API

Focus on accuracy—make sure documentation matches the current codebase.

Bakım takvimi oluşturma

Dokümantasyon güncellemelerini düzenli iş akışına ekle:

  • Aylık: /init çalıştır ve değişiklikleri incele
  • Sürümlerden önce: Tüm dokümantasyonu güncelle
  • Büyük yeniden düzenlemelerden sonra: Etkilenen dokümantasyonu yeniden oluştur
  • Kod incelemelerinde: /init'in çalıştırılıp çalıştırılmadığını ve belgelerin güncellenip güncellenmediğini kontrol et

Sapma tespitini otomatikleştirme (gelişmiş)

CI'da dokümantasyon hijyenini zorlamak isteyen takımlar için AGENTS.md ve .bob/'un güncel olduğunu doğrulayan bir pull request kontrolü ekle. Kontrol, /init'i branch'e karşı çalıştırır, ardından çıktı commit edilenden farklıysa başarısız olur — geliştiricinin PR'yi açmadan önce yapay zeka bağlamını güncellemeyi unuttuğunu sinyalleyerek. Bunu en iyi uygulamalar bölümündeki PR şablonu kontrol listesiyle birleştirerek dokümantasyon güncellemelerini inceleme sürecinin zorunlu bir parçası haline getir.

Sonuç: Dokümantasyon, düzenli bakım sayesinde kodla senkronize kalır.

Yapay zeka kod dokümantasyon iş akışları için en iyi uygulamalar

/init'i geliştirme sürecine entegre etme

/init'i iş akışının düzenli bir parçası haline getir:

  • Yeni modüller veya özellikler ekledikten sonra çalıştır
  • Büyük yeniden düzenlemelerden sonra çalıştır
  • Pull request oluşturmadan önce çalıştır
  • Aktif projeler için aylık olarak çalıştır

Yapay zeka bağlamını ve kullanıcı belgelerini birlikte commit etme

AGENTS.md dosyalarını her zaman kullanıcıya yönelik dokümantasyonla birlikte commit'le:

git add AGENTS.md .bob/ README.md docs/
git commit -m "docs: update for [feature/change]"

Bu, her iki katmanı sürüm kontrol sisteminde senkronize tutar ve deposunu Mintlify gibi Markdown kaynak dosyalarından API dokümantasyonu oluşturan araçlar için kendi kendini belgeleyen hale getirir.

Yapay zeka tarafından oluşturulan belgeleri taslak olarak ele alma

Yapay zeka destekli kod dokümantasyon araçları başlangıç noktaları oluşturur, nihai ürünler değil. Her zaman:

  • Doğruluk açısından gözden geçir
  • Kod örneklerinin çalışıp çalışmadığını kontrol et
  • Teknik ayrıntıları doğrula
  • Ton ve stili ayarla
  • Yapay zekanın kaçırabileceği bağlamı ekle

Hassasiyet için bağlam bahslerini kullanma

Dokümantasyonun belirli bölümlerini güncellerken @ bahslerini kullan:

@src/auth @docs/authentication.md Update the authentication documentation to reflect the new OAuth flow

Bu, Bob'un ilgili koda ve dokümantasyona odaklanmasına yardımcı olur.

Dokümantasyonu kod incelemelerine dahil etme

Pull request şablonuna dokümantasyon kontrolleri ekle:

## Documentation Checklist
- [ ] Ran `/init` to update AGENTS.md
- [ ] Updated README if user-facing changes
- [ ] Updated API docs if endpoints changed
- [ ] Added code examples for new features
- [ ] Verified all code snippets work

Docstring'lerle kod kalitesini koruma

Docstring'ler ve JSDoc yorumları eklemek için Bob'u kullan:

@src/api Review all functions in this directory and add JSDoc comments to any that lack them. Include parameter types, return types, and usage examples.

Bu hem kod kalitesini hem de dokümantasyonu geliştirir.

Yaygın senaryoları giderme

Dokümantasyon kodla eşleşmiyor

Sorun: Oluşturulan dokümantasyon var olmayan özellikleri açıklıyor veya son değişiklikleri kaçırıyor.

Çözüm:

  1. Yapay zeka bağlamını güncellemek için /init çalıştır
  2. Bob'un ne tespit ettiğini görmek için AGENTS.md değişikliklerini incele
  3. Etkilenen dokümantasyonu Docs Architect ile yeniden oluştur
  4. Kod örneklerinin çalışıp çalışmadığını manuel olarak doğrula

/init önemli bağlamı kaçırıyor

Sorun: AGENTS.md'de iş kuralları veya dağıtım kuralları gibi projeye özgü ayrıntılar eksik.

Çözüm: /init'in tespit edemediği bağlamı eklemek için AGENTS.md'yi manuel olarak düzenle. Bu dosya özelleştirilmek üzere tasarlanmıştır.

Dokümantasyon güncellemeleri çok uzun sürüyor

Sorun: Büyük projeler için dokümantasyonu yeniden oluşturmak zaman alıcıdır.

Çözüm: Belirli bölümleri güncellemek için bağlam bahslerini kullan:

@docs/api.md @src/api/users.ts Update only the user API documentation to reflect the new endpoints

Takım üyeleri belgeleri güncellemeyi unutuyor

Sorun: Pull request'lerde dokümantasyon güncellemeleri eksik.

Çözüm:

  • PR şablonuna dokümantasyon kontrolleri ekle
  • /init'in çalıştırıldığını doğrulayan CI kontrolleri kur
  • Dokümantasyon incelemesini kod inceleme sürecinin bir parçası haline getir

Yapay zeka yanlış kod örnekleri oluşturuyor

Sorun: Dokümantasyondaki kod parçacıkları çalışmıyor veya kullanımdan kaldırılmış API'leri kullanıyor.

Çözüm:

  • Oluşturulan kod örneklerini her zaman test et
  • Bob'u mevcut koda yönlendirmek için bağlam bahslerini kullan: @src/api/current-implementation.ts
  • Doğruluğu vurgulamak için Docs Architect modu talimatlarını güncelle

Sonraki adımlar

IBM Bob kullanarak yapay zeka kod dokümantasyonunun pratikte nasıl çalıştığını öğrendin. Şunları nasıl yapacağını gördün:

  • /init'i geliştirme iş akışına entegre etme
  • Kullanıcıya yönelik dokümantasyon oluşturmak için özel modlar kullanma
  • Özellik geliştirme ve kod incelemeleri sırasında dokümantasyonu sürdürme
  • Dokümantasyonu kod değişiklikleriyle senkronize tutma

Bu iş akışını projelerine uygulama

  1. Bununla başla /init: Mevcut projen üzerinde çalıştır
  2. Modunu oluştur: Docs Architect'i takımının ihtiyaçlarına göre özelleştir
  3. Geliştirirken belgele: Belgelerini kod değişiklikleriyle birlikte güncelle
  4. PR'lerde incele: Dokümantasyonu kod incelemesinin bir parçası haline getir
  5. Düzenli olarak sürdür: Aylık /init çalıştırmalarını planla
Bu konu nasıl?

Bu sayfada

Ne başarırsınÖn koşullarYapay zeka kod dokümantasyonu pratikte nasıl çalışırYapay zeka dokümantasyon iş akışıGerçek dünya senaryolarıSenaryo 1: İlk proje dokümantasyonuÇalışma alanını kurma/init ile yapay zeka tarafından okunabilir bağlam oluşturmaOluşturulan bağlamı incelemeDocs Architect modu oluşturmaİlk dokümantasyonu oluşturmaSenaryo 2: Yeni bir özelliği belgelemeÖzelliği Bob'un yardımıyla yazmaYapay zeka bağlamını güncellemek için /init'i yeniden çalıştırmaYeni özellik için dokümantasyon oluşturmaSenaryo 3: Dokümantasyon kontrolleriyle kod incelemesiKod değişikliklerini inceleme/init'in çalıştırılıp çalıştırılmadığını kontrol etmeEksik dokümantasyonu oluşturmaSenaryo 4: Yeni bir takım üyesini işe alıştırma/init çalıştırmasını sağlamaKeşif için Ask modunu kullanmaKişiselleştirilmiş işe alıştırma belgeleri oluşturmaSenaryo 5: Zaman içinde dokümantasyonu sürdürmeDokümantasyon sapmasını tespit etmeDokümantasyonu sistematik olarak güncellemeBakım takvimi oluşturmaSapma tespitini otomatikleştirme (gelişmiş)Yapay zeka kod dokümantasyon iş akışları için en iyi uygulamalar/init'i geliştirme sürecine entegre etmeYapay zeka bağlamını ve kullanıcı belgelerini birlikte commit etmeYapay zeka tarafından oluşturulan belgeleri taslak olarak ele almaHassasiyet için bağlam bahslerini kullanmaDokümantasyonu kod incelemelerine dahil etmeDocstring'lerle kod kalitesini korumaYaygın senaryoları gidermeDokümantasyon kodla eşleşmiyor/init önemli bağlamı kaçırıyorDokümantasyon güncellemeleri çok uzun sürüyorTakım üyeleri belgeleri güncellemeyi unutuyorYapay zeka yanlış kod örnekleri oluşturuyorSonraki adımlarBu iş akışını projelerine uygulama