# Kural sistemleri ve davranış yönlendirmesi (/tr/docs/verdent-for-vscode/agents-rules/rule-systems)

> Verdent'in davranışını kural sistemleri aracılığıyla kontrol etme



Kural dosyaları, Verdent'in kodlama oturumları sırasında nasıl davrandığını ve yanıt verdiğini tanımlayan Markdown belgeleridir. Yapay zeka aracısının davranışını, çıktı biçimlendirmesini, karar alma sürecini ve proje standartlarına uyumunu yönlendirir.

**Amaç:** Kurallar, kodu veya ayarları değiştirmeden Verdent'in davranışını özelleştirmenize olanak tanır. Oturumlar boyunca kalıcı olan kodlama kurallarını, tercih edilen kalıpları, iletişim tarzını ve görev yürütme tercihlerini belirlerler.

**Kurallar nasıl çalışır:** Verdent konuşmalar sırasında kural dosyalarına sürekli başvurur ve yönergeleri kod üretimine, analize, dokümantasyona ve karar almaya uygular. Kurallar, kullanıcı tercihleriyle tutarlılığı sağlamak için her aracı yanıtını etkiler.

**Üç kategori:**

* **Genel tercihler** (VERDENT.md) - Kişisel kodlama tarzı, dil tercihleri
* **Projeye özgü standartlar** (AGENTS.md) - Ekip kuralları, mimari kalıplar
* **Plan özelleştirmesi** (Plan.md) - Plan Mode çıktı biçimi ve içeriği

**Kural önceliği:** Kurallar çakıştığında Verdent şu önceliği uygular: **AGENTS.md** (en yüksek) → **VERDENT.md** (orta) → **varsayılanlar** (en düşük)

***

## Kullanıcı kuralları (VERDENT.md) [#kullanıcı-kuralları-verdentmd]

VERDENT.md, tüm projeler ve oturumlar genelinde geçerli olan genel tercihleri tanımlar. Kişisel kodlama tarzını, tercih edilen araçları, iletişim tercihlerini ve varsayılan davranışları belirler.

### Konum ve kapsam [#konum-ve-kapsam]

**Dosya konumu:** `~/.verdent/VERDENT.md`

**Kapsam:** Tüm projeler için geneldir

**Erişim:**

* Settings → Rules → User Rules
* `~/.verdent/VERDENT.md` konumunda doğrudan dosya düzenleme

**Değişiklikler ne zaman etkili olur:** Kurallar yeni konuşmalarda hemen uygulanır ve mevcut konuşma yanıtlarını etkiler.

***

### Kullanım senaryoları [#kullanım-senaryoları]

<Tabs>
  <Tab title="Kodlama tercihleri">
    **Kodlama tercihleri**

    * Girinti stili (2 boşluk, 4 boşluk, sekme)
    * Adlandırma kuralları (camelCase, snake\_case, PascalCase)
    * Tercih edilen dil özellikleri (ES6+, TypeScript strict mode, tip ipuçları)

    Kişisel kodlama tarzınızı ve tüm projeler genelinde uygulanan kuralları tanımlayın.
  </Tab>

  <Tab title="Çıktı dili">
    **Çıktı dili**

    * Varsayılan yanıt dili (örneğin, "Her zaman İspanyolca yanıt ver")
    * Teknik terim yönetimi ("Fransızca karşılığı olmadığında İngilizce terimleri kullan")

    Verdent'in yanıtlarında ve açıklamalarında kullandığı dili kontrol edin.
  </Tab>

  <Tab title="Kod yorumları">
    **Kod yorumları**

    * Tercih edilen ayrıntı düzeyi ("Ayrıntılı yorumlar" veya "Yalnızca minimal yorumlar")
    * Yorum dili ("Yorumları Fransızca yaz")

    Kodun ne kadar ve hangi dilde yorumlanması gerektiğini belirtin.
  </Tab>

  <Tab title="Dokümantasyon">
    **Dokümantasyon stili**

    * Kodun nasıl belgelendirileceği (JSDoc, TSDoc, docstring'ler)
    * Dokümantasyona kullanım örnekleri ekleme

    API dokümantasyonu ve kod dokümantasyonu biçimi için standartlar belirleyin.
  </Tab>

  <Tab title="İletişim">
    **İletişim**

    * Yanıtların tonu ve ayrıntı düzeyi ("Kısa açıklamalar" veya "Ayrıntılı açıklamalar")
    * Açıklama stili ("Önce kodu göster, sonra açıkla")

    Verdent'in sizinle nasıl iletişim kurduğunu ve bilgileri nasıl sunduğunu özelleştirin.
  </Tab>
</Tabs>

***

### Biçim ve sözdizimi [#biçim-ve-sözdizimi]

VERDENT.md, madde işaretleri veya numaralı listelerle düz Markdown biçimi kullanır.

**Yapı:**

```markdown
# User Rules

## Code Style Preferences
- Always use TypeScript strict mode
- Prefer functional components in React
- Include JSDoc comments for exported functions

## Documentation
- Add JSDoc comments for all exported functions
- Include usage examples in component documentation

## Communication
- Provide explanations before showing code
- Highlight breaking changes explicitly
```

**Yazım stili:**

* Açık, yönlendirici dil kullanın ("Her zaman kullan...", "Tercih et...", "Asla...")
* Başlıklarla mantıksal bölümlere ayırın
* Tek tek kurallar için madde işaretleri kullanın
* İstenen davranış hakkında spesifik olun

***

### Geliştirici türüne göre örnekler [#geliştirici-türüne-göre-örnekler]

<Tabs>
  <Tab title="TypeScript">
    ```markdown
    # User Rules

    ## TypeScript Preferences
    - Use strict mode in tsconfig.json
    - Prefer interfaces over type aliases for object shapes
    - Include return types on all functions
    - Use const assertions where appropriate

    ## Code Organization
    - One component per file
    - Named exports instead of default exports
    - Organize imports: external, internal, types

    ## Documentation
    - TSDoc comments for public APIs
    - Include @param and @returns tags
    ```

    **Uygulama:** Verdent'ten yeni bir React bileşeni oluşturmasını istediğinizde otomatik olarak şunları yapar:

    * Strict mode ile TypeScript kullanır
    * Adlandırılmış bir export oluşturur (varsayılan değil)
    * @param/@returns etiketleriyle TSDoc yorumları ekler
    * İçe aktarmaları kategoriye göre düzenler
  </Tab>

  <Tab title="Python veri bilimi">
    ```markdown
    # User Rules

    ## Python Style
    - Follow PEP 8 conventions
    - Use type hints for function signatures
    - Prefer list comprehensions over map/filter

    ## Data Analysis
    - Use pandas for data manipulation
    - Include DataFrame.head() after transformations
    - Document assumptions about data

    ## Output Format
    - Show shape and info() after operations
    - Include visualization examples
    ```

    **Uygulama:** Verdent'ten veri analizi kodu yazmasını istediğinizde şunları yapar:

    * Veri işlemleri için pandas kullanır
    * Tüm fonksiyonlara tip ipuçları ekler
    * Dönüşümlerden sonra DataFrame.head() ve shape gösterir
    * Veri varsayımlarını belgeleyen satır içi yorumlar ekler
  </Tab>

  <Tab title="Full-Stack JS">
    ```markdown
    # User Rules

    ## JavaScript Preferences
    - Use ES6+ features (arrow functions, destructuring)
    - Async/await over promises
    - Template literals for string interpolation

    ## Testing
    - Jest for unit tests
    - Include test cases for edge conditions
    - Aim for 80%+ code coverage

    ## Code Review
    - Flag potential performance issues
    - Suggest security improvements
    ```

    **Uygulama:** Verdent şunları yapar:

    * ES6+ sözdizimiyle modern JavaScript yazar
    * Promise zincirleri yerine async/await kullanır
    * %80 kapsama hedefleyen Jest testleri üretir
    * Performans ve güvenlik endişelerini proaktif olarak tespit eder
  </Tab>

  <Tab title="Çok dilli">
    ```markdown
    # User Rules

    ## Communication
    - Always respond in French
    - Use technical English terms when no French equivalent exists
    - Provide French variable/function names when appropriate

    ## Code Comments
    - Write comments in French
    - Documentation in both French and English
    ```

    **Uygulama:** Tüm Verdent yanıtları Fransızca olur, uygun yerlerde teknik terimler İngilizce kalır. Kod yorumları ve dokümantasyon dil tercihlerinizi takip eder.
  </Tab>

  <Tab title="Minimalist">
    ```markdown
    # User Rules

    ## Code Style
    - Minimal comments - code should be self-documenting
    - Short, focused functions (< 20 lines)
    - Avoid unnecessary abstractions

    ## Output Preferences
    - Brief explanations
    - Show code first, explain after
    - No verbose documentation unless requested
    ```

    **Uygulama:** Verdent şunları yapar:

    * Özlü, kendi kendini belgeleyen kod üretir
    * Fonksiyonları 20 satırın altında tutar
    * Kodu gösterdikten sonra kısa açıklamalar sunar
    * Açıkça istemediğiniz sürece ayrıntılı yorumlardan kaçınır
  </Tab>
</Tabs>

***

### Nasıl oluşturulur ve düzenlenir [#nasıl-oluşturulur-ve-düzenlenir]

<Tabs>
  <Tab title="Ayarlar menüsü">
    **Çoğu kullanıcı için önerilir**

    1. Verdent üst çubuğundaki **Settings** düğmesine tıklayın
    2. Açılır menüden **Rules** öğesini seçin
    3. **User Rules** öğesini seçin
    4. Dosya VS Code düzenleyicisinde açılır
    5. Markdown biçimini kullanarak düzenleyin
    6. Dosyayı kaydedin (`Cmd+S` / `Ctrl+S`)

    Bu yöntem dosyayı otomatik olarak bulur ve varsayılan düzenleyicinizde açar.
  </Tab>

  <Tab title="Doğrudan dosya düzenleme">
    **İleri düzey kullanıcılar için önerilir**

    1. `~/.verdent/VERDENT.md` konumuna gidin
    2. Herhangi bir metin düzenleyicide açın
    3. Markdown içeriğini düzenleyin
    4. Değişiklikleri kaydedin

    Yapılandırma dosyalarıyla doğrudan çalışmayı tercih ediyorsanız bu yöntem daha hızlıdır.
  </Tab>
</Tabs>

***

## Proje kuralları (AGENTS.md) [#proje-kuralları-agentsmd]

AGENTS.md, mevcut proje için aracı davranışını kontrol eden projeye özgü kuralları tanımlar. Projeye özgü ekip kodlama standartlarını, mimari kalıpları, test gereksinimlerini ve geliştirme iş akışlarını belirler.

### Konum ve kapsam [#konum-ve-kapsam-1]

**Dosya konumu:** Proje kök dizini

**Kapsam:** Yalnızca mevcut proje

**Sürüm kontrolü:** Ekip genelinde paylaşım için git'e işlenebilir

**Erişim:**

* Settings → Rules → Project Rules
* `<project-root>/AGENTS.md` konumunda doğrudan düzenleme

***

### Kullanım senaryoları [#kullanım-senaryoları-1]

<Tabs>
  <Tab title="Ekip kuralları">
    **Ekip kuralları**

    Tüm ekip üyelerinin uyduğu paylaşılan kodlama standartları:

    * Ekip genelinde tutarlı girinti
    * Bileşenler/fonksiyonlar için adlandırma kuralları
    * Dosya organizasyon kalıpları

    Tüm geliştirme ekibi genelinde tutarlı kodlama tarzını zorunlu kılın.
  </Tab>

  <Tab title="Mimari">
    **Mimari kalıplar**

    Projeye özgü tasarım kalıpları:

    * MVC, mikro hizmetler, monorepo yapısı
    * Durum yönetimi yaklaşımı (Redux, Context, Zustand)
    * API tasarım kalıpları (REST, GraphQL)

    Proje için mimari kararları ve kalıpları tanımlayın.
  </Tab>

  <Tab title="Test">
    **Test gereksinimleri**

    Beklenen test kapsamı ve çerçeveler:

    * Minimum kapsam eşikleri (%80, %90)
    * Test çerçeveleri (Jest, pytest, Vitest)
    * Test dosyası adlandırma kuralları

    Proje için test standartları ve kalite kapıları belirleyin.
  </Tab>

  <Tab title="İş akışları">
    **Geliştirme iş akışları**

    Derleme komutları, dağıtım prosedürleri, PR yönergeleri:

    * Testlerin nasıl çalıştırılacağı (`pnpm test`, `npm run test`)
    * Belirli paketler için derleme komutları
    * PR başlığı biçim gereksinimleri

    Ekip iş akışlarını ve geliştirme prosedürlerini belgeleyin.
  </Tab>

  <Tab title="Teknoloji">
    **Teknoloji kısıtlamaları**

    Onaylanmış kütüphaneler ve çerçeve sürümleri:

    * İzin verilen bağımlılıklar
    * Çerçeve sürüm gereksinimleri
    * Platform desteği (iOS 14+, Android API 26+)

    Teknoloji yığını seçimlerini kontrol edin ve tutarlılığı koruyun.
  </Tab>
</Tabs>

**Ekip iş birliği:** AGENTS.md proje kökünde saklanır ve sürüm kontrolüne işlenebilir, böylece tüm ekip üyelerinin tutarlı aracı davranışıyla çalışması sağlanır.

<Tip>
  Tüm ekip üyeleri genelinde tutarlı yapay zeka davranışı sağlamak için AGENTS.md'yi sürüm kontrolü aracılığıyla ekibinizle paylaşın.
</Tip>

***

### Biçim ve sözdizimi [#biçim-ve-sözdizimi-1]

AGENTS.md, VERDENT.md'ye benzer şekilde yapılandırılmış bölümler ve madde işaretleriyle Markdown biçimi kullanır, ancak projeye özgü gereksinimlere odaklanır.

**Yapı:**

```markdown
# AGENTS.md

## Dev environment tips
- Command for navigating workspace
- Installation commands
- Environment setup instructions

## Testing instructions
- Test execution commands
- Coverage requirements
- CI/CD integration details

## PR instructions
- Title format requirements
- Pre-commit checklist
- Review guidelines
```

**Yazım stili:**

* Buyurgan, yönlendirici dil
* İş akışı alanına göre düzenlenmiş (geliştirme, test, dağıtım)
* Spesifik komutlar ve prosedürler
* Kişisel tercihler değil, ekip genelinde standartlar

***

### Proje türüne göre örnekler [#proje-türüne-göre-örnekler]

<Tabs>
  <Tab title="Monorepo">
    ```markdown
    # AGENTS.md

    ## Dev environment tips
    - Use `pnpm dlx turbo run where <project_name>` to jump to a package
    - Run `pnpm install --filter <project_name>` to add package to workspace
    - Check the name field in package.json to confirm the right name

    ## Testing instructions
    - Run `pnpm turbo run test --filter <project_name>` for all checks
    - From package root: `pnpm test`
    - Focus on one test: `pnpm vitest run -t "<test name>"`
    - Fix all errors before merge

    ## PR instructions
    - Title format: [<project_name>] <Title>
    - Always run `pnpm lint` and `pnpm test` before committing
    ```

    **Uygulama:** Bu monorepo üzerinde çalışırken Verdent şunları yapar:

    * Gezinme ve test için turbo komutlarını kullanır
    * PR başlıklarını proje adı ön ekiyle biçimlendirir
    * Commit önermeden önce lint ve test komutlarını çalıştırır
  </Tab>

  <Tab title="React/TypeScript">
    ```markdown
    # AGENTS.md

    ## Code Standards
    - Use functional components with hooks
    - TypeScript strict mode required
    - Named exports only (no default exports)
    - PropTypes or TypeScript interfaces for all components

    ## File Organization
    - One component per file
    - Components in `src/components/`
    - Hooks in `src/hooks/`
    - Utils in `src/utils/`

    ## Testing
    - Jest + React Testing Library
    - Test all user interactions
    - 80%+ coverage required
    ```

    **Uygulama:** Verdent'in oluşturduğu tüm React bileşenleri şunları yapar:

    * Hook'larla fonksiyonel bileşenler kullanır
    * TypeScript arabirimleri içerir
    * Doğru dizine yerleştirilir
    * %80 kapsama hedefleyen Jest testleri içerir
  </Tab>

  <Tab title="Backend API">
    ```markdown
    # AGENTS.md

    ## API Standards
    - All endpoints include input validation
    - Use async/await for asynchronous operations
    - Consistent error format: { error: string, code: number }
    - Rate limiting on public endpoints

    ## Security
    - Never log sensitive data (passwords, tokens, PII)
    - Parameterized queries only (prevent SQL injection)
    - Validate and sanitize all inputs

    ## Testing
    - Unit tests for all business logic
    - Integration tests for API endpoints
    - Test success and error cases
    ```

    **Uygulama:** API uç noktaları oluştururken Verdent şunları yapar:

    * Girdi doğrulamasını otomatik olarak ekler
    * Veritabanı işlemleri için parametreli sorgular kullanır
    * Hem başarı hem de hata durumları için testler üretir
    * Hassas verileri günlüğe kaydetmekten kaçınır
  </Tab>

  <Tab title="Mobil uygulama">
    ```markdown
    # AGENTS.md

    ## Platform Support
    - iOS 14+ and Android API 26+
    - React Native 0.72+
    - Test on both platforms before PR

    ## State Management
    - Use Redux Toolkit
    - Async operations with Redux Thunk
    - Normalize state shape

    ## Performance
    - Images: WebP format, max 500KB
    - Bundle size: monitor with bundle analyzer
    - FlatList for long lists (>20 items)
    ```

    **Uygulama:** Mobil uygulama kodu şunları yapar:

    * Minimum platform sürümlerini destekler
    * Durum için Redux Toolkit kullanır
    * Görüntüleri WebP biçimine optimize eder
    * Uzun listelerde performans için FlatList kullanır
  </Tab>

  <Tab title="Python Django">
    ```markdown
    # AGENTS.md

    ## Django Conventions
    - Follow Django best practices and PEP 8
    - Class-based views preferred
    - Django ORM for database operations
    - Migrations: never edit generated files

    ## Testing
    - pytest-django for all tests
    - Factory Boy for test fixtures
    - Coverage must be 90%+

    ## Deployment
    - Docker compose for local development
    - Environment variables in .env (never committed)
    - Run migrations before deployment
    ```

    **Uygulama:** Django kodu şunları yapar:

    * Sınıf tabanlı görünümler kullanır
    * Ham SQL yerine Django ORM kullanır
    * Factory Boy fixture'larıyla pytest testleri üretir
    * %90+ test kapsamı hedefler
  </Tab>
</Tabs>

***

### VERDENT.md'den farkları [#verdentmdden-farkları]

**Kapsam:**

* **VERDENT.md:** Tüm projeler genelinde kişisel tercihler
* **AGENTS.md:** Yalnızca belirli proje için ekip standartları

**Öncelik:**

* **AGENTS.md:** Daha yüksek öncelik - proje tutarlılığı için user\_rules'u geçersiz kılar
* **VERDENT.md:** Daha düşük öncelik - hiçbir proje kuralı çakışmadığında uygulanır

**İçerik odağı:**

* **VERDENT.md:** Bireysel kodlama tarzı, iletişim tercihleri, kişisel araçlar
* **AGENTS.md:** Ekip kuralları, proje mimarisi, paylaşılan iş akışları, teknoloji yığını

**Sürüm kontrolü:**

* **VERDENT.md:** Paylaşılmaz - bireyin makinesinde kalır
* **AGENTS.md:** git'e işlenir - tüm ekiple paylaşılır

**Depolama:**

* **VERDENT.md:** `~/.verdent/VERDENT.md` (genel)
* **AGENTS.md:** Proje kök dizini (projeye özgü)

**Örnek çakışma çözümü:**

```
VERDENT.md: "I prefer 2-space indentation"
AGENTS.md: "This project uses 4-space indentation"
→ Result: 4-space indentation (team standard wins)
```

**Hangisi ne zaman kullanılır:**

* **VERDENT.md:** Tüm projeler genelinde istediğiniz kişisel tercihler
* **AGENTS.md:** Tüm ekibin bu proje için uyması gereken standartlar

***

## Plan kuralları (Plan.md) [#plan-kuralları-planmd]

Plan.md, Plan Mode'da üretilen planların içeriğini ve biçimini özelleştirir. Plan ayrıntı düzeyini, dahil edilen bölümleri, biçimlendirme tercihlerini ve görüntülenen bilgileri kontrol eder.

### Konum ve kapsam [#konum-ve-kapsam-2]

**Dosya konumu:** \~/.verdent/plan\_settings.json

**Kapsam:** Tüm projeler için geneldir

**Uygulama:** Yalnızca Plan Mode sırasında plan üretilirken uygulanır

**Erişim:**

* Settings → Rules → Plan Rules
* \~/.verdent/plan\_settings.json konumunda doğrudan dosya düzenleme

***

### Kullanım senaryoları [#kullanım-senaryoları-2]

<Tabs>
  <Tab title="Plan yapısı">
    **Plan yapısı**

    Dahil edilecek bölümleri tanımlayın:

    * Özet, ön koşullar, adımlar, doğrulama
    * Risk değerlendirmesi, geri alma prosedürleri
    * Süre tahminleri, kritik yol

    Her planda hangi bölümlerin ve bilgilerin görüneceğini kontrol edin.
  </Tab>

  <Tab title="Ayrıntı düzeyi">
    **Ayrıntı düzeyi**

    Ayrıntı derecesini kontrol edin:

    * Üst düzey genel bakış (her biri 1-2 saatlik aşamalar)
    * Ayrıntılı uygulama adımları (15-30 dakikalık görevler)
    * Fonksiyon düzeyinde ayrıntılar (imzalar, dosya yolları)

    Uygulama planlarının ne kadar ayrıntılı ve spesifik olması gerektiğini ayarlayın.
  </Tab>

  <Tab title="Biçim">
    **Biçim tercihleri**

    Sunum stilini seçin:

    * Numaralı listeler veya madde işaretleri
    * Kod parçacıkları veya açıklamalar
    * Diyagramlar (sözlü olarak açıklanmış)

    Plan bilgilerinin nasıl biçimlendirileceğini ve görüntüleneceğini özelleştirin.
  </Tab>

  <Tab title="Bilgi">
    **Bilgi dahil etme**

    Ek öğeleri belirtin:

    * Satır içi süre tahminleri
    * Risk seviyeleri (düşük/orta/yüksek)
    * Ekip iş birliği için rol atamaları
    * Vurgulanan test gereksinimleri

    Planları daha uygulanabilir hale getirmek için bağlam ve meta veri ekleyin.
  </Tab>
</Tabs>

***

### Biçim ve sözdizimi [#biçim-ve-sözdizimi-2]

Plan.md, istenen plan yapısını ve içeriğini açıklayan bölümlerle Markdown biçimi kullanır.

**Yapı:**

```markdown

---
name: Plan Rules
version: 1.0.0
last_updated: 2025-11-26
---

## Plan Structure
- Start with brief summary (2-3 sentences)
- Include estimated time for each major step
- List prerequisites before implementation steps
- Identify potential risks

## Level of Detail
- Break tasks into subtasks of 15-30 minutes
- Include specific file paths for modifications
- List functions/components to create/modify

## Format
- Use numbered lists for sequential steps
- Use bullet points for options
- Include code snippets for complex changes
```

***

### Planlama stiline göre örnekler [#planlama-stiline-göre-örnekler]

<Tabs>
  <Tab title="Ayrıntılı teknik">
    ```markdown
    ---
    name: Detailed Technical
    version: 1.0.0
    last_updated: 2025-11-26
    ---

    ## Plan Structure
    - Executive summary (2-3 sentences)
    - Prerequisites and dependencies
    - Numbered implementation steps
    - Testing and verification strategy
    - Rollback procedures

    ## Level of Detail
    - Break into 20-30 minute tasks
    - Specific file paths for all modifications
    - Function signatures for new code
    - Database schema changes with migration steps

    ## Format
    - Numbered lists for sequence
    - Code blocks for complex logic
    - Diagrams for architecture changes (describe verbally)
    ```

    **Uygulama:** Planlar şunları içerir:

    * En üstte yönetici özeti
    * 20-30 dakikalık görev dökümleri
    * `src/components/Auth/Login.tsx` gibi spesifik dosya yolları
    * `async function authenticateUser(credentials: UserCredentials): Promise<AuthResult>` gibi fonksiyon imzaları
    * Test ve geri alma prosedürleri
  </Tab>

  <Tab title="Üst düzey stratejik">
    ```markdown
    ---
    name: High-Level Strategic
    version: 1.0.0
    last_updated: 2025-11-26
    ---

    ## Plan Structure
    - Brief overview (1 paragraph)
    - Major phases only (3-5 high-level steps)
    - Key decisions and trade-offs
    - Success criteria

    ## Level of Detail
    - High-level phases (1-2 hours each)
    - Avoid implementation specifics
    - Focus on approach and strategy

    ## Format
    - Bullet points for flexibility
    - Minimal code examples
    - Emphasize "why" over "how"
    ```

    **Uygulama:** Planlar üst düzey olur ve şunlara odaklanır:

    * 3-5 ana aşamada stratejik yaklaşım
    * Uygulama ayrıntıları yerine "neden" açıklamaları
    * Karar noktaları ve dengeleme noktaları
    * Spesifik uygulama olmadan başarı kriterleri
  </Tab>

  <Tab title="Süre odaklı">
    ```markdown
    ---
    name: Time-Conscious
    version: 1.0.0
    last_updated: 2025-11-26
    ---

    ## Plan Structure
    - Time estimates for each step
    - Total project duration estimate
    - Parallel tasks identified
    - Critical path highlighted

    ## Level of Detail
    - Tasks sized to 30-minute increments
    - Dependencies clearly marked
    - Blocking operations identified

    ## Format
    - Include time estimates inline
    - Mark parallel tasks
    - Highlight critical path with bold
    ```

    **Uygulama:** Planlar şunları içerir:

    * Süre tahminli her adım: "Kimlik doğrulama ara yazılımı oluştur (45 dakika)"
    * Toplam süre: "Tahmini toplam: 6 saat"
    * İşaretlenmiş paralel görevler: "Adım 3 ile paralel yapılabilir"
    * Engelleyici işlemleri göstermek için kalın yazılmış kritik yol
  </Tab>

  <Tab title="Risk odaklı">
    ```markdown
    ---
    name: Risk-Focused
    version: 1.0.0
    last_updated: 2025-11-26
    ---

    ## Plan Structure
    - Risk assessment for each phase
    - Mitigation strategies included
    - Rollback procedures defined
    - Testing requirements emphasized

    ## Level of Detail
    - Identify potential failure points
    - Document error handling approach
    - Include recovery procedures

    ## Format
    - Risk levels: low, medium, high
    - Separate "Risks" section for each phase
    - Mitigation steps in sub-bullets
    ```

    **Uygulama:** Her aşama şunları içerir:

    * Risk değerlendirmesi: "Risk: yüksek (üretimde veritabanı taşıması)"
    * Azaltma: "Önce staging üzerinde taşımayı çalıştır, test sorgularıyla doğrula"
    * Geri alma: "Sorun oluşursa taşımayı down script ile geri al"
  </Tab>

  <Tab title="Ekip iş birliği">
    ```markdown
    ---
    name: Team Collaboration
    version: 1.0.0
    last_updated: 2025-11-26
    ---

    ## Plan Structure
    - Role assignments for each task
    - Coordination points identified
    - Review checkpoints included
    - Communication requirements

    ## Level of Detail
    - Specify who handles each component
    - List integration points between team members
    - Include pair programming opportunities

    ## Format
    - Use mentions for role assignments
    - Mark collaboration points
    - Include "Review required" markers
    ```

    **Uygulama:** Planlar şunları belirtir:

    * "Backend API (Backend ekibi): Kimlik doğrulama uç noktaları oluştur"
    * "Entegrasyon noktası: Frontend ekibi backend'den gelen API spesifikasyonunu bekler"
    * "İnceleme gerekli: Birleştirmeden önce güvenlik ekibi incelemesi"
  </Tab>
</Tabs>

***

### Plan kuralları ne zaman uygulanır? [#plan-kuralları-ne-zaman-uygulanır]

**Plan kuralları uygulaması:**

* **Zamanlama:** Yalnızca Plan Mode sırasında plan üretilirken uygulanır
* **Kapsam:** Kod üretimini değil, plan biçimini ve içeriğini kontrol eder
* **Bağımsızlık:** VERDENT.md veya AGENTS.md ile çakışmaz

**Diğer kural türleri uygulaması:**

* **VERDENT.md:** Tüm modlarda (Agent, Plan, Chat) sürekli uygulanır
* **AGENTS.md:** Projeye özgü davranış için tüm modlarda sürekli uygulanır

**Etkileşim örneği:**

```
Plan Mode activated:
1. VERDENT.md: "Use TypeScript" → Applied to code in plan
2. AGENTS.md: "Follow project conventions" → Applied to approach
3. plan_rules.md: "Include time estimates" → Applied to plan format
→ Result: Plan shows TypeScript code following project conventions with time estimates
```

**Moda özgü davranış:**

* **Agent Mode:** VERDENT.md + AGENTS.md uygulanır (plan\_rules.md yok)
* **Plan Mode:** VERDENT.md + AGENTS.md + Plan.md tümü uygulanır
* **Chat Mode:** VERDENT.md + AGENTS.md uygulanır (Plan.md yok)

***

## Kural önceliği ve çakışma çözümü [#kural-önceliği-ve-çakışma-çözümü]

Kurallar çakıştığında Verdent tutarlı davranış sağlamak için öncelik uygular.

### Öncelik sırası [#öncelik-sırası]

**1. Proje kuralları (AGENTS.md) - En yüksek öncelik** Projeye özgü kurallar genel tercihleri geçersiz kılar. Ekip standartları, tutarlılık için bireysel tercihlere göre öncelik kazanır.

**2. Kullanıcı kuralları (VERDENT.md) - Orta öncelik** Hiçbir projeye özgü kural çakışmadığında genel tercihler uygulanır.

**3. Varsayılan davranış - En düşük öncelik** Hiçbir kural belirtilmediğinde Verdent'in yerleşik varsayılanları uygulanır.

**Örnek çakışma çözümü:**

```
VERDENT.md: "Use 2-space indentation"
AGENTS.md: "Use 4-space indentation for this project"
→ Result: Verdent uses 4-space indentation (project rules win)
```

**Plan kuralları:** Plan.md, Plan Mode sırasında bağımsız olarak uygulanır ve kullanıcı/proje kurallarıyla çakışmaz. Plan biçimini kontrol ederken VERDENT.md ve AGENTS.md plan içindeki kod stilini kontrol eder.

<Note>
  Plan kuralları yalnızca Plan Mode çıktı biçimini etkiler. Verdent'in çözümleri nasıl analiz ettiğini veya uyguladığını değiştirmez.
</Note>

<Tip>
  Önceliği hatırlayın: AGENTS.md (en yüksek) → VERDENT.md (orta) → varsayılanlar (en düşük). Proje kuralları çakışmaları her zaman kazanır.
</Tip>

<Info>
  Ayrıntılı çakışma çözüm algoritmaları, çakışmalar sırasında hangi kuralın uygulandığını görme mekanizmaları ve kuralların geçici olarak askıya alınması için geçersiz kılma mekanizmaları şu anda geliştirme aşamasındadır.
</Info>

***

### Kural çakışmalarında sorun giderme [#kural-çakışmalarında-sorun-giderme]

Bir kuralla çelişen beklenmedik davranış gözlemlediğinizde bu hata ayıklama stratejisini izleyin:

#### Adım 1: Çakışmayı belirleyin [#adım-1-çakışmayı-belirleyin]

1. Bir kuralla çelişen beklenmedik davranışı gözlemleyin
2. Duruma hangi kuralların uygulanabileceğini kontrol edin
3. Kural dosyaları arasında çelişkileri arayın

#### Adım 2: Kural önceliğini kontrol edin [#adım-2-kural-önceliğini-kontrol-edin]

```
AGENTS.md (highest) → VERDENT.md (medium) → defaults (lowest)
```

Proje kuralları kişisel tercihleri geçersiz kılar.

#### Adım 3: İzolasyonda test edin [#adım-3-i̇zolasyonda-test-edin]

**VERDENT.md'yi devre dışı bırakın:** Dosyayı geçici olarak yeniden adlandırın veya temizleyin, çakışmanın çözülüp çözülmediğini test edin

**AGENTS.md olmadan test edin:** user\_rules davranışını izole etmek için AGENTS.md olmadan projede çalışın

**Yeni konuşma:** Konuşma bağlamı etkisini ortadan kaldırmak için yeni bir oturum başlatın

***

### Yaygın çakışma senaryoları [#yaygın-çakışma-senaryoları]

#### Senaryo 1: Biçimlendirme çakışması [#senaryo-1-biçimlendirme-çakışması]

```
VERDENT.md: "Use 2-space indentation"
AGENTS.md: "Use 4-space indentation"
→ Resolution: AGENTS.md wins (project standard)
→ Fix: Accept project standard or discuss with team
```

#### Senaryo 2: Aynı dosyada çelişen kurallar [#senaryo-2-aynı-dosyada-çelişen-kurallar]

```
AGENTS.md:
- "Prefer functional components"
- "Use class components for complex state"
→ Resolution: Verdent interprets based on context
→ Fix: Clarify when each rule applies
```

Örnek düzeltme:

```markdown
- Prefer functional components for simple UI
- Use functional components with hooks for complex state
- Only use class components for legacy code maintenance
```

#### Senaryo 3: Kural çok belirsiz [#senaryo-3-kural-çok-belirsiz]

```
"Write good tests"
→ Problem: What is "good"?
→ Fix: "Generate unit tests with 80%+ coverage, include edge cases"
```

***

### Hata ayıklama stratejisi [#hata-ayıklama-stratejisi]

**1. Açık test:** Verdent'e "\[belirli davranış] için hangi kuralı takip ediyorsun?" diye sorun

Örnek:

```
You: "Which rule are you following for indentation?"
Verdent: "I'm using 4-space indentation from AGENTS.md (line 12),
which overrides your VERDENT.md preference for 2-space indentation."
```

**2. Kademeli iyileştirme:** Belirsiz kurallara spesifiklik ekleyin

<Tip>
  Kural çakışmalarını hata ayıklarken, hangi kuralın beklenmedik davranışa neden olduğunu izole etmek için kuralları tek tek geçici olarak devre dışı bırakın.
</Tip>

Önce:

```markdown
- Use appropriate error handling
```

Sonra:

```markdown
- Wrap async operations in try/catch blocks
- Return error objects with message and code fields
- Log errors with context (function name, input parameters)
```

**3. Öncelik işaretleyicileri:** Pazarlık edilemez kurallar için "CRITICAL:" veya "REQUIRED:" kullanın

```markdown
## Security Rules
- **CRITICAL:** Never log passwords, API keys, or tokens
- **REQUIRED:** All user inputs must be validated and sanitized
- Preferred: Use parameterized queries for database operations
```

***

### Kural yazma için en iyi uygulamalar [#kural-yazma-için-en-iyi-uygulamalar]

**Spesifik ve yönlendirici olun:**

* Açık, buyurgan dil kullanın ("Her zaman kullan...", "Asla...", "Tercih et...")
* Belirsiz ifadelerden kaçının ("Şunu yapmaya çalış..." → "Her zaman...")
* İstemediğinizi değil, tam olarak istediğinizi belirtin

**İyi:**

```markdown
- Use async/await for asynchronous operations
- Include JSDoc comments for all exported functions
```

**Kaçının:**

```markdown
- Try to use modern JavaScript features
- Add comments when necessary
```

**Mantıksal olarak düzenleyin:**

* İlgili kuralları bölüm başlıkları altında gruplayın
* Konuları ayırın (stil, test, dokümantasyon, güvenlik)
* Kural dosyaları genelinde tutarlı yapı kullanın

**Kuralları sürdürülebilir tutun:**

* Özlü kurallar yazın (madde başına bir kavram)
* Proje geliştikçe kuralları gözden geçirin ve güncelleyin
* Geçersiz kuralları derhal kaldırın

**Önemli kuralları önceliklendirin:**

* Kritik kuralları her bölümde önce yerleştirin
* Pazarlık edilemez standartlar için vurgu kullanın ("Kimlik bilgilerini **ASLA** commit etmeyin")
* Hataları veya güvenlik sorunlarını önleyen kurallara odaklanın

**Kuralların etkinliğini test edin:**

* Verdent'in kuralları pratikte takip ettiğini doğrulayın
* Kural uygulamasını test etmek için yeni bir konuşma başlatın
* Gerçek aracı davranışına göre kuralları iyileştirin

**Ayrıntı ve esnekliği dengeleyin:**

* Çok spesifik → Uyum sağlamayan katı davranış
* Çok belirsiz → Tutarsız davranış
* Bağlama uygun kararlar için alan bırakacak şekilde açık rehberlik hedefleyin

**Ekip değerlendirmeleri (AGENTS.md):**

* Kural oluşturmaya ekibi dahil edin
* Açık olmayan kuralların gerekçesini belgeleyin
* Ekip kurallarını kişisel tercihlere değil, paylaşılan standartlara odaklı tutun

***

## Ayrıca bakın [#ayrıca-bakın]

<CardGroup cols="2">
  <Card title="Alt aracı yönetimi" icon="robot" href="/docs/verdent-for-vscode/agents-rules/subagent-management">
    Projeye özgü görevler için özelleştirilmiş alt aracılar oluşturun ve yönetin
  </Card>

  <Card title="En iyi uygulamalar: İstemler" icon="message-lines" href="/docs/verdent-for-vscode/best-practices/prompts">
    VerdentP'den en iyi şekilde yararlanmak için etkili istemler yazma
  </Card>
</CardGroup>