The case for staying on .NET Framework isn't technical anymore — it's inertia. The carrying cost of legacy .NET infrastructure is real, ongoing, and growing larger as modern tooling assumes .NET 8.
Read →The conventional advice in 2026 is to start with an ORM and optimize later. The CleenUI codebase has 700+ stored procedures, Dapper, and no ORM. Here is what that decision actually means in production.
Read →.NET 11 shipped at .NET Conf on November 10 — an STS release with C# 15 union types, OpenAPI 3.2 by default in ASP.NET Core, and an MCP server project template in the SDK. For teams on .NET 8 LTS, which hit end-of-support this month, the more important question is which upgrade target to choose.
Read →In the CleenUI codebase, a module is not a folder or a namespace. It is a complete vertical slice from UI to database, covering a defined production domain. Here is what is inside one.
Read →What does it mean to inherit 524 API endpoints? It means 524 operations that will not appear in your team's sprint backlog — and a first sprint that is about your application, not the platform it runs on.
Read →Three hundred-plus tables, seven hundred-plus stored procedures, and no ORM. Here is why that choice holds up under the kind of load B2B SaaS applications actually see.
Read →Technical due diligence is not a general code review. It has a specific checklist. The codebases that pass cleanly share one trait: they explain themselves to an outside reviewer in 72 hours.
Read →The difference between a module and a feature is depth, not scope. A feature is a behavior. A module is a behavior that runs UI to database, in production, with real data, under real load.
Read →Migration moves code. Modernization imposes a new architectural spine. Most legacy .NET projects confuse the two — and that confusion is why rewrites fail.
Read →Gergely Orosz made a point last week that's technically correct and practically incomplete: he's never seen a startup fail from architecture choices. He's right about the failure mode. Wrong about when the bill arrives.
Read →Milan Jovanović is right that integration tests with real services return the best ROI. What he didn't say: the return only holds when the data layer has a stable, typed interface. Stored procedures give you that. An ORM does not.
Read →Most teams know their legacy .NET codebase needs to move. They defer anyway, because the cost of moving looks bigger than the cost of staying. Here is what that calculation usually gets wrong.
Read →Milan Jovanović's May 2026 post made the distinction clearly: vertical slices are not modules. Understanding the difference is particularly important now, when AI agents generate code and the patterns they generate into determine the structural quality of the output.
Read →Every team building B2B SaaS on .NET faces the data access decision: ORM vs. stored procedures. The case for stored procedures gets stronger, not weaker, as AI tools generate more of the code.
Read →Milan Jovanović's agent-ready .NET template combining Clean Architecture and Vertical Slice Architecture with Claude Code Skills is pointing toward the right architecture. The production surface is a different question.
Read →The property that distinguishes a code footprint from a well-designed template is not documentation quality or design correctness. It is production history — the decisions that survived real query loads, real multi-tenant constraints, real incidents.
Read →Andrej Karpathy's 'agentic engineering' framework — coordinating fallible agents while preserving correctness, security, taste, and maintainability — requires something concrete to preserve them against. The codebase is that thing.
Read →Not all architectural decisions carry equal weight under agent pressure. The ones that hold are module boundaries, data access contracts, and interface clarity — not framework choices or naming conventions.
Read →A B2B SaaS platform needs more than the features on the roadmap. It needs the infrastructure those features run on. CleenUI's 20 production-ready modules ship that infrastructure already built.
Read →Most .NET modernization projects stall because teams underestimate the surface area. Here's what a clean migration path actually requires — and what a .NET 8 foundation already has in place.
Read →The ORM versus stored-procedure debate has been running for twenty years. In 2026, with AI agents writing the data access code, the stored-procedure approach has a compounding advantage most teams haven't seen yet.
Read →Every B2B SaaS application needs background processing. Teams always discover this requirement late. The Azure Functions + WebJobs solution in CleenUI is a 12-project Visual Studio solution that ships with the codebase — not with month five of the project.
Read →The vibe-coding paradox is not visible at the demo. It becomes visible in the week a senior engineer joins the team and reads the codebase. What they find is a recognizable set of problems — and a bill that wasn't in the hiring budget.
Read →Twenty vertical-slice modules in CleenUI each run a complete path from UI components through API, service, repository, and database layers. A field retrospective put it plainly: the modular monolith won when AI coding agents entered the picture. Here is what one module actually contains.
Read →Seven hundred stored procedures in the CleenUI codebase aren't a legacy pattern. They're an explicit interface contract between the application and the data layer — one that survives team changes, schema migrations, and AI-generated queries better than runtime-generated SQL does.
Read →Andrej Karpathy declared vibe coding passé at Sequoia Ascent 2026 and named the successor: agentic engineering. The rebranding is accurate. The underlying problem — speed without architectural accountability — is still present, and still the reason some teams ship platforms while others accumulate liability.
Read →Vertical slice architecture is a real improvement over layered architecture. But most .NET teams doing modernization stop there, treating feature slices as modules. Milan Jovanović is right that they aren't the same thing — and the confusion stalls more modernization efforts than any technical problem does.
Read →AI coding tools have accelerated code generation. What they haven't changed is the list of primitives every B2B SaaS platform needs before its first real feature can ship — auth, background processing, multi-tenancy, a real data layer. Teams keep rebuilding these from scratch.
Read →The CleenUI codebase uses Dapper + ADO.NET against 700+ stored procedures across 300+ Azure SQL tables. Not as a legacy holdover — as a deliberate architecture decision made when the codebase was designed and confirmed by production deployment.
Read →Andrej Karpathy observed that deep technical expertise is an even greater multiplier in the AI era, not a lesser one. The specific expertise that compounds is architectural — the ability to set context that constrains what the AI generates toward coherent output.
Read →Milan Jovanović's observation that vertical slices are not modules names the confusion precisely. In CleenUI, a module is a macro-architectural boundary with real data ownership — not a code organization choice.
Read →Gergely Orosz's AMA on AI-native SDLCs focused on governance and hiring. What it left underspecified: the data access pattern chosen for a codebase determines how much structural drift an AI-native workflow will accumulate.
Read →Teams migrating from older .NET frameworks to .NET 8 spend months on the runtime upgrade and make the architectural decision by accident. The gap is in what they decide to carry forward.
Read →Milan Jovanović drew the distinction this week: modules solve the macro problem — business boundaries, data ownership, inter-module contracts. Vertical slices solve the micro. Most teams skip the macro. Here's the concrete cost.
Read →AI coding tools amplify what's already in the codebase. A structurally coherent codebase amplifies output. An incoherent one amplifies noise. Andrej Karpathy and Gergely Orosz are both pointing at the same fact: the multiplier works in both directions.
Read →700+ stored procedures against Azure SQL, accessed via Dapper. The decision to avoid an ORM predates AI coding tools by years — and it turns out to be exactly the right architecture for a world where agents write the data access layer.
Read →Teams are spending real money building context layers so AI tools can understand their engineering systems. The problem they're solving is real. The diagnosis is wrong.
Read →Most teams treat legacy .NET modernization as a framework upgrade. It's actually two separate problems at different levels of the architecture — and solving one without the other doesn't get you there.
Read →Milan Jovanović drew the line clearly: modules are business boundaries — data ownership, inter-module contracts. Vertical slices are feature code organization within those boundaries. Conflating them is a different and costlier mistake than most teams realize.
Read →Vertical slices and modules solve different problems at different levels of abstraction. CleenUI's 20 production modules are macro architecture decisions — each owns its data, its service layer, and its API surface. That distinction changes how teams reason about growth and how AI tools perform.
Read →Modular monolith is the architectural consensus in 2026. But most discussions treat it as an abstract principle. Here is what it looks like in practice: five enforced layers, 300+ Azure SQL tables, 700+ stored procedures, and 20 vertical-slice modules — each owning its own data.
Read →Microsoft shipped .NET 11 Preview 7 on August 11 — the final preview before RC. NativeAOT is now the default for the CLI tooling, and .NET 11 continues hardening NativeAOT publishing for API workloads. GA is November 10. The data access pattern you chose determines how clean the migration is.
Read →When code review fades as a quality gate — because AI generation speed outpaces human review cycles — codebase structure has to carry what the review process used to carry. That's an architecture problem, not an AI tooling problem.
Read →The tether that keeps vibe coding from becoming technical debt isn't a governance policy or a review checklist. It's the enforced structure of the codebase itself — and you can't add it after the AI sessions start.
Read →Most B2B SaaS teams scope at the application layer. That means a query missing a parameter returns cross-tenant data, not an error. Multi-tenant scoping done right lives in the data layer — in the stored procedures — where AI agents and developers can't accidentally bypass it.
Read →Running an AI coding agent against a legacy .NET codebase is one of the fastest structural audits available. The agent's failure modes map directly to the modernization problems a formal audit would find — in an afternoon instead of a week.
Read →The .NET community is converging on modular monolith architecture in 2026. CleenUI's codebase was structured this way from the start — along with a data access decision the ORM-first crowd still argues about: Dapper plus stored procedures, all the way down.
Read →Gergely Orosz documented that AI coding models fail at Meta and Google because both run monoliths with non-standard tooling. For .NET shops on legacy systems, this is the migration argument updated for 2026.
Read →Dapper + stored procedures was a bet made when CleenUI was designed. In the AI coding era — where generated code hits the data layer constantly — that bet turns out to pay better than expected.
Read →A vertical-slice module runs from UI to DB in a complete, coherent cut. When AI generates code against a module that already runs, it has the full context: the component, the endpoint, the service, the stored procedure, the table. That context is what makes generated code integrate.
Read →Most .NET modernization projects stall not because the new architecture is wrong, but because the team underestimates what they're carrying. Here's what legacy .NET actually looks like and what a clean landing target costs to reach.
Read →When AI agents generate data access code against 700+ named stored procedures, they cannot write ad-hoc SQL. The procedure is the interface. This is not a constraint on the agent — it is the constraint that makes agent-generated data access safe.
Read →Milan Jovanović is right that microservices impose a tax before they deliver any benefit. But the right alternative isn't just 'start with a monolith.' A code footprint is different in kind — production-proven decisions already made, not a starting shape you fill in.
Read →Karpathy moved to 80% agent coding and still says his AI writes bloated code he's stopped trying to fix. The thing agents cannot generate is the architecture itself — the decisions about where things live and what 'fits' means in a given system.
Read →Most architectural arguments about monoliths vs. microservices miss the real decision: which architectural shape survives growth without operational overhead? For most B2B SaaS teams, the modular monolith with .NET 8 and Azure SQL is still the answer.
Read →CleenUI ships with 20 vertical-slice modules, each running UI to database. Here is why the vertical slice is the right default organizational unit for a B2B SaaS codebase, and what it changes about how features get built.
Read →Teams running WebForms, .NET Framework, or sprawling stored-procedure codebases aren't facing a rewrite decision — they're facing a migration question. Here is what that migration actually involves and where most teams get stuck.
Read →The chatbot era of AI coding is over. Agentic systems are arriving — and the codebase they operate against is the context that determines whether their output integrates or accumulates.
Read →The common concern is that AI coding tools will devalue architectural skill. The actual dynamic is the opposite — architectural decisions made before AI adoption compound through every AI-generated output that follows.
Read →A vertical-slice module is not a folder of related files. It is a complete system unit from UI to database. Understanding what that means in practice explains why AI tools generate more coherently into a modular codebase than into a flat one.
Read →The decision to use Dapper + ADO.NET against stored procedures is architectural, not accidental. It's a deliberate choice about who owns the query plan — and in the AI era, it turns out to be exactly the right choice.
Read →AI agents don't modernize a codebase — they generate against it. When the foundation is legacy .NET, every AI-assisted session inherits and amplifies the patterns already there.
Read →Microservices split what should not be split. An ORM adds a mapping layer between your code and your query plan. The modular monolith on .NET 8 + Azure SQL avoids both traps. Here is the architecture and why it holds.
Read →Auth, billing, notifications, file handling — every B2B SaaS team builds these before they reach their differentiator. Here is what the CleenUI codebase ships so that list is already done.
Read →M01–M20 are not stubs. Each module runs the full stack — UI to stored procedure. Here is what a vertical slice actually contains and why it matters for the first sprint.
Read →On June 22, GitHub added Claude as a selectable agent provider in JetBrains IDEs, and announced Copilot's default model switches from GPT-4 Turbo to Project Polaris in August. The model is now an interchangeable configuration. The codebase it acts on is not.
Read →AI generates code at the syntax layer. Engineers hold the structure. Martin Fowler and Kent Beck said as much at The Pragmatic Summit in February 2026. Here is what that means in practice for a B2B SaaS build.
Read →.NET 11 Preview 5 ships an MCP server template in the SDK. The scaffold is the easy part — what it exposes about your existing API surface is the more useful finding.
Read →Most legacy .NET systems weren't built badly — they were built for a different era. The path to .NET 8 is defined by boundary decisions, not big-bang rewrites.
Read →Gergely Orosz named the pattern: tokenmaxxing, gaming AI usage metrics the same way teams used to game lines-of-code counts. The real AI productivity signal is what ships — and that depends on the codebase underneath the agents.
Read →CleenUI ships 20 production-ready vertical-slice modules — M01 Security through M20 Contracts & E-Signature. Here is what each one covers and why the modular monolith shape matters more than the count.
Read →CleenUI's data layer runs on Dapper and ADO.NET against 700+ stored procedures. Here is the reasoning behind that choice and why it still holds in a .NET 8 world where alternatives are more capable than they have ever been.
Read →Configure a demo environment in about twenty seconds — theme, spacing, the modules you care about, sample data for your industry — then launch the full dashboard in your browser. Nothing to install, no signup.