The Hidden Cost of Multi-Stack AI: Token Waste, Context Confusion, and the 200-vs-60 Problem

Tokens-per-second is a vanity metric. The number that actually matters is Cost Per Task - how many tokens (and dollars) it takes for AI to complete a real unit of work in your codebase.

And for most .NET projects, that number is embarrassingly high.

Where the Tokens Go

A typical Blazor component with JavaScript interop and CSS isolation requires the AI to understand:

1. The .razor file (Razor syntax + HTML)
2. The .razor.cs code-behind (C# component logic)
3. The .razor.css scoped styles
4. The wwwroot/js/interop.js file (JavaScript interop)
5. The service registration in Program.cs
6. The _Imports.razor for namespace resolution

That is ~200 tokens of context just to describe the architecture before the AI writes a single line of new code. And that is one component. A real feature touching 3-4 components burns 600-800 tokens on context alone.

In Ivy, the same feature is one file:

[App]
class SalesDashboard : ViewBase
{
    public override object? Build()
    {
        var db = UseService<AppDbContext>();
        var period = UseState("month");

        var sales = db.Sales
            .Where(s => period.Value == "all" || s.Region == period.Value);

        return Layout.Vertical()
            | Text.H1("Sales Dashboard")
            | period.ToSelectInput(new Option<string>[] {
                new("all", "All Regions"),
                new("month", "This Month")
            })
            | sales.ToDataTable(s => s.Id)
                .Header(s => s.Product, "Product")
                .Header(s => s.Revenue, "Revenue")
                .Header(s => s.Region, "Region");
    }
}

~60 tokens of context. The AI sees the entire feature - data access, state, UI - in one place. No architecture to explain. No file relationships to describe. No implicit conventions to encode.

Context Pollution Is Real

The token cost is not just financial. It is cognitive - for the AI.

Large context windows do not solve the problem. They make it worse. The AGENTS.md optimization guide for Claude Code documents how irrelevant context degrades answer quality. Teams are spending engineering time curating what context their AI sees, writing rules files and project documentation specifically to help AI ignore the noise.

Multi-stack projects are inherently noisy. The AI needs to understand that IInteropService in C# maps to window.interop in JavaScript, which depends on interop.css loading in the right order. Each mapping is another place for context confusion.

Single-stack frameworks eliminate an entire category of context. There is no mapping between languages because there is only one language.

The GitLab Paradox

GitLab's research found something unexpected: developers who adopted AI tools wanted to consolidate their toolchain, but the number of tools they used did not actually decrease. AI added another layer of context switching rather than reducing it.

This matches what we see with multi-stack AI. Adding Copilot to a Blazor project does not simplify the architecture. It adds another participant who needs to understand the architecture. And that participant hallucinates when confused.

What 200-vs-60 Means in Practice

The difference is not just efficiency. It is error rate.

When AI has 200 tokens of architectural context to track, it drops things. It forgets that the code-behind uses a different namespace. It generates CSS for a component that uses CSS isolation differently. It calls a JavaScript function that was renamed in a recent refactor.

When AI has 60 tokens of context, it tracks everything. The data query, the state, the UI - all visible in one scope. The error rate drops because the comprehension is higher.

Less context is not a limitation. It is a feature.