Harika İmleç Kuralları Artık İmleç Yapay Zeka IDE'niz İçin Kurabilirsiniz

Yazılım geliştirme dünyası sürekli gelişiyor ve son yıllardaki en heyecan verici gelişmelerden biri, yapay zeka destekli kodlamanın yükselişi oldu. Cursor gibi araçlar, geliştiricilerin kod yazma, anlama ve bakımını yapma şeklini devrim niteliğinde değiştiriyor. Ancak bu yapay zeka asistanlarının gücünden gerçekten yararlanmak için, varsayılan ayarların ötesine geçmeniz ve bunları belirli projelerinize göre uyarlamanız gerekir. İşte tam da bu noktada .cursorrules dosyaları devreye giriyor.

Cursorrules Nedir ve Neden Önemlidir?

Temel olarak, .cursorrules dosyaları, Cursor AI'ya proje özel talimatlar ve yönergeler sağlayan yapılandırma dosyalarıdır. Bunları, ekibinizin kolektif bilgi ve en iyi uygulamalarını doğrudan yapay zekanın karar verme sürecine dahil etmenin bir yolu olarak düşünebilirsiniz. Bu kuralları tanımlayarak, Cursor'ın projenizin mimarisi, kodlama stili ve teknoloji yığınıyla uyumlu kod üretmesini sağlayabilirsiniz.

Çözüm: Modern Cursor Kuralları ile Kalıcı, Kapsamlı Rehberlik

Cursor'ın modern Kurallar sistemi, proje özel bilgilerini ve kişisel tercihlerinizi doğrudan yapay zekanın bağlamına gömmenize olanak tanıyarak bunu çözer. Bu, yapay zekanın tutarlı, doğru ve standartlarınıza uygun kod üretmesini sağlar.

Mevcut sistemde iki ana kural türü vardır:

1. Proje Kuralları: Projeniz içindeki .cursor/rules dizininde saklanan bu kurallar, sürüm kontrollüdür ve kod tabanına göre kapsamlandırılmıştır. Alanla ilgili bilgileri kodlamak, kalıpları standartlaştırmak ve proje iş akışlarını otomatikleştirmek için mükemmeldirler.
2. Kullanıcı Kuralları: Cursor ayarlarınızda genel olarak tanımlanan bu kurallar, tüm projelerinizde geçerlidir. Yanıt stili veya yaygın olarak kullanılan kitaplıklar gibi kişisel tercihleri ayarlamak için idealdirler.

(Not: Proje kökündeki eski .cursorrules dosyası hala desteklenmektedir ancak kullanımdan kaldırılmıştır. Yeni Proje Kuralları sistemine geçmeniz önerilir.)

Modern CursorRules Nasıl Çalışır

Standart sohbet etkileşimlerinden farklı olarak, kurallar kalıcı bir bağlam sağlar. Bir kural uygulandığında (otomatik veya manuel olarak), içeriği yapay zeka modeline (Agent veya Cmd-K) gönderilen istemin başına eklenir. Bu, yapay zekanın belirtilen yönergeleri tutarlı bir şekilde izlemesini sağlar.

Proje Kurallarını Kurma ve Kullanma

Proje kuralları, yapay zekanın belirli bir kod tabanında nasıl davranacağı üzerinde ayrıntılı kontrol sağlar.

1. Konum: Projenizin kökünde bir .cursor/rules dizini oluşturun.

2. Biçim: Her kural, .mdc (Markdown Bileşenleri) uzantısına sahip kendi dosyasında bulunur. MDC, hem meta verileri (ön madde) hem de kural içeriğini sağlar.

3. Kural Yapısı: Bir .mdc kural dosyası tipik olarak şöyle görünür:

---
description: Agent Requested kuralları için isteğe bağlı açıklama.
globs: ["optional/glob/pattern/**", "*.py"] # Auto Attached kuralları için
alwaysApply: false # Always kuralları için True
---

# Kural İçeriği Buradan Başlar
- Bu belirli kitaplığı/deseni kullanın.
- Bunu yapmaktan kaçının.
- Bağlam için belirli dosyalara başvurun: @path/to/important/file.ts

4. Kural Türleri (Meta Verilerle Belirlenir):

5. Kural Oluşturma: .mdc dosyalarını manuel olarak oluşturabilir veya Komut Paletini (Cmd+Shift+P veya Ctrl+Shift+P) kullanıp "New Cursor Rule" araması yapabilirsiniz.

6. Kural Oluşturma: Yapay zekanın nasıl davranması gerektiğini iyileştirdiğiniz bir sohbet konuşmasından sonra, o etkileşime dayalı bir kuralı otomatik olarak oluşturmak için /Generate Cursor Rules komutunu kullanın.

Kullanıcı Kuralları: Küresel Tercihleriniz

Kullanıcı Kuralları daha basittir.

1. Cursor Settings > Rules > User Rules'a gidin.
2. Düz metin talimatları girin (MDC formatı burada desteklenmez).
3. Bu kurallar her zaman tüm projelerinize uygulanır.

Örnek Kullanıcı Kuralı:

React'i her zaman açıkça içe aktarın: `import React from 'react';`
Özet olarak yanıt verin. Dolgu ifadelerinden kaçının.
Sınıf bileşenleri yerine Hooks ile işlevsel bileşenleri tercih edin.

Kural Yazma İçin En İyi Uygulamalar

• Belirli ve Eyleme Geçirilebilir Olun: Belirsiz talimatlar daha az etkilidir. Yapay zekaya tam olarak ne yapması veya yapmaması gerektiğini söyleyin.
• Kısa Tutun: Açıklık ve kısalık hedefleyin. 500 satırın altında olmak iyi bir kılavuzdur.
• Örnekler Kullanın: Noktaları göstermek için kısa kod parçacıkları veya referans dosyaları (@filename.ext) ekleyin.
• Parçalara Ayırın: Karmaşık standartları daha küçük, odaklanmış kurallara ayırın.
• Açıklamalar Kullanın: Agent Requested kuralları için, yapay zekanın bunları ne zaman kullanacağını bilmesi için net açıklamalar yazın.
• Yineleyin: Yapay zekanın performansına göre kurallarınızı iyileştirin.

Harika Kural Örnekleri (.mdc formatını kullanarak)

Sağlanan rules-mdc dosyalarından ilham alan, modern formatı gösteren bazı örnekler şunlardır:

1. Django En İyi Uygulamaları (django.mdc)

---
description: Django en iyi uygulamaları, modeller, görünümler, şablonlar ve ORM kullanımı hakkında rehberlik sağlar.
globs: ["*.py"]
alwaysApply: false
---

# Django Geliştirme Kılavuzları

## Genel
- Django Stil Kılavuzu ve PEP 8'i izleyin.
- Mümkün olduğunda Django'nun yerleşik özelliklerini kullanın (kimlik doğrulama, yönetici, formlar).
- Uygulamaları modüler ve yeniden kullanılabilir tutun.

## Modeller (`models.py`)
- Açıklayıcı model ve alan adları kullanın.
- Tüm modeller için `__str__` yöntemleri tanımlayın.
- Sıralama, ayrıntılı adlar vb. için `Meta` seçenekleri ekleyin.
- `on_delete` uygun şekilde belirtilmiş `ForeignKey` kullanın (örneğin, `models.CASCADE`, `models.SET_NULL`).
- Örnek: `author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts')`

## Görünümler (`views.py`)
- Ortak kalıplar için Sınıf Tabanlı Görünümleri (CBV'ler) tercih edin (Liste, Ayrıntı, Oluştur, Güncelle, Sil).
- Basit veya son derece özel mantık için İşlev Tabanlı Görünümleri (FBV'ler) kullanın.
- Uygun kimlik doğrulama ve izinleri uygulayın (`@login_required`, `PermissionRequiredMixin`).
- İstisnaları zarif bir şekilde işleyin (örneğin, `try...except ObjectDoesNotExist`).
- `get_object_or_404` kısayolunu kullanın.

## Şablonlar
- Şablonları uygulamaya özel dizinlerde düzenleyin (`templates/<app_name>/`).
- Şablon kalıtımını kullanın (`{% extends 'base.html' %}`).
- Statik dosyaları `{% load static %}` ve `{% static 'path/to/file.css' %}` kullanarak yükleyin.
- Şablonlarda karmaşık mantıktan kaçının; bunun yerine şablon etiketlerini veya filtreleri kullanın.

## ORM
- Sorgu kümesi filtrelemeyi (`.filter()`, `.exclude()`) verimli bir şekilde kullanın. Gereksiz verileri yüklemekten kaçının.
- Veritabanı sorgularını optimize etmek için `select_related` (bire-bir/yabancı anahtar için) ve `prefetch_related` (çok-çok/ters yabancı anahtar için) kullanın.
- Veritabanı düzeyinde toplamalar için `.annotate()` kullanın.
- Tembel yükleme ve potansiyel N+1 sorgu sorunlarına dikkat edin.

## Formlar (`forms.py`)
- Veri doğrulama ve HTML oluşturma için Django Formlarını kullanın.
- Doğrudan modellere bağlı formlar için `ModelForm`'u tercih edin.
- Özel doğrulama yöntemleri tanımlayın (`clean_<fieldname>()`, `clean()`).

## URL'ler (`urls.py`)
- Açıklayıcı URL adları kullanın (`path('articles/<int:pk>/', views.ArticleDetailView.as_view(), name='article-detail')`).
- `include()` kullanarak uygulamaya özel `urls.py` dosyalarını ekleyin.

## Ayarlar (`settings.py`)
- Hassas veriler için ortam değişkenlerini kullanın (SECRET_KEY, veritabanı kimlik bilgileri). Sırları göndermeyin.
- `STATIC_URL`, `STATIC_ROOT`, `MEDIA_URL`, `MEDIA_ROOT`'u doğru yapılandırın.

## Test Etme
- Django'nun `TestCase` veya `pytest-django`'sunu kullanarak birim testleri ve entegrasyon testleri yazın.
- Modelleri, görünümleri, formları ve yardımcı programları test edin.

2. Dockerfile En İyi Uygulamaları (docker.mdc)

---
description: Verimli ve güvenli Dockerfile'lar yazma yönergeleri.
globs: ["Dockerfile", "*.Dockerfile"]
alwaysApply: false
---

# Dockerfile En İyi Uygulamaları

## Temel Görüntü
- Resmi, minimum temel görüntüleri kullanın (örneğin, `python:3.11-slim`, `node:18-alpine`, `golang:1.20-alpine`).
- Tekrarlanabilirlik için kesin sürümleri veya özetleri belirtin (`python:3.11.4-slim-bullseye`).
- Boyut için Alpine görüntülerini tercih edin, ancak `musl libc` uyumluluk sorunlarına karşı `glibc`'ye dikkat edin.

## Katmanları ve Yapı Bağlamını En Aza İndirin
- Katmanları azaltmak için ilgili komutları `&&` kullanarak zincirleyin (örneğin, `apt-get update && apt-get install -y --no-install-recommends package && rm -rf /var/lib/apt/lists/*`).
- Yapı bağlamından gereksiz dosyaları/dizinleri (örneğin, `.git`, `node_modules`, `.venv`, günlükler, yerel yapılandırma) hariç tutmak için bir `.dockerignore` dosyası kullanın.

## Yapı Verimliliği
- Talimatları en azdan en sık değişene doğru sıralayın (örneğin, uygulama kodunu kopyalamadan önce bağımlılıkları yükleyin).
- Docker yapı önbelleğinden etkili bir şekilde yararlanın.
- Son görüntüyü küçük tutmak, yapı bağımlılıklarını çalışma zamanı bağımlılıklarından ayırmak için çok aşamalı yapılar kullanın.

## Güvenlik
- Kapsayıcıları kök olmayan bir kullanıcı olarak çalıştırın. Özel bir kullanıcı/grup oluşturun (`RUN groupadd -r appuser && useradd -r -g appuser appuser`) ve ona geçin (`USER appuser`).
- Sırları doğrudan Dockerfile'da saklamaktan kaçının. Çalışma zamanında yapı argümanlarını (`ARG`), ortam değişkenlerini (`ENV`) veya gizli yönetim araçlarını kullanın.
- Trivy veya Docker Scout gibi araçları kullanarak görüntüleri güvenlik açıkları için tarayın.
- Saldırı yüzeyini en aza indirin: yalnızca gerekli paketleri yükleyin (`--no-install-recommends`).

## Talimatlar
- Özellikle `ADD`'in özelliklerine (otomatik çıkarma veya URL getirme gibi) ihtiyacınız olmadıkça `COPY` yerine `ADD` kullanın.
- Ana kapsayıcı komutu için `ENTRYPOINT`'i tercih edin ve geçersiz kılınabilen varsayılan argümanlar için `CMD` kullanın. JSON dizi biçimini kullanın (örneğin, `ENTRYPOINT ["python", "app.py"]`).
- Sonraki talimatlar (`RUN`, `CMD`, `ENTRYPOINT`, `COPY`, `ADD`) için çalışma dizinini ayarlamak için `WORKDIR` kullanın.
- Gerekli bağlantı noktalarını `EXPOSE` kullanarak açığa çıkarın.

## Örnek Çok Aşamalı Yapı (Python)
```dockerfile
# Yapı Aşaması
FROM python:3.11-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt
COPY . .

# Son Aşama
FROM python:3.11-alpine
WORKDIR /app
# Kök olmayan kullanıcı oluştur
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
# Yüklenen paketleri ve uygulama kodunu oluşturucu aşamasından kopyala
COPY --from=builder /root/.local /usr/local
COPY --from=builder /app .
# Gerekirse komut dosyalarının yürütülebilir olduğundan emin olun
# RUN chmod +x ./entrypoint.sh
USER appuser
EXPOSE 8000
ENTRYPOINT ["python"]
CMD ["manage.py", "runserver", "0.0.0.0:8000"]

**3. Python Black Biçimlendirme (`black.mdc`)**

```mdc
---
description: Python kod biçimlendirmesinin Black stil kılavuzuna uymasını sağlar.
globs: ["*.py"]
alwaysApply: false
---

# Python için Black Kod Biçimlendirme Kuralları

- Black kod stiline sıkı sıkıya bağlı kalın. Black pazarlık edilemez ve minimum yapılandırmaya sahiptir.
- Varsayılan satır uzunluğu 88 karakterdir.
- Mümkün olduğunda dizeler için çift tırnak işareti (`"`) kullanın, ancak Black tutarlılığı ele alacaktır.
- Black, girintiyi, boşluğu, sondaki virgülleri ve satır sonlarını otomatik olarak işler.
- Kodun taahhüt etmeden önce `black .` kontrolünden geçtiğinden emin olun.
- Black'i ön taahhüt kancalarınıza veya CI/CD hattınıza entegre edin.

## Örnek Entegrasyon (ön taahhüt)
```yaml
# .pre-commit-config.yaml
repos:
-   repo: <https://github.com/psf/black>
    rev: 23.3.0 # Güncel bir kararlı sürüm kullanın
    hooks:
    -   id: black

Black Çalıştırma

• Belirli dosyaları biçimlendirin: black my_module.py your_script.py
• Tüm projeyi biçimlendirin (.gitignore kontrolü): black .
• Dosyaları değiştirmeden kontrol edin: black --check .

**4. React En İyi Uygulamaları (`react.mdc`)**
(Benzer içerik yapısına sahip `react.mdc` adlı bir dosya olduğu varsayılarak)

```mdc
---
description: Modern React bileşenleri ve uygulamaları yazma yönergeleri.
globs: ["*.js", "*.jsx", "*.ts", "*.tsx"]
alwaysApply: false
---

# React Geliştirme En İyi Uygulamaları

## Bileşenler
- Sınıf Bileşenleri yerine Hooks ile İşlevsel Bileşenleri tercih edin.
- Bileşen adları için PascalCase kullanın (`MyComponent`).
- Bileşenleri küçük ve odaklanmış tutun (Tek Sorumluluk İlkesi).
- En üstte açık `import React from 'react';` kullanın (daha yeni JSX dönüşümleriyle kesinlikle gerekli olmasa da, açıklık için iyi bir uygulamadır).
- Props için `propTypes` (JavaScript kullanılıyorsa) veya TypeScript arabirimleri tanımlayın.
- Props için yapılandırmayı kullanın: `function MyComponent({ name, count }) { ... }`

## Durum Yönetimi
- Basit bileşen yerel durumu için `useState` kullanın.
- Daha karmaşık durum mantığı veya durum geçişleri önceki duruma bağlı olduğunda `useReducer` kullanın.
- Birden fazla bileşenin aynı duruma erişmesi gerektiğinde durumu en yakın ortak ataya taşıyın.
- Küresel veya paylaşılan durum için, orta karmaşıklık için Context API'yi (`useContext`) veya daha büyük uygulamalar için özel durum yönetimi kitaplıklarını (Redux, Zustand, Jotai) düşünün.

## Hooks
- Hooks'ları yalnızca işlevsel bileşenlerin veya diğer özel Hooks'ların en üst düzeyinde çağırın.
- Hooks'ları döngüler, koşullar veya iç içe geçmiş işlevler içinde çağırmayın.
- Hooks Kurallarına uyun. Bunları uygulamak için ESLint eklentilerini (`eslint-plugin-react-hooks`) kullanın.
- Yan etkiler için (`useEffect`) (veri getirme, abonelikler, manuel DOM manipülasyonları) kullanın. Etkinin ne zaman çalışacağını kontrol etmek için bir bağımlılık dizisi ekleyin.
- Performansı gerektiğinde optimize ederek (genellikle `React.memo` veya ağır hesaplamalarla ilgili) işlevleri ve değerleri sırasıyla belleğe almak için `useCallback` ve `useMemo` kullanın.

## Anahtarlar
- Öğe listelerini işlerken kararlı ve benzersiz `key` props'ları sağlayın (`<li key={item.id}>`). Liste sırası değişebiliyorsa veya öğeler eklenebiliyorsa/silinebiliyorsa, dizi dizinlerini anahtar olarak kullanmaktan kaçının.

## Dosya Yapısı
- Dosyaları özellik veya rota (örneğin, `/features/Auth`, `/components/common`) ile düzenleyin.
- Belirli bir özellikle ilgili bileşenleri, stilleri, testleri ve hooks'ları bir araya getirin.

## Stil Verme
- Tutarlı bir stil yaklaşımı seçin: CSS Modülleri, Styled Components, Emotion, Tailwind CSS, düz CSS/SASS.
- Basit dinamik ayarlamaların ötesinde hiçbir şey için satır içi stillerden kaçının.

## Performans
- Bileşenleri belleğe almak ve gereksiz yeniden oluşturmaları önlemek için `React.memo` kullanın.
- React DevTools Profiler ile performansı analiz edin.
- Başlangıç paket boyutunu azaltmak için kod bölmeyi (örneğin, `React.lazy` ve `Suspense`) düşünün.

## Erişilebilirlik (a11y)
- Anlamsal HTML öğeleri kullanın (`<button>`, `<nav>`, `<main>`).
- Gerekirse uygun ARIA özniteliklerinin kullanıldığından emin olun.
- Klavye navigasyonu ve ekran okuyucularla test edin.

Sonuç: Hassas Yapay Zeka Yardımını Kucaklayın

Modern Cursor Kuralları (.cursor/rules ve Kullanıcı Kuralları), yapay zeka destekli geliştirmenin tüm gücünden yararlanmak için gereklidir. Proje standartlarını ve kişisel tercihleri tanımlamaya az miktarda zaman ayırarak, Cursor'ın gerçek, bağlam farkında bir eş programcı gibi hareket etmesini sağlarsınız. Bu, daha yüksek kod kalitesine, artan üretkenliğe, daha iyi ekip işbirliğine ve azaltılmış teknik borca yol açar. Genel yapay zeka önerilerini ayarlamayı bırakın ve Kuralları kullanarak Cursor'ı hassas bir şekilde yönlendirmeye başlayın.