<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Okan Yurt on Medium]]></title>
        <description><![CDATA[Stories by Okan Yurt on Medium]]></description>
        <link>https://medium.com/@okanyurt?source=rss-58bcab69e460------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lg89gvIf7i91_DcoVrT1Dg@2x.jpeg</url>
            <title>Stories by Okan Yurt on Medium</title>
            <link>https://medium.com/@okanyurt?source=rss-58bcab69e460------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:03:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@okanyurt/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[.NET 11 Çıktı: Geçmeli miyiz, .NET 12'yi mi Beklemeliyiz?]]></title>
            <link>https://okanyurt.medium.com/net-11-%C3%A7%C4%B1kt%C4%B1-ge%C3%A7meli-miyiz-net-12yi-mi-beklemeliyiz-9ff48e98c081?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ff48e98c081</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[dotnet-core]]></category>
            <category><![CDATA[upgrade]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 15:01:06 GMT</pubDate>
            <atom:updated>2026-11-11T15:01:06.017Z</atom:updated>
            <content:encoded><![CDATA[<p>Şirketler, uygulama ölçekleri ve kendi denemeleriniz için pratik bir değerlendirme</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*wkzBZIgytgyeqN6Rkk6AkQ.png" /></figure><p>Kaynak: .NET Team, .NET Blog</p><h3>Kısa cevap</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m4CcwpYUzvFxqRx96WVCDg.png" /></figure><p>.NET 11, 10 Kasım 2026&#39;da .NET Conf 2026&#39;da yayınlandı ve bir STS (Standard Term Support) sürümü. Kurumsal production için bugünkü doğru hedef hâlâ .NET 10 LTS; .NET 11&#39;e ise yeni projeler, async-ağırlıklı servisler ve yıllık upgrade disiplini olan ekipler geçmeli. Kişisel projelerde ve lokalde ise beklemenin hiçbir anlamı yok: kurun, kendi kodunuzla ölçün.</p><p>Bu sürümü özel kılan bir detay var: Microsoft 2025&#39;te STS desteğini 18 aydan 24 aya çıkardı. Sonuç olarak <strong>.NET 10 (LTS) ve .NET 11 (STS) aynı gün, Kasım 2028&#39;de destekten çıkıyor.</strong> Yani .NET 11&#39;e geçmek “daha kısa destek” anlamına gelmiyor; sadece .NET 10&#39;un bir yıllık production olgunluğundan vazgeçmek anlamına geliyor.</p><p>Aynı gün (10 Kasım 2026) .NET 8 LTS ve .NET 9 STS de destekten çıktı. Hâlâ bu sürümlerde olan sistemler artık güvenlik yaması almıyor; asıl acil iş .NET 11 değil, bu sistemleri taşımak.</p><h3>Neler değişti</h3><p>.NET 11 bir devrim değil, .NET 10&#39;un üzerine inşa edilen bir adım; ama iki alan gerçekten yapısal: runtime async ve C# 15&#39;teki union types.</p><h3>Runtime</h3><ul><li><strong>Runtime Async:</strong> async/await dönüşümü compiler’dan JIT’e taşındı. Feature flag ile opt-in, yeni syntax yok. Daha temiz stack trace, daha az allocation, daha küçük binary (bir örnekte 10 zincirli Task metodu ~10,7 KB’tan ~5,2 KB’a indi). .NET 12&#39;de default olması planlanıyor.</li><li><strong>JIT:</strong> bounds check elimination, devirtualization, constant folding, x64&#39;te tek MUL’a düşen Math.BigMul, FP16 ve Arm SVE2 intrinsics. Kod değişikliği olmadan bedava performans.</li><li><strong>NativeAOT:</strong> paylaşımlı interface dispatch helper, Linux/macOS’ta in-process crash logging.</li></ul><h3>C# 15</h3><ul><li><strong>Union types</strong> ve closed modifier: hiyerarşiyi assembly&#39;ye kapatır, switch&#39;te exhaustiveness kontrolü sağlar. Result/Either pattern&#39;leri ve domain modelleme için uzun süredir beklenen özellik.</li><li><strong>Collection expression arguments</strong> (with(...)), extension indexers, labeled break/continue. Küçük ergonomi kazanımları; with() syntax&#39;ı toplulukta eleştirildi.</li><li><strong>Memory safety yenilemesi</strong> (safe, unsafe(expr)): sadece preview, LangVersion=preview gerekir. Production&#39;da kullanmayın.</li></ul><h3>ASP.NET Core 11 ve EF Core 11</h3><ul><li><strong>ASP.NET Core:</strong> async validation, default OpenAPI 3.2, static SSR için CacheView, Blazor WASM’de IHostedService, circuit auto-pause.</li><li><strong>EF Core:</strong> FullJoin, MaxBy/MinBy SQL çevirisi, full-text + vector hybrid search, GroupBy yeniden yazımı, split query optimizasyonu (benchmark’ta %22–29).</li></ul><h3>BCL, AI, MAUI ve SDK</h3><ul><li><strong>BCL:</strong> Zstandard compression, LINQ FullJoin, post-quantum crypto (ML-KEM, HPKE), genişleyen Process API.</li><li><strong>AI:</strong> Microsoft.Extensions.AI, Microsoft Agent Framework ve dotnet new mcpserver template. Blazor AI component&#39;leri hâlâ experimental.</li><li><strong>MAUI:</strong> tüm platformlarda CoreCLR default runtime. Mobil ekipler için test edilmesi gereken büyük değişiklik.</li><li><strong>SDK:</strong> Native AOT CLI host, warm MSBuild server (default açık), dotnetup (preview), file-based apps.</li></ul><h3>Dikkat edilmesi gereken breaking change’ler</h3><ul><li><strong>Donanım tabanı:</strong> x86/x64&#39;te minimum artık x86-64-v2 (SSE4.2, POPCNT vb.). Yaklaşık 2013 öncesi CPU&#39;larda uygulama hiç açılmaz. On-prem eski sunucuları kontrol edin.</li><li><strong>Sayısal davranış:</strong> Math.Round artık doğru yuvarlıyor, küçük integral tiplere float dönüşümü saturating, decimal/BigInteger dönüşümleri değişti. Finans ve raporlama kodunda sonuçları karşılaştırın.</li><li><strong>Hosting:</strong> Bir BackgroundService fail olursa IHost.RunAsync/StopAsync artık exception fırlatıyor. Daha önce sessizce ölen worker’lar görünür hale gelecek.</li><li><strong>SDK/NuGet:</strong> Restore artık global packages klasöründe daha yüksek sürüm aramıyor; VSTest Newtonsoft.Json bağımlılığını kaldırdı.</li><li><strong>Kriptografi/TLS:</strong> Linux’ta AIA fetch zincir başına 2 ile sınırlı, SslStream server-side AIA download default kapalı, macOS’ta DSA kaldırıldı.</li></ul><p>Tam liste için Microsoft’un <a href="https://learn.microsoft.com/en-us/dotNET/core/compatibility/11">.NET 11 breaking changes</a> sayfasına bakın.</p><h3>Şirketler için ne ifade ediyor</h3><p>Kurumsal açıdan .NET 11&#39;in asıl mesajı şu: destek süresi artık kararı belirleyen faktör değil, çünkü .NET 10 ve .NET 11 aynı gün bitiyor. Kararı belirleyen faktör, ekibinizin yıllık upgrade yapabilecek olgunlukta olup olmadığı.</p><ul><li><strong>Upgrade maliyeti düşük, ama sıfır değil.</strong> .NET 10&#39;dan 11&#39;e geçiş çoğu projede TargetFramework değişikliği + paket güncellemesi + test turu. Riskler sayısal davranış değişiklikleri, donanım tabanı ve üçüncü parti paketlerin uyumluluğu.</li><li><strong>.NET 11&#39;de olup .NET 12&#39;ye kadar beklemeye değecek özellik yok.</strong> Runtime async opt-in, memory safety preview, Blazor WASM’in CoreCLR’a geçişi .NET 12&#39;de tamamlanacak. .NET 11, .NET 12 LTS’nin “provası” niteliğinde.</li><li><strong>AI tek başına geçiş sebebi değil.</strong> Microsoft.Extensions.AI ve Agent Framework out-of-band paketler olduğu için .NET 10&#39;da da kullanılabiliyor.</li><li><strong>Ekosistem gecikmesi.</strong> Bulut sağlayıcıları, kurumsal NuGet paketleri ve APM ajanları genelde yeni sürüme birkaç hafta ile birkaç ay arasında yetişir. Geçmeden önce kendi stack’inizi kontrol edin.</li><li><strong>Topluluk tepkisi karışık.</strong> Preview döneminde collection expression with() syntax&#39;ı, dilin şişmesi ve AI odaklı roadmap&#39;in Native AOT/Blazor WASM gibi çekirdek konuların önüne geçmesi eleştirildi (<a href="https://visualstudiomagazine.com/articles/2026/02/11/devs-souring-on-net-11.aspx">Visual Studio Magazine</a>).</li></ul><h3>Hangi uygulamalar geçirilebilir</h3><p>Küçük ve stateless servisler hemen geçebilir; büyük monolitler ve regüle sistemler .NET 10 LTS’de kalıp .NET 12&#39;yi beklemeli.</p><h3>Geçebilirsiniz</h3><ul><li><strong>Yeni greenfield projeler:</strong> .NET 11 ile başlayın. Destek .NET 10 ile aynı gün bitiyor; Kasım 2027&#39;de .NET 12 LTS’ye geçiş küçük bir adım olacak.</li><li><strong>Küçük/orta ölçekli API’ler, mikroservisler, worker’lar:</strong> Runtime async ve JIT kazanımları doğrudan latency/allocation’a yansır. Container ve otomatik CI/CD varsa rollback ucuz.</li><li><strong>Native AOT servisler ve CLI araçları:</strong> Ölçerek geçin; trimming uyarılarını yeniden kontrol edin.</li></ul><h3>Pilotla, dikkatli geçin</h3><ul><li><strong>EF Core ağırlıklı, sorgu yoğun uygulamalar:</strong> Optimizasyonlar faydalı ama üretilen SQL’i ve planları karşılaştırın.</li><li><strong>.NET MAUI:</strong> CoreCLR default runtime oldu; startup, bellek ve platforma özel davranışları cihaz üzerinde doğrulayın.</li><li><strong>Eski on-prem sunucular:</strong> Önce donanımı kontrol edin; x86-64-v2 olmayan CPU&#39;da uygulama başlamaz.</li></ul><h3>Bekleyin</h3><ul><li><strong>Büyük monolitler:</strong> Upgrade maliyeti kazançtan büyük; .NET 12 LTS’ye tek seferde geçin.</li><li><strong>Finans, sağlık, kamu gibi regüle sistemler:</strong> Math.Round ve float dönüşüm değişiklikleri sayısal sonuçları etkileyebilir; sertifikasyon maliyeti yüksek.</li><li><strong>Blazor WebAssembly:</strong> CoreCLR’a geçiş .NET 12&#39;de tamamlanacak; AI component’leri experimental.</li></ul><h3>Hemen harekete geçin</h3><ul><li><strong>Hâlâ .NET 8 / .NET 9&#39;da olanlar:</strong> Destek 10 Kasım 2026&#39;da bitti. Hemen .NET 10 LTS’ye geçin.</li></ul><h3>Geçmeli miyiz, .NET 12&#39;yi mi beklemeliyiz</h3><p>Çoğu kurumsal ekip için en akıllıca yol: production’ı .NET 10 LTS’de tutmak, .NET 11&#39;i staging ve pilot servislerde koşmak, Kasım 2027&#39;de .NET 12 LTS’ye geçmek. .NET 12 muhtemelen Kasım 2030&#39;a kadar desteklenecek ve runtime async’in default olması, Blazor WASM’in CoreCLR’a geçişi gibi .NET 11&#39;de yarım kalan işleri tamamlayacak.</p><p>Kararı hızlı vermek için dört soru:</p><ol><li><strong>Yılda bir framework upgrade’ini CI/CD ve test otomasyonunuzla rahatça yapabiliyor musunuz?</strong> Evet ise .NET 11&#39;e geçmek neredeyse bedava; şimdi geçmek .NET 12 geçişini de küçültür.</li><li><strong>Runtime async, C# 15 union types veya EF Core 11 optimizasyonlarından ölçülebilir fayda bekliyor musunuz?</strong> Evet ise pilot servisle başlayın ve sayılarla karar verin.</li><li><strong>Regülasyon, sertifikasyon veya müşteri sözleşmesi LTS şartı koşuyor mu?</strong> Evet ise tartışma bitti: .NET 10 LTS, sonra .NET 12 LTS.</li><li><strong>Kritik bağımlılıklarınız (APM, ORM, UI kütüphaneleri, hosting) .NET 11&#39;i destekliyor mu?</strong> Hayır ise bekleyin.</li></ol><p><strong>Geçmenin avantajı:</strong> Ücretsiz performans, C# 15 özellikleri, .NET 12&#39;ye daha küçük bir adım, ekibin yeni sürümlere alışması.</p><p><strong>Beklemenin avantajı:</strong> Bir upgrade döngüsü atlanır, .NET 10&#39;un 1 yıllık production olgunluğu korunur, .NET 12&#39;nin tamamlanmış özellikleri tek seferde gelir.</p><blockquote>Aradaki fark destek süresi değil, ekip zamanı. Upgrade sizin için bir sprint’in birkaç günüyse geçin; bir çeyreğe yayılan projeyse .NET 12&#39;yi bekleyin.</blockquote><h3>Benim tercihim</h3><p>Geçen yıl .NET 10 çıktığında LTS olduğu için hiç beklemedim. Kasım 2025&#39;te çalışmalara başlayıp mevcut uygulamamı .NET 10&#39;a taşıdım, kurumda gerekli yerleri de güncellettim. Üç yıllık LTS desteği bu yatırımı haklı çıkarıyordu.</p><p>Bu sefer kurumsal tarafta bir güncelleme yapmayacağım. Sebep uygulamanın kendisi değil: kurumsal bir framework geçişi sadece kodu değil, onu çevreleyen DevOps zincirini de kapsıyor. Build agent’larındaki SDK’lar, CI/CD pipeline’ları, container base image’ları, analiz ve güvenlik tarama araçları hepsi yeni sürüme uyarlanmak zorunda. Bunu .NET 11 için yapmak, bir yıl sonra .NET 12 LTS için aynı işi tekrar yapmak demek.</p><p>Onun yerine yeni başladığım, risk taşımayan bir uygulamada .NET 11&#39;i deneyeceğim. Bu uygulama için kurumdaki DevOps araçlarını .NET 11&#39;e uyarlamaya geçmeyeceğim. Böylece runtime async’i, C# 15&#39;i ve yeni SDK’yı gerçek bir projede görmüş olacağım; kurumsal geçişi ise .NET 12 LTS ile tek seferde yapacağım.</p><blockquote>Kısacası: LTS’de kurum, STS’de deneme.</blockquote><h3>Kendi başınıza: kesin deneyin</h3><p>Şirket kararı ne olursa olsun, lokalde ve kişisel projelerde .NET 11&#39;i beklemek için hiçbir sebep yok. SDK’lar yan yana kurulur, global.json ile proje bazında sürüm sabitlenir; hiçbir şeyi bozmadan deneyebilirsiniz. Farkları okuyarak değil, kendi kodunuzda ölçerek görün.</p><pre># Mevcut SDK&#39;ları görün<br>dotnet --list-sdks<br><br># Bir projeyi .NET 11&#39;e alın (csproj)<br># &lt;TargetFramework&gt;net11.0&lt;/TargetFramework&gt;<br># Aynı kodu iki runtime&#39;da karşılaştırmak için multi-target<br># &lt;TargetFrameworks&gt;net10.0;net11.0&lt;/TargetFrameworks&gt;</pre><pre>&lt;!-- Runtime async&#39;i deneyin (opt-in) ve C# 15 özelliklerini açın --&gt;<br>&lt;PropertyGroup&gt;<br>  &lt;TargetFramework&gt;net11.0&lt;/TargetFramework&gt;<br>  &lt;LangVersion&gt;15&lt;/LangVersion&gt;<br>  &lt;Features&gt;$(Features);runtime-async=on&lt;/Features&gt;<br>&lt;/PropertyGroup&gt;</pre><p>Runtime async flag adını GA dokümantasyonundan doğrulayın; preview boyunca değişti.</p><p>Neleri karşılaştırmalı:</p><ul><li><strong>Performans:</strong> BenchmarkDotNet ile aynı benchmark’ı --runtimes net10.0 net11.0 ile koşun. Allocation ve ortalama süreye bakın.</li><li><strong>Runtime async:</strong> Derin async zincirli bir endpoint’te exception fırlatın; stack trace’i iki sürümde karşılaştırın. Binary boyutunu da ölçün.</li><li><strong>C# 15:</strong> Bir Result/Error tipini union type ile yeniden yazın, closed hiyerarşide eksik case bırakıp compiler uyarısını görün.</li><li><strong>EF Core 11:</strong> Aynı LINQ sorgusunun ürettiği SQL’i ToQueryString() ile iki sürümde karşılaştırın (özellikle GroupBy ve split query).</li><li><strong>Startup ve bellek:</strong> Native AOT ile publish edin; binary boyutu, cold start ve RSS’i ölçün.</li><li><strong>AI:</strong> dotnet new mcpserver ile küçük bir MCP server kurup Microsoft.Extensions.AI&#39;ı deneyin.</li><li><strong>Sayısal testler:</strong> Math.Round ve float dönüşümleri kullanan unit test’leri iki runtime’da koşun; fark varsa şirket geçişinde de olacak.</li></ul><p>Bu denemelerin bir yan faydası da var: şirkette .NET 12 kararı masaya geldiğinde elinizde tahmin değil, kendi kodunuzdan çıkmış sayılar olur.</p><h3>Sonuç</h3><ul><li><strong>Production:</strong> .NET 10 LTS’de kalın, .NET 8/9&#39;daki sistemleri hemen taşıyın.</li><li><strong>Yeni projeler ve küçük servisler:</strong> .NET 11 ile başlayın; destek .NET 10 ile aynı gün bitiyor.</li><li><strong>Büyük ve regüle sistemler:</strong> .NET 12 LTS’yi (Kasım 2027) bekleyin, .NET 11&#39;i staging’de prova olarak kullanın.</li><li><strong>Kendiniz için:</strong> Bu hafta kurun, multi-target edin, ölçün.</li></ul><h3>Kaynaklar</h3><ul><li><a href="https://www.ntcompatible.com/story/net-11-release-15-runtime-async-and-an-aifirst-stack">.NET 11 Release: C# 15, Runtime Async, and an AI-First Stack (NTCompatible)</a></li><li><a href="https://www.thurrott.com/dev/343717/microsoft-releases-net-11">Microsoft Releases .NET 11 (Thurrott)</a></li><li><a href="https://www.fast-report.com/blogs/overview-net-11">What’s New in .NET 11 (Fast Reports)</a></li><li><a href="https://devblogs.microsoft.com/dotnet/dotnet-sts-releases-supported-for-24-months/">.NET STS releases now supported for 24 months (.NET Blog)</a></li><li><a href="https://learn.microsoft.com/en-us/dotNET/core/compatibility/11">Breaking changes in .NET 11 (Microsoft Learn)</a></li><li><a href="https://learn.microsoft.com/en-ie/dotnet/core/compatibility/jit/11/minimum-hardware-requirements">.NET 11 minimum hardware requirements (Microsoft Learn)</a></li><li><a href="https://visualstudiomagazine.com/articles/2026/02/11/devs-souring-on-net-11.aspx">Devs Souring on .NET 11? (Visual Studio Magazine)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ff48e98c081" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Agentic Coding Tools on a Real Codebase: What Works and What Doesn’t]]></title>
            <link>https://okanyurt.medium.com/using-agentic-coding-tools-on-a-real-codebase-what-works-and-what-doesnt-c5b6ef1a3c17?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5b6ef1a3c17</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-coding-tool]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[developer-tools]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 16:43:21 GMT</pubDate>
            <atom:updated>2026-07-06T16:43:21.591Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GDUOESkxeheuIM0Vun6nPg.jpeg" /></figure><p>“AI-assisted coding” has gone through three generations. First generation: line completion (early Copilot) — the model predicts the next token, and the decision loop is entirely yours. Second generation: chat-based assistants — you copy-paste code, and the model only knows as much context as you hand it. Third generation is <strong>agentic coding</strong>: the model drives its own tool-use loop, reaching into the file system with tools like grep/read/edit, exploring the codebase, forming a plan, applying the change, then running build/test to verify its own output. This piece walks through the technical details of using this third generation (terminal-based agentic assistants like Claude Code) on a production, enterprise .NET/React codebase.</p><h3>What Changed Architecturally: The Plan → Act → Verify Loop</h3><p>Classic autocomplete is a single-step prediction: input (context window + cursor position) → output (next line). In the agentic model, the loop is multi-step, and at each step the model emits a <strong>tool call</strong>, the result is fed back into context, and the model decides the next step:</p><pre>1. Discovery  : find relevant classes/interface implementations via grep/glob<br>2. Reading    : read the relevant files in full (repository, service, DbContext)<br>3. Planning   : derive which layers (Domain/Application/Infrastructure) the change touches<br>4. Applying   : apply diff-based edits across files<br>5. Verifying  : run build/test commands, read the output, loop back to step 2 if it fails</pre><p>This is a classic ReAct (Reason-Act) loop, and the key distinction is: <strong>the model explores the codebase through real file-system tools — shell commands, grep, AST-like search — not through embeddings or RAG.</strong> In other words, it doesn’t rely on a pre-built vector index; it reads and greps the same way an engineer would. The practical consequence: the more consistently named and layered a codebase is (say, CQRS plus the repository pattern applied cleanly), the more accurate the agent’s discovery step turns out to be.</p><h3>Case 1: Gateway Timeout on Grid Export — Root Cause and Fix</h3><p>The problem: an endpoint that exported large tables (thousands of audit rows) to Excel started hitting the API gateway’s 15-second timeout as data volume grew.</p><p><strong>Root cause</strong> (found by the agent): the export pipeline materialized the <em>entire</em> result set into memory via .ToListAsync() on an IQueryable&lt;T&gt;, handed that full list to an Excel library in one shot to build the workbook, and finally wrote the whole file to the response as a single byte[]. Three critical points were all synchronous and monolithic at once: <strong>DB materialization → in-memory serialization → single response write</strong>. The gateway sees nothing until the first byte arrives; once query time plus serialization time crossed 15 seconds, the connection was cut.</p><p><strong>Fix</strong> (proposed and implemented by the agent): move to chunked/streaming export —</p><ul><li>Keyset pagination on the DB side (Where(x =&gt; x.Id &gt; lastId).Take(pageSize) instead of Skip/Take), avoiding the performance hit of large offsets.</li><li>Row-by-row streaming on the Excel-writing side (writing and flushing page by page instead of holding the whole workbook in RAM).</li><li>Chunked transfer encoding on the HTTP response side so the first bytes go out early — the gateway sees “connection alive, data flowing” within the first seconds instead of one long blocking call.</li></ul><p>The agent’s real contribution here wasn’t the chunked-export <em>idea</em> itself (that’s a well-known pattern) — it was spotting that the export mechanism lived in a <strong>single shared helper layer</strong> across the codebase, and working out in advance how many different grid/export call sites the change would touch. That systematically removes the risk of “fix it in one place, only to later discover the same logic was copy-pasted in three others” — something human engineers routinely miss.</p><p><strong>Limit:</strong> it didn’t get chunk/page size or the gateway’s real timeout behavior right on the first try (some gateways still apply an idle timeout even on chunked responses) — that required an engineer who knew the production environment’s actual behavior to measure and tune it.</p><h3>Case 2: Multi-Tenant OIDC — the Dynamic Authentication Scheme Problem</h3><p>The second problem was more architectural: each tenant needed its own OIDC identity provider (its own issuer, client id, discovery endpoint). In ASP.NET Core, AddOpenIdConnect by default registers a scheme <strong>statically at startup</strong> — but tenant identity can only be resolved once a request arrives (from a subdomain or header). So the classic services.AddAuthentication().AddOpenIdConnect(...) approach simply doesn&#39;t work.</p><p>The resulting architecture: resolve OIDC options <strong>at request time</strong> based on tenant context via IOptionsMonitor&lt;OpenIdConnectOptions&gt; plus a dynamic scheme provider; a tenant&#39;s OIDC config (issuer, client secret, etc.) has to live in the <strong>tenant-level DbContext</strong>, not the host-level one, since each tenant has its own isolated data schema.</p><p>A change like this hits four layers at once: TenantConfiguration (EF entity configuration), TenantDbContext, the authentication middleware pipeline, and scheme registration in the DI container. This is exactly where the agent&#39;s strength showed up: it grepped across those four layers and updated all references consistently — and consistency across this kind of cross-cutting change is precisely what human engineers most often forget a piece of.</p><p><strong>Limit:</strong> deciding “which OIDC claims can be overridden per tenant vs. which must stay fixed for security reasons” was a business-rule call — the agent could offer a sensible suggestion, but it had no way of knowing the compliance requirement, so that decision stayed with a human.</p><h3>The Verification Layer: Why “Tests Passed” Isn’t Enough</h3><p>The agent’s self-verification step (running build + test + lint) matters, but it isn’t sufficient, because:</p><ul><li><strong>Coverage numbers don’t guarantee behavioral correctness.</strong> Our project has a minimum coverage threshold for new code; the agent can write tests that clear that bar without necessarily validating the <em>right</em> scenario — for instance, whether a mocked IRepository correctly simulates real IQueryable behavior (chaining Where/OrderBy), or whether tests pass falsely because a library like MockQueryable wasn&#39;t used where it should have been. That needs a human review pass.</li><li><strong>Static analysis has blind spots.</strong> Build green, tests green — but runtime-only issues like concurrency/race conditions, N+1 queries, or transaction boundaries don’t show up at compile time.</li><li><strong>Organizational constraints aren’t written anywhere in the codebase.</strong> Things like a build environment requiring VPN access, or a specific SDK version not being installed, are context the agent has no access to — a human has to supply it.</li></ul><h3>Conclusion</h3><p>The real technical value of agentic coding tools lies in doing <strong>discovery and consistency</strong> work across a large, layered codebase far faster and more systematically than a human engineer — especially on cross-cutting questions like “how many places does this change actually touch.” But even getting root-cause analysis right isn’t enough on its own: business-rule decisions, the real behavior of the production environment, and compliance requirements still demand human expertise. The right boundary: use the agent as leverage for discovery and implementation, and keep verification and architectural judgment in human hands.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5b6ef1a3c17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting Goals Is Not Enough — Build a System]]></title>
            <link>https://okanyurt.medium.com/setting-goals-is-not-enough-build-a-system-46b405a6c594?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/46b405a6c594</guid>
            <category><![CDATA[motivation]]></category>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[growth-mindset]]></category>
            <category><![CDATA[self-discipline]]></category>
            <category><![CDATA[success-mindset]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Thu, 18 Jun 2026 16:10:07 GMT</pubDate>
            <atom:updated>2026-06-18T16:10:07.011Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iZ8wZ24pbMojUebJhuywzQ.png" /></figure><p>What separates winners from everyone else?</p><p>A few days ago, I came across a video by Fatih Topçu, a runner whose content I enjoy following. While listening to him, I found myself reflecting on something I’ve been thinking about for a long time:</p><p>Is success really about setting goals, or is there something more important behind it?</p><p>Today, almost every personal development book or video tells us the same thing:</p><p><em>“Set your goals.”</em></p><p>But then what?</p><p>Does everyone who sets goals become successful?</p><p>Of course not.</p><p>Because goals provide direction, but systems are what move you forward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l5pGREqYt8br5dsoyltTcA.png" /></figure><h3>Success Is Never an Accident</h3><p>When we look at people who have achieved remarkable things, one common trait stands out: they didn’t quit.</p><p>Success is often the visible outcome. People see the medal, the promotion, the business, or the achievement. What they don’t see is everything that happened behind the scenes.</p><p>The early mornings.</p><p>The training sessions nobody witnessed.</p><p>The nights spent working while others were resting.</p><p>The failures, setbacks, and countless attempts before getting it right.</p><p>Success is the result of time, effort, discipline, and patience working together.</p><p>That’s why success is rarely about one single factor. Wanting something is not enough. Planning alone is not enough either.</p><p>Planning, systems, persistence, resilience, and consistency…</p><p>Real success emerges from the combination of all of them.</p><h3>Everyone Has a Different Timeline</h3><p>One of the biggest mistakes we make is constantly comparing ourselves to others.</p><p>Someone becomes a successful athlete at 18.</p><p>Someone else reaches the peak of their career at 32.</p><p>One person retires at 40.</p><p>Another starts over at 40.</p><p>From the outside, some people may seem “ahead” while others appear “behind.” But in reality, everyone is running a different race.</p><p>Measure your progress against who you were yesterday, not against the people around you.</p><p>Because that’s where the real competition lies.</p><h3>The Life Lesson Running Taught Me</h3><p>Running has taught me this lesson better than anything else.</p><p>When you’re new to running, you’re constantly looking around.</p><p>Someone passes you.</p><p>Someone seems faster.</p><p>Someone looks stronger.</p><p>And immediately, your mind starts talking:</p><p><em>“I’m too slow.”</em></p><p><em>“I need to speed up.”</em></p><p><em>“Everyone is better than me.”</em></p><p>These thoughts often push you to run harder than you should.</p><p>Imagine you’re running a 15-kilometer race.</p><p>Because you’re trying to keep up with others, you spend too much energy in the first few kilometers.</p><p>The result?</p><p>You burn out long before the finish line.</p><p>As you gain experience, however, you begin to understand something important:</p><p>The real race isn’t against others.</p><p>It’s against yourself.</p><p>When you outperform yesterday’s version of yourself…</p><p>When you improve compared to last month…</p><p>When you become a little stronger, a little wiser, and a little more disciplined…</p><p>That’s when real growth begins.</p><p>Life works the same way.</p><h3>Take Ownership of Your Life</h3><p>Many of us spend years waiting for a magical solution.</p><p>A mentor to appear.</p><p>A book that changes everything.</p><p>An opportunity that suddenly arrives.</p><p>Someone who will solve our problems for us.</p><p>But life doesn’t work that way.</p><p>If the problems are ours, the responsibility for solving them is ours too.</p><p>Nobody can be disciplined on our behalf.</p><p>Nobody can fight our battles for us.</p><p>Nobody can take the necessary steps except us.</p><p>This is why I don’t believe motivation alone is enough.</p><p>Motivation comes and goes.</p><p>Some days you’ll feel unstoppable.</p><p>Other days you’ll feel like doing nothing at all.</p><p>That’s exactly where people with systems gain an advantage.</p><p>They continue not because they feel inspired every day, but because they have built habits.</p><p>They move forward not because motivation is always present, but because their process is.</p><h3>Final Thoughts</h3><p>Setting goals is important.</p><p>But goals alone won’t take you where you want to go.</p><p>What truly drives success are the habits you repeat, the systems you build, and the small actions you take every single day.</p><p>Stop comparing yourself to others.</p><p>Compare yourself to who you were yesterday.</p><p>Trust the process.</p><p>Commit to the struggle.</p><p>Because success is rarely one giant leap.</p><p>More often, it is the accumulation of small, consistent steps taken over time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46b405a6c594" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infrastructure Design Trade-offs: Flexibility vs. Over-Engineering]]></title>
            <link>https://okanyurt.medium.com/infrastructure-design-trade-offs-flexibility-vs-over-engineering-a09e3cf8c5f2?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/a09e3cf8c5f2</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[engineering-culture]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Wed, 08 Apr 2026 12:33:14 GMT</pubDate>
            <atom:updated>2026-04-08T12:33:14.470Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Why software projects get rewritten every three years — and what architectural decisions can break that cycle.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SRqvq3riw34Rilpu5XUcdQ.png" /></figure><p>A question that keeps coming up on LinkedIn and among fellow engineers: <em>“How much flexibility is actually enough?”</em> Behind that question are two distinct fears — on one side, building without enough foresight and drowning in technical debt months later; on the other, spending enormous effort on features nobody ever uses.</p><p>Finding the right position between these two extremes is not merely a technical decision. It is, at its core, a product strategy question.</p><h3>What “project lifespan” actually means</h3><p>There is a scenario I have seen repeat itself throughout my professional career: a freshly written system that looks clean at the start hits a “we’re having performance issues, let’s rewrite it” moment three years later. That process drains both teams and budgets in ways that compound over time.</p><p>And yet — three years is genuinely a short lifespan for a project.</p><p><strong>Key statistics:</strong></p><ul><li>68% of large software projects are considered failures (Standish Group, 2023)</li><li>3.6× average cost overrun on IT projects (McKinsey IT Benchmark)</li><li>45% of shipped features are rarely or never used (Chaos Report)</li></ul><p>These numbers are not coincidental. When infrastructure design does not receive enough attention from day one, performance problems become inevitable as data grows. Features planned for later simply cannot be built on top of what already exists.</p><blockquote><em>“The real cost of a project is not just its development time — it is the technical debt that structure carries for years.”</em></blockquote><h3>What flexibility actually means</h3><p>Flexibility is one of the most misunderstood concepts in software. It is often interpreted as “being ready for everything” — when in reality, the definition is much simpler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BbiJLUdpJy05zKJ5M4BReg.png" /></figure><p>Flexibility means new changes can be added to the existing system with minimal structural disruption. A flexible system does not need to pre-contain features that are not yet needed. But it must leave the door open for what is coming. That distinction matters enormously.</p><p><strong>Flexibility looks like:</strong></p><ul><li>Abstraction layers are properly designed</li><li>Dependencies are loose and replaceable</li><li>Data model supports future growth</li><li>New features don’t break existing code</li><li>Only what is needed gets built</li></ul><p><strong>Over-engineering looks like:</strong></p><ul><li>Abstraction layers nobody uses</li><li>Unnecessary configuration complexity</li><li>Code written for hypothetical scenarios</li><li>Architecture the team struggles to understand</li><li>“Let’s add this too” decisions that slip deadlines</li></ul><h3>The real cost of over-engineering</h3><p>Over-engineering almost always starts with good intentions. “This might be useful,” “we’ll need it later,” “if we do it now we’ll save time down the road” — these phrases will sound familiar. And sometimes those predictions are right. Most of the time they are not.</p><p><strong>Real data:</strong> According to Gartner research, approximately 64% of features built in enterprise software projects are never used or rarely used by end users. A large portion of that effort goes toward “we might need it someday” assumptions that never actually materialise.</p><p>The concrete consequences of over-engineering:</p><ul><li>Missed deadlines and extended timelines</li><li>Teams losing focus on the actual customer problem</li><li>A codebase that is difficult to understand and expensive to maintain</li><li>Testing and documentation costs for features nobody uses</li><li>Loss of motivation — effort never translates into visible output</li></ul><h3>The power of MVP — and how to use it correctly</h3><p>The solution lies in the MVP (Minimum Viable Product) mindset. But there is a trap here too: interpreting MVP as “cheap, incomplete product.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5C_yXxuSRQPgRDNyWHSTEg.png" /></figure><p>An MVP is the simplest solution that addresses the customer’s real need — and it must be built on an infrastructure that can be extended healthily. “Simple” and “poorly designed” are not the same thing.</p><p><strong>The right MVP cycle:</strong></p><ol><li><strong>Analyse the customer’s real need</strong> — What problem is being solved? Who uses it? What is genuinely sufficient for the first three months?</li><li><strong>Define MVP scope clearly</strong> — Keep scope tight. Push “let’s add this too” decisions to the next iteration.</li><li><strong>Build infrastructure for growth</strong> — Simple for today, open for tomorrow. Data models and abstractions should be thought through upfront.</li><li><strong>Ship, then collect real data</strong> — User behaviour is a far better guide than assumptions.</li><li><strong>Iterate based on actual need</strong> — Prioritise features using real usage data, not speculation.</li></ol><p>This cycle makes products generate value faster, and keeps team motivation healthy. Seeing concrete results — a feature that gets used, a problem that gets solved — is a far more powerful driver than the endless “development in progress” spiral that over-engineering creates.</p><h3>So where is the line?</h3><p>There is a simple test I use in practice: <em>“Did someone currently using this system ask for this, or did I imagine it?”</em></p><p>If a feature or abstraction is not grounded in a real customer need or a near-certain upcoming requirement — it can wait. Keeping the architecture flexible for it, without writing that code yet, is the right call both for time and for code quality.</p><blockquote><em>“Good architecture is not about knowing what the future holds. It is about building something that can adapt — whatever the future brings.”</em></blockquote><h3>In closing</h3><p>Flexibility is a proactive architectural decision. Over-engineering is the product of a reactive anxiety — the “what if we need it” fear. What separates these two mindsets is an analytical perspective that keeps customer need at the centre.</p><p>If you want to avoid rewriting your project three years from now, start asking two questions today: Can my infrastructure hold up as data grows? Can the features coming next actually be built on top of what I have?</p><p>If the answer to both is yes — nothing more is needed. Sufficient and flexible are the same thing.</p><p><em>What’s your take? How do you strike the balance between flexibility and over-engineering in your own projects? If you have a concrete experience — a decision that paid off, or one you’d make differently — I’d love to read it in the comments.</em></p><p><em>Sources: Standish Group CHAOS Report 2023, McKinsey Digital IT Benchmark Study, Gartner Software Feature Utilization Survey, The Pragmatic Programmer (Thomas &amp; Hunt)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a09e3cf8c5f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git in Practice — Part 2: Merge Strategy]]></title>
            <link>https://okanyurt.medium.com/git-in-practice-part-2-merge-strategy-b082a3713d5f?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/b082a3713d5f</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 06:31:00 GMT</pubDate>
            <atom:updated>2026-03-20T06:31:00.468Z</atom:updated>
            <content:encoded><![CDATA[<p>In the first part of this series, we established the foundation — how to structure your branches, name them consistently, and decide which workflow fits your team. But a well-organized branch structure is only half the story.</p><p>Once your feature is developed and ready, a new question emerges: <strong>How do you bring it back?</strong></p><p>Do you preserve every commit as it was written? Do you squash the noise into a single clean entry? Do you rewrite history to keep things linear? Each of these choices leads to a different outcome — not just in how your repository looks, but in how traceable your work is, how your CI/CD pipeline behaves, and even how developer contributions are measured over time.</p><p>This is where merge strategy comes in. And much like branch management, there is no universally correct answer — only the one that aligns with how your team actually works.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lt0HoTxBiRURxM4J1gnU2Q.png" /></figure><h3>What Is a Merge Strategy?</h3><p>You have defined your branch management. You know which branch to branch off from for feature development, your branch naming conventions, and your workflow. But how will you move your feature branch into develop, main, or other base branches?</p><p>That answer is your <strong>merge strategy.</strong></p><p>A merge strategy is not just about “merging code.” It is a decision that directly impacts how your commit history takes shape, the traceability of your changes, and the long-term health of your repository.</p><h3>Merge Options</h3><p><strong>1. Regular Merge ( — no-ff)</strong></p><pre>git merge --no-ff feature-branch</pre><p>Creates a merge commit. All commits from the feature branch are preserved as-is, with a merge commit added on top. The branch history remains clearly visible.</p><p>📌 When to use: When you want to preserve branch history and context.</p><p><strong>2. Fast-Forward ( — ff)</strong></p><pre>git merge --ff feature-branch</pre><p>If the target branch is a direct ancestor of the source branch, no merge commit is created. The pointer simply moves forward. History appears linear.</p><p>📌 When to use: For small, independent, and straightforward changes.</p><p><strong>3. Squash Merge</strong></p><pre>git merge --squash feature-branch<br>git commit -m &quot;feat: new feature&quot;</pre><p>Squashes all commits from the feature branch into a single commit. The original commit history is not carried over to the target branch.</p><p>📌 When to use: When you want to clean up “work in progress” commits in a PR or simplify history.</p><p><strong>4. Rebase</strong></p><pre>git rebase main</pre><p>Technically not a merge, but a commit rewriting operation. Commits from the feature branch are re-applied on top of the target branch as if they originated there. History appears linear and clean.</p><p>📌 When to use: When you want a linear commit history.</p><p><strong>5. Cherry-Pick</strong></p><pre>git cherry-pick &lt;commit-hash&gt;</pre><p>Selectively applies specific commits to another branch. Instead of merging an entire branch, only the desired commits are picked.</p><p>📌 When to use: When you need to apply one or a few specific commits to a different branch.</p><h3>Which Strategy, When?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*Md_AQ-56BqDspIIXosmQ3Q.png" /></figure><blockquote><em>The options in the “Complete merge” screen on Azure DevOps and GitHub PRs map directly to these strategies.</em></blockquote><h3>The Core Topic: Commit Hash IDs</h3><p>The most critical technical difference between merge strategies is <strong>whether commit hash IDs change.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/1*cN8rOModNaX4sTzWRIlYsw.png" /></figure><p>Git compares differences between branches based on commit hash IDs. This means hash changes have a much broader impact than you might initially expect.</p><h3>Impact on Workflows</h3><p><strong>Bulk Development Workflow</strong></p><p>In this workflow, where all development progresses on a single feature branch, using squash, rebase, or cherry-pick will not cause any meaningful issues. Since development moves linearly, hash changes do not create critical problems.</p><p><strong>Feature-Based Development Workflow</strong></p><p>In this workflow, where each piece of development has its own feature branch, hash changes play a far more decisive role.</p><p>In feature-based development, having the same change exist with <strong>the same hash</strong> across base branches such as develop, staging, and main is critical for traceability and consistency.</p><p>When hashes change:</p><ul><li>Tracking which branch contains a given change becomes difficult.</li><li>Conflict resolution can produce misleading results.</li><li>Automation tools and CI/CD pipelines may behave incorrectly.</li></ul><h3>Developer Performance Measurement</h3><p>If developer performance is being measured through Git commit history — which is a common practice — hash changes directly affect the reliability of those measurements.</p><p>Having a change progress through its entire lifecycle with the same hash across all base branches ensures that contributions are tracked transparently.</p><p>When squash or rebase is used, original commits and their authors are lost or mixed up. This distorts performance data and hides the true picture of developer contributions.</p><p>For this reason, if performance measurement is a priority, <strong>Regular Merge or Fast-Forward</strong> should be preferred.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YgTY9uaIG3lMMgkHNx1dBQ.png" /></figure><h3>The Most Critical Rule: Consistency</h3><p>The most overlooked point when choosing a merge strategy is consistency.</p><blockquote><em>Whatever strategy is chosen for </em><em>develop must be applied to all other base branches as well.</em></blockquote><p>Merging into develop with squash and then using regular merge into main leads to history inconsistencies and traceability issues.</p><p>Adopting a single strategy across all base branches is the foundation of a healthy repository. Make this decision as a team, document it in your Pull Request templates or contribution guide, and ensure every team member follows it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tQ9zIvIFtHRchxBKtBx1IA.png" /></figure><h3>Conclusion</h3><p>Choosing a merge strategy is not just a technical preference — it is an <strong>engineering decision.</strong> Your team’s workflow, development model, and performance measurement needs should shape this decision.</p><p>If you want to preserve history and ensure transparency → <strong>Regular Merge</strong> If you want a clean and linear history → <strong>Rebase or Squash</strong> If traceability and performance measurement are priorities → <strong>Regular Merge or Fast-Forward</strong> In every case → <strong>Adopt the same strategy across all base branches</strong></p><p><em>In the next part of the series, we will cover Conflict Resolution strategies.</em></p><p><em>To read Git in Practice — Part 1: Branch Management, </em><a href="https://medium.com/@okanyurt/git-in-practice-part-1-branch-management-25e6df7053b8"><em>click here.</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b082a3713d5f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git in Practice — Part 1: Branch Management]]></title>
            <link>https://okanyurt.medium.com/git-in-practice-part-1-branch-management-25e6df7053b8?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/25e6df7053b8</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Thu, 19 Mar 2026 07:01:00 GMT</pubDate>
            <atom:updated>2026-03-19T07:01:00.751Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5W0Amg-_n04GgWyFoTE9KA.png" /></figure><p>“Plans are nothing; planning is everything.” — Dwight D. Eisenhower</p><p>In Git workflows, the question is rarely about following a rigid rulebook — it’s about how well your process adapts to change. Every team moves at a different pace, faces different constraints, and delivers value in its own way. That’s why choosing a branch management strategy isn’t about right or wrong, but about finding the structure that best supports how you actually build and ship software.</p><p>This article explores two different Git branch management approaches based on real-world scenarios. There is no universally correct or incorrect workflow — only the one that fits your needs.</p><p><strong>Introduction</strong></p><p>You can shape your Git flow according to the project you are working on and your team’s needs. This flexibility is one of Git’s greatest strengths. However, it also brings the question: <em>“Which strategy should I choose?”</em></p><p>In this article, I will cover two fundamental approaches: <strong>Bulk Development</strong> and <strong>Feature-Based Development</strong>. Both are battle-tested workflows widely used across the industry. My goal is not to tell you which one is “better,” but to help you understand which one is more appropriate for a given situation.</p><p><strong>1. Bulk Development Workflow</strong></p><p><strong>Core Structure</strong></p><p>This approach relies on <strong>3 main branches</strong>:</p><ul><li>develop → Feeds the test environment</li><li>preprod → Feeds the pre-production (UAT) environment</li><li>master → Feeds the production environment</li></ul><p><strong>Note:</strong> In some organizations, the test and UAT environments are the same. In that case, develop and master alone may be sufficient.</p><p><strong>Workflow Steps</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*cNNAX6Ph4_Tr5yOlqMPQlQ.png" /></figure><ol><li>Development begins by creating a feature branch off develop.</li><li>Once development is complete, a PR is opened from the feature branch to develop. After code review, it is merged.</li><li>The develop branch is deployed to the <strong>test environment</strong>.</li><li>Once all tests pass, develop is moved to preprod via a PR and merge.</li><li>In the preprod environment, <strong>UAT (User Acceptance Testing)</strong> is conducted by the Product Owner, business stakeholder, or customer.</li><li>UAT feedback is evaluated:</li></ol><ul><li>Items identified as <strong>new features</strong> → Added to the backlog as new items.</li><li>Items identified as <strong>bugs</strong> → Fixed and re-tested.</li></ul><ol><li>After UAT approval, a PR is opened from preprod to master, and following the merge, the master branch is deployed to <strong>production</strong>.</li></ol><p><strong>Advantages</strong></p><ul><li>Development, testing, and UAT processes are all handled <strong>in batches</strong>, which simplifies planning and coordination.</li><li>The Git flow is straightforward; developers carry minimal branch management overhead.</li><li>Since all changes are tested together, <strong>regression risk</strong> is easier to manage.</li></ul><p><strong>Disadvantages</strong></p><ul><li>In the real world, batch-based progress is not always possible. What happens when only 5 out of 10 items in a sprint are complete?</li><li>A single unfinished item can block the entire package from moving forward.</li><li>Urgent hotfix scenarios can complicate the flow significantly.</li></ul><p><strong>When to Use</strong></p><p>The bulk development workflow is ideal for projects with <strong>predictable and regular release cycles</strong>. It suits teams following Waterfall or stricter Agile sprint delivery plans.</p><p><strong>2. Feature-Based Development Workflow</strong></p><p><strong>Motivation</strong></p><p>You are working with Agile Scrum and picked 10 items for a sprint. Only 5 are ready in the test environment. On top of that, you want UAT testing for those 5 to run in parallel. You encounter scenarios like:</p><ul><li>4 out of 5 items should go to preprod, but 1 should not.</li><li>Or 3 should go, 2 should not.</li></ul><p>For these kinds of situations, a <strong>feature-based development workflow</strong> is the right choice.</p><p><strong>Core Structure</strong></p><p>This approach also uses <strong>3 main branches</strong>, but this time each branch independently feeds its own environment:</p><ul><li>develop → Feeds the test environment</li><li>preprod → Feeds the UAT environment</li><li>master → Feeds the production environment</li></ul><p><strong>Case 1: Batch Production Release After UAT</strong></p><p>In this case, features are released to production <strong>as a single package</strong> after UAT is complete.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qwzdkeE6U-2ssbcbcuteXA.png" /></figure><p><strong>Workflow steps:</strong></p><ol><li>The feature branch is created <strong>from preprod</strong>. <em>(This is a critical point — it is branched from preprod, not develop.)</em></li><li>Development is completed on the feature branch.</li><li>A PR is opened to develop to send it to the test environment. Code review is performed and the branch is merged.</li><li>The develop branch is deployed to the <strong>test environment</strong>.</li><li>Once testing is complete, a PR is opened from the same feature branch to preprod.</li><li>Since a thorough code review was already done on the develop PR, only a basic review is needed at this stage.</li><li>The feature merged into preprod is deployed to the <strong>UAT environment</strong>.</li><li>After all UAT testing is complete, a regression test is run.</li><li>Once the package is approved, a PR is opened from preprod to master and deployed to <strong>production</strong>.</li></ol><p><strong>When to use:</strong> If UAT will be conducted on a feature-by-feature basis but the production release will still be done as a batch, this workflow is the right choice. It is important to avoid unnecessary over-engineering — if you do not need to release each feature individually to production, there is no need to model it that way.</p><p><strong>Case 2: Feature-by-Feature Production Release</strong></p><p>In this case, each feature can be independently released to production after UAT approval.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*9Ty6gW2qqgd-E8Yzh4-FXg.png" /></figure><p><strong>Workflow steps:</strong></p><ol><li>The feature branch is created <strong>from master</strong>. <em>(All promotions across environments will be done through this branch.)</em></li><li>Development is completed, a PR is opened to develop, and it is merged.</li><li>develop is deployed to the <strong>test environment</strong>.</li><li>Once testing is complete, a PR is opened from the same feature branch to preprod and merged.</li><li>preprod is deployed to the <strong>UAT environment</strong>.</li><li>Features approved in UAT are merged into master <strong>individually</strong> via separate PRs.</li><li>Only the selected and approved feature branches are promoted to production.</li></ol><p><strong>When to use:</strong> If you need the flexibility to selectively release features at both the UAT and production stages, this is the right workflow. However, keep in mind that as the number of branches grows, so does the management overhead — this tradeoff should be carefully considered.</p><p><strong>Comparison Table</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BDfj58IYRxnazo3hSDSLyA.png" /></figure><p><strong>Important Notes</strong></p><p><strong>Avoid the Over-Engineering Trap</strong></p><p>If all the items coming into preprod will move forward as a single batch after UAT, adopting a feature-by-feature production release workflow only creates unnecessary effort. Model your solution to match your actual needs — do not go beyond them.</p><p><strong>These Workflows Are Not Competing Alternatives</strong></p><p>Both approaches are widely used and valid in the industry. The answer to “which one is correct?” is always: <strong>“The one that fits your needs.”</strong></p><p><strong>Pre-Production Stages Vary by Organization</strong></p><p>Topics such as staging environments, hotfix policies, and canary deployments vary greatly from company to company and process to process. These details are outside the scope of this article.</p><p><strong>Conclusion</strong></p><p>There is no single right path in Git branch management. Your team size, release frequency, testing processes, and organizational constraints all determine which workflow is right for you.</p><p>In the next article, I will cover <strong>merge strategies</strong> (Merge Commit, Squash Merge, Rebase) that sit on top of these branch management workflows — examining how each one affects git history and which scenarios call for which strategy.</p><p><strong>Stay tuned.</strong></p><p><em>Feel free to share your real-world experiences and questions in the comments.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25e6df7053b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coverage ≠ Quality: Rethinking Unit Tests in the Age of AI]]></title>
            <link>https://okanyurt.medium.com/coverage-quality-rethinking-unit-tests-in-the-age-of-ai-39ddb337d08f?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/39ddb337d08f</guid>
            <category><![CDATA[code-coverage]]></category>
            <category><![CDATA[aiin-development]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Sun, 15 Feb 2026 06:16:00 GMT</pubDate>
            <atom:updated>2026-02-15T06:16:00.747Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uOC-LVSzbWmxOcHLYKmA4Q.png" /></figure><h3>Unit Test Coverage: Are We Really Measuring Quality?</h3><h3>Introduction</h3><p>A Friday afternoon. The sprint is ending, the demo must be ready. The Product Owner is waiting in the room. The team lead asks: “Are the tests done?”</p><p>“It’s working, we already showed it. We’ll write the tests next week.”</p><p>This scene repeats every day in software teams across Turkey. Writing unit tests is often seen as a “waste of time.” Especially in teams under high delivery pressure, testing takes a back seat.</p><p>But the real question is: <strong>Is not writing tests faster, or is moving forward without tests more expensive?</strong></p><p>We’re in 2025, where AI agents have increased test writing speed by 400%, where GitHub Copilot can generate tests with a single command. Yet we still ask:</p><ul><li>Are unit tests really necessary?</li><li>How meaningful is reaching an 80% coverage target?</li><li>Can AI solve this problem?</li></ul><p>In this article, we’ll examine unit test coverage not just as a metric, but as an engineering discipline. We’ll discuss in depth the real situation in Turkey, global trends, and the impact of AI.</p><h3>1. What is a Unit Test? (Reality, Not Theory)</h3><p>A unit test is a method of testing the smallest testable units of code (function, method, class) in isolation. But this definition is incomplete.</p><h3>The Real Purpose of Unit Testing</h3><p>Most developers write unit tests to “verify code correctness.” This is partially true. <strong>The real purpose is to document system behavior and guarantee its changeability.</strong></p><p>Let’s look at an example:</p><pre>public class OrderCalculator<br>{<br>    public decimal CalculateTotal(Order order)<br>    {<br>        var subtotal = order.Items.Sum(i =&gt; i.Price * i.Quantity);<br>        var discount = order.DiscountCode != null <br>            ? ApplyDiscount(subtotal, order.DiscountCode)<br>            : 0;<br>        var tax = (subtotal - discount) * 0.18m;<br>        <br>        return subtotal - discount + tax;<br>    }<br>}</pre><p>This code works. But what happens when a developer comes 6 months later and wants to change this?</p><pre>// Let&#39;s increase the tax rate to 20%<br>var tax = (subtotal - discount) * 0.20m;</pre><p><strong>Without unit tests:</strong> You’ll notice in production (customer complaint → revenue loss)<br> <strong>With unit tests:</strong> You’ll see a red test in CI within 30 seconds</p><h3>3 Fundamental Properties of Test Writing</h3><ol><li><strong>Fast:</strong> Should run in milliseconds</li><li><strong>Isolated:</strong> Should not depend on database, API, file system</li><li><strong>Deterministic:</strong> Should give the same result on every run</li></ol><p>Tests that meet these properties can <strong>safely run in CI/CD pipelines</strong> and shorten the developer feedback loop.</p><h3>2. Why Write Tests? (Real Benefits)</h3><h3>2.1 Refactoring Safety (The Most Critical Benefit)</h3><p>Software development means constant change. Requirements change, performance gets optimized, technical debt gets paid. The only way to make these changes <strong>safely</strong> is through test coverage.</p><p><strong>Real Scenario:</strong><br> You want to change the order calculation algorithm in a legacy e-commerce system. But there are 200 different edge cases: discount codes, corporate customers, campaign combinations…</p><ul><li><strong>Without tests:</strong> Every change is a potential production bug</li><li><strong>With tests:</strong> 200 scenarios are verified in 5 minutes</li></ul><h3>2.2 Changeability Guarantee</h3><p>Martin Fowler’s famous quote: <em>“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”</em></p><p>I add to this: <strong>“Writing tests doesn’t guarantee code correctness, it guarantees changeability.”</strong></p><h3>2.3 Design Feedback Mechanism</h3><p>When writing tests, you’ll notice if your code has design problems:</p><ul><li>If a method takes too many dependencies → It’s hard to mock</li><li>If there’s tight coupling → Tests can’t be isolated</li><li>If there’s a God class → Test setup becomes complex</li></ul><p><strong>If writing tests feels difficult, the code design is bad.</strong> This is an alarm bell.</p><h3>2.4 Catching Edge-Case Scenarios</h3><p>AI-generated code only covers happy paths. But what happens in production:</p><pre>❌ null values<br>❌ empty collections<br>❌ integer overflow<br>❌ concurrent modification<br>❌ timezone differences<br>❌ float precision errors</pre><p>Writing unit tests <strong>forces</strong> you to think about these scenarios.</p><h3>3. Why is Unit Test Culture Weak in Turkey?</h3><h3>3.1 Delivery-First Culture</h3><p>In many Turkish software companies, KPIs are defined as:</p><ul><li>How many features were delivered in the sprint?</li><li>What’s the story point velocity?</li><li>Were planned tasks completed?</li></ul><p><strong>Test coverage is never a KPI.</strong></p><p>This is a wrong management approach. Because:</p><blockquote><em>Delivering fast and fixing bugs in production for 3 days is </em><strong><em>more expensive</em></strong><em> than delivering slowly and never fixing bugs.</em></blockquote><h3>3.2 “It Works” Mentality</h3><p>A common approach in Turkey:</p><pre>Developer: &quot;I wrote the code, it works.&quot;<br>Tech Lead: &quot;Did you write tests?&quot;<br>Developer: &quot;Is it necessary? I manually tested it anyway.&quot;</pre><p>The cost of this approach:</p><ul><li><strong>1 month later:</strong> Another developer changes the code → production bug</li><li><strong>6 months later:</strong> That developer left → code becomes untouchable</li><li><strong>1 year later:</strong> Code gets rewritten (technical debt explosion)</li></ul><h3>3.3 The Time Pressure Myth</h3><p>Saying “we don’t have time to write tests” actually means: <strong>“We have time to fix bugs in production.”</strong></p><p><strong>The real calculation:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*Z9eHnrX-Z5qd51ab142REg.png" /></figure><p>Writing tests actually <strong>saves time</strong>.</p><h3>3.4 Optimistic Developments</h3><p>However, there are positive changes in Turkey in recent years:</p><ul><li><strong>Enterprise companies:</strong> Sonar, Quality Gates becoming widespread</li><li><strong>Fintech/banking:</strong> 80% coverage mandatory</li><li><strong>Startups:</strong> Test awareness increasing with CI/CD culture</li></ul><h3>4. Coverage Metric: Is It Misleading?</h3><h3>4.1 90% Coverage But Bugs in Production?</h3><p>Yes, it’s possible. Because coverage measures <strong>code execution</strong>, not <strong>correctness</strong>.</p><p><strong>Bad Test Example:</strong></p><pre>[Test]<br>public void CalculateTotal_ShouldWork()<br>{<br>    var order = new Order <br>    { <br>        Items = new List&lt;OrderItem&gt; <br>        { <br>            new OrderItem { Price = 100, Quantity = 2 }<br>        }<br>    };<br>    <br>    var result = calculator.CalculateTotal(order);<br>    <br>    // ❌ NO ASSERT!<br>    // This test provides 100% line coverage but validates nothing<br>}</pre><p>The developer who wrote this test will see “green” in the coverage report. But the test produces no value.</p><h3>4.2 Coverage Types</h3><p><strong>Line Coverage:</strong></p><pre>if (user.IsAdmin)  // Did this line execute?<br>    GrantAccess();  // Did this line execute?</pre><p><strong>Branch Coverage:</strong></p><pre>if (user.IsAdmin)  // ✅ Was the true case tested?<br>    GrantAccess();  <br>else               // ✅ Was the false case tested?<br>    DenyAccess();</pre><p><strong>Meaningful Coverage:</strong></p><pre>// ✅ Test doesn&#39;t just execute, it validates<br>Assert.That(result.HasAccess, Is.True);<br>Assert.That(result.Reason, Is.EqualTo(&quot;Admin privilege&quot;));</pre><h3>4.3 Industry Standards</h3><p>Results from research:</p><ul><li><strong>80% coverage</strong> → Healthy target (optimal cost/benefit)</li><li><strong>60–75%</strong> → Acceptable minimum</li><li><strong>90%+</strong> → Critical systems (banking, healthcare, aviation)</li><li><strong>100%</strong> → Expensive and unnecessary (examples of 2 years effort for the last 5%)</li></ul><p><strong>However:</strong> These numbers are meaningless alone. The real question: <strong>Are the tests meaningful?</strong></p><h3>5. The Impact of AI Agents on Unit Test Writing</h3><h3>5.1 Shocking Statistics in 2025</h3><p>AI test generation adoption:</p><ul><li><strong>72%</strong> → QA teams using AI-driven test tools</li><li><strong>81%</strong> → Development teams using AI in test workflows</li><li><strong>25%</strong> → Google’s new code written by AI</li></ul><p><strong>Productivity increases:</strong></p><ul><li><strong>10 weeks → 2 weeks</strong> → With NVIDIA’s HEPH framework</li><li><strong>60–80% coverage</strong> → Automatic with GitHub Copilot TestPilot</li><li><strong>80%+ coverage with one click</strong> → BaseRock AI</li><li><strong>1 month → 2 hours</strong> → ExpressoTS case study (206 tests, 89% coverage)</li></ul><h3>5.2 What Does AI Do?</h3><p><strong>GitHub Copilot (2025):</strong></p><p>Visual Studio 2026 now has built-in test generation:</p><pre>// Just write this:<br>@Test #BankAccount</pre><p>Copilot:</p><ol><li>Analyzes the BankAccount class</li><li>Creates MSTest/xUnit/NUnit tests</li><li>Suggests edge cases</li><li>Does mocking setup</li><li>Adds assertions</li></ol><p><strong>Other AI Tools:</strong></p><ul><li><strong>Diffblue Cover</strong> → With reinforcement learning (no LLM hallucination!)</li><li><strong>EarlyAI</strong> → 24/7 running agent, creates autonomous PRs</li><li><strong>Qodo Cover</strong> → CI/CD integrated, PR merged to HuggingFace</li><li><strong>GitAuto</strong> → 90%+ coverage target, works autonomously</li></ul><h3>5.3 What Can’t AI Do?</h3><p><strong>Critical Limitations:</strong></p><ol><li><strong>Doesn’t truly understand business rules</strong></li></ol><pre>// AI can write this:<br>   Assert.That(discount, Is.GreaterThan(0));<br>   <br>   // But can&#39;t write this:<br>   Assert.That(discount, Is.EqualTo(subtotal * 0.15m), <br>       &quot;VIP customers get 15% discount as per business rule #42&quot;);</pre><p><strong>2. Doesn’t generate domain knowledge</strong></p><ul><li>In an e-commerce system, “can a discount code be applied when cart is empty?”</li><li>This is a business rule question. AI can’t know this.</li></ul><p><strong>3. No risk intuition</strong></p><ul><li>Which function is critical? Which edge case will blow up in production?</li><li>AI can <strong>learn</strong> this from data, but can’t intuit it.</li></ul><p><strong>4. Can’t distinguish test meaningfulness</strong></p><ul><li>A test without assertions also provides “coverage” to AI</li><li>Can’t understand the difference between meaningful test vs fake coverage</li></ul><h3>5.4 The Golden Rule</h3><blockquote><strong><em>AI increases test writing speed, but the developer still determines test value.</em></strong></blockquote><p>AI should be your <strong>assistant</strong>, not your <strong>replacement</strong>.</p><p><strong>Correct Workflow:</strong></p><pre>1. AI writes boilerplate test (30 seconds)<br>2. Developer reviews, adds edge cases (5 minutes)<br>3. Developer strengthens business logic assertions (5 minutes)<br>4. Merge!</pre><p><strong>Wrong Workflow:</strong></p><pre>1. AI writes test<br>2. Developer sees &quot;green&quot; and merges<br>3. Bug appears in production</pre><h3>6. Mutation Testing: Beyond Coverage</h3><h3>6.1 Is Coverage Sufficient?</h3><p>Question: <strong>Does a test suite with 90% coverage actually catch bugs?</strong></p><p>Answer: <strong>Maybe.</strong></p><h3>6.2 What is Mutation Testing?</h3><p>Mutation testing <strong>intentionally injects bugs</strong> into your code and checks whether your tests catch them.</p><p><strong>Example:</strong></p><pre>// Original code:<br>if (age &gt;= 18)<br>    return &quot;Adult&quot;;<br>// Mutation 1: Operator change<br>if (age &gt; 18)  // ❌ 18-year-olds are no longer &quot;Adult&quot;<br>    return &quot;Adult&quot;;<br>// Mutation 2: Constant change<br>if (age &gt;= 19)  // ❌ 18-year-olds are no longer &quot;Adult&quot;<br>    return &quot;Adult&quot;;</pre><p><strong>If your tests don’t catch these mutations:</strong><br> → You have coverage, but the test is <strong>worthless</strong>.</p><h3>6.3 Mutation Testing Tools (.NET)</h3><ul><li><strong>Stryker.NET</strong> → Most popular mutation testing tool</li><li><strong>PIT (Java)</strong> → Mutation testing for Java</li></ul><p><strong>Example Report:</strong></p><pre>Mutation Score: 75%<br>❌ Killed: 30 mutants<br>✅ Survived: 10 mutants<br>⚠️  Timeout: 2 mutants</pre><p><strong>Survived mutants</strong> → Bugs your tests didn’t catch!</p><h3>6.4 Cost of Mutation Testing</h3><p>Mutation testing is <strong>expensive</strong>:</p><ul><li>The entire test suite runs for each mutation</li><li>Targeting 100% mutation score is <strong>not practical</strong></li><li>But it’s <strong>essential</strong> for critical business logic</li></ul><p><strong>Recommendation:</strong></p><ul><li>Core business logic → 80%+ mutation score</li><li>Utility/helper code → 50% mutation score is enough</li><li>Only line coverage → ❌ Not sufficient</li></ul><h3>7. Conclusion: 3 Golden Rules</h3><h3>✅ 1. Unit Tests Are a Safety Net</h3><p>Software development means constant change. Test coverage allows you to make these changes <strong>safely</strong>.</p><p><strong>Without tests:</strong> Every refactor is a gamble<br> <strong>With tests:</strong> Every refactor is an opportunity</p><h3>✅ 2. Coverage ≠ Quality</h3><p>90% coverage means nothing if:</p><ul><li>Assertions aren’t meaningful</li><li>Edge cases aren’t tested</li><li>Business logic isn’t validated</li></ul><p><strong>Meaningful test &gt; High coverage</strong></p><h3>✅ 3. AI = Accelerator, Not Quality Guarantee</h3><p>AI revolutionized test writing in 2025:</p><ul><li>GitHub Copilot writes tests with one command</li><li>BaseRock AI provides 80% coverage</li><li>Diffblue Cover adds tests to legacy code</li></ul><p><strong>But:</strong><br> AI can’t determine test <strong>value</strong>. Developers must still:</p><ul><li>Know business logic</li><li>Identify risk areas</li><li>Intuitively catch edge cases</li></ul><h3>Final Thoughts</h3><p>Unit test culture in Turkey is open to development. But this isn’t a “backwardness,” it’s an <strong>opportunity</strong>.</p><p>Thanks to AI tools in 2025:</p><ul><li>The “I don’t have time” excuse is gone</li><li>Legacy code can now be tested</li><li>Junior developers are learning with AI mentoring</li></ul><p><strong>The question is no longer:</strong> “Should I write tests?”<br> <strong>The question is:</strong> “How do I improve test quality?”</p><p>And remember:</p><blockquote><em>Writing tests isn’t for validating your code, it’s for </em><strong><em>having the courage to change it</em></strong><em>.</em></blockquote><p><strong>Okan Yurt</strong><br> Senior Software Engineer<br> <em>Writing about AI-augmented .NET development, test automation, and engineering excellence.</em></p><h3>References</h3><ol><li><a href="https://devblogs.microsoft.com/dotnet/github-copilot-testing-for-dotnet/">GitHub Copilot Testing for .NET</a> — Microsoft DevBlogs</li><li><a href="https://qualizeal.com/the-rise-of-agentic-ai-transforming-software-testing-in-2025-and-beyond/">The Rise of Agentic AI in Testing</a> — QualiZeal</li><li><a href="https://gitauto.ai/blog/best-unit-test-agents-2025">9 Best Unit Test Agents 2025</a> — GitAuto</li><li><a href="https://www.atlassian.com/continuous-delivery/software-testing/code-coverage">What is Code Coverage?</a> — Atlassian</li><li><a href="https://stryker-mutator.io/docs/stryker-net/introduction/">Mutation Testing with Stryker.NET</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39ddb337d08f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Killer of Project Builds: StyleCop]]></title>
            <link>https://okanyurt.medium.com/the-killer-of-project-builds-stylecop-38d582903938?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/38d582903938</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[dotnet-10]]></category>
            <category><![CDATA[build-optimization]]></category>
            <category><![CDATA[stylecop]]></category>
            <category><![CDATA[code-quality]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 10:11:11 GMT</pubDate>
            <atom:updated>2026-02-05T10:11:11.100Z</atom:updated>
            <content:encoded><![CDATA[<p>Before this article, I shared my perspective on why code style standards matter. In my post <em>“</em><a href="https://medium.com/@okanyurt/daha-okunabilir-ve-y%C3%B6netilebilir-kod-i%CC%87%C3%A7in-stil-standartlar%C4%B1-f3832f348a9d"><em>Code Style Standards for More Readable and Maintainable Code</em></a><em>”</em>, I discussed the importance of clean and understandable code for long-term project sustainability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i_aTu_0WbHvtYO7xAnJtfQ.png" /></figure><p>A tool that works quietly in the background for years can one day turn into the biggest bottleneck in your project.<br>StyleCop was exactly that for me: for more than 5 years, it was the guardian of code standards — then suddenly, the killer of build times.<br>In this article, I share a real performance problem I faced after migrating to .NET 10 and how I approached it.</p><p>I have used StyleCop for over five years in almost every project I worked on to enforce coding standards. Until recently, I had never experienced any serious performance issues.</p><p>Especially in projects where multiple developers work together, things like line formatting, unused or unnecessary using statements, and naming conventions are often pushed to the background. As teams grow, everyone applies their own styling perspective. Over time, this leads to increasing technical debt and reduced code readability.</p><p>This is where StyleCop shines. When you define unwanted behaviors in rulesets, it breaks the build locally and forces all developers to follow the same standard. For years, this made StyleCop an essential tool for me.</p><h3>Everything Was Fine… Until .NET 10</h3><p>In November 2025, I completed the migration to .NET 10. Even though our RESTful service is not very large, I noticed that local build times sometimes increased to 3–4 minutes. Previously, even 1–2 minute build times felt like something you could postpone fixing. But at this point, it became truly painful.</p><p>Interestingly, the first build was always the slowest. After caching kicked in, build times dropped to around 30 seconds to 1 minute. The issue was not constant, but it seriously hurt the developer experience.</p><p>At this stage, I decided to analyze the problem in detail and enabled detailed diagnostics to see exactly where the build process was getting stuck.</p><h3>Searching for the Problem: From Simple to Complex</h3><p>When I started the investigation, I had <strong>three different suspects</strong> that could be causing the slowdown. These included analyzers, SourceLink, and additional build-time scanning processes. In particular, I observed that analyzers and SourceLink were consuming a significant amount of time and scanning many things — including history — on every build.</p><p>My approach was straightforward:</p><p>Disable the suspicious part, run the build, and measure the impact. If there is a clear improvement, you have found the culprit. If nothing changes, eliminate that option and move on to the next suspect.</p><p>I disabled these three areas one by one, starting from the simplest and moving toward the most complex, measuring build times at each step. The main goal of this article is not just the final solution, but also to show how a real-world performance problem can be approached systematically and what can be learned from the process.</p><h3>Suspicions Become Clear: Analyzers Take the Stage</h3><p>Eventually, I clearly identified analyzers as the main source of the problem. I do not want to say “StyleCop is bad” directly, but it was obvious that some of its rulesets were performing unnecessary checks.</p><p>My first instinct was not to remove StyleCop completely. In the project, some rules were configured as None or Warning. This meant that even if there was a styling issue, it would not break the build. Removing StyleCop entirely could cause these rules to disappear and potentially turn some cases into Error.</p><p>Because of this, I chose a more controlled approach.</p><p>I kept StyleCop in the project but disabled analyzer and SourceLink scanning during development. These checks were only enabled during the release phase. This brought local build times back to a usable level.</p><h3>Facing Reality: Letting Go of an Old Dependency</h3><p>At the first opportunity, I performed a deeper investigation. I discovered that the StyleCop.Analyzers package (version 1.2.0-beta) last received an update in 2023:</p><p><a href="https://www.nuget.org/packages/StyleCop.Analyzers/1.2.0-beta.556">https://www.nuget.org/packages/StyleCop.Analyzers/1.2.0-beta.556</a></p><p>For a modern platform like .NET 10, relying on such an old package raised serious questions. I asked myself a simple question:</p><p>Can I solve this without depending on an external package?</p><p>The answer was yes.</p><p>As a first step, I decided to remove StyleCop completely from the project. Instead, I defined the necessary rules directly in the project’s .editorconfig file. Code style and standards were preserved, while analyzer overhead was significantly reduced.</p><p>The result?</p><p>Build times dropped to around 10 seconds.</p><h3>Closing: Performance Gains and the Next Step</h3><p>In this article, I shared how I identified a build performance issue and why I decided to move away from StyleCop. In the next step, I will explain how to maintain code style and standards during development without negatively impacting build times or performance.</p><p>I will cover that in the next article.</p><p>Even though build times have been dramatically reduced at this point, the real question does not end here:</p><p>How can we protect code style and standards without hurting the developer experience, slowing down local builds, or bloating CI pipelines?</p><p>In the next article, I will walk through how I achieved this balance step by step — without completely disabling analyzers and with almost zero cost during development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38d582903938" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Got Faster with AI, but Are We Losing Control?]]></title>
            <link>https://okanyurt.medium.com/we-got-faster-with-ai-but-are-we-losing-control-9f6668380e15?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f6668380e15</guid>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[developer-experience]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Sat, 31 Jan 2026 06:01:01 GMT</pubDate>
            <atom:updated>2026-01-31T06:01:01.850Z</atom:updated>
            <content:encoded><![CDATA[<p>The adoption of AI tools such as Copilot and Cursor has significantly increased in software teams. As a natural result, productivity has improved. Today, instead of spending most of our time writing code, we focus more on <strong>deciding what should be built</strong> and <strong>designing the basic algorithm</strong>. We no longer develop software the way we used to, by manually implementing fundamental pieces over and over again.</p><p>This is a major advantage.</p><p>However, in this article, I want to focus on another perspective that comes with this acceleration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YwpLaBzh59ME29e0fVwX6Q.png" /></figure><p><strong>Prompt-Based Coding and the Reality of Vibe Coding</strong></p><p>Prompt-based coding and approaches like vibe coding continue to evolve in their own lane. This is not something to resist; it is a reality to accept.<br> But there is a critical risk that should not be ignored:</p><p>AI tools do not only accelerate development — <strong>they can also increase human complacency</strong>.</p><p>We gradually hand over control.<br> We get used to ready-made solutions.<br> And sometimes, we push code written via prompts without questioning it enough.</p><p>As a result, we may unintentionally:</p><ul><li>Commit irrelevant changes,</li><li>Add more code than necessary,</li><li>Introduce unnecessary dependencies,</li><li>Modify unrelated folders or files.</li></ul><p>And all of this can easily be normalized with a simple justification: <em>“It works.”</em></p><p><strong>Keeping Control at the Center</strong></p><p>At this point, the focus must shift back to <strong>control</strong>.</p><p>Whether the code is written by a human or generated by AI, the following questions must be asked more rigorously during developer testing:</p><ul><li>Is this code really necessary?</li><li>Has more code than needed been written?</li><li>Were unnecessary or irrelevant packages added?</li><li>Why was this change made in this specific folder?</li><li>Does the implementation truly meet the actual requirements?</li></ul><p>Under <strong>Normal Conditions (NŞA — Normal Conditions)</strong>, <strong>code that is not under control should not be used</strong>.<br> If the developer does not have full ownership of the code, then that code is outside NŞA.</p><p>“AI wrote it” is not a valid excuse.<br> “It works” is not sufficient.</p><p><strong>The Inspiration Behind This Article</strong></p><p>This article was inspired by a conversation with colleagues from the testing team.</p><p>After analyzing certain metrics — such as:</p><ul><li>An increase in the number of bugs since Cursor usage became more common,</li><li>A rise in irrelevant or unnecessary documentation coming from developers,</li><li>And in some cases, AI-generated documentation being added <strong>directly without review</strong> —</li></ul><p>it became clear that this topic deserved deeper discussion.</p><p>The goal here is not to blame anyone, but to improve the overall process.</p><p><strong>Not Developer vs. Tester, but Developer + Tester</strong></p><p>One critical point must be emphasized:<br> <strong>Developers and testers are not opponents.</strong></p><p>Unfortunately, unnecessary conflicts often arise between these roles in many organizations. In reality, they are part of the same team, working toward the same goal.</p><p>The purpose of the testing team is to:</p><ul><li>Improve quality under normal conditions,</li><li>Minimize issues after production release,</li><li>Identify blind spots that developers may miss.</li></ul><p>A developer often struggles to view their own code with a second perspective.<br> This is completely human.</p><p>That is exactly where testers add value — by identifying:</p><ul><li>Missed scenarios,</li><li>Overlooked details,</li><li>Risks that surface in non-production environments.</li></ul><p>This is not an ego battle.<br> And it should never be a competition.</p><p><strong>Building Quality Together</strong></p><p>This article itself is proof of that collaboration.<br> A conversation with a tester friend, and seeing the process through their perspective, triggered the need to document what I believe is right.</p><p>Quality is not produced in isolation.<br> Speed alone has no meaning.</p><p>AI allows us to write code faster.<br> But <strong>control, ownership, and responsibility</strong> are more important than ever.</p><p><strong>Conclusion</strong></p><p>Today, a good developer is not the one who writes the best prompt,<br> but the one who <strong>questions the generated code the most effectively</strong>.</p><p>Under normal conditions, the developer owns the code.<br> Unowned code is not just technical debt — <br> it is also a serious risk to team culture.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f6668380e15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting More Out of GitHub Copilot with Fewer Premium Requests]]></title>
            <link>https://okanyurt.medium.com/getting-more-out-of-github-copilot-with-fewer-premium-requests-411f8df229d6?source=rss-58bcab69e460------2</link>
            <guid isPermaLink="false">https://medium.com/p/411f8df229d6</guid>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[Okan Yurt]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 12:20:00 GMT</pubDate>
            <atom:updated>2026-01-28T12:20:00.211Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Practical tips on tokens, requests, and everyday Copilot optimization</strong></h3><p><strong>What We Actually Consume When We “Ask” an LLM</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r0pFzByrlJljA28G08KoCg.png" /></figure><p>This article was born out of a casual conversation with friends while using GitHub Copilot.<br> We kept asking the same questions:</p><ul><li>What exactly is a <em>token</em>?</li><li>What does a <em>premium request</em> really mean?</li><li>Why do some models cost more?</li><li>And most importantly: <strong>how can we reduce premium request usage without losing productivity?</strong></li></ul><p>Let’s break it down from start to finish.</p><p><strong>1. What Is a Token?</strong></p><p>A <strong>token</strong> is the smallest unit of text that a Large Language Model (LLM) understands and processes.</p><p>Think of it like this:</p><p><strong>Token ≈ Cell of thought</strong></p><p>Not exactly a word, not exactly a character — but something in between.</p><p>Examples:</p><ul><li>“Hello” → 1 token</li><li>“authentication” → 2–3 tokens</li><li>“System.Guid?” → multiple tokens</li></ul><p>LLMs don’t read sentences the way humans do.<br> They read <strong>streams of tokens</strong>, predict the next token, and build responses step by step.</p><p>So when you send:</p><ul><li>a long prompt</li><li>a large code file</li><li>or ask for detailed explanations</li></ul><p>You’re actually sending <strong>hundreds or thousands of tokens</strong>.</p><p><strong>2. What Is a Request?</strong></p><p>A <strong>request</strong> is one complete interaction with the model.</p><p>It includes:</p><ul><li>your input tokens (prompt, code, context)</li><li>the model’s output tokens (the response)</li></ul><p>So:</p><p>One request = input tokens + output tokens</p><p>But here’s the critical part 👇<br> <strong>Not all requests are equal in cost.</strong></p><p><strong>3. What Is a Premium Request?</strong></p><p>In tools like <strong>GitHub Copilot</strong>, a <em>Premium Request</em> is a request that:</p><ul><li>Uses a <strong>high-end model</strong> (GPT-5, Claude Sonnet, Claude Opus, etc.)</li><li>Or exceeds certain <strong>token/context limits</strong></li><li>Or involves <strong>agent-style, multi-step reasoning</strong></li></ul><p>That’s why you see <strong>multipliers</strong> like:</p><ul><li>1x</li><li>0.33x</li><li>3x</li></ul><p><strong>Example:</strong></p><ul><li>GPT-5 → 1x</li><li>Claude Opus → 3x</li><li>Lightweight / mini models → 0.33x</li></ul><p>So if you have <strong>300 premium requests</strong>:</p><ul><li>Using a 3x model burns them <strong>3x faster</strong></li><li>Using a 0.33x model stretches them much further</li></ul><p><strong>4. Are 10-Token and 1,000-Token Requests Equal?</strong></p><p>Short answer: <strong>No — but also yes (from a quota perspective).</strong></p><p>From a <strong>billing/quota</strong> standpoint:</p><ul><li>Both count as <strong>1 request</strong></li></ul><p>From a <strong>system cost</strong> standpoint:</p><ul><li>The 1,000-token request is far heavier</li></ul><p>That’s why platforms combine:</p><ul><li><strong>request limits</strong></li><li><strong>token limits</strong></li><li><strong>model multipliers</strong></li></ul><p>Premium requests are a <em>coarse-grained limiter</em>, not a precise cost meter.</p><p><strong>5. Ask vs Agent Mode — Same Cost?</strong></p><p>Not exactly.</p><p><strong>Ask Mode</strong></p><ul><li>Single-shot</li><li>Minimal context</li><li>Usually cheaper</li><li>Fewer internal steps</li></ul><p><strong>Agent Mode</strong></p><ul><li>Multi-step reasoning</li><li>Reads files</li><li>Writes plans</li><li>Executes sub-tasks</li><li>Calls the model <strong>multiple times</strong></li></ul><p>Even if you see <em>one action</em>, under the hood it may trigger:</p><p>3–10 model calls</p><p>Which means:</p><ul><li>Faster premium request consumption</li><li>Higher token usage</li></ul><p><strong>6. What Happens When You Select “Auto” Model?</strong></p><p>When you choose <strong>Auto</strong>, Copilot dynamically selects a model based on:</p><ul><li>Prompt size</li><li>Task type (code completion, refactor, explanation)</li><li>Required reasoning depth</li><li>Current system load</li></ul><p>Typical behavior:</p><ul><li>Simple autocomplete → lightweight model</li><li>Complex refactor / reasoning → premium model</li><li>Ambiguous tasks → safer, stronger model</li></ul><p>So <strong>Auto optimizes for quality first</strong>, not quota conservation.</p><p><strong>7. How to Optimize Premium Request Usage</strong></p><p>This is the part everyone actually cares about 👇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V6zBWFCoK_d4C6Jd9uPQag.png" /></figure><p><strong>1. Be Precise, Not Verbose</strong></p><p>Bad:</p><p>“Can you refactor this entire solution and explain everything?”</p><p>Better:</p><p>“Refactor this method to remove LINQ allocations.”</p><p><strong>2. Limit Context Size</strong></p><ul><li>Don’t paste entire files unless needed</li><li>Ask about <strong>specific functions</strong></li><li>Trim irrelevant code</li></ul><p>Tokens add up <em>fast</em>.</p><p><strong>3. Use Agent Mode Only When Needed</strong></p><p>Agent mode is powerful — but expensive.</p><p>Use it for:</p><ul><li>Multi-file refactors</li><li>Architectural changes</li></ul><p>Avoid it for:</p><ul><li>Simple questions</li><li>Syntax fixes</li><li>Small optimizations</li></ul><p><strong>4. Prefer Auto or Lightweight Models for Iteration</strong></p><ul><li>Draft with cheap models</li><li>Finalize with premium ones</li></ul><p>Think of it like:</p><p><strong>Sketch first, polish later</strong></p><p><strong>5. Ask for Diffs, Not Full Rewrites</strong></p><p>Instead of:</p><p>“Rewrite this class”</p><p>Try:</p><p>“Show only the changes needed”</p><p>Less output = fewer tokens.</p><p><strong>8. Mental Model to Remember</strong></p><p>Here’s the simplest way to think about it:</p><ul><li><strong>Token</strong> → the smallest thinking unit</li><li><strong>Request</strong> → one conversation turn</li><li><strong>Premium Request</strong> → a turn using expensive brainpower</li><li><strong>Agent Mode</strong> → multiple brains working together</li></ul><p>Once you see it this way, optimization becomes natural.</p><p><strong>Final Thoughts</strong></p><p>Copilot isn’t “expensive” by default.<br> It becomes expensive when we’re vague, oversized, or careless with context.</p><p>When you:</p><ul><li>ask sharper questions</li><li>scope your requests</li><li>choose the right mode</li></ul><p>You get <strong>better answers</strong>, <strong>faster</strong>, and with <strong>fewer premium requests burned</strong>.</p><p>And honestly?<br> That’s a skill worth developing as much as coding itself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=411f8df229d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>