New AiGen Functionality in CodeRush for Visual Studio

• Identifies which related types matter for the request
• Traverses the solution hierarchy as needed
• Optimally packs a reasonable portion of the context window with only the most relevant information
• Sends that optimized and packed context to the reasoning model

// Shared helpers that derived validators can (and should) reuse.
protected void RequireCustomer(Customer? customer, ValidationResult result) {
    if (customer is null) {
        result.Add("Customer is required.");
        if (StopOnFirstError)
            return;
    }

    if (customer?.BillingAddress is null) {
        result.Add("Billing address is required.");
        if (StopOnFirstError)
            return;
    }

    if (string.IsNullOrWhiteSpace(customer?.BillingAddress?.CountryCode)) {
        result.Add("Billing address country is required.");
    }
}

• Speed — generating fewer output tokens (to support the fine grained delta) is faster than regenerating all the code that doesn't change.

• Cost — output tokens are significantly more expensive than input tokens.

• Precision — small, focused changes reduce churn and unintended side effects.

Note both the size of the method and how little code AiGen needs to generate to apply the change.

The prompt doesn’t require exact symbol names or structured references — we describe intent, and AiGen resolves the implementation from surrounding context.

This example demonstrates fine-grained deltas in practice: smaller outputs, lower token usage, reduced latency, and a more immediate turnaround — especially when working inside large methods.

After AiGen applies the change, you can find evidence of the smaller delta in two places:

1. AiGen Navigator status bar: Check the Reasoning out token count and the elapsed time (114 output tokens and 3.2 seconds, respectively, in the screenshot below). Fine-grained deltas yield small output token counts — typically far smaller than the count required to regenerate an entire method.image
   
   
2. Editor selection: Selecting a change in the AiGen Navigator (e.g., "∆ selection") highlights the inserted/modified region, making the delta boundary immediately visible. In the screenshot below, the selection represents the small portion of the method that was regenerated. The rest of the method was untouched by AI.
   
   

• which change was blocked,
• why it was blocked, and
• exactly what AiGen was prepared to do.

if (order.Customer is null)
  throw new InvalidOperationException("Customer is required.");

if (order.Customer is null)
  return null;

if (order.Customer is null) {
  Console.Error.WriteLine($"[{nameof(OrderSubmissionService)}] Order submission failed: {nameof(order.Customer)} is required. OrderId='{order.OrderId ?? "<null>"}'.");
  throw new InvalidOperationException("Customer is required.");«Caret»
}

Everything else proceeds as expected -- no rollback, no guesswork, and no silent overwrites.

Runtime State to Tests: Debug-Time Object Reconstruction

Example: Turning a Debug-Time Bug into a Targeted Test

• Region is empty or whitespace

• The computed label (which includes cityRegionPostal) contains a dangling comma and extra spaces

• Reconstruct the runtime object graph for the order parameter using live debug-time values
• Locate the appropriate OrderAddressFormatterTests fixture
• Generate a new xUnit test that reproduces the observed state and behavior
• Add targeted assertions that detect the formatting defectUnderstand the object graph in scope (including nested properties/objects)

    [Fact]
    public void BuildShippingLabel_RegionBlank_NoDoubleSpaces_AndNoDanglingComma() {
        // Arrange (debug-time values)
        var address = new Address {
            City = "Seattle",
            Region = " ", // blank/whitespace
            PostalCode = "98101",
            CountryCode = "US",
            Line1 = "123 Example St"
        };
        var customer = new Customer { DisplayName = "Ada Lovelace", BillingAddress = address, Id = "C-42" };
        var order = new Order {
            Customer = customer,
            DiscountAmount = 10m,
            Subtotal = 120m,
            OrderId = "DBG-1001",
            TaxAmount = 0m
        };

        var formatter = new OrderAddressFormatter();

        // Act
        string label = formatter.BuildShippingLabel(order);

        // Assert
        Assert.DoesNotContain("  ", label);       // no double spaces anywhere
        Assert.DoesNotContain(", ", label);       // no dangling comma + space
        Assert.DoesNotMatch(@",\s*(—|$)", label); // no comma before em-dash or end
        Assert.DoesNotMatch(@",\s+\d", label);    // no comma followed by spaces then digits (e.g., ",  98101")
        Assert.Contains("Seattle", label);
        Assert.Contains("98101", label);
    }

• Easily capture real-world edge cases
• Generate focused, high-signal tests
• Preserve the conditions that exposed the issue

Large-Scale Architectural Changes: Evolving Interfaces Across Many Implementations

Example: Generating and Evolving Order Rules

namespace CodeRush.AiGen.Main.ArchitecturalEdits;

public interface IOrderRule {
    RuleResult Apply(Order order);
}

• Generate multiple production-quality types in a single request
• Maintain a shared contract across many implementations
• Respect namespace organization and solution structure
• Coordinate multi-file changes across a codebase

Evolving the Contract Across the Hierarchy

• Large-scale architectural refactorings
• Contract evolution across many implementers
• Coordinated multi-file updates without manual intervention
• High-level structural changes (in addition to surgical edits)

Fixing Code Using Active Compiler Errors

Until now, we’ve focused on how AiGen understands source code, hierarchy, and runtime state. But AiGen can also reason over active compiler errors — both at the caret and across the Visual Studio Errors list.

This allows you to resolve broken code using short, natural prompts, without needing to restate what the error is or why it occurred.

Example: Fixing a Real Compiler Error with “Fix this”

// Demo toggle:
// TODO: Uncomment the line below to intentionally introduce a compiler error on the `where` clause, below.
//#define DEMO_ACTIVE_ERRORS

public async Task<int> GetHighValueOrderCountAsync(decimal minSubtotal) {
  var orders = await GetOrdersAsync().ConfigureAwait(false);
  return orders.Count(o => o.Subtotal >= minSubtotal);
}

• Read live compiler diagnostics from the editor
• Infer intent from the actual error, not just the source text
• Generate a non-trivial corrective refactor with a minimal prompt
• Resolve failures without requiring developers to restate what the compiler already knows

What This Update Unlocks

• You can ask for surgically precise changes inside large methods without paying or waiting for redundant regeneration.
• You can continue working while AI requests are in-flight, or even launch multiple agents in parallel when tasks impact non-overlapping areas of code.
• Individual conflicts -- caused by overlapping edits while AI requests are in-flight -- are isolated and surfaced in the UI, rather than forcing all-or-nothing outcomes.
• Debug-time state observations can be turned into targeted tests, grounded in real execution data.

Limitations

AiGen is optimized to work fast in C# files and XAML. However, as with any tooling involving AI models, AiGen has some limitations:

• AiGen can generate new files in any programming language and add them to the active project, but it can only modify C# and XAML files.
• ​Multi-agent support and editing while AI is in-flight is currently available in C# only, For XAML, wait for the AI response to land before making changes to the same XAML file.
• Blazor support is pending
• There are some reasonable depth limitations on reconstructing debug-time object graphs and on traversing class hierarchies for the context window.
• AiGen cannot delete files or remove files from the project.
• Aside from adding new files and installing NuGet packages, AiGen cannot modify the project file or the solution file (so there's currently no way to create or add new projects or add/modify project properties).
• AiGen is not a chat window based tool, and there is no history/memory of previous actions. Context is derived entirely from your prompt, the editor view, surrounding code, the solution source, debug values, etc..
• There are the usual limitations and disclaimers on the power of AI itself. Sometimes AI "hallucinates" (this is especially true when generating code based on frameworks that have changed or where API evolution has introduced breaking changes over time). Also, it is possible to have a request so complex AI has difficulty implementing it correctly.