Claude Code ile uygulama geliştirmek, 1. bölüm: Kod yazmadan önce

Cla­ude Code’u ilk kez açan bi­ri­nin yap­tı­ğı şey ge­nel­de ay­nı­dır: “Bana bir müş­te­ri yö­ne­tim uy­gu­la­ma­sı yaz.” Beş da­ki­ka son­ra ek­ran­da dört yüz sa­tır kod var­dır. Uy­gu­la­ma bel­ki ça­lı­şır da. Ama bir­kaç soru ce­vap­sız ka­lır: Han­gi dos­ya­la­ra do­ku­nul­du? Han­gi pa­ket­ler ku­rul­du? Ve­ri­ta­ba­nı­na han­gi kul­la­nı­cıy­la bağ­la­nıl­dı? Ve en önem­li­si: Bu kodu ya­rın kim an­la­ya­cak, kim ba­kı­mı­nı ya­pa­cak?

Kod üre­ten bir soh­bet ile pro­je­ni­zin için­de ça­lı­şan bir asis­tan ara­sın­da­ki fark bu­ra­da baş­lar. Cla­ude Code pro­je­ni­zi okur, dos­ya dü­zen­ler, ko­mut ve test ça­lış­tı­rır. Bu güç, doğ­ru bir çer­çe­ve için­de kul­la­nıl­dı­ğın­da bir eki­bin haf­ta­lar­ca sü­ren işi­ni gün­le­re in­di­rir. Çer­çe­ve­siz kul­la­nıl­dı­ğın­da ise kim­se­nin tam an­la­ma­dı­ğı, ba­kı­mı ya­pı­la­ma­yan ve gü­ven­li­ği be­lir­siz bir ya­zı­lım üre­tir.

Bu yazı, Cla­ude Code ile uy­gu­la­ma ge­liş­tir­mek: Fi­kir­den ya­yı­na bir yol ha­ri­ta­sı se­ri­si­nin ilk bö­lü­mü. Bu bö­lüm­de Cla­ude Code’a tek sa­tır kod yaz­dır­ma­dan önce ya­pıl­ma­sı ge­re­ken­le­ri an­la­tı­yo­rum. İkin­ci bö­lüm plan mo­dun­dan ya­yı­na ka­dar olan kıs­mı kap­sı­yor. Seri bo­yun­ca ör­nek ola­rak ba­sit bir CRM ku­ru­yo­ruz: müş­te­ri­ler, yet­ki­li­ler, gö­rüş­me not­la­rı ve fır­sat­lar.

Bir ön not: Bu se­ri­yi ta­kip et­mek için usta bir ya­zı­lım­cı ol­ma­nız ge­rek­mi­yor, ama kodu oku­ya­bil­mek bü­yük avan­taj. Çün­kü bü­tün ya­zı­nın üze­ri­ne ku­rul­du­ğu ilke şu: Kodu siz an­la­mı­yor­sa­nız, o kod si­zin de­ğil­dir. Cla­ude Code ya­zar; ama ya­yı­na gi­den her sa­tır­dan siz so­rum­lu­su­nuz.

1. Ne yapacağınızı bir sayfada yazın

İlk adı­mın Cla­ude Code ile hiç­bir il­gi­si yok. Bir me­tin dos­ya­sı açın ve uy­gu­la­ma­nı­zı bir say­fa­da ta­rif edin. Bu say­fa iki işe ya­rar: Size ne yap­mak is­te­di­ği­ni­zi net­leş­ti­rir, Cla­ude Code’a da her ko­nuş­ma­da geri dö­ne­ce­ği bir pu­su­la olur.

Ör­nek CRM için böy­le bir say­fa şöy­le gö­rü­nür:

# Ürün tanımı: Basit CRM

## Amaç
Satış ekibinin müşteri bilgilerini, görüşmelerini ve açık fırsatlarını
tek bir yerden takip etmesi. Bugün bu bilgiler kişisel Excel dosyalarında.

## Kullanıcılar
- Satış temsilcisi: kendi müşterilerini ve fırsatlarını yönetir.
- Satış müdürü: ekibinin bütün müşterilerini ve fırsatlarını görür.

## Üç ana iş
1. Müşteri ve yetkili kaydı açmak, aramak, güncellemek.
2. Bir görüşmeyi not olarak kaydetmek.
3. Fırsatları aşamalarıyla (yeni, teklif, kazanıldı, kaybedildi) izlemek.

## Veri
Müşteri (unvan, vergi numarası, telefon), yetkili, görüşme notu, fırsat.

## "Bitti" ne demek?
Bir temsilci yeni bir müşteriyi, ilk görüşmesini ve bir fırsatı
beş dakikadan kısa sürede kaydedebiliyor; müdür ekibinin açık
fırsatlarını tek ekranda görüyor.

## Şimdilik yapmayacaklarımız
- Teklif ve fatura üretmek
- E-posta entegrasyonu
- Mobil uygulama

En de­ğer­li bö­lüm son­da­ki lis­te­dir. CRM pro­je­le­ri ya­zı­sın­da an­lat­tı­ğım “her­ke­sin her is­te­ği” tu­za­ğı­na kar­şı en iyi ko­run­ma, neyi yap­ma­ya­ca­ğı­nı­zı baş­tan yaz­mak­tır. Cla­ude Code is­tek­li bir asis­tan­dır; ona sı­nır çiz­mez­se­niz kap­sam her ko­nuş­ma­da bi­raz daha bü­yür.

2. Araçları kurmak

Cla­ude Code’u iki ayrı yer­den kul­la­na­bi­lir­si­niz. İki­si aynı mo­to­ru, aynı ayar­la­rı ve aynı pro­je dos­ya­la­rı­nı kul­la­nır; fark ça­lış­ma bi­çi­min­de­dir.

• VS Code ek­len­ti­si gün­lük ge­liş­tir­me için idealdir. Claude’un yap­tı­ğı her de­ği­şik­li­ği edi­tör­de fark gö­rü­nü­mün­de (diff) gö­rür, ka­bul ya da red­de­der­si­niz. Seç­ti­ği­niz kodu ya da bir dos­ya­yı doğ­ru­dan bağ­lam ola­rak ve­re­bi­lir­si­niz.
• Ter­mi­nal uzun sü­ren gö­rev­ler, oto­mas­yon ve su­nu­cu üze­rin­de­ki iş­ler için daha ra­hat­tır.

Ku­ru­lu­mun ikin­ci ya­rı­sı Git’tir ve is­te­ğe bağ­lı de­ğil­dir. Cla­ude Code ile ça­lı­şır­ken Git si­zin gü­ven­lik ağı­nız­dır: Her an­lam­lı adım­dan son­ra bir com­mit, her de­ne­me için ayrı bir dal. Yan­lış gi­den bir adı­mı geri al­ma­nın en gü­ve­ni­lir yolu bu­dur.

Pro­je­ye baş­lar­ken han­gi dos­ya­nın ne işe ya­ra­dı­ğı­nı bil­mek de önem­li. Ku­ral ba­sit: Eki­bin or­tak ku­ral­la­rı re­po­da, ki­şi­sel ter­cih­ler dı­şa­rı­da.

Dosya	Ne için	Git’e girer mi?
CLAUDE.md	Projenin ekip için ortak talimatları	Evet
CLAUDE.local.md	Bu projedeki kişisel notlarınız	Hayır, .gitignore’a ekleyin
.claude/settings.json	Ekibin ortak ayarları: izinler, hook’lar	Evet
.claude/settings.local.json	Bu projedeki kişisel ayarlarınız	Hayır
~/.claude/CLAUDE.md	Bütün projelerde geçerli kişisel tercihleriniz	Projenin parçası değil

3. Ortama uygun teknoloji: Kodu yazan değil, işleten belirler

Cla­ude Code her dil­de kod ya­za­bil­di­ği için tek­no­lo­ji seç­mek hiç bu ka­dar ko­lay ol­ma­mış­tı. Tu­zak da tam bu­ra­da. Asıl soru “han­gi­si­ni yaz­dı­ra­bi­li­rim?” de­ğil, “bunu kim ça­lış­tı­ra­cak, kim gü­ven­li­ği­ni sağ­la­ya­cak, ben­den son­ra kim ba­kı­mı­nı ya­pa­cak?” so­ru­su­dur.

Di­ye­lim ki şir­ke­ti­ni­zin uy­gu­la­ma­la­rı Windows su­nu­cu­lar­da, IIS üze­rin­de React ve Node.js ile ça­lı­şı­yor. Ken­di por­ta­lı­nı­zı Flut­ter ve Java ile ya­zar­sa­nız, bil­gi iş­lem eki­bin­den hiç bil­me­di­ği bir şeyi iş­let­me­si­ni, gün­cel­le­me­si­ni ve gü­ven­li­ği­ni sağ­la­ma­sı­nı is­te­miş olur­su­nuz. Uy­gu­la­ma bir haf­ta son­ra ça­lı­şır; ama bir yıl son­ra sa­hip­siz ka­lır.

Se­çim ya­par­ken ba­kı­la­cak şey mev­cut or­tam­dır: su­nu­cu­lar ve ba­rın­dır­ma, şir­ke­tin otu­rum açma sis­te­mi, kul­la­nı­lan ve­ri­ta­ba­nı, ya­yın sü­re­ci ve eki­bin bil­di­ği dil­ler. Bu or­ta­mın için­de ka­lan se­çe­nek­ler ara­sın­da ise şu ilke yol gös­te­rir:

Ya­pay ze­ka­nın en iyi ça­lış­tı­ğı yapı, in­sa­nın da en ko­lay ba­kım yap­tı­ğı ya­pı­dır.

Ya­pay zeka; açık kay­nak­ta çok ör­ne­ği bu­lu­nan, tip­li, ka­rar­lı ve bir işin ya­pı­lış bi­çi­mi bel­li olan tek­no­lo­ji­ler­de en iyi so­nu­cu ve­rir. TypeScript, C#, Java gibi tip­li dil­ler­de asis­ta­nın ha­ta­la­rı­nın önem­li bir kıs­mı­nı der­le­yi­ci, kod hiç ça­lış­ma­dan ya­ka­lar. Her altı ayda bir kök­lü de­ği­şen ça­tı­lar­da ise asis­tan eski ve yeni ya­zım bi­çim­le­ri­ni ka­rış­tı­ra­bi­lir. Bu öl­çüt­ler­le bir­kaç güç­lü se­çe­nek:

Yapı	Ne zaman uygun	Yapay zeka açısından güçlü yanı	Dikkat
React ve Node.js (uçtan uca TypeScript)	Şirket zaten JavaScript ve Node kullanıyorsa	Tek dil; arayüz ile sunucu arasında ortak tipler	Paket bolluğu: İzin verilen paketleri yazın, asistan her işe yeni paket eklemesin
Angular ve Python (FastAPI)	Kurumsal bir arayüz ile veri ağırlıklı bir arka uç bir aradaysa	Angular’ın katı düzeni; Python tiplerinden üretilen ortak API sözleşmesi	İki dil: API sözleşmesi tek kaynak olmalı, elle kopyalanmamalı
React ya da Angular ile ASP.NET Core (C#)	Microsoft ekosistemi: Windows sunucular, IIS, SQL Server, kurumsal giriş	Güçlü tipli bir dil ve yerleşik kurumsal kalıplar	Sunucudaki .NET sürümüyle uyumu baştan netleştirin
Django (Python, tek proje)	Küçük ekip, hızlı başlangıç, çok etkileşimli olmayan ekranlar	Çok kararlı ve yaygın; hazır giriş sistemi, yönetim paneli, veritabanı katmanı	Çok etkileşimli ekranlarda sınırlarına daha erken gelinir

Bu se­ri­de­ki ör­nek CRM’i An­gu­lar ve Python (FastAPI) ile ku­ru­yo­ruz. Angular’ın katı dü­ze­ni asis­ta­nın kodu da­ğıt­ma­sı­nı ön­ler; FastAPI’de ta­nım­la­nan tip­ler­den oto­ma­tik bir API söz­leş­me­si çı­kar ve An­gu­lar ta­ra­fı­nın is­tem­ci­si bu söz­leş­me­den üre­ti­le­bi­lir. İki ayrı dil ol­du­ğu hal­de “müş­te­ri” nes­ne­si­nin ta­nı­mı tek bir kay­nak­tan ge­lir.

Uzun dos­ya, az oku­nan dos­ya­dır. Aynı il­ke­nin bir de dos­ya dü­ze­yin­de­ki kar­şı­lı­ğı var. Cla­ude Code çok uzun bir dos­ya­yı tek se­fer­de oku­maz; ilk bö­lü­mü­nü okur, ge­ri­si için tek­rar tek­rar par­ça is­ter. Bu, bağ­la­mı hız­la tü­ke­tir ve dos­ya­nın bir kıs­mı­nı göz­den ka­çır­ma, yan­lış yeri dü­zen­le­me ris­ki­ni ar­tı­rır. Aynı dos­ya bir in­san için de okun­maz hal­de­dir. Her dos­ya tek bir iş yap­sın, kod iş alan­la­rı­na göre kla­sör­len­sin (musteriler/, gorusmeler/, firsatlar/) ve bir­kaç yüz sa­tı­rı ge­çen dos­ya­lar bö­lün­sün. Bu ku­ra­lı aşa­ğı­da CLAUDE.md’ye ya­za­cak, hook’lar­la da des­tek­le­ye­ce­ğiz.

Pro­je de­ğil, port­föy dü­şü­nün. Ya­pay zeka her yeni pro­je­yi is­te­di­ği­niz tek­no­lo­ji­de sı­fır­dan baş­lat­ma­yı ko­lay­laş­tır­dı­ğı için şir­ket­ler­de tek­no­lo­ji kar­ma­şa­sı hiç ol­ma­dı­ğı ka­dar hız­lı bü­yü­ye­bi­lir. Be­de­li pro­je­yi ku­rar­ken de­ğil, ay­lar son­ra iş­le­tir­ken or­ta­ya çı­kar: Bir pro­je MSSQL’de, biri PostgreSQL’de, biri MariaDB’de ise üç ayrı ye­dek­le­me, iz­le­me ve gün­cel­le­me dü­ze­ni, üç ayrı uz­man­lık ge­re­kir. Bu­nun ye­ri­ne şir­ke­tin iç uy­gu­la­ma­la­rı için bir kez ka­rar ve­rin ve ya­zın: tek bir ve­ri­ta­ba­nı mo­to­ru, bir ya da en faz­la iki dil, tek bir ya­yın yön­te­mi, tek bir gi­riş sis­te­mi. Bu ka­rar­la­rı içe­ren bir şab­lon pro­je ve onun­la ge­len or­tak bir CLAUDE.md ha­zır­la­yın; her yeni pro­je ora­dan baş­la­sın. Stan­dart­tan sap­mak müm­kün, ama ya­zı­lı bir ge­rek­çey­le.

Ka­çı­nıl­ma­sı ge­re­ken­ler kı­sa­ca:

• Her pro­je­de fark­lı bir dil, çatı ve ve­ri­ta­ba­nı.
• Tek pro­je­de üç dört dil.
• Yeni ve az bi­li­nen ça­tı­lar; asis­tan eği­tim ta­ri­hin­den son­ra çık­mış sü­rüm­ler­de ol­ma­yan fonk­si­yon­lar uy­du­ra­bi­lir.
• Kü­çük bir CRM için mik­ro­ser­vis­ler.
• Her işe yeni bir kütüphane.

4. Projenin hafızası: CLAUDE.md

CLAUDE.md, Cla­ude Code’un her otu­ru­mun ba­şın­da oku­du­ğu ta­li­mat dos­ya­sı­dır. Pro­je­nin ne ol­du­ğu­nu, na­sıl ça­lış­tı­rıl­dı­ğı­nı ve han­gi ku­ral­la­ra uyu­la­ca­ğı­nı bu­ra­da söy­ler­si­niz. Her ko­nuş­ma­da aynı şey­le­ri baş­tan an­lat­mak zo­run­da kal­maz­sı­nız.

Baş­la­ma­nın en ko­lay yolu /init ko­mu­tu­dur. Cla­ude pro­je­ni­zi in­ce­ler ve bul­du­ğu ko­mut­lar­la, ya­pıy­la, ku­ral­lar­la bir tas­lak CLAUDE.md ha­zır­lar; dos­ya za­ten var­sa üze­ri­ne yaz­maz, iyi­leş­tir­me öne­rir. Son­ra bu tas­la­ğı, Claude’un ken­di ba­şı­na keş­fe­de­me­ye­ce­ği bil­gi­ler­le siz ta­mam­lar­sı­nız: ürün ta­nı­mı, tek­no­lo­ji ka­rar­la­rı, ya­sak­lar.

Cla­ude Code’un bel­ge­le­ri CLAUDE.md dos­ya­sı­nı 200 sa­tı­rın al­tın­da tut­ma­yı öne­ri­yor: Uzun dos­ya­lar daha faz­la bağ­lam tü­ke­tir ve ta­li­mat­la­ra uyu­mu azal­tır. Bu yüz­den CLAUDE.md bir el ki­ta­bı de­ğil, bir özet ol­ma­lı. Sa­de­ce be­lir­li kla­sör­ler­de ge­çer­li ku­ral­la­rı ayrı ku­ral dos­ya­la­rı­na ta­şı­ya­bi­lir­si­niz; bun­lar yal­nız­ca Cla­ude o kla­sör­ler­de ça­lı­şır­ken yük­le­nir. Baş­ka bir dos­ya­yı @docs/urun.md gibi bir ya­zım­la CLAUDE.md’ye bağ­la­mak da müm­kün; ama bağ­la­nan dos­ya da her otu­rum­da yük­len­di­ği için bağ­lam ma­li­ye­ti­ni azalt­maz.

Ör­nek CRM’in CLAUDE.md dos­ya­sı şöy­le baş­la­ya­bi­lir:

# Basit CRM

Satış ekibi için müşteri, görüşme ve fırsat takibi.
Ürün tanımı: @docs/urun.md

## Teknoloji
- Arayüz: Angular (TypeScript). Sunucu: Python, FastAPI. Veritabanı: PostgreSQL.
- Bunların dışında dil, çatı ya da veritabanı ekleme.
- Yeni bir paket eklemeden önce sor; adını, ne işe yaradığını ve neden
  gerektiğini açıkla.

## Komutlar
- Sunucuyu çalıştır: `uvicorn app.main:app --reload`
- Sunucu testleri: `pytest`
- Arayüz: `npm start`, testler: `npm test`

## Yapı
- Kod iş alanlarına göre klasörlenir: musteriler/, gorusmeler/, firsatlar/.
- Her dosya tek bir iş yapar; 300 satırı geçen dosyayı böl.

## Kurallar
- Testler geçmeden bir işi bitmiş sayma.
- Veritabanı şemasını yalnızca migration dosyasıyla değiştir, asla elle.
- Şifre, anahtar ya da bağlantı bilgisini koda yazma; ortam değişkeninden oku.
- Gerçek müşteri verisi kullanma; örnek veriyi kendin üret.

## Yasaklar
- .env dosyalarını okuma ya da değiştirme.
- Canlı veritabanına bağlanma.
- main dalına doğrudan push yapma.

Bu dos­ya­nın en bü­yük düş­ma­nı es­ki­me­si­dir: Kod de­ği­şir ama CLAUDE.md de­ğiş­mez­se Cla­ude es­ki­miş ta­li­mat­la­ra göre ça­lı­şır. Bunu na­sıl ön­le­ye­ce­ği­mi­zi ikin­ci bö­lüm­de ay­rı­ca an­la­ta­ca­ğım.

5. Skill’ler: az ama doğru

Skill, Cla­ude Code’a be­lir­li bir işi na­sıl ya­pa­ca­ğı­nı öğ­re­ten, pa­ket­len­miş bir ta­li­mat se­ti­dir; ge­re­kir­se yar­dım­cı be­tik­ler de içe­rir. Ör­ne­ğin bir gü­ven­lik de­ne­ti­mi­ni adım adım na­sıl ya­pa­ca­ğı­nı ya da bir ra­por bi­çi­mi­ni na­sıl üre­te­ce­ği­ni an­la­tan bir skill. Ken­di skill’le­ri­ni­zi ya­za­bi­le­ce­ği­niz gibi ha­zır olan­la­rı da ku­ra­bi­lir­si­niz. Ha­zır skill’leri bul­mak için skills.sh iyi bir baş­lan­gıç nok­ta­sı; lis­te­le­nen skill’ler tek bir ko­mut­la ku­ru­lur:

npx skills add <sahibi/repo>

Kur­mak ko­lay ol­du­ğu için çok kur­ma eği­li­mi do­ğar. Faz­la skill’in dört be­de­li var­dır:

• Bağ­lam şi­şer. Cla­ude, han­gi skill’i ne za­man kul­la­na­ca­ğı­na ka­rar ve­re­bil­mek için ku­ru­lu her skill’in açık­la­ma­sı­nı ko­nuş­ma­nın ba­şın­dan iti­ba­ren elin­de tu­tar. Ne ka­dar çok skill, o ka­dar az yer.
• Ta­li­mat­lar ça­kı­şır. Ben­zer iş­ler için bir­den faz­la skill olun­ca Cla­ude yan­lış ola­nı se­çe­bi­lir ya da aynı işi her se­fe­rin­de fark­lı ya­par.
• Gü­ven­lik. Bir skill, si­zin bil­gi­sa­ya­rı­nız­da si­zin yet­ki­le­ri­niz­le ça­lı­şan be­tik­ler içe­re­bi­lir. Üçün­cü ta­raf bir skill, kur­du­ğu­nuz bir ya­zı­lım ka­dar dik­kat is­ter.
• Ba­kım. Unu­tul­muş ve es­ki­miş bir skill, pro­je­yi çok­tan de­ğiş­miş ku­ral­la­ra göre yön­len­dir­me­ye de­vam eder.

Pra­tik ku­ral: Sı­fır­la baş­la­yın. Bir işi Claude’a üçün­cü kez ta­rif et­ti­ği­niz­de, o ta­rif bir skill ol­ma­yı hak edi­yor­dur. Kur­ma­dan önce içe­ri­ği­ni oku­yun, sa­de­ce gü­ven­di­ği­niz kay­nak­lar­dan ku­run ve pro­je­ye özel skill’leri pro­je kla­sö­rün­de tu­tun. /context ko­mu­tu, ku­ru­lu skill’le­rin bağ­lam­da ne ka­dar yer kap­la­dı­ğı­nı da gös­te­rir.

6. Hook’lar: ricadan kurala

CLAUDE.md’ye yaz­dı­ğı­nız bir ku­ral bir ri­ca­dır. Cla­ude çoğu za­man uyar; ama uzun bir otu­rum­da, ara­ya gi­ren on­lar­ca dos­ya­nın ara­sın­da unu­ta­bi­lir. Hook ise Cla­ude Code’un be­lir­li an­lar­da her se­fe­rin­de ça­lış­tır­dı­ğı bir ko­mut­tur: bir dos­ya dü­zen­len­dik­ten son­ra, bir ko­mut ça­lış­ma­dan önce, Cla­ude işi­ni bi­tir­di­ğin­de ya da ona­yı­nı­zı bek­le­di­ğin­de. Mo­de­lin ha­tır­la­ma­sı­na bağ­lı de­ğil­dir.

Ör­nek CRM için iki hook ye­ter­li bir baş­lan­gıç: Her dü­zen­le­me­den son­ra dos­ya­yı bi­çim­len­dir­mek ve teh­li­ke­li ko­mut­la­rı daha ça­lış­ma­dan dur­dur­mak. Hook’lar eki­bin or­tak ayar dos­ya­sı .claude/settings.json’a ya­zı­lır:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/bicimlendir.sh" }]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/tehlikeli-komut.sh" }]
      }
    ]
  }
}

Hook’a ge­len bil­gi, ör­ne­ğin dü­zen­le­nen dos­ya­nın adı ya da ça­lış­tı­rıl­mak is­te­nen ko­mut, JSON ola­rak ve­ri­lir. Bi­çim­len­dir­me be­ti­ği dos­ya­nın tü­rü­ne göre doğ­ru ara­cı ça­lış­tı­rır:

#!/bin/bash
# .claude/hooks/bicimlendir.sh
DOSYA=$(jq -r '.tool_input.file_path')
case "$DOSYA" in
  *.py) ruff format "$DOSYA" ;;
  *.ts | *.html | *.scss) npx prettier --write "$DOSYA" ;;
esac

Teh­li­ke­li ko­mut be­ti­ği ise ko­mu­tu in­ce­ler ve ge­re­kir­se en­gel­ler. Cla­ude en­gel­len­di­ği­ni ve ne­de­ni­ni gö­rür, baş­ka bir yol arar:

#!/bin/bash
# .claude/hooks/tehlikeli-komut.sh
KOMUT=$(jq -r '.tool_input.command')

if echo "$KOMUT" | grep -qiE 'rm -rf|drop (table|database)|git push .*main'; then
  jq -n '{
    hookSpecificOutput: {
      hookEventName: "PreToolUse",
      permissionDecision: "deny",
      permissionDecisionReason: "Bu komut proje kurallarına göre engellendi."
    }
  }'
fi

Be­tik­le­ri ça­lış­tı­rı­la­bi­lir yap­ma­yı unut­ma­yın (chmod +x .claude/hooks/*.sh). Windows’ta aynı hook’lar PowerShell be­tik­le­riy­le ya­zı­la­bi­lir. Hook’u ken­di­niz yaz­mak zo­run­da da de­ğil­si­niz; Claude’a ne is­te­di­ği­ni­zi an­la­tın, be­ti­ği ve aya­rı o yaz­sın, siz oku­yup onay­la­yın.

Hook’la­rın baş­ka ye­rin­de kul­la­nım­la­rı da var: Cla­ude işi­ni bi­tir­di­ğin­de test­le­ri ça­lış­tı­rıp so­nu­cu ona geri ver­mek, Cla­ude ona­yı­nı­zı bek­le­di­ğin­de size bil­di­rim gön­der­mek ya da bir lint ku­ra­lıy­la dos­ya uzun­lu­ğu sı­nı­rı­nı de­net­le­mek. Pra­tik ku­ral: Bir ku­ra­lı CLAUDE.md’de ikin­ci kez ha­tır­lat­mak zo­run­da kal­dıy­sa­nız, o ku­ral hook ol­ma­yı hak edi­yor­dur.

7. Güvenlik çerçevesi: önce çit, sonra bahçe

Cla­ude Code’a kod yaz­dır­ma­ya baş­la­ma­dan önce neye do­ku­na­bi­le­ce­ği­ni ve neye asla do­ku­na­ma­ya­ca­ğı­nı be­lir­le­yin.

İzin mo­du­nu bi­lin. Cla­ude Code’un bir­kaç ça­lış­ma modu var: Her iş­lem­de size so­ran ma­nu­el mod, dos­ya dü­zen­le­me­le­ri­ni onay­sız ya­pan mod, sa­de­ce oku­yup plan çı­ka­ran plan modu ve iş­lem­le­ri si­zin ye­ri­ni­ze ikin­ci bir mo­de­lin de­ğer­len­dir­di­ği auto modu. Gün­cel sü­rüm­ler­de ter­mi­nal ve VS Code otu­rum­la­rı var­sa­yı­lan ola­rak auto mo­dun­da baş­lar. Has­sas bir pro­je­de bunu bi­lin ve ge­re­ki­yor­sa ma­nu­el mod­da ça­lı­şın. Mod­lar ara­sın­da ter­mi­nal­de Shift+Tab ile, VS Code’da mod gös­ter­ge­sin­den ge­çi­lir. Bü­tün izin kont­rol­le­ri­ni ka­pa­tan modu şir­ket pro­je­le­rin­de hiç kul­lan­ma­yın.

Ku­ral­la­rı ya­zın. Mod ne olur­sa ol­sun, ayar dos­ya­sı­na yaz­dı­ğı­nız ku­ral­lar sı­nı­rı çi­zer. Bir ya­sak­la­ma ku­ra­lı, daha dar bir izin ku­ra­lıy­la de­li­ne­mez:

{
  "permissions": {
    "allow": ["Bash(pytest *)", "Bash(npm test *)"],
    "ask": ["Bash(git push *)", "Bash(alembic upgrade *)"],
    "deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"]
  }
}

Bu ayar­la test­ler onay­sız ça­lı­şır; push ve ve­ri­ta­ba­nı şe­ma­sı­nı de­ğiş­ti­ren ko­mut­lar her se­fe­rin­de size so­ru­lur; şif­re­le­rin dur­du­ğu dos­ya­lar hiç oku­na­maz.

Şif­re­ler koda gir­mez. Bağ­lan­tı bil­gi­le­ri ve anah­tar­lar or­tam de­ğiş­ken­le­rin­de ya da şir­ke­tin şif­re yö­ne­ti­ci­sin­de du­rur; kod on­la­rı ora­dan okur. Claude’un .env dos­ya­la­rı­nı oku­ya­ma­ma­sı bu yüz­den önem­li: Oku­ya­ma­dı­ğı bir şif­re­yi yan­lış­lık­la bir dos­ya­ya, bir loga ya da bir commit’e ya­za­maz.

Asis­ta­na asla yet­ki­li bir ve­ri­ta­ba­nı kul­la­nı­cı­sı ver­me­yin. Claude’un ve ge­liş­tir­me or­ta­mı­nı­zın bağ­lan­dı­ğı ve­ri­ta­ba­nı kul­la­nı­cı­sı, işi için ge­re­ken en az yet­ki­ye sa­hip ol­ma­lı. Tab­lo sil­me ya da şema de­ğiş­tir­me yet­ki­si ol­ma­ma­lı, can­lı ve­ri­ta­ba­nı­na hiç bağ­la­na­ma­ma­lı:

CREATE ROLE crm_gelistirme LOGIN PASSWORD '...';
GRANT CONNECT ON DATABASE crm_gelistirme TO crm_gelistirme;
GRANT USAGE ON SCHEMA crm TO crm_gelistirme;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA crm TO crm_gelistirme;
-- Tablo silme, tabloyu boşaltma ya da şema değiştirme yetkisi yok.

Şema de­ği­şik­lik­le­ri bu kul­la­nı­cıy­la de­ğil, sü­rüm­lü mig­ra­ti­on dos­ya­la­rıy­la ve ayrı bir yet­kiy­le ya­pı­lır. Cla­ude mig­ra­ti­on dos­ya­sı­nı ya­za­bi­lir; ama onu siz okur­su­nuz ve onay­lı bir sü­reç uy­gu­lar.

Sa­tır dü­ze­yi gü­ven­lik (RLS) ikin­ci ki­lit­tir. Uy­gu­la­ma­nın ken­di ku­ra­lı, ör­ne­ğin “her tem­sil­ci sa­de­ce ken­di eki­bi­nin müş­te­ri­le­ri­ni gö­rür”, kod­da unu­tul­sa bile ve­ri­ta­ba­nın­da ga­ran­ti al­tı­na alı­na­bi­lir:

ALTER TABLE crm.musteri ENABLE ROW LEVEL SECURITY;

CREATE POLICY ekip_musterileri ON crm.musteri
    USING (ekip_id = current_setting('app.ekip_id', true)::int);

Uy­gu­la­ma her is­tek­te app.ekip_id de­ğe­ri­ni otu­rum­da­ki kul­la­nı­cı­nın eki­bi­ne göre ayar­lar; yan­lış ya­zıl­mış bir sor­gu bile baş­ka bir eki­bin müş­te­ri­si­ni gö­re­mez. De­ğer hiç ayar­lan­ma­mış­sa ko­şul hiç­bir sa­tır­la eş­leş­mez: Uy­gu­la­ma bir yer­de eki­bi ayar­la­ma­yı unu­tur­sa ek­ran boş ge­lir, baş­ka­sı­nın ve­ri­si gel­mez. Önem­li bir ay­rın­tı: PostgreSQL’de sü­per kul­la­nı­cı­lar RLS’e ta­kıl­maz, tab­lo­nun sa­hi­bi de ay­rı­ca zor­lan­ma­dık­ça ta­kıl­maz. Yet­ki­li kul­la­nı­cı ver­me­me­nin bir ne­de­ni daha. SQL Server’da da aynı fi­kir bir ko­şul fonk­si­yo­nu ve bir gü­ven­lik po­li­ti­ka­sıy­la uy­gu­la­nır.

Uy­dur­ma pa­ket tu­za­ğı. Ya­pay zeka ba­zen var ol­ma­yan ama ku­la­ğa ger­çek­çi ge­len bir pa­ket adı öne­rir. Kötü ni­yet­li ki­şi­ler de tam bu uy­dur­ma ad­lar­la za­rar­lı pa­ket­ler ya­yım­lar. Cla­ude bir pa­ket ek­le­mek is­te­di­ğin­de pa­ke­tin ger­çek­ten var ol­du­ğu­nu, ki­min ya­yım­la­dı­ğı­nı, ne ka­dar kul­la­nıl­dı­ğı­nı ve kay­nak ko­du­nun ne­re­de ol­du­ğu­nu kont­rol edin. Ba­ğım­lı­lık dos­ya­la­rı­nı sa­bit­le­yin ve dü­zen­li ola­rak bir ba­ğım­lı­lık ta­ra­ma­sı ça­lış­tı­rın; npm audit ve pip-audit bu iş için var. CLAUDE.md’deki “yeni pa­ket ek­le­me­den önce sor” ku­ra­lı bu yüz­den ora­da.

8. KVKK ve şirket verisi: Asistana neyi asla vermezsiniz?

Bir ön­ce­ki bö­lüm tek­nik çiti an­la­tı­yor­du. Bu bö­lüm dav­ra­nış­la il­gi­li: Cla­ude Code’a ya da her­han­gi bir ya­pay zeka soh­be­ti­ne neyi ya­pış­tır­dı­ğı­nız.

Asla pay­la­şıl­ma­ya­cak­lar: Müş­te­ri ve ça­lı­şan bil­gi­le­ri, söz­leş­me­ler, fi­nan­sal ve­ri­ler, iç ya­zış­ma­lar, baş­ka sis­tem­le­rin şif­re­le­ri ve bağ­lan­tı bil­gi­le­ri. Ki­şi­sel ve­ri­ler KVKK kap­sa­mın­da­dır; bir ya­pay zeka hiz­me­ti­ne gön­de­ril­me­le­ri, şir­ke­tin bu iş­le­me için bir da­ya­na­ğı ve ona­yı ol­ma­dan ya­pıl­ma­ma­lı­dır.

Ger­çek veri ye­ri­ne ör­nek veri. Ge­liş­tir­me için ger­çek müş­te­ri lis­te­si­ne ih­ti­ya­cı­nız yok. Claude’dan ger­çek­çi ama uy­dur­ma bir ör­nek veri seti üret­me­si­ni is­te­yin: Türk­çe isim­ler, ge­çer­li bi­çim­de te­le­fon­lar, kont­rol ha­ne­si tu­tan ama kim­se­ye ait ol­ma­yan ver­gi nu­ma­ra­la­rı. Bir ha­ta­nın kay­na­ğı­nı bul­mak için ger­çek bir kay­da bak­ma­nız ge­re­ki­yor­sa, onu önce ano­nim­leş­ti­rin. Aynı dik­kat log dos­ya­la­rı ve ek­ran gö­rün­tü­le­ri için de ge­çer­li; iki­si de çoğu za­man ki­şi­sel veri içe­rir.

He­sa­bı­nı­zın veri aya­rı­nı bi­lin. Anthropic’in bi­rey­sel plan­la­rın­da (Free, Pro, Max), Cla­ude Code otu­rum­la­rı da­hil, ve­ri­le­ri­ni­zin mo­del eği­ti­min­de kul­la­nı­lıp kul­la­nıl­ma­ya­ca­ğı si­zin seç­ti­ği­niz bir ayar­dır ve giz­li­lik ayar­la­rın­dan de­ğiş­ti­ri­le­bi­lir. Ku­rum­sal plan­lar ve API gibi ti­ca­ri ko­şul­lar­da­ki hiz­met­ler bu kap­sam­da de­ğil­dir. Şir­ket işi için han­gi he­sap­la ça­lış­tı­ğı­nı­zı ve şir­ke­ti­ni­zin ya­pay zeka po­li­ti­ka­sı­nı bi­lin.

Pra­tik bir test: Bir şeyi soh­be­te ya­pış­tır­ma­dan önce ken­di­ni­ze so­run: “Bunu şir­ket dı­şın­dan bi­ri­ne e-pos­tay­la gön­de­rir miy­dim?” Ce­vap ha­yır­sa, ya­pış­tır­ma­yın.

9. Promptu dışarıda olgunlaştırın, Claude Code’a temiz verin

Cla­ude Code’a ya­rım bir fi­kir­le baş­la­mak ca­zip ge­lir: Bir şey is­ter­si­niz, so­nu­ca ba­kar­sı­nız, dü­zel­tir­si­niz, tek­rar is­ter­si­niz. Her tur hem za­man hem kul­la­nım har­car; otu­rum da ya­rım kal­mış de­ne­me­ler­le do­lar ve Claude’un ne­yin ge­çer­li ol­du­ğu­nu ayırt et­me­si zor­la­şır.

Daha iyi bir yol: Fik­ri önce bir soh­bet ara­yü­zün­de, ör­ne­ğin claude.ai’da, ol­gun­laş­tı­rın. Be­lir­siz nok­ta­la­rı sor­du­run, al­ter­na­tif­le­ri ko­nu­şun, ek­sik­le­ri ta­mam­la­yın. En son­da dört par­ça­lı te­miz bir gö­rev ta­nı­mı çı­ka­rın ve Cla­ude Code’a sa­de­ce bu son hali ve­rin:

• Bağ­lam: Ne üze­rin­de ça­lı­şı­lı­yor, il­gi­li dos­ya­lar han­gi­le­ri?
• He­def: Ne ya­pı­la­cak?
• Kı­sıt: Neye do­ku­nul­ma­ya­cak, han­gi ku­ral­la­ra uyu­la­cak?
• Ka­bul kri­te­ri: İş ne za­man bit­miş sa­yı­la­cak?

Fark, aynı is­te­ğin iki ha­lin­de açık­ça gö­rü­lür. Önce ya­rım fi­kir:

müşteri listesine arama ekle

Son­ra ol­gun­laş­mış hali:

Bağlam: musteriler/ altındaki liste ekranı ve GET /musteriler uç noktası.

Hedef: Listeye, unvan ya da vergi numarasıyla arama yapan bir arama kutusu ekle.

Kısıt:
- Arama sunucu tarafında yapılsın; bütün listeyi tarayıcıya çekme.
- Türkçe karakterler doğru eşleşsin: "Sukru" araması "Şükrü"yü bulsun.
- Yeni paket ekleme. Mevcut tablo bileşenini kullan.

Kabul kriteri:
- Unvanın bir kısmıyla ya da vergi numarasının tamamıyla arama çalışıyor.
- Boş arama bütün listeyi gösteriyor.
- Yeni davranış için sunucu tarafında test var ve bütün testler geçiyor.

İkin­ci prompt’u yaz­mak bir­kaç da­ki­ka sü­rer; ama ilk de­ne­me­de doğ­ru işe baş­la­tır. Türk­çe ka­rak­ter kı­sı­tı­nın ne­den önem­li ol­du­ğu­nu te­kil­leş­tir­me ya­zı­sın­da­ki Türk­çe ka­rak­ter tu­za­ğı ay­rın­tı­lı an­la­tı­yor. Bir uya­rı: Bir ön­ce­ki bö­lüm­de­ki ku­ral bu dış soh­bet­ler için de ge­çer­li. Fik­ri ol­gun­laş­tı­rır­ken de şir­ket ve­ri­si pay­laş­ma­yın.

10. Gücü nerede harcamalı? Effort, model ve alt ajanlar

Cla­ude Code’da iki ayar­la ne ka­dar “güç” har­ca­dı­ğı­nı­zı be­lir­ler­si­niz: han­gi mo­de­lin ça­lış­tı­ğı ve mo­de­lin ne ka­dar dü­şü­ne­ce­ği. Mo­del /model ko­mu­tuy­la, dü­şün­me dü­ze­yi (ef­fort) /effort ko­mu­tuy­la de­ği­şir; ef­fort low, medium, high, xhigh ve max dü­zey­le­rin­den bi­ri­ne ayar­la­nır.

Her işi en pa­ha­lı mo­de­le yap­tır­ma­yın. En güç­lü mo­del ve en yük­sek ef­fort, ger­çek­ten dü­şün­me­yi ge­rek­ti­ren iş­ler için­dir: mi­ma­ri ka­rar­lar, plan­la­ma, inat­çı bir ha­ta­nın kay­na­ğı­nı bul­mak. Bir pla­nın mad­de­le­ri­ni tek tek uy­gu­la­mak, test yaz­mak, kü­çük dü­zelt­me­ler ise daha hız­lı bir mo­de­lin ve daha dü­şük bir ef­fort dü­ze­yi­nin işi­dir. Yük­sek ayar bu iş­ler­de daha iyi so­nuç ver­mez; sa­de­ce daha ya­vaş ça­lı­şır ve daha faz­la kul­la­nım tü­ke­tir. Var­sa­yı­la­nı en yük­sek­te bı­rak­ma­yın; ge­rek­ti­ğin­de yük­sel­tin. Cla­ude Code’un bu­nun için ha­zır bir mo­del aya­rı da var: opusplan plan mo­dun­da en güç­lü mo­de­li, uy­gu­la­ma­da daha hız­lı ola­nı kul­la­nır. Bu iş bö­lü­mü­nü ikin­ci bö­lüm­de bir plan dos­ya­sı üze­rin­den ay­rın­tı­lı an­la­ta­ca­ğım. Ne ka­dar kul­la­nım har­ca­dı­ğı­nı­zı /usage ko­mu­tuy­la gö­re­bi­lir­si­niz.

Alt ajan­la­rı ge­re­ğin­den faz­la kul­lan­ma­yın. Alt ajan­lar ken­di bağ­lam­la­rın­da, ana ko­nuş­ma­dan ba­ğım­sız ça­lı­şır ve aynı anda bir­kaç iş yü­rü­te­bi­lir. Ca­zip gö­rü­nür­ler; ama her yeni ajan yö­ne­til­me­si ge­re­ken bir iş daha de­mek­tir:

• Ça­kış­ma. Aynı dos­ya­la­ra do­ku­nan iki ajan bir­bi­ri­nin de­ği­şik­li­ği­ni ezer.
• İn­ce­le­me yükü. On aja­nın yap­tı­ğı­nı göz­den ge­çir­mek, işi ken­di­ni­zin yap­ma­sın­dan uzun sü­re­bi­lir.
• Ma­li­yet. Her ajan ayrı bir bağ­lam açar ve ana ko­nuş­may­la aynı kul­la­nım li­mi­tin­den har­car.

Alt ajan­la­rı bir­bi­rin­den ba­ğım­sız ve ço­ğun­luk­la oku­ma ağır­lık­lı iş­le­re ve­rin: kod ta­ba­nın­da ara­ma, araş­tır­ma, in­ce­le­me. Aynı dos­ya­la­ra ya­zan pa­ra­lel iş­ler çı­kar­ma­yın; pa­ra­lel de­ği­şik­lik ger­çek­ten ge­re­ki­yor­sa her ajan ayrı bir ça­lış­ma kop­ya­sın­da (worktree) ça­lış­sın. So­nuç­la­rı bir­leş­ti­ren hep tek bir yer ol­sun: ana otu­rum ve siz.

Bu bö­lüm, skill’ler bö­lü­mün­de­ki uya­rı­nın bir tek­ra­rı as­lın­da: Daha faz­la araç daha iyi so­nuç de­mek de­ğil­dir. Yö­ne­te­me­di­ği­niz her par­ça bir risk­tir.

Hazırlık kontrol listesi

• Ürün ta­nı­mı bir say­fa­da ya­zı­lı; “şim­di­lik yap­ma­ya­cak­la­rı­mız” lis­te­si var.
• Pro­je Git’te; her an­lam­lı adım bir com­mit.
• Tek­no­lo­ji, şir­ke­tin mev­cut or­ta­mı­na ve stan­dar­dı­na uy­gun.
• CLAUDE.md 200 sa­tı­rın al­tın­da; tek­no­lo­ji ka­rar­la­rı, ko­mut­lar, ku­ral­lar ve ya­sak­lar ya­zı­lı.
• Ku­ru­lu skill’ler az, okun­muş ve gü­ve­ni­lir kay­nak­tan.
• Bi­çim­len­dir­me ve teh­li­ke­li ko­mut en­ge­li hook ola­rak ta­nım­lı.
• İzin ku­ral­la­rı ya­zı­lı; .env ve şif­re dos­ya­la­rı oku­na­mı­yor.
• Ge­liş­tir­me ve­ri­ta­ba­nı kul­la­nı­cı­sı en az yet­ki­li; can­lı­ya eri­şi­mi yok; RLS açık.
• Ger­çek müş­te­ri ve­ri­si yok; ör­nek veri üre­til­di.
• Gö­rev­ler bağ­lam, he­def, kı­sıt ve ka­bul kri­te­riy­le ya­zı­lı­yor.
• Var­sa­yı­lan mo­del ve ef­fort aya­rı her iş için en yük­sek­te de­ğil.

Bonus: Projeyi başlatan ilk prompt

Ha­zır­lık bit­ti­ğin­de Cla­ude Code’a ve­re­ce­ği­niz ilk gö­rev, ya­zıl­mış ku­ral­la­rı an­la­yıp bir plan çı­kar­mak­tır; kod yaz­mak de­ğil. Aşa­ğı­da­ki prompt’u plan mo­dun­da ve­rin. Kö­şe­li pa­ran­tez­li yer­le­ri ken­di pro­je­ni­ze göre dol­du­run:

Yeni bir projeye başlıyoruz. Önce @docs/urun.md dosyasındaki ürün tanımını
ve CLAUDE.md'deki kuralları oku. Henüz kod yazma.

Senden istediğim:
1. Ürün tanımını kendi cümlelerinle beş maddede özetle. Belirsiz ya da
   çelişkili bulduğun yerleri soru olarak listele.
2. CLAUDE.md'deki teknoloji kararlarına uyan bir klasör yapısı öner.
   [Angular, FastAPI, PostgreSQL] dışında bir teknoloji önermen gerekirse
   önce gerekçesini yaz ve onayımı bekle.
3. Kurulması gereken paketleri listele; her biri için ne işe yaradığını
   ve neden gerektiğini yaz. Hiçbirini kurma.
4. İlk dikey dilim olarak "müşteri ekle ve listele" işini uçtan uca
   (veritabanı tablosu, migration, API uç noktası, arayüz ekranı, testler)
   küçük adımlara böl. Her adımın "bitti" tanımını yaz.

Bu planı docs/plan.md dosyasına yazmayı öner; ben onaylamadan hiçbir
dosya oluşturma.

Bu prompt’un so­nun­da eli­niz­de bir kod de­ğil, bir plan olur. Pla­nın na­sıl oku­na­ca­ğı­nı, dü­zel­ti­le­ce­ği­ni ve uy­gu­la­tı­la­ca­ğı­nı, ek­ra­nı kod­la­ma­dan önce ta­sa­rı­mın na­sıl se­çi­le­ce­ği­ni ve uy­gu­la­ma­nın gü­ven­li bir şe­kil­de na­sıl ya­yı­na alı­na­ca­ğı­nı se­ri­nin ikin­ci bö­lü­mün­de an­la­ta­ca­ğım.

Özet

• Kodu siz an­la­mı­yor­sa­nız, o kod si­zin de­ğil­dir. Cla­ude Code ya­zar; so­rum­lu­luk siz­de ka­lır.
• Önce bir say­fa: Kim kul­la­na­cak, han­gi üç işi ya­pa­cak, “bit­ti” ne de­mek ve şim­di­lik neyi yap­ma­ya­cak­sı­nız.
• Or­ta­ma uy­gun tek­no­lo­ji: Kodu ya­zan de­ğil, iş­le­ten be­lir­ler. Ya­pay ze­ka­nın en iyi ça­lış­tı­ğı yapı, in­sa­nın da en ko­lay ba­kım yap­tı­ğı ya­pı­dır: tip­li dil­ler, kü­çük dos­ya­lar, tu­tar­lı bir dü­zen. Pro­je de­ğil port­föy dü­şü­nün.
• CLAUDE.md kısa ve gün­cel ol­ma­lı; skill’ler az ve gü­ve­ni­lir; ku­ral­lar hook’lar­la ga­ran­ti al­tın­da.
• Önce çit, son­ra bah­çe: İzin­ler, en az yet­ki­li ve­ri­ta­ba­nı kul­la­nı­cı­sı, RLS ve pa­ket kont­ro­lü.
• Şir­ket ve­ri­si asis­ta­na git­mez; ör­nek ve­ri­yi asis­tan üre­tir.
• Prompt dı­şa­rı­da ol­gun­la­şır, içe­ri­de te­miz ve­ri­lir. Güç, ge­rek­ti­ği yer­de har­ca­nır.

Cla­ude Code’a ne ka­dar iyi bir çer­çe­ve ve­rir­se­niz, o ka­dar az kod yaz­ma­nız ve o ka­dar çok ka­rar ver­me­niz ge­re­kir. İyi bir çer­çe­ve­de kod yaz­mak, işin en ko­lay kıs­mı­dır.