10 Dakikada Cursor Kullanım Limitlerine Takılmayı Ciddi Şekilde Azaltacak Workflow

Öncelikle bu yazı, “AI artık her şeyi yapıyor, yazılımcılara gerek kalmadı” diyerek ortalıkta dolaşan, kullandığı teknolojinin en temel problemini bile anlamadan sadece prompt yazarak ürün geliştirdiğini sanan kişiler için değil.
Bu yazı; saatlerce dokümantasyon okuyan, kullandığı framework’ün neden var olduğunu anlamaya çalışan, hatayı Agent’a atmadan önce kendi mimarisini sorgulayan ve AI’ı bir “sihirli değnek” değil, teknik üretkenliğini artıran bir ekip arkadaşı olarak gören yazılımcılar için.
Vibe coding yapan biri, Agent ne derse ona razı olmak zorundadır. Model yanlış dosyayı değiştirirse fark edemez. Yanlış abstraction kurarsa anlayamaz. Gereksiz context yerse durduramaz. Token’ları yanar, proje şişer, hata büyür.
Ama teknolojisini bilen bir yazılımcı için AI bambaşka bir şeydir.
Doğru context’i verir. Doğru sınırı çizer. Yanlış çıktıyı yakalar. Agent’ı planlatır, yönlendirir, gerektiğinde durdurur.
Bu yüzden mesele “AI yazılımcıları bitirecek mi?” değil.
AI, ne yaptığını bilmeyenleri daha hızlı batıracak; ne yaptığını bilenleri ise çok daha güçlü hale getirecek.
Bu yazıda Cursor kullanırken token’ları boşa yakmamak, Agent’ı daha kontrollü kullanmak ve AI destekli geliştirme sürecini gerçekten yazılımcı gibi yönetmek için uygulayabileceğin workflow’u anlatacağım.
AI kod editörleri inanılmaz hız kazandırıyor ama kontrolsüz kullanıldığında çok hızlı token yakıyor.
Özellikle Cursor gibi yapay zeka destekli editör kullanıyorsan bu hissi biliyorsundur.
Bir feature üzerinde çalışıyorsun. Agent’a birkaç prompt veriyorsun. Sonra bir bakıyorsun; aynı dosyalar tekrar tekrar okunmuş, context şişmiş, model aynı şeyi defalarca açıklamış, birkaç kez yanlış yoldan gidilmiş ve sen fark etmeden kullanım hakkının büyük kısmı gitmiş.
Benim için asıl kırılma noktası şuydu:
Cursor kötü çalışmıyordu.
Ben Cursor’ı yanlış kullanıyordum.
Çünkü AI editörlerinde limitleri bitiren şey genellikle “çok soru sormak” değil. Asıl pahalı olan şey, yanlış context ile kod yazdırmak, agent’ı plansız çalıştırmak, aynı işi birkaç kez baştan yaptırmak ve gereksiz dosyaları sürekli bağlama sokmak.
Bu yazıda Cursor kullanırken daha az token harcamak, daha temiz çıktı almak ve Agent’ı daha kontrollü kullanmak için uygulayabileceğin pratik bir workflow anlatacağım.
Ben Cursor üzerinden anlatacağım ama bu yazı Cladue, Antigravity kullananlar içinde haliyle geçerli olacak. O yüzden “Cursor” kısmına hiç takılma. Bu yöntemleri hangisine uygularsan, aynı sonucu alacaksın.
Bu yöntemler limitleri yok etmez tabiki. Ama Agent’ları daha bilinçli kullanırsan, aynı işi çok daha az denemeyle, daha az context şişmesiyle ve daha az model harcamasıyla bitirebilirsin.
1. Kod Yazdırmadan Önce Plan Yaptır

Bu bazen küçük değişikliklerde işe yarar. Ama yeni feature, refactor, auth sistemi, dashboard yapısı, ödeme entegrasyonu, RBAC, database schema değişimi gibi işlerde doğrudan kod yazdırmak genellikle pahalıya patlar.
Çünkü Agent ilk seferde yanlış varsayım yaparsa, sonrasında onu düzeltmek için 5–10 prompt daha atarsın. Bu sırada eski context büyür, dosyalar tekrar okunur, kod tekrar değiştirilir ve token kullanımı katlanır.
Cursor’ın kendi önerdiği güçlü yöntemlerden biri Plan Mode kullanmaktır. Plan Mode’da Agent hemen kod yazmaz; önce codebase’i araştırır, ilgili dosyaları bulur, senden gerekiyorsa netleştirme ister, sonra uygulanabilir bir plan çıkarır.
Benim önerdiğim pratik akış şu:
Önce kod yazma.
Bu feature için mevcut codebase'i incele. İlgili dosyaları, mevcut pattern'leri ve riskli noktaları çıkar. Sonra bana uygulanabilir bir plan ver.
Plan şunları içersin:
- Hangi dosyalar değişecek?
- Hangi yeni dosyalar eklenecek?
- Backend/frontend ayrımı ne olacak?
- Veritabanı veya API değişikliği var mı?
- Riskli noktalar neler?
- Test veya manuel kontrol adımları neler?
Ben onaylamadan kod yazma.
Bu prompt basit görünüyor ama Cursor kullanımını ciddi şekilde değiştiriyor.
Çünkü Agent artık “hemen üretici” değil, önce “analizci” oluyor.
Özellikle büyük projelerde şunu unutma:
Plansız Agent, junior developer gibi davranır. Planlı Agent, teknik task alan bir ekip arkadaşı gibi davranır.
2. Büyük İşi Tek Prompt’a Yükleme
Agent’lar artık çok gelişti ve güçlü, bu yüzden her şeyi tek seferde yaptırmak cazip geliyor.
Mesela:
RBAC sistemi kur, admin/editor/viewer rollerini ekle, UI’da yönetim paneli yap, MongoDB şemasını düzenle, permission kontrolü ekle, middleware yaz, sidebar’ı role göre filtrele.
Bu kötü bir prompt değil ama tek seferde çok büyük. Opus veya Sonnet gibi çok güçlü bir agent’ta seçiliyse, tatmin edici bir şeyde çıkabilir.
Ancak böyle bir prompt Agent’ı, Database schema, Backend auth, UI state, Form validation, Edge case’ler vs. hakkında aynı anda düşünmeye zorlar.
Bu kadar büyük context, hem hata ihtimalini artırır hem de token kullanımını şişirir.
Bunun yerine işi böl:
Aşama 1: Sadece mevcut auth ve project erişim yapısını analiz et. Kod yazma.
Aşama 2: RBAC için önerilen MongoDB schema tasarımını çıkar. Kod yazma.
Aşama 3: Sadece backend permission middleware’ini ekle.
Aşama 4: Sadece UI’da role/permission yönetim ekranının iskeletini çıkar.
Aşama 5: Sidebar ve route erişimini role göre filtrele.
Aşama 6: Son olarak tüm değişiklikleri review et ve eksik güvenlik noktalarını listele.
Buradaki amaç yavaşlamak değil.
Tam tersine, Agent’ın yanlış yöne 30 dosya değiştirmesini engellemek.
Agent ile verimli çalışmanın temel kuralı şu:
Büyük işi küçük, doğrulanabilir parçalara böl. Her parçanın sonunda diff’i oku. Sonra bir sonraki adıma geç.
3. Uzun Chat’leri Sürekli Kullanma

Aynı chat üzerinde uzun konuşmalar sessiz token katilidir.
Aynı Agent sohbetinde saatlerce devam ettiğinde, model eski bağlamı tekrar tekrar taşımaya başlar. İlk başta işe yarıyor gibi görünür ama bir süre sonra iki problem çıkar:
Birincisi, token kullanımı artar.
İkincisi, modelin dikkati dağılır.
Eski kararlar, vazgeçilen fikirler, değişmiş dosyalar, artık geçerli olmayan açıklamalar hâlâ context içinde kalabilir.
Bu yüzden uzun bir Agent konuşmasını sonsuza kadar sürdürmek yerine, belirli noktalarda temiz başlangıç yapmalısın.
Benim kullandığım yöntem:
Bu oturumu yeni bir Cursor chat’inde devam ettireceğim.
Bana bu konuşmadaki güncel ve hâlâ geçerli bilgileri özetleyen bir handoff prompt hazırla.
Şunları dahil et:
- Projenin amacı
- Yapılan değişiklikler
- Alınan teknik kararlar
- Değişen dosyalar
- Devam edilmesi gereken yer
- Dikkat edilmesi gereken riskler
- Artık geçerli olmayan kararlar
Sonra yeni chat açıp bu handoff prompt’u yapıştır.
Bu yöntem hem context’i temizler hem de Agent’ın gereksiz eski detaylarla oyalanmasını engeller.
Kural basit:
Bir chat çok uzadıysa, onu “hafıza” gibi kullanma. Özet al, yeni chat’e geç.
4. Cursor Rules ile Tekrar Tekrar Aynı Şeyleri Anlatma
Cursor’da token israfının büyük kısmı aynı talimatları sürekli tekrar etmekten gelir.
Mesela her seferinde şunları yazıyorsan:
TypeScript kullan. Clean code yaz. Mevcut folder structure’a uy. Gereksiz abstraction yapma. MongoDB tarafında ObjectId ilişkilerine dikkat et. Next.js App Router kullanıyoruz. Expo tarafında styled-components kullanıyoruz.
Bunları her prompt’ta yazmak yerine Cursor Rules kullanmalısın.
Benim önerdiğim yapı:
.cursor/ rules/ project-architecture.mdc code-style.mdc backend-rules.mdc frontend-rules.mdc ai-workflow.mdc
Örnek bir project-architecture.mdc:
Project Architecture Rules
- Mevcut folder structure’a uy.
- Yeni klasör açmadan önce benzer bir pattern var mı kontrol et.
- Gereksiz abstraction oluşturma.
- Büyük dosyaları küçük ama anlamlı parçalara böl.
- Business logic’i UI component içine gömme.
- API, service, validation ve UI katmanlarını ayrı tut.
- Kod yazmadan önce ilgili mevcut dosyaları incele.
- Emin olmadığın yerde varsayım yapma, önce plan çıkar.
Örnek ai-workflow.mdc:
AI Workflow Rules
- Büyük değişikliklerde önce plan ver, hemen kod yazma.
- Plan içinde değişecek dosyaları listele.
- Her değişiklikten sonra kısa bir özet ver.
- Kod yazdıktan sonra potansiyel riskleri belirt.
- Linter/test varsa çalıştırmayı öner veya çalıştır.
- Aynı problemi üçüncü kez düzeltmeye çalışıyorsan dur ve yaklaşımı yeniden değerlendir.
Bunu bir kez kurduğunda her prompt daha kısa olur.
Daha önemlisi, Agent her seferinde projeye sıfırdan gelmiş gibi davranmaz.
5. “Memory Bank” Sistemi Kur
Cursor Rules statik kurallar için iyidir.
Ama proje ilerledikçe bazı kararlar değişir:
- Bu projede artık Redux Toolkit kullanılacak.
- Auth middleware değişti.
- Eski API yapısı deprecated oldu.
- Bazı teknik borçlar sonra çözülecek.
- Form validation için artık Zod kullanılacak.
- Yeni component’ler mevcut design system üzerinden yazılacak.
Çünkü Cursor’daki bir Agent sohbetinde aldığın karar, yeni açtığın başka bir sohbette otomatik olarak hatırlanmayabilir. Bu yüzden projeye küçük bir Memory Bank dosyası eklemek çok işe yarar.
Yapı:
docs/ memory.md
Örnek memory.md:
Proje Hafızası
Son güncelleme: 2026-05-04
Proje Özeti
Bu proje React, TypeScript ve Node.js ile geliştirilmiş bir web uygulamasıdır.
Proje iki ana parçadan oluşur:
- Frontend: React uygulaması
- Backend: Node.js API
Temel amaç; codebase’i basit, okunabilir ve bakımı kolay tutmaktır.
Mevcut Mimari
- Frontend component’leri
src/componentsaltında tutulur. - Sayfa seviyesindeki ekranlar
src/pagesaltında tutulur. - Ortak utility fonksiyonları
src/utilsaltında tutulur. - API request fonksiyonları
src/servicesaltında tutulur. - Backend route’ları
server/routesaltında tutulur. - Backend business logic’i
server/servicesaltında tutulur.
Aktif Teknik Kararlar
- Yeni yazılan tüm kodlarda TypeScript kullanılmalı.
- React tarafında functional component kullanılmalı.
- Component’ler küçük ve odaklı tutulmalı.
- Business logic doğrudan UI component’lerinin içine yazılmamalı.
- API çağrıları için service fonksiyonları kullanılmalı.
- Yeni validation logic gerektiğinde Zod tercih edilmeli.
- Gereksiz abstraction yerine basit fonksiyonlar tercih edilmeli.
Kullanılmaması Gereken / Kaçınılacak Yapılar
- Yeni class-based React component oluşturma.
- Çok küçük bir durum değilse business logic’i page component’lerinin içine koyma.
- Önce sormadan yeni bir state management library ekleme.
- Task gerektirmediği sürece çalışan mevcut kodu baştan yazma.
- Nedenini açıklamadan folder structure’ı değiştirme.
Devam Eden İşler
- User settings sayfası iyileştiriliyor.
- Form validation yapısı standart hale getiriliyor.
- Bazı eski API çağrılarının hâlâ
src/servicesaltına taşınması gerekiyor.
Bilinen Sorunlar
- Bazı component’ler çok büyük ve ileride parçalanmaları gerekebilir.
- Formlardaki hata mesajları tamamen tutarlı değil.
- Bazı API fonksiyonları hâlâ gevşek tipli response döndürüyor.
AI Talimatları
Büyük bir değişiklik yapmadan önce:
- Bu dosyayı oku.
- İlgili mevcut dosyaları incele.
- Mevcut pattern’i açıkla.
- Kısa bir plan öner.
- Çok sayıda dosyayı düzenlemeden önce onay bekle.
Önemli bir teknik karar değiştiğinde, bu dosyanın güncellenmesini öner.
Agent’a memory.md oluşturtmak için prompt:
Bu proje için bir Memory Bank dosyası oluşturmanı istiyorum.
Önce codebase’i incele ama kod yazma.
Şunları analiz et:
- Projenin genel amacı ne?
- Kullanılan ana teknolojiler neler?
- Folder structure nasıl?
- Frontend/backend ayrımı var mı?
- Önemli mimari pattern’ler neler?
- Tekrar eden kod yazım alışkanlıkları neler?
- Dikkat edilmesi gereken deprecated veya eski yapılar var mı?
- Yeni kod yazarken uyulması gereken kurallar neler?
Sonra docs/memory.md dosyası için sade ve güncel bir içerik öner.
Dosya şu bölümleri içersin:
- Project Summary
- Tech Stack
- Current Architecture
- Active Technical Decisions
- Deprecated / Avoid
- Current Work In Progress
- Known Issues
- AI Instructions
Önemli:
- Varsayım yapma.
- Emin olmadığın yerleri "Unknown" veya "Needs confirmation" olarak işaretle.
- Gereksiz uzun yazma.
- Bu dosya Agent’ın projeyi daha hızlı anlaması için kullanılacak.
- Kod değiştirme, sadece
docs/memory.mdiçeriğini öner.
Bir feature tamamlandıktan veya mimari karar değiştikten sonra da şu prompt’u kullanabilirsin:
Son yaptığımız değişikliklere göre docs/memory.md
dosyasını güncellememiz gerekiyor mu?
Önce mevcut docs/memory.md dosyasını oku.
Sonra son değişiklikleri incele.
Şunları söyle:
- Hangi bilgiler hâlâ doğru?
- Hangi bilgiler değişti?
- Yeni eklenmesi gereken teknik karar var mı?
- Deprecated / Avoid bölümüne eklenmesi gereken bir şey var mı?
- Known Issues bölümünde güncelleme gerekiyor mu?
Önce öneri ver. Ben onaylamadan dosyayı değiştirme.
6. Codebase Indexing’i Temiz Tut
Agent’ların gücü codebase context’inden gelir.
Ama codebase context’i kirliyse Agent da kirli düşünür.
Özellikle büyük projelerde gereksiz dosyaların indexlenmesi hem aramayı zayıflatır hem de context yönetimini pahalılaştırır.
Cursor, .cursorignore ve .cursorindexingignore dosyalarıyla hangi dosyalara erişilebileceğini veya hangi dosyaların indexlenmeyeceğini kontrol etmeyi destekliyor -> Döküman
Benim önerdiğim başlangıç .cursorignore veya .cursorindexingignore mantığı:
node_modules .next dist build coverage .expo .turbo .cache .env .env.* *.log
package-lock.json
yarn.lock
pnpm-lock.yaml
Burada dikkat etmen gereken şey şu:
Lock file’ları bazen gerekli olabilir. Ama çoğu feature geliştirme prompt’unda Agent’ın package-lock.json veya devasa build çıktılarıyla uğraşmasına gerek yoktur.
Ayrıca büyük projelerde şunu da yapabilirsin:
docs/archive legacy tmp generated
Tabii gerçekten gerekli dosyaları dışlamadığından emin olmalısın.
Cursor’a ne kadar temiz context verirsen, Agent o kadar az saçmalar.
7. Her Şey İçin En Güçlü Modeli Kullanma

Cursor’ın en güzel taraflarından biri farklı modelleri aynı editör içinde kullanabilmen.
Ama her iş için en güçlü modeli kullanmak genellikle israftır.
Basit görevler için güçlü model kullanmana gerek yok:
- Regex yazdırmak
- Küçük component refactor’ı
- Basit TypeScript type düzeltmesi
- CSS class düzenleme
- Kısa açıklama isteme
- Küçük utility function yazdırma
Bunlarda daha ucuz veya daha hızlı bir model yeterli olabilir. Deneyimlerime göre composer 2, iyi bir prompt ile bu tarz küçük geliştirmeleri temiz bir şekilde halledebiliyor.
Güçlü modeli şuralarda kullan:
- Büyük mimari kararlar
- Multi-file refactor
- Kritik bug analizi
- Auth, permission, payment gibi riskli işler
- Database schema değişiklikleri
- Production’a yakın kod review
Benim model kullanımı için pratik ayrımım şöyle:
Basit soru / açıklama: Daha ucuz veya hızlı model (composer 2)
Kod okuma / küçük düzenleme: Orta seviye model (gemini, composer)
Büyük feature / refactor / kritik karar: Güçlü model (sonnet, opus)
Final review: Güçlü model (sonnet, opus)
Yani güçlü modeli baştan sona yaktırmak yerine, onu final kalite kontrol ve zor kararlar için sakla.
8. MCP’leri Gerektiği Kadar Kullan

MCP, Cursor’ı dış araçlara bağlamak için çok güçlü bir sistem.
Örneğin GitHub, PostHog, database, dokümantasyon, issue tracker veya başka servisleri Cursor’a bağlayabilirsin.
Ama her MCP’yi açmak iyi fikir değildir.
Çünkü her ek araç, Agent’ın karar alanını büyütür. Yanlış yapılandırılmış MCP’ler gereksiz context, gereksiz tool çağrısı ve daha karmaşık cevaplara yol açabilir.
Cursor’ın MCP tarafında dynamic context discovery ile statik context’i azaltmaya çalıştığı ve MCP tool kullanılan koşulda toplam agent token kullanımını düşüren bir test sonucu paylaştığı da var. Bu iyi bir gelişme ama yine de MCP’leri bilinçli kurmak gerekir.
Benim önerim:
Her projede maksimum 2–3 gerçekten gerekli MCP ile başla.
Örneğin:
- GitHub MCP
- PostHog MCP
- Docs/Context MCP
Database MCP kullanıyorsan production erişimi verme. Read-only veya local/dev ortamla sınırla.
MCP için güvenli prompt örneği:
Gerekmedikçe MCP tool çağırma. Önce local codebase’i incele. Harici tool sadece mevcut context yetersizse kullanılsın. Production verisi üzerinde write işlemi yapma.
9. Agent’a Test ve Linter Hedefi Ver
Agent’ların en büyük problemi şu:
Çıktı bazen doğru görünür ama çalışmaz.
Cursor’ın kendi best practice makalesinde de Agent’lara doğrulanabilir hedefler verilmesi, typed language, linter ve test kullanılması öneriliyor.
Bu yüzden “şunu yap” demek yerine “şunu yap ve şu kontrollerden geçir” demek daha iyi.
Örnek:
Bu değişikliği yaptıktan sonra:
- TypeScript error var mı kontrol et.
- İlgili route/component compile oluyor mu kontrol et.
- Varsa mevcut testleri çalıştır.
- Test yoksa manuel kontrol adımlarını yaz.
- Riskli gördüğün yerleri ayrıca listele.
Bu, token’ı artırıyor gibi görünebilir ama uzun vadede azaltır.
Çünkü bozuk kodu 5 prompt sonra düzeltmektense, ilk seferde kontrol ettirmek daha ucuzdur.
10. Agent’ı Sonsuz Döngüye Sokma

Bazen Cursor Agent aynı hatayı tekrar tekrar düzeltmeye çalışır.
Şöyle bir döngü oluşur:
- Kod yazar.
- Hata alır.
- Bir şeyi değiştirir.
- Başka hata çıkar.
- Önceki düzeltmeyi bozar.
- Yeniden dener.
- Daha da karışır.
Bu noktada devam etmek token yakmaktır.
Benim kuralım:
Agent aynı problemi iki kez çözemiyorsa, üçüncü denemede durdur.
Sonra şu prompt’u ver:
Dur.
Şu ana kadar ne denedin? Hangi hatalar oluştu? Hangi varsayım yanlış çıkmış olabilir? Alternatif çözüm yollarını listele. Kod yazma.
Bu prompt Agent’ı “panik halinde kod değiştirme” modundan çıkarıp tekrar analiz moduna alır.
Bonus: Gerektiğinde Kod Yaz
Cursor, Agent, MCP, skills, rules, memory bank derken bazen en basit şeyi unutuyoruz:
Burası hâlâ yazılım geliştirme.
AI sana hız kazandırabilir, dosyalar arasında gezebilir, pattern yakalayabilir, boilerplate yazabilir, refactor önerebilir ve test senaryosu çıkarabilir. Ama bu senin artık kod yazmayacağın anlamına gelmez.
Bazen bir problemi çözmenin en hızlı yolu Agent’a 8 prompt daha yazmak değil, dosyayı açıp 5 satır kod yazmaktır.
- Değişiklik çok küçükse
- Ne yapılacağını zaten net biliyorsan
- Agent aynı hatayı ikinci kez tekrar ediyorsa
- Kodun bulunduğu dosyayı sen Agent’tan daha iyi anladıysan
- Sadece bir type, import veya condition düzeltilecekse
- Agent çözümü gereksiz büyütmeye başladıysa
- İşin mantığı basit ama context’i anlatması uzunsa
bu durumlarda kodu kendin yazmak çoğu zaman daha mantıklıdır.
Mesela bir component içinde sadece şu kontrol eksikse:
if (!user) return null;
Ya da bir import hatası varsa:
import { ObjectId } from "mongodb";
Bunu kendin eklemek, Agent’a “şu hatayı çöz” deyip tüm dosyayı tekrar okutmandan daha ucuz ve daha hızlıdır.
Sonuç

Agent’ı “sihirli kod yazıcı” gibi kullanırsan hem limitlere daha hızlı takılırsın hem de codebase’in dağılmaya başlar. Asıl verim daha iyi plan yapabilmekten geçiyor.
Benim öğrendiğim en önemli şey:
AI ile hızlı kod yazmanın sırrı, Agent’a daha çok iş vermek değil; Agent’a daha net sınırlar vermek.
Bunu yaptığında hem kullanım limitlerine daha az yaklaşırsın hem de ortaya çıkan kod çok daha okunabilir, sürdürülebilir ve güvenilir olur.