Mark Miller on CodeRush & IDE Productivity

New AiGen Functionality in CodeRush for Visual Studio

Mark Miller (DevExpress) — Thu, 26 Feb 2026 08:00:00 Z

CodeRush's AiGen is Faster and Smarter for Everyday Development

AI-assisted coding tools live or die by two factors: speed and quality of the code response. If an AI response takes too long, or if it regenerates more code than necessary, developers won't use it for small, focused changes.

With this release, CodeRush’s AiGen takes significant leaps forward on both fronts. The improvements are all about making AI genuinely fast and useful during day-to-day development -- where precision, latency, and context matter most.

We'll cover what’s new in this release using real world examples that you can easily try yourself (clone the sample project).

Improved Context Acquisition & Architectural Awareness

One of the challenges for AI coding assistants is how to get sufficient context for a correct code response, without exceeding the model's context window limits. Some AI tools solve this by placing the burden of specifying this additional context -- the files to include in a query -- on the user. This can get tedious when many files are involved. Simple AI tooling might see the file you’re editing, but miss surrounding architectural relationships -- interfaces, implementors, ancestors, descendants, helper classes, and corresponding test fixtures.

To meet this challenge, AiGen now starts each request with a lightweight context-acquisition pass which:

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

The result is higher quality code -- without you having to name (or worry about missing) related types to submit to the model explicitly.

Example: Consolidating Validation Logic Using the Type Hierarchy

In the sample project, open the ContextAcquisition folder and navigate to OrderValidator.cs.

Inside the ValidateCore() method, you’ll see some validation logic.

protected override void ValidateCore(Order order, ValidationResult result) {
    if (order is null) {
        result.Add("Order is required.");
        return;
    }

    // TODO: Ask AiGen to consolidate this based on what we have in the base class.

    var customer = order.Customer;

    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.");
        if (StopOnFirstError) return;
    }

    if (string.IsNullOrWhiteSpace(order.OrderId)) {
        result.Add("OrderId is required.");
    }
}

This logic duplicates some of the behavior already implemented in the ancestor class (BaseValidator<T> -- check out its RequireCustomer() method).

// 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.");
    }
}

This kind of duplication can happen in systems that evolve over time.

Back in OrderValidator.cs, place your caret inside the ValidateCore()method, Rather than telling AiGen exactly how to fix it, we can talk to it the way we might speak to a human teammate.

Invoke AiGen (double-tap and hold the right Ctrl key if speaking or press Caps+G if you prefer to type -- see AiGen setup for more details). Then say something like (one of the following):

“Consolidate this logic with what we already have in the base class.”

“Take a look at the ancestor class and see if we can reuse any of that code here.”

Notice, the prompts are void of symbol or file names. They're just expressions of intent.

AiGen uses the hierarchy to discover the relevant base class, identifies the overlapping logic, and refactors the code so the shared behavior lives where it belongs -- in the base class -- while keeping order-specific checks local.

After applying this change, the AiGen Navigator will appear. You can click the "Show Difference View" button to see the before and after for the changes applied to this method:

”

Here, AiGen consolidates the duplicated validation logic into a single call to RequireCustomer(), while maintaining the existing StopOnFirstError behavior.

The AiGen navigator's status bar shows total in/out token counts for both the initial context pass ("Ctx in/out"), and the main reasoning model ("Reasoning in/out"). Output token counts are low, as they should be (only 67 output tokens were used by the reasoning model to produce the minimal, targeted change shown in the screenshot). Output tokens typically cost four times more than input tokens, so we want to keep the output token count low, The status bar also shows estimated cost (about 3 cents) and how long it took from request to integrated response (2.5 seconds, in this example). If you're interested to see how CodeRush stacks up against competing AI tooling solutions, note the AiGen completion time in the status bar, undo this last change and try the same prompt on the same code in any other competing AI coding assistance tool.

Speed Where It Matters: Fine-grained Deltas

Most AI coding assistants treat every change the same way: they regenerate large chunks of code, even when only a few lines actually need to change. This approach can break down quickly in real projects -- especially when methods are large and the requested change is small. With most AI tooling it just doesn't make sense to ask AI for small changes when you'll have to wait for an entire method or even a type to be regenerated.

CodeRush's AiGen takes a different approach.

Instead of regenerating entire members, AI works to produce only the smallest deltas to support fast surgical code integrations without manual copy/paste.

This impacts:

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.

Example: Small Business Rule Change Inside a Large Method

In the sample project, open the FineGrainedDeltas folder and navigate to OrderTaxCalculator.cs. Notice the ComputeTaxes() method is non-trivial and could resemble real production code, with multiple early exits, counters, and guard clauses.

Inside the main loop, you’ll see a TODO describing a business rule:

// TODO: Apply the customer's discount tax policy when calculating taxableBase.

This is a subtle rule change. We don’t want to rewrite the method -- we just want to adjust how the taxable base is calculated under specific conditions.

Let's delete the TODO comment and invoke AiGen. You can double-tap the right Ctrl key and keep it held down while using a natural, descriptive prompt such as:

“Let's incorporate the customer discount policy.

AiGen should:

Change only the minimal code region required
Leave the rest of the method untouched
Apply the update directly in the editor (no manual copy/paste)

Turning this:

decimal taxableBase = order.Subtotal - order.DiscountAmount;

into something like this:

decimal taxableBase = customer.DiscountPolicy switch {
    Customer.Discounts.ReduceTaxableBase => order.Subtotal - order.DiscountAmount,
    Customer.Discounts.FullyTaxable => order.Subtotal,
    _ => order.Subtotal - order.DiscountAmount
};

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:

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
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.

This is why AiGen feels fast even when working inside large blocks of code: you’re not overpaying (in time or tokens) for code that isn’t changing.

What's also exciting about these optimized deltas, you are free to edit (or apply tooling to) surrounding code while waiting for AI to return.

Which brings us to our next topic....

Working While AI Is Running: In-Flight Changes & Conflict Navigation

One of the most frustrating aspects of modern AI-assisted coding tools is that they repeatedly block your flow. You ask for help, then you wait -- hands off the keyboard -- until the response finally returns.

AiGen removes that bottleneck.

When AiGen requests are launched, you’re free to continue coding. You can edit the same file, move elsewhere in the solution, or even launch additional coding agents. AiGen anchors each request to the code state at launch and safely validates those changes on return.

When changes are non-overlapping -- as they can be in intentional multi-agent workflows -- AiGen applies the results cleanly and without interruption.

For example, you can ask AiGen to modify one part of a C# method while you continue working in another part of the same method.

If in-flight edits overlap with part of a reasoning response's intended changes, AiGen withholds only the conflicting change and surfaces both the reason and the change it was prepared to apply. We'll see an example of this in a moment.

Scenario A: Non-Conflicting Changes -- AI + Human

Navigate to the InFlightEdits folder and open OrderSubmissionService.cs. The Submit() method contains several failure points -- exactly the kind of code where you might want better diagnostics. To prepare for this simultaneous edit demo, first, copy the following text to the clipboard:

> Logs any failures.

Next, place the caret anywhere inside the Submit() method and invoke AiGen with a request like:

“Add logging around failures in this method.”

While the AI request is running, move the caret to the XML documentation comment and paste the text from the clipboard to the end of the XML doc comment. The goal is to make this change before the AI response lands (if AI is faster, you can undo and try again -- you typically have 2-5 seconds to make the change while this logging request is in-flight).

When the AI response lands, you’ll see:

The logging changes are applied correctly.

Your manual documentation edit is preserved.

No manual merging is required.

AiGen doesn’t lock the editor or assume code is frozen while it works. It assumes you’re still working -- because you are.

Scenario B: Parallel, Non-Conflicting Changes -- Multiple AI Agents

Let's undo our recent changes and restore OrderSubmissionService.cs to its original cloned state.

For this next scenario, we'll launch two AI agents simultaneously to work on the same method.

The first agent will add logging (like we just did in the last scenario), and the second agent will add telemetry so we can track orders (using the TrackOperationAttribute declared in the Shared folder).

Start by opening TrackOperationAttribute.cs from the Shared folder and examining the class. This is the custom attribute we'll use for telemetry. Note that it includes properties for:

Name -- describes whatever we're tracking
Category -- groups related telemetry events

Next, switch back to OrderSubmissionService.cs and place the caret in the Submit() method. The next two steps should be performed back to back.

Launch the first agent with: “Add logging around failures in this method.”
Launch the second agent with: "Add the track operation attribute. Category is orders."

The goal here is to start up a second agent while the first is still inflight. If the first AI response lands before you can launch the second, perform an undo (close the AiGen Navigator) and then copy the second prompt to the clipboard. Then after launching the first agent by voice, invoke the second agent with Caps+G (plus a paste).

When multiple AI responses land, the AiGen Navigator shows multiple landings using tabs. In the screenshot below, notice the agents landed in reverse order from take-off, with the tracking attribute finishing first.

Notice AiGen correctly discovered the TrackOperationAttribute from the Shared folder and added it with appropriate values for both Name and Category. Also note the orange arrow in the screenshot above -- it points to the second AI landing ("Failure logging" in this example -- your tabs may have different tab titles and agents may complete in a different order than they were launched).

AiGen Navigator tabs may display one or more of the following icons:

⭐ Star -- the landing has not yet been viewed (typically a recent result).
✔️ Check -- all changes were successfully integrated (no conflicts)
❗ Exclamation -- one or more conflicts occurred on landing

Notice that:

One agent modifies the **method body** (logging)
The other modifies the **method metadata** (the attribute)

Because these changes target **different structural regions**, both land successfully without conflict.

Skilled developers can safely run multiple AI agents in parallel when:

The requested changes **do not overlap**, and
Each agent’s task can be completed **independently** of the others.

Note: When multiple in-flight AI agents complete their changes, undo follows landing order, not launch order — the most recently applied change is undone first. This mirrors standard Visual Studio editor behavior and keeps AI changes fully integrated into the undo stack.

Scenario C: Conflicting Changes

Now let’s look at what happens when a conflict does occur.

Start by undoing the previous edits to restore OrderSubmissionService.Submit()to its original state.

Note: When multiple in-flight AI agents complete their changes, undo follows landing order, not launch order -- the most recently applied change is undone first. This mirrors normal Visual Studio editor behavior and keeps AI changes fully integrated into the standard undo stack.

Next, we'll launch the same AI request as before:

“Add logging around failures in this method.”

While the request is in flight, make a meaningful overlapping change to one of the failure points. For example, replace a throw with an early return null;.

When the reasoning response lands, AiGen detects that one of the targeted code blocks has changed since the request was launched. Rather than guessing or overwriting your work, AiGen blocks only the conflicting integration while allowing all non-conflicting changes to apply normally.

In the screenshot below, notice that logging was successfully added around every remaining throw statement (the five "selection" entries marked with only the delta symbol). Only the single failure point we modified in our example was held back.

For the blocked change, AiGen shows:

The original code as it existed when the request was launched

The current code at apply time

The reasoning model's attempted replacement

This makes the conflict isolated,explicit, and safe to reason about. You can clearly see:

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

Because AiGen typically produces **fine-grained deltas**, conflicts are isolated to the smallest possible change. A single overlapping edit does not invalidate the rest of the AI response — only the affected update is held back, while all other safe modifications are integrated.

The conflict report for the blocked delta shows the original code at request time and the current code at apply time, as well as the attempted replacement. You might see something like this:

The change for this member was skipped because the target code changed inflight.

Original code at request time:

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

Current code at apply time:

if (order.Customer is null)
  return null;

Attempted replacement:

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»
}

Original and current code blocks must match on landing.

This section demonstrates how AiGen behaves when the code changes while AI requests are in flight — including parallel agents and isolated conflicts.

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

Runtime State to Tests: Debug-Time Object Reconstruction

So far, all of the examples have focused on static code -- types, methods, and edits driven by what’s visible in the editor. The next capability goes a step further by incorporating runtime state.

When you invoke AiGen while stopped at a breakpoint, it can now inspect the live debug-time values in scope and include them (if appropriate) as part of the request. That allows the reasoning model to also work from actual execution data, not just source code.

This is especially powerful when the issue you’re investigating only becomes obvious at runtime.

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

From the DebugRuntimeState folder open OrderAddressFormatter.cs. The BuildShippingLabel() method formats a shipping label from customer and address data.

Place a breakpoint on the final line of this method and run the program. When execution stops, inspect the values inside the Visual Studio debugging environment. In this scenario, you’ll notice that:

Region is empty or whitespace

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

The bug is subtle and data-dependent. You could fix it immediately -- but it’s a good idea to capture the behavior in a test first, so it doesn’t regress.

While still stopped at the breakpoint (with the caret inside the BuildShippingLabel() method), invoke AiGen and say:

“Create a test case for this method based on these debug-time parameter values.

Add asserts to make sure the label has no double spaces and no dangling comma when the region is blank.”

While waiting for the response, you might want to drill into the order parameter. It has a Customer property that in turn holds the BillingAddress with the empty region that led to this bug.

AiGen will:

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)

You should get a test case like this (note the object graph reconstruction at the top, which recreates the somewhat sophisticated debug-time state that exposed the bug):

    [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);
    }

This workflow makes it practical to capture real-world edge cases in the moment they are discovered. Instead of manually attempting to duplicate observed state, you can promote live runtime data directly into a durable, repeatable test.

After creating the new test case, you can stop debugging and run the test case if you like (it should fail since the issue we discovered in the sample code hasn't been fixed yet).

Why This Matters

This capability closes a familiar gap in debugging workflows. Developers often discover bugs while stepping through code, but translating those live-data observations into tests is tedious and error-prone.

By grounding test generation in captured debug-time values, AiGen makes it practical to:

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

It’s a natural extension of pair programming: you identify the problem while debugging, and AiGen helps you lock it down with a test before you move on.

Large-Scale Architectural Changes: Evolving Interfaces Across Many Implementations

So far, we’ve focused on fast, fine-grained edits — the kind that make AI practical for everyday work. But AiGen is not limited to small changes. It can also perform broad, cross-cutting architectural updates that span multiple files, types, and layers of a solution.

This next example demonstrates AiGen’s ability to generate new types in bulk and then evolve an interface contract across all of its implementers.

Example: Generating and Evolving Order Rules

In the sample project, open the ArchitecturalEdits folder and navigate to IOrderRule.cs. You’ll see a minimal interface:

namespace CodeRush.AiGen.Main.ArchitecturalEdits;

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

Place your caret inside the interface and invoke AiGen with the following prompt:

“I need ten non-trivial implementers of this interface. Put them in the rules namespace.”

Unlike previous demos, this request generates multiple new classes, each implementing distinct business logic. Because the reasoning model is synthesizing several non-trivial implementations, this step may take longer than the earlier examples.

When the request completes, AiGen creates a new Rules namespace containing ten concrete implementations of IOrderRule — each reflecting realistic order-processing concerns such as fraud detection, pricing validation, eligibility checks, and fulfillment constraints.

This demonstrates AiGen’s ability to:

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

Now return to IOrderRule.cs and invoke AiGen again with:

“Add two properties — name and description — and update all implementers.”

AiGen updates the interface to include the new properties, then propagates those changes across all existing rule implementations — ensuring each class remains compliant with the updated contract.

Because this step modifies existing code rather than generating new types, it typically completes much faster than the bulk-creation step.

Together, these prompts demonstrate AiGen’s ability to perform:

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)

Earlier examples highlighted AiGen’s speed and precision for small changes. This scenario shows the other side of the system — the ability to reshape architecture across an entire subsystem when needed.

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”

In the sample project, open the ActiveErrorAnalysis folder and navigate to OrderQueryService.cs.

At the top of the file, you’ll see a demo toggle:

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

Now place your caret on the Where() call in the broken LINQ query and invoke AiGen. Simply say:

“Fix this.”

There’s no need to explain the problem. AiGen inspects the active compiler diagnostics, analyzes the surrounding code, and determines the appropriate fix.

Here is a typical AiGen response to this error and surrounding code:

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

The fix is driven by real compiler feedback, not by a manually described problem.

This demonstrates AiGen’s ability to:

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

In practice, this makes AI useful not just for writing new code — but for repairing broken code quickly and contextually.

What This Update Unlocks

Taken together, these examples illustrate a shift in how AI assistance fits into everyday development.

AI Assistance is no longer something you reach for only when you’re willing to pause, wait, and review a large block of regenerated code. With faster/smarter context acquisition, fine-grained deltas, conservative integration, and awareness of both code and runtime state, it also becomes practical to use AI for small, precise tasks -- the kind that make up most real work.

In practice, this means:

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.

None of this requires verbose prompts, detailed instructions, or explicitly naming symbols or files. AiGen is designed to infer intent from context -- types, hierarchy, editor state, and runtime values -- so you can speak naturally and stay in flow.

If you’re an existing CodeRush user, these capabilities are available now in the latest release. If you’re new to CodeRush (it's free on the Visual Studio Marketplace), the sample project referenced in this post is a good place to start exploring how AiGen behaves in real scenarios.

AI tooling works best when it’s fast, precise, and respectful of the code you already have. This release is about moving closer to that ideal -- so AI becomes something you use routinely, not something you have to plan around.

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.

Advanced AI Setup for AiGen and AiFind in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 09 Sep 2025 16:00:00 Z

This post explores advanced setup options for CodeRush's AI-powered features. CodeRush currently supports two AI providers — OpenAI’s direct API and Microsoft’s Azure OpenAI Service. An API key is needed for either service.

Let's first enable AI features and select a service, then dive into the appropriate section for individual options on the service you select.

Quick Jump:

About AiGen & AiFind

CodeRush AI features are a powerful alternative to chat-based AI coding assistance. CodeRush AI assistance is generally:

Faster (smaller context window - one question + one answer).
Cheaper (fewer tokens, lower environmental impact).
More integrated (multiple AI-driven responses are immediately integrated directly into the source).
Safer (single undo/redo, language-specific agents check/condition response before insertion, AI usage is logged and auditable, supports Azure enterprise tenant so your source code is secure).

General Setup

To enable CodeRush AI features, follow these steps:

Bring up the CodeRush Options dialog.
Navigate to the "IDE->Cognitive->General" options page.
Check the "Enable Cognitive Features" checkbox. You can also optionally enable voice features. For more about voice setup and troubleshooting, click here.
Navigate to the "IDE->Cognitive->API Keys" options page.
If you have an OpenAI direct API key, click "OpenAI (official API)". If you prefer to use Azure OpenAI, click "Azure Open AI (Microsoft-hosted)"
Fill out the service-specific options. I'll dive into each of these options in the separate sections below. Jump to OpenAI direct API setup or Azure Open AI setup.
Enter your chosen service API key in the corresponding field below. API keys are stored on the local machine in the specified environment variables.

OpenAI direct API setup is next. Or jump ahead to Azure Open AI setup.

OpenAI direct API setup

Bring up the CodeRush Options dialog.
Navigate to the "IDE->Cognitive->API Keys" options page.
Select the "OpenAI (official API)" service. You will need an API key from OpenAI.
Select the desired model and fill out the service-specific options. The user interface will adapt to allow you to configure settings for the model you select.

Individual options are covered next.

Max Response Tokens

This is the maximum length of the reply. This tells the model how many tokens it’s allowed to generate at most. Larger values give longer answers (but likely cost more), while smaller values produce shorter, faster replies. Since the response is often generated code, it's generally a good idea to use the maximum response token limit supported by the model. I recommend 16k-32k for a solid experience, or an even higher limit if the model and your budget can support it. This field accepts whole numbers (e.g., "4096") as well as multiplier abbreviations (e.g., using "k" for x1000 and "M" for x1000000 as in 128k or 1M). Setting this field to a value higher than your model can support may result in an error response returned from OpenAI, so if you see that simply dial back the number in this field until it is in range.

Token Pricing

This is the cost per 1M tokens (input & output). CodeRush uses these values to estimate the cost of each interaction, showing it in the AiGen Navigator's status bar and recording it in the logs. Input tokens (prompts + context sent to AI) and output tokens (the AI’s response) typically have different prices, so you’ll see two fields here. The values specified here don’t change how the API calls are made — it’s just for cost tracking and visibility.

Note that values entered here can be in any currency. Whatever currency you use, CodeRush will use in the logs and in the display text on the status bar.

Note also that when you switch models, CodeRush will auto-fill these fields with the latest pricing at the time of our last build. You can check these prices for accuracy by clicking the link below the Token Pricing fields. You can also use this to compare the relative pricing of the different models (careful -- some models can be significantly more expensive than others). You can find OpenAI's latest pricing here (the same link also exists in the API keys Options page).

Temperature

This setting adjusts how predictable or creative the AI’s replies are. Lower values (near 0) produce more consistent, reliable results, while higher values (near 1) encourage more variation and creativity. This option is supported and visible when gpt-4.1 and earlier models are selected, and does not appear for gpt-5 models and up.

Verbosity & Reasoning Effort

These controls let you tune how much detail the model includes in its answers (Verbosity) and how much internal effort it invests in solving the problem (Reasoning Effort). Lower settings are generally faster and cheaper, while higher settings provide more thorough, detailed, and accurate responses at the cost of speed and token usage. These options appear only when you select gpt-5 and later models in the options dialog. They are hidden for gpt-4.1 and earlier models.

Performance Note

Both Verbosity and Reasoning Effort affect performance and token cost:

Higher verbosity means more tokens returned (increasing costs).
Higher reasoning effort means more compute cycles occur inside the model, so responses may take noticeably longer.

Once you have the options set as desired, jump down to the Quick Test section below for instructions on how you can try this out.

Deploying a new Azure Resource

Before you can use Azure OpenAI with CodeRush AiGen, you’ll need to create a new Azure resource (full, official Microsoft guide is here). This resource hosts your deployments (specific models such as gpt-4 or gpt-5) and provides the endpoint and API keys that CodeRush uses to connect.

If you already have an Azure OpenAI resource created, you can jump ahead to Azure Open AI setup.

1. Sign in to the Azure Portal at portal.azure.com.

2. Click Create a resource, search for OpenAI.

3. Find the Azure OpenAI service, click Create, and select "Azure OpenAI"

4. On the Basics page:

Select your Subscription.
Choose or create a Resource group.
Pick a Region that supports Azure OpenAI.
Under the Instance Details section, enter a unique resource Name. This resource name will be used in the CodeRush options dialog.
Leave the pricing tier at Standard S0.

5. Click Next until you land on the Review + submit page, then click Create at the bottom of the page. Deployment usually takes less than a minute.

6. Once deployment finishes, click Go to resource.

7. Select Explore Azure AI Foundry portal. This should open the AI Foundry in a new browser tab.

8. Inside AI Foundry, open the Chat Playground, click Create a deployment, and choose a model (e.g. gpt-4.1, gpt-5, etc.) and click Confirm.

9. Enter a Deployment name (or accept the default). This deployment name will be used in the CodeRush options dialog.

10. Click Deploy.

11, Back on the previous browser tab for your Azure OpenAI service, click the "Click here to manage keys" link. This will bring up the Keys and Endpoint page. You can copy your API keys from this page (also needed for setup, below).

If you encountered any challenges on setting up a new Azure OpenAI resource, be sure to check out the full, official Microsoft guide here.

Azure OpenAI Setup

Base Model

This setting is for user interface efficiency only. It does not control which model Azure actually runs and this value never leaves your machine when Azure OpenAI service provider is selected. In this context, it is only used to adjust UI defaults and available options to match the capabilities of the model you deployed in Azure.

Example: If your Azure deployment uses gpt-5, choosing gpt-5 as the base model here will unlock sliders like Verbosity and Reasoning Effort.

Resource Name

The Resource Name entered when creating your Azure OpenAI resource in the portal (step 3, on the Azure Basics page, if you were following the instructions above).

Example: "DevWork".

Deployment Name

The Deployment Name you gave when deploying your selected model (e.g. gpt-4.1, gpt-5, etc) in Azure AI Foundry (step 8 from above).

Example: "gpt5-4.1"

API Version

The Azure OpenAI APIs require an explicit api-version.

Example: "2024-10-21" (for Chat/Completions).

CodeRush combines this with your Resource Name and Deployment Name to generate the full endpoint URL.

A preview of the constructed endpoint appears in the options dialog so you can verify everything looks correct.

Max Response Tokens

Same as described earlier — controls the maximum length of responses.

See earlier section: Max Response Tokens.

Token Pricing (Input/Output)

Same as described earlier — used only by CodeRush to estimate cost per interaction.

See earlier section: Token Pricing.

Verbosity, Reasoning Effort, and Temperature

These sliders behave exactly as described earlier: Verbosity and Reasoning Effort are available in gpt-5 models and up. Temperature applies to gpt-4.1 and earlier.

See earlier sections: Verbosity & Reasoning Effort, Temperature.

Quick Test

Now with AI features enabled and an AI Service selected, it's time to test out the new features.

First, create a new C# project (e.g., console or WPF).
Place the caret inside some C# code.
If using voice, Tap and hold the right Ctrl key (like a double-tap) and say "I need a new customer class with all the usual properties" (and release the Ctrl key when done speaking). Alternatively, press Caps+G to invoke the CodeRush AiGen Prompt window, enter the same text, and click Send.

After a few moments, you should have a new class named "Customer" added to the project with properties for Name, Email, Address, etc.

Next Steps

That’s it — you’re all set to start using CodeRush with AI assistance in Visual Studio. Give it a try and let us know how you like it!

Download CodeRush from the Visual Studio Marketplace

Drop us a note anytime at support@devexpress.com. We love listening to your feedback.

AiGen & AiFind in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 24 Jun 2025 07:09:00 Z

In the 25.1 release of CodeRush, we’re introducing two new features designed to radically improve how you write and find code — AiGen and AiFind.

Built into CodeRush (a free extension for Visual Studio), AiGen and AiFind help you generate, modify, and navigate code using natural language prompts. These features bring the power of AI directly into your development environment, delivering faster AI responses at a lower cost.

No separate tool windows, no context switching, no copying/pasting, no typing (using optional voice input), and more focus on solving real problems.

Let’s dive in.

Setup Notes

Setup requires an OpenAI API key for AI features and an Azure Cognitive Services Speech API key for voice-to-text. Full setup details are here.

The instructions here are for voice prompts (which is the easiest way to code with AI), however if you prefer to type your prompts you can press Caps+G to bring up the AiGen Prompt window (assuming you have enabled the CodeRush's Caps as a Modifier feature - if not you can create a new shortcut binding to the AiGenFromPrompt command).

AiGen - Your Coding Assistant is Really Here

Just double-tap and hold the right Ctrl key inside the Visual Studio editor, and say what you need (release the Ctrl key when you have finished your voice request). You can ask for new classes, new methods, XAML layout changes or styles, or modifications to existing code. AiGen will integrate the AI response directly with your existing code. Here are some of my favorite AiGen use cases:

Creating new classes
Creating test cases
Adding DebuggerDisplay[] attributes
Creating data entry forms
Changing a window/form's design and its associated code behind in a single step
Modifying a group of methods or statements (e.g., consolidating/optimizing/transforming similar blocks of code)
Upgrading legacy code to a more modern approach (e.g., changing old test case asserts to fluent assertions)
Anything tedious so I stay focused on the big picture

AiGen can do almost anything you need, just ask. If AiGen can't do it, it will let you know (I'll include a limitations section below).

Let's explore some practical examples.

Follow Along

In the upcoming examples, I'll demonstrate sample prompts and responses. You might want to follow along and try these examples, however note that because we are using AI there is a certain non-deterministic element to these examples. Your results may vary. And AI results may not always be accurate.

Debugger Display Attribute

This is one of my favorite examples, because it is the smallest change, but it demonstrates the speed and intelligence of AI even for a small change. Consider the following class in C#:

public class Fraction {
    public int Numerator { get; set; }
    public int Denominator { get; set; }

    public Fraction(int numerator, int denominator) {
        if (denominator == 0) {
            throw new ArgumentException("Denominator cannot be zero.", nameof(denominator));
        }
        Numerator = numerator;
        Denominator = denominator;
    }
}

This class is a great start, but at debug time inspecting every instance will reveal the same value "{ Fraction }", regardless of what it contains. We need a DebuggerDisplay attribute so we can see the value for each instance at a glance.

Place the caret inside this class, double-tap and hold the right Ctrl key and say something like "Can I get a debugger display attribute?". As you speak you'll see feedback that CodeRush is listening. After you release the Ctrl key, you should see the "Thinking..." animation feedback. This means your query (along with pertinent context) has been sent to AI for processing. Within a few moments (about 5 seconds when I tried it just now) AiGen should insert an attribute into the code that looks like this:

[DebuggerDisplay("{Numerator}/{Denominator}")]
public class Fraction {
...

This is one of the things I love about working with AI -- you can supply a hint of what you want and it regularly infers and delivers exactly what you need. And in this example, it's in a place where there is no IntelliSense (inside the string parameter), so an error-prone location where precision and care must otherwise be used to avoid time-consuming mistakes. Could I add this myself in five seconds by hand? Unlikely. It would take nearly five seconds to just move the caret into the correct location.

You also might have noticed the AiGen Navigation window appear:

This UI appears after any AiGen or AiFind query, and allows you to navigate through all the changes. Since there was only one change in this example, we can close this window. You can also ignore it -- it will auto-close 10 seconds after making any change in VS. Regardless, we will talk about this window later in this post.

Adding Operator Overloads

Let's stay in the Fraction class for a moment. With the caret inside this class, double-tap and hold the right Ctrl key and say: "Can I get some math operator overloads?"

After a moment you should see methods like the following inserted into your Fraction class:

[DebuggerDisplay("{Numerator}/{Denominator}")]
public class Fraction
{
	public static Fraction operator +(Fraction a, Fraction b)
	{
		int numerator = a.Numerator * b.Denominator + b.Numerator * a.Denominator;
		int denominator = a.Denominator * b.Denominator;
		return new Fraction(numerator, denominator);
	}

	public static Fraction operator -(Fraction a, Fraction b)
	{
		int numerator = a.Numerator * b.Denominator - b.Numerator * a.Denominator;
		int denominator = a.Denominator * b.Denominator;
		return new Fraction(numerator, denominator);
	}

	public static Fraction operator *(Fraction a, Fraction b)
	{
		int numerator = a.Numerator * b.Numerator;
		int denominator = a.Denominator * b.Denominator;
		return new Fraction(numerator, denominator);
	}

	public static Fraction operator /(Fraction a, Fraction b)
	{
		if (b.Numerator == 0)
		{
			throw new DivideByZeroException("Cannot divide by a fraction with zero numerator.");
		}
		int numerator = a.Numerator * b.Denominator;
		int denominator = a.Denominator * b.Numerator;
		return new Fraction(numerator, denominator);
	}
	public int Numerator { get; set; }
	public int Denominator { get; set; }

	public Fraction(int numerator, int denominator)
	{
		if (denominator == 0)
		{
			throw new ArgumentException("Denominator cannot be zero.", nameof(denominator));
		}

		Numerator = numerator;
		Denominator = denominator;
	}
}

Adding Test Cases

With the new operator overloads, our improved Fraction class is easier to use. Now let's verify that with some test cases. Double-tap and hold the right Ctrl key and say something like, "How about some test cases?".

And within seconds you should have a new class and file, FractionTests.cs, added to your project.

On my machine, with the NUnit framework already referenced, AI built this:

[TestFixture]
public class FractionTests
{
    [Test]
    public void TestAddition()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(1, 3);
        var result = fraction1 + fraction2;
        Assert.AreEqual(5, result.Numerator);
        Assert.AreEqual(6, result.Denominator);
    }

    [Test]
    public void TestSubtraction()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(1, 3);
        var result = fraction1 - fraction2;
        Assert.AreEqual(1, result.Numerator);
        Assert.AreEqual(6, result.Denominator);
    }

    [Test]
    public void TestMultiplication()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(2, 3);
        var result = fraction1 * fraction2;
        Assert.AreEqual(2, result.Numerator);
        Assert.AreEqual(6, result.Denominator);
    }

    [Test]
    public void TestDivision()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(3, 4);
        var result = fraction1 / fraction2;
        Assert.AreEqual(4, result.Numerator);
        Assert.AreEqual(6, result.Denominator);
    }

    [Test]
    public void TestZeroDenominatorThrowsException()
    {
        Assert.Throws<ArgumentException>(() => new Fraction(1, 0));
    }

    [Test]
    public void TestZeroNumeratorInDivisionThrowsException()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(0, 1);
        Assert.Throws<DivideByZeroException>(() => fraction1 / fraction2);
    }
}

Notice in the highlighted lines above where we are exercising our new operator overloads

Legacy Code and New Frameworks

To upgrade legacy code or use a new framework, open that file and simply say what you need. For example, in the test class we just created, we might want to convert all those Assert.AreEqual calls to something more fluent.

For example, double-tap and hold the right Ctrl key and say something like, "Hey, can we convert all these Assert.AreEqual calls to Assert.That calls?"

Within seconds, AiGen changes every method in the class to look like this:

[TestFixture]
public class FractionTests
{
    [Test]
	public void TestAddition()
	{
		var fraction1 = new Fraction(1, 2);
		var fraction2 = new Fraction(1, 3);
		var result = fraction1 + fraction2;
		Assert.That(result.Numerator, Is.EqualTo(5));
		Assert.That(result.Denominator, Is.EqualTo(6));
	}

    [Test]
	public void TestSubtraction()
	{
		var fraction1 = new Fraction(1, 2);
		var fraction2 = new Fraction(1, 3);
		var result = fraction1 - fraction2;
		Assert.That(result.Numerator, Is.EqualTo(1));
		Assert.That(result.Denominator, Is.EqualTo(6));
	}

    [Test]
	public void TestMultiplication()
	{
		var fraction1 = new Fraction(1, 2);
		var fraction2 = new Fraction(2, 3);
		var result = fraction1 * fraction2;
		Assert.That(result.Numerator, Is.EqualTo(2));
		Assert.That(result.Denominator, Is.EqualTo(6));
	}

    [Test]
	public void TestDivision()
	{
		var fraction1 = new Fraction(1, 2);
		var fraction2 = new Fraction(3, 4);
		var result = fraction1 / fraction2;
		Assert.That(result.Numerator, Is.EqualTo(4));
		Assert.That(result.Denominator, Is.EqualTo(6));
	}

    [Test]
    public void TestZeroDenominatorThrowsException()
    {
        Assert.Throws<ArgumentException>(() => new Fraction(1, 0));
    }

    [Test]
    public void TestZeroNumeratorInDivisionThrowsException()
    {
        var fraction1 = new Fraction(1, 2);
        var fraction2 = new Fraction(0, 1);
        Assert.Throws<DivideByZeroException>(() => fraction1 / fraction2);
    }
}

Undo and Redo in a Single Step

Now might be a good time to take a look at the undo stack.

Notice that every AiGen operation is prefixed and labeled, explaining each change. AiGen operations, even those spanning multiple files and locations, will appear as a single entry in the stack and can be easily undone (or redone) in a single step.

When you redo an AiGen operation, the Navigator reappears so you can see a summary of changes.

Creating A New Class

Creating a new class is easy. Just double-tap and hold the right Ctrl key and say something like this: "I need a new class named user with properties for first name, last name, and birth date. And I would like a unique ID property that's set to a new guid any time an instance is created."

If you're following along, try this in a new WPF application. AI builds this new class, wrapping it in the default project namespace, and adds its file to the project:

using System;

namespace WpfDX {
    public class User {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateTime BirthDate { get; set; }
        public Guid UniqueID { get; }

        public User() {
            UniqueID = Guid.NewGuid();
        }
    }
}

Note we're increasing the complexity a bit, providing multiple specifications to describe the code we want in the same prompt.

Creating a User Interface

Now, let's copy this class to the clipboard. Placing a class on the clipboard is one way to let AI know you want to work with this class. To quickly copy this class to the clipboard, place the caret on the first public keyword (on the class declaration) and press Ctrl+C. If you have CodeRush's smart copy feature enabled, the entire class will be selected and placed on the clipboard.

Next, switch to the MainWindow.xaml file. In my sample project, my XAML looks like this (I've created a DockPanel on line 9, but if yours is showing a Grid that's fine too):

<Window x:Class="WpfDX.MainWindow"
		xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
		xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
		xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
		xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
		xmlns:local="clr-namespace:WpfDX"
		mc:Ignorable="d"
		Title="MainWindow" Height="450" Width="800">
	<DockPanel/>
</Window>

For reference, my code-behind file starts off relatively empty, looking like this:

using System;
using System.Windows;

namespace WpfDX {
	public partial class MainWindow : Window {
		public MainWindow() {
			InitializeComponent();
		}
	}
}

Double-tap and hold the right Ctrl key and say "I want to create a data table for the user class, which I've placed on the clipboard. Can we populate this form with, say 50 users filled with sample data?"

After a few seconds, changes should be integrated in both the XAML and the code behind, and the AiGen Navigator appears. My version for this demo looks like this:

The AiGen/AiFind Navigator

The Navigator window provides a summary of all code changes in this operation in the Results tree view on the left. In my screenshot above, it shows three changes to my code behind file (MainWindow.xaml.cs), and one change to my designer file (MainWindow.xaml).

Each change is prefixed by an icon that shows whether it's an addition (plus symbol), a change (a delta symbol), or a deletion (minus symbol). You can click on a change and the Navigator will highlight that change in the code, or you can press F7 and F8 to navigate backward and forward through the results.

Tip: If the change is large and does not fit onscreen, you can turn on Selection Previews to see both the top and bottom of the selection (open the CodeRush Options window and navigate to the "Editor->All Languages->Selection" options page.

Feel free to explore the changes by clicking on the results, or Run your application. I got this:

Not bad for zero lines of hand-written code.

As an expert in UI, I'm immediately noticing that the border contrast is too high. We'll upgrade to a more professional look in a minute, but before we go there, let's dive into the Difference View.

The Difference View

Often it's sufficient to navigate to the change. But sometimes its useful to see a difference. If a difference view is available, the "Show Difference View" button will be available (turned off by default to conserve screen space). Click this button (or press F9).

You can see in the Difference View (diff view) above, CodeRush has opened up the <DockPanel> tag and added a single DataGrid child.

Once you turn on the Difference View, it stays on until the Navigator is closed. You can always hide it in the right-click context menu.

Triggered Prompts

You may recall in our last example to create the data table we used the word "clipboard" in our prompt. When CodeRush matches certain regular expression triggers to your spoken/written prompts, it can send additional instructions to AI. In this case, it sent the clipboard contents as part of a rich context, so AI can generate the highest quality code.

You have full control over this behavior (and other triggered prompt modifications) on the "Triggered Prompts" options page (open the CodeRush Options window and navigate to the "IDE->Cognitive" section to find it).

You can use Triggered Prompts to provide conditional instructions, or "always on" instructions (just set the trigger to the universal regular expression matching pattern ".*").

Taking it to the Next Level

So far we've created a data table with some sample data. Next I'm going to switch over to the MainWindow.xaml file, double-tap and hold the right Ctrl key, and say "I'd like to convert these controls over to their DevExpress equivalents." Follow along if you have the DevExpress controls installed. If not, you can download a free trial here.

For me, this request took about 20 seconds. When it completed, the first thing I noticed was an "Invalid Markup" message in the XAML. But not to worry, because the AiGen Navigator is up and it's presenting a NuGet package install page.

Installing NuGet Packages

The NuGet Packages page lets you install packages needed to support the AI generated changes.

I can just click these Install buttons to start the NuGet package install. You can install these packages in any order (and you can certainly choose not to install at all).

The Navigator confirms successful installation by placing checkmarks next to each package:

As soon as these packages finish installing, the XAML designer preview updates showing the DevExpress controls. The designer preview now looks like this:

Excellent. This may be a good time for a reminder that we haven't typed any lines of code yet. Before we run, let's return to the AiGen Navigator and take a closer look at the changes.

AI Conversion to DevExpress Controls

If you've been following along with our example, so far we've created a new User class, we created a DataGrid and initialized it with sample data. Next we converted our application to use DevExpress controls instead of the ordinary WPF controls that come with .NET.

In my example, the Navigator shows two changes to the XAML and one to the code behind (interesting!). First, let's look at the XAML changes using the Diff View (F9 to toggle).

First, you can see AiGen removed the DataGrid control and replaced it with a GridControl that's parenting a TableView. Careful readers may also notice in my screen shot that it renamed the grid control to "userGridControl" (another interesting choice).

It also added the dxg namespace (you can see this by clicking the xmlns:dxg attribute entry in the Navigator tree view.

The last change is in the code behind. Using F8 (or simply clicking) to navigate to this change, the diff view reveals why the code behind was changed.

Ah... perfect. It renamed the control on the designer to match the new DevExpress WPF control type, and also updated the reference in the code behind. Nice.

I should point out that AI may not get it right every time. Sometimes you may have to make minor adjustments to the code or undo altogether (you can also click the Edit Prompt button on the Navigator if you want to try again).

Trying Out the New Application

So far we used AI to convert our DataGrid to a DevExpress GridControl . Now it's time to see it in action. Run the application and try it out. Here's what I have:

The default cell border contrast with the DevExpress controls is already better out of the box.

AiFind - Your AI-Powered Search

Just double-tap and hold the right Ctrl key inside the Visual Studio editor in the file you want to search, and state what you are looking for. For example, you might say "I'm looking for security issues in this code." or "Show me any methods involved in preparing an order for processing" or "I need to see any buttons that do not yet have a style assigned". AiFind will search the active file and highlight the code elements satisfying your search in the AiFind Navigator.

The F8 and F7 shortcuts (for Next/Previous AiFind result) are really useful for high-speed navigation.

Limitations

As with anything involving AI, there are some limitations to what AI assistance can do in this release.

AiFind currently works in the active file.
C# and XAML code folding agents are supplied
You can create new types contained in their own files, but there is no ability yet to create new files holding other non-C# type content.
Cannot delete files or remove files from the project.
Aside from installing NuGet packages, you cannot modify the project file or the solution file (so no way to create or add new projects).
Cannot perform refactorings on references spanning multiple files (use solid refactoring tools for this instead).
Contextual code awareness is currently limited to designer + code behind + clipboard (if you mention "clipboard" in your prompt), plus a project overview (language, framework, ui framework, and references).
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 the API has broken over time). Also, it is possible to have a request that is so complex AI has difficulty implementing it correctly.

More Voice Features

CodeRush contains powerful features for voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Voice Setup
Voice to Code
Comment Dictation
String Dictation
Voice Commands
Copilot Voice Support
Voice Input Modes

Voice Input Modes in CodeRush for Visual Studio

Mark Miller (DevExpress) — Mon, 16 Dec 2024 10:00:00 Z

CodeRush versions 24.1.5 and up add dynamically selectable Input Modes to its Voice to Code technology, useful for dictating mixed-mode code expressions, such as code expressions that include string literals or undeclared identifiers.

Background

CodeRush's Voice to Code features include dedicated Input Modes selected automatically based on context. For example, if voice features are used inside a string literal, dictation mode is active and your spoken words (along with spaces, sentence capitalization, punctuation, etc.) will appear inside the string. A summary of the three primary input modes is summarized below:

User-activated Input Modes

Users can change the input mode while talking by pressing a modifier key (such as Alt or Shift), allowing a subset of the spoken words to be interpreted according to that newly activated input mode. Any words spoken while one or both of these modifier keys are held down will be interpreted with the specified alternate input mode.

For example, if the caret is inside a string and dictation mode is active, the user can hold down the Alt key to convert their spoken words to an interpolated string symbol/expression reference (see string dictation for more details). Or if the caret is inside an XML Documentation Comment, and dictation mode is active, the user can hold down the Alt key to reference a symbol (e.g., a parameter to the method, another member, or another class), and CodeRush will insert the appropriate <cref> or <paramref> tags for that symbol (see comment dictation for more details).

In both examples, simply hold a modifier key down while speaking the words that need the alternate interpretation.

New in this Release

CodeRush adds additional switchable input modes in this release, allowing you to create new identifiers (hold down the Alt key) and string literals (hold down the Shift key) in voice-to-code.

Specific examples of the new modes follow in the sections below.

Here's a summary of currently supported user-activated modes:

Shift Key for String Literals

If you need a string literal in your voice-to-code session, hold down the Shift key while talking.

For example, to adorn a unit test method with a new Category attribute for a category named "Core", you first position the caret inside square brackets ([]). This tells CodeRush you want to dictate an Attribute. Then hold down the right Ctrl key and say "Category Core", also holding down the Shift key while saying the word "Core". CodeRush will generate the following attribute with the string literal "Core" for your test case:

[Category("Core")]

For another example, consider the following code:

public Customer CreateCustomer(string name, int id) {
    return new Customer(name, id, DateTime.UtcNow);
}

public void CreateTestCustomers() {
    var testCustomer = ;
}

With the caret on line containing the incomplete assignment to testCustomer (before the semicolon), hold down the right Ctrl key to start the voice-to-code session, and say "Create Customer with John Smith and forty two", also holding down the Shift key while saying the words "John Smith". CodeRush will generate the following expression for the assignment that includes the string literal "John Smith":

public void CreateTestCustomers() {
    var testCustomer = CreateCustomer("John Smith", 42);
}

You can even create code like this entire line (e.g., declare the new variable initialized with a method call having a string literal as an argument) in a single voice-to-code session (more on this below).

Alt Key for New Identifiers

If you need to reference a yet-to-be-declared identifier, hold down the Alt key while speaking the words of the new identifier name. As an example, consider the following code:

void GetPercentOfTotal(double num1, double num2, double percent, out double answer) {  
}

To declare a new variable called totalSum, and assign it the sum of num1 and num2, just say "total sum gets num one plus num two" (hold down the Alt key while saying "total sum"). CodeRush will declare the totalSum variable and initialize it with the following code:

var totalSum = num1 + num2

Continuing the example in this method, on the next line you could say "temp answer gets total sum times percent" (holding down the Alt key while saying "temp answer") to generate this code:

var tempAnswer = totalSum * percent

Declaring new variables by voice also works with ref and out parameters. For example, consider the following code:

public bool TimeIsValid(string accountingPeriod) {

}

If the caret is inside the method and the spoken words are "date time try parse accounting period result" (and the Alt key is held down while speaking the word "result"), CodeRush will generate the following code, declaring a new variable named result as an out parameter, like this:

DateTime.TryParse(accountingPeriod, out var result)

If you want your undeclared identifier to be a method call, release the Alt key after you say the method name and follow it with the spoken keyword "with" along with any optional arguments you want to pass to the method. If the new method call will have no arguments you can end the spoken phrase with the word "with".

For example, with the caret inside the body of a method, you can say "initialize core engines with" (holding down the Alt key while saying "initialize core engines") to generate the following call to the specified undeclared method:

InitializeCoreEngines()

As another example, consider the following code:

void CertifyProficiency(string name, Guid id) {
    var student1 =  ; 
}

Inside the method before the semicolon, hold down the right Ctrl key to start a voice-to-code session, and say "create student with name and I.D.", holding down the Alt key while speaking the words "create student", CodeRush will create a new method call with the specified arguments, like this:

void CertifyProficiency(string name, Guid id) {
    var student1 = CreateStudent(name, id);
}

Note that the Alt key is only needed when referencing undeclared methods and variables in speech. To call existing methods, simply refer to them by name while speaking (with only the right Ctrl key down).

Using the New Modifiers Together

You can use the Alt and Shift modifiers in a single spoken phrase.

For example, if the spoken words are "display message gets hello world", and you hold down the Alt key while saying "display message", and later hold the Shift key down while saying "hello world", CodeRush declares a new variable named displayMessage, initializing it to the literal string "hello world." like this:

var displayMessage = "hello world."

For a more sophisticated example, consider the following code:

public Customer CreateCustomer(string name, int id) {
    return new Customer(name, id, DateTime.UtcNow);
}

public void CreateTestCustomers() {
    ; 
}

With the caret before the semicolon in the CreateTestCustomers method, try saying "test customer one gets create customer with Jackie Smith and one seventy two", holding down the Alt key while saying "test customer one", and later hold the Shift key down while saying "Jackie Smith ", CodeRush will generate the following code:

var testCustomerOne = CreateCustomer("Jackie Smith", 172)

In this example CodeRush declares a new variable (testCustomerOne), creates the assignment statement (from the word "gets") and passes in the string literal Jackie Smithas an argument to the CreateCustomer() method.

Usability Tips

Using voice with modifier keys to dynamically change the input mode while talking can seem a bit tricky at first. Here are some suggestions to make approaching this easier:

Create code in small pieces (shorter voice-to-code sessions). You don't have to create an entire line of code in a single session.
Take it easy. It's okay to pause while talking as you transition modifier keys between an up or down state.
Don't worry about precision. CodeRush is fairly tolerant of early/lagging modifier key presses and releases, so they don't have to occur right at the small pauses between the spoken words. As long as the transition occurs after the middle of the preceeding word, and before the middle of the next spoken word, CodeRush will snap the time of transition to the point between the two words.
You can invoke an alternate input mode exclusively for an entire voice-to-code session. So for example, if you need a string literal at the caret, you can hold down both the Ctrl and Shift keys (Ctrl to start the voice-to-code session, and Shift to switch to string literal input mode), and dictate the text of the string you need. When you're done, release both keys and CodeRush will insert the string containing your spoken words into the code.

More Voice Features

CodeRush contains powerful features for voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Voice Setup
Voice to Code
Comment Dictation
String Dictation
Voice Commands
Copilot Voice Support

Comment Dictation in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 05 Mar 2024 08:05:00 Z

CodeRush Voice features include a powerful voice-to-text dictation engine available in C# comments.

Comment Dictation features are triggered with the right Ctrl key. Make sure you've set up voice features first.

Also available:

Dictation features also let you automatically include intelligent code references (for example, “see also” markup in an XML doc comment).

To start voice dictation with the caret inside a comment, simply hold down the right Ctrl key and start speaking. Release the Ctrl key when you are done.

To reference in-scope symbols while dictating, hold the Alt key down (while keeping the Ctrl key down). Release the Alt key when you have completed your symbol reference (and release the Ctrl key when you have finished dictating).

You can insert multiple code references inside a single dictation (just hold the Alt key down while referencing code expressions and release to return to normal spoken dictation, repeating as necessary).

For example, let’s say I want to fill in the XML doc comment for the following method:

I can press the right Ctrl key speak the following, holding down the Alt key when saying the bolded/highlighted words:

"This exciting method adds num one and num two, returning the result."

Notice for the words spoken when the Alt key was down ("num one" and "num two"), CodeRush mapped those spoken words to in-scope symbols, determining that both of these symbols were parameters, and finally inserting the appropriate <paramref name...> tags inside the XML Doc Comment.

You can similarly add cross-reference tags (e.g., "<seealso cref...>") for symbols that are not parameters using the exact same steps shown above.

Just hold the Alt key down while saying the name of any in-scope symbol in your code and CodeRush will generate the appropriate tag.

Reminder: the Ctrl key is held down for the entire dictation. The Alt key is only needed when you say words referencing symbols in your code.

Productivity Suggestions

Use the CodeRush template "/t" on an empty line to generate a new // TODO: comment in the code, and then immediately follow that with holding the Ctrl key and saying exactly what you want in the TODO.
You can also reference symbols inside regular comments - just hold down the Alt key while saying the name of the symbol you want to reference.

More Voice Features

This release contains powerful features that support voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Your Feedback Matters!

String Dictation in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 05 Mar 2024 08:04:00 Z

CodeRush Voice features include a powerful voice-to-text dictation engine available in C# strings.

String Dictation features are triggered with the right Ctrl key. Make sure you've set up voice features first.

Also available:

String dictation features let you automatically include intelligent code references (for example, a reference to an in-scope symbol or perhaps a simple expression inside an interpolated string).

To start voice dictation inside a string, hold down the right Ctrl key and start speaking. Release the Ctrl key when you are done.

To reference code while dictating, hold the Alt key down (while keeping the Ctrl key down) as you say the code references or simple expressions. Release the Alt key when you have completed your code reference (wait to release the Ctrl key until you have finished dictating). You can insert multiple code references inside a single dictation (just hold the Alt key down while referencing code expressions and release for normal spoken dictation).

For example, consider the following method:

Let's write the value of time1 to the Console. To do this, press the right Ctrl key and speak the following, holding down the Alt key when saying the bolded/highlighted words:

"name of time one is time one"

Notice for the words spoken when the Alt key was down, CodeRush mapped those spoken words to the time1 parameter, and inserted the appropriate nameof call.

The Ctrl key is held down for the entire dictation. The Alt key is held at the start because we're starting with a code reference, but the Alt key is only needed when you say words referencing code outside the string.

You can also reference simple expressions in strings. For example, consider the following method:

Here, let's show that the total of the two numbers equals their sum. Press the right Ctrl key and speak the following, holding down the Alt key when saying the bolded/highlighted words:

"num one plus num two equals num one plus num two"

More Voice Features

This release contains powerful features that support voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Your Feedback Matters!

Voice to Code in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 05 Mar 2024 08:02:00 Z

One of the more exciting features in this release is Voice to Code, which uses Visual Studio's IntelliSense to intelligently convert spoken words to code.

Voice to Code features are triggered with the right Ctrl key. Make sure you've set up voice features first.

To create a new simple expression inside source code, hold down the right Ctrl key and say the expression. Release the right Ctrl key when you have finished saying the expression.

For example, for qualified expressions like “a.b.c()”, you can omit the dots and parens and simply say “a b c”.

Also available:

Simple Expressions

In our initial release, Voice to Code supports the following simple expressions:

Qualified references to any symbol in scope (e.g., "myCustomer.DataPoints.Length")
nameof() and typeof() calls.
Method calls (e.g., "myCase.ToString()")
Linq expressions using method syntax (e.g, "myPoints.Select(x => x.Y).Max()")
Binary expressions (e.g, "myList.Count + myOtherList.Count" or "dataPoint.Time < DateTime.UtcNow) )
Numbers (e.g, "3.14159", "2024", "100", or "-9876543210.0123456789").

You can also reference symbols inside comments and strings, and add simple expressions to interpolated strings.

Groundbreaking Next Generation Voice to Code Technology

The Voice to Code engine works with Visual Studio's IntelliSense to evaluate a multiverse of phonetic interpretations, always trying to match the best code to the spoken phrase.

As an example, consider the following simple expression that might appear inside an NUnit test case:

Is.EqualTo(3)

To get this expression, hold down the right Ctrl key inside Visual Studio (with the caret in a place where this expression could go) and simply say "is equal to three”.

Release the right Ctrl key when you are done speaking. If the caret is inside an NUnit test case, the engine will find the "Is" class, then find its "EqualTo" method, and see that EqualTo() accepts a parameter (so it passes the "3" in as an argument because that makes the most sense in this context).

Along the path to finding this solution, the engine evaluates other in-scope alternatives, possibly including in-scope variations that end in "23" (since the words "to three" sound exactly like "2 3").

As a result, you rarely need to tell the engine where the dot qualifier goes - it simply solves that problem using IntelliSense. For example, if I want the expression "A().B().C().D()", I can say "A B C D". Of course, you can also explicitly point out where to place each dot delimiter by saying "dot" (which might be useful for resolving phonetic collisions).

The Voice to Code engine knows if it is inserting a method, property, parameter, etc, and so it formats the code appropriately. That means method calls will always include parens, and Linq expressions will automatically include the “x => x” lambda declaration. For example, in the following code…

if you want to return the highest y-value in a list of Points called "myPoints", hold down the right Ctrl key and simply say:

"my points select y max"

and you’ll get the following Linq expression:

myPoints.Select(x => x.Y).Max()

Let's take a closer look. In the code we want to create, we only said the important words (highlighted in yellow, below):

Let’s consider another example. The following in-progress method wants to calculate the age in days that have passed since the specified DateTime parameter (named “time”).

With the caret where we want our expression, hold down the right Ctrl key and say:

“date time UTC now minus time, total days”.

(release the Ctrl key when you are done)

The Voice to Code engine generates this:

(DateTime.UtcNow - time).TotalDays

Note that the engine realizes the subtracted difference between our two spoken DateTime instances is a TimeSpan (due to DateTime’s declared minus operator overload), and it knows the TotalDays property is available on TimeSpan instances (but not on the DateTime time instance). And so the engine concludes TotalDays must apply to the binary expression, and adds enclosing parentheses accordingly.

Understanding binary expressions, method calls, and Linq expressions means you can omit the punctuation and pretty much say only the essential identifiers, operators, and numbers. CodeRush uses your spoken words along with IntelliSense to find the best fit.

More on Numbers

Numbers can be spoken a single digit at a time (e.g., "one two three" to get 123), in pairs (like “twenty twenty-four” to get “2024”), or using numeric words and multipliers (e.g., "one hundred and twenty three" to get 123, or “negative three thousand two hundred and fourteen” to get “-3214”). Use the word “point” to specify a decimal separator (e.g., "three point one four" to get 3.14).

Enums

The Voice to Code engine understands many places where enum elements are expected (e.g., parameters, assignments, equality comparisons, etc.), and as a result it's unlikely you'll ever need to explicitly say the Enum type name. For example, consider the following code:

Now, with the caret where you want your expression, hold down the right Ctrl key and say

"flavor equals chocolate".

CodeRush will generate the following equality comparison expression:

flavor == IceCreamFlavors.Chocolate

Notice it correctly gets the name of the enum type ("IceCreamFlavors") without it ever having to be said.

Again, highlighting the important parts of that expression that need to be said:

Enum type names are generally never needed in the spoken phrase.

Attributes

To add an attribute, first enter the open square bracket into the code, and then press the right Ctrl key while saying the name of the attribute (and any arguments you want to pass).

For example, consider the following code...

if we want our ApiKey property to never appear in Visual Studio's debugger variable windows, with the caret inside the square brakets, press the right Ctrl key and say:

"debugger browsable never"

and you'll get this attribute:

[DebuggerBrowsable(DebuggerBrowsableState.Never)]

More Voice Features

This release contains powerful features that support voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Limitations

The engine works on simple expressions. This is a 1.0 release, and while we think there's groundbreaking power in what's shipping, there are some limitations. For starters, the technology is currently only available in C#. And the Voice to Code engine cannot recognize types that are not directly visible from the caret position -- using statements need to be in place to reference types in those namespaces.

Additionally, the following structural code blocks are not supported (we recommend using CodeRush templates instead for all of these):

Type and member declarations.
Flow control elements (like for loops, try/finally, if/else, etc.).

Here's some of what the Voice to Code technology does not yet support:

boolean literals (false, true)
null literal
assignment statements
!= comparisons
string literals
is or as
scientific notation numeric literals
multiple arguments to a method call
named parameters
instance creation
Linq query syntax
semicolons placed after statements
property and array indexers
Boolean and binary operators like &&, ||, etc.
bit shifting operators like <<, >>, etc.

We expect many of these limitations to be solved in subsequent releases.

Your Feedback Matters!

Voice Commands in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 05 Mar 2024 08:01:00 Z

Voice Commands let you control and access Visual Studio by voice. Voice Commands are fully customizable, are context-aware, and support inferred intent (e.g. a “Build Solution” voice command can be triggered with the phrase “please compile all my projects”.

To invoke a Voice Command, hold down the left Ctrl key and say the command. Make sure you've set up voice features first.

Release the Ctrl key when you have finished.

Also available:

Opening Files

The most important Voice Command for developers working in large solutions is the Open fileName command. This command allows you to open any file in your solution. Just hold down the left Ctrl key and say “Open” followed by only the file name (the file extension is unnecessary if the file uses the default extension for the project). This feature is a huge productivity boost when working in very large solutions (e.g., more than 10,000 files). It is the fastest/easiest way to open files (much faster than using a mouse or keyboard). It even works if you only remember a portion of the camel case file name parts (or if you say the parts slightly out of order).

For example, if my solution contains a file named StreamDeckStorageServices.cs, I can open that file with any of these spoken phrases:

"open stream decks storage"
"open streaming deck service"
"open deck storage service"

Showing Tool Windows

The second most important Voice Command to learn is the Show Me toolWindowName command. Just hold down the left Ctrl key and say “Show me” followed by the name/title of the Visual Studio tool window (Microsoft ships about 100 different ones with Visual Studio). This will open the selected tool window in Visual Studio. Here are some examples:

"show me Call Stack"
"show me Locals"
"show me Watch 3"
"show me Parallel Watch 2"
"show me Immediate"
"show me Solution Explorer"
"show me Properties"
"show me Threads"
"show me Modules"

Navigating Types and Members

To jump to any member in the active class, say "member" followed by the name of the member.

To jump to any type in the solution, say "type" followed by the name of the type.

Bookmarks

You can drop a permanent named bookmark anywhere in the code and return to it laters by voice. To drop a bookmark, hold down the left Ctrl key and say “Bookmark” followed by the name of the bookmark. For example:

"bookmark storage"

Later, to return to that bookmark, hold down the left Ctrl key and say “Go to” followed by the same name of the bookmark. For example:

"go to storage"

Other Voice Commands

Voice Commands make accessing files and tool windows easy. They are also great for commands you may execute irregularly for which you don’t already have memorized shortcuts. Some examples of prebuilt Voice Commands shipping in CodeRush:

"copy file path" - copies the full path of the active file to the clipboard.
"open containing folder" (or "file location") - opens the folder containing the active document in a new instance of Windows Explorer.
"new folder" - adds a new folder to the project (in the same folder containing the active document).
"add class" - adds a new item to the project
"add existing item" - adds an existing item to the project
"project properties" - opens the properties window for the active project
"filter solution explorer" - activates the Solution Explorer's search filter TextBox (you can then hold down the right Ctrl key a say the filter you want to use)
"repeat last test run" - repeats the last test run in the last mode it was run under (e.g., debug or normal)
"run this" - runs the active test case (or runs all the test cases in the active test class)
"debug this" - debugs the active test case
"implementations" - navigates to implementations of the active interface member
"full screen" - toggles full screen mode
"NuGet packages" - brings up the NuGet package manager for the solution
"show me CodeRush test runner" - brings up the CodeRush Test Runner tool window
"DevExpress" - opens up the devexpress.com web site.

Just hold down the left Ctrl key and say any of the commands above (many of these commands also support inferred intent, so you don’t need to be precise when you say them).

Custom Voice Commands

You can create your own voice commands on the CodeRush Voice Commands options page. You can also edit/delete/enable/disable existing voice commands on this page.

You can get to this page quickly from the CodeRush | Voice Commands... menu item (this options page is in the IDE/Cognitive options folder).

Creating a New Folder for Your Voice Commands

Take a moment to consider what folder will contain your new command. While you can select one of the existing folders, for reasons based on versioning, updating, and sharing we recommend creating a new folder to hold your commands. To create a new folder, click the New Folder icon at the top:

Enter a folder name, and check the "Make this a top level folder" checkbox.

Click OK.

Adding a New Voice Command

Click the New Voice Command button at the top left.

An empty Voice Command is added to the active folder. The voice command contains the following fields/options:

First, decide the words you want to say to execute the command. For this example, we'll create a new Voice Command that applies code changes during debugging (invoking the Visual Studio command "Debug.ApplyCodeChanges"). In this case we might want to trigger this command with two different phrases:

"apply code changes"
"hot reload"

For the words to say, we can use a pipe symbol to separate equivalent alternatives. So in this field we could enter "apply code changes | hot reload".

If you have supplied an OpenAI API key, you may want to check the "Allow Semantic Equivalents" checkbox. In this example, it would allow you to invoke the command by saying "let's apply these awesome code changes" or "it's time to reload at super high temperature". This means you won't have to recall the specific words of the command - just the essence of what you want to do. Checking this checkbox will send any spoken phrase that is not perfectly matched to OpenAI to get the inferred match.

Choose the command to bind to this new Voice Command. The combobox on this page lists all CodeRush commands. If you want to bind to a Visual Studio command (like “Edit.Copy”), simply enter it here. You can find a complete list of Visual Studio commands in the Visual Studio Options dialog on the Keyboard & Shortcuts page. For our example, let's enter Debug.ApplyCodeChanges.

You can leave the Parameters textbox empty (some CodeRush commands can take additional parameters).

The last option for our Voice Command is Context, which lets you determine when this voice command is available. Specifying context is generally a good idea because it can improve performance, increase accuracy, and shorten the prompt sent to OpenAI when Allow Semantic Equivalents is turned on. For this example command, it only makes sense to invoke it when actively debugging. To add a context, click the "..." button to the right of the Context TextBox. The Select Context Provider dialog will appear.

In the filter dialog at the top, enter "Debug" and click the System\DebugMode context. This context is true when you are debugging in Visual Studio:

The filled-out fields for this example command should now look like this:

If you've been following along with this example so far, click OK and try it out! Start a debugging session, enter a breakpoint, change some code, hold down the left Ctrl key and state your command! Look to the status bar for confirmation that code changes have been applied. Congratulations! You have just created your first Voice Command!

More Voice Features

This release contains powerful features that support voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Your Feedback Matters!

Voice Setup in CodeRush for Visual Studio

Mark Miller (DevExpress) — Tue, 05 Mar 2024 08:00:00 Z

This blog post provides an overview of the new Voice Features in CodeRush for Visual Studio and shows you how to set up and enable the features.

Voice Features are invoked by holding down one of the two Ctrl keys while speaking.

Also available:

Setup involves three steps:

Entering your API keys
Enabling Voice Features
Setting Microphone Level

API Keys

CodeRush Voice Features requires an Azure Speech Services API key. At the time of this post, you can create a free Azure account that includes 5 audio hours of speech to text processing services every month.

To set up a new OpenAI account (and get your OpenAI API key), click here.

Once you have set up your Azure account, create a new Speech Service if necessary, and copy one of the keys shown in the Keys and endpoint section:

Also note the Location/Region setting on this page.

Inside the CodeRush options dialog, navigate to the IDE\Cognitive\API Keys options page, and enter your Azure Speech Service API key (copied from the previous step) and the Azure Location/Region (which you can also copy from Azure):

CodeRush stores these API Keys as environment variables on your machine.

If you want to use the "Allow semantic equivalents" feature in Voice Commands, you'll need to also add an Open AI API key.

Once your API keys have been entered, click on the IDE\Cognitive\General options page.

Enabling Voice Features

On the IDE\Cognitive\General options page, check the "Enable Voice Features" checkbox. Optionally you can also enable the "Enable Cognitive Features" checkbox to turn on the "Allow semantic equivalents" feature in Voice Commands. This option will also impact future cognitive features in CodeRush.

Setting Microphone Level

Below the Enable Voice Features checkbox, there is a slider allowing you to set the volume threshold that must be exceeded for CodeRush to start listening (when the Ctrl key is down).

The easiest way to set this for your location is to remain quiet for a moment, and then click the Auto Set button. This will measure the ambient volume in the room and set the threshold slightly above that level. If you regularly listen to music on speakers or work in a location with more ambient noise, make sure that your location's noise source is available at its normal levels when you click Auto Set.

After setting the threshold, speak normally into your microphone. The volume meter should turn light blue when you are speaking (your volume exceeds the threshold), and be light orange when you are quiet (when the volume falls below the threshold).

Quick Test

Try these two tests after setting the API keys and enabling Voice Features:

Comment Dictation

Open or create a new C# file.
Go to an empty line in the file and enter "//" to start a comment.
Hold down the right Ctrl key and say "Hello Visual Studio."

Your spoken words should appear inside the comment:

Voice Commands

Open a Visual Studio solution.
Open any file from that solution holding down the left Ctrl key and saying "Open filename" (where filename is the name of the file you want to open). The file extension is not required if it's a *.cs file inside a C# project.

The file you specified should be opened immediately.

If either of these tests fail to work as expected, see the Troubleshooting section below.

Voice Feedback UI

When using Voice Features in Visual Studio, the Voice Feedback UI will appear near the caret in the code. The Voice Feedback UI shows live microphone volume levels when speaking (while one of the Ctrl keys is held down), and provides a color-coded animation and label corresponding to the kind of Voice Feature you are using.

For example, when naming a new identifier, you'll see feedback that might look something like this while you're speaking:

Once the Ctrl key is held down and from the moment you start talking, CodeRush immediately starts an audio streaming session with Azure Cognitive Services and the feedback UI starts to fade in. You can abort the session by pressing any non-modifier key, by moving the mouse a short distance, or by clicking the mouse. You can stop the streaming session and use the intended Voice Feature by simply releasing the Ctrl key when you are done speaking.

The Voice Feedback UI has other appearances:

When entering expressions in code (or inside interpolated strings), the animation is orange:

When dictating comments, strings, and some TextFields and TextBoxes (any place where human-readable display text might be expected) the feedback UI animation is green and the label describes what CodeRush is listening for:

If the Alt key is held down while speaking (useful for referencing code inside comment or string dictations), the animation goes to orange (to indicate code expressions can be spoken) and an indicator to the right shows the Alt key is down:

When referencing a code symbol from inside an XML Doc Comment (by holding down the Alt key), the animation turns purple and there's an indicator to the right:

As shown earlier, new identifiers are pink:

Type references are yellow:

And when listening for voice commands, the animation is blue:

Each of these different modes represents different voice processing engines working in the background to turn your spoken words into something sensible.

Troubleshooting

The following suggestions may help resolve unexpected results with CodeRush Voice Features.

Nothing happens when I hold the Ctrl key and speak.

Bring up the CodeRush IDE\Cognitive\General options page. Make sure you can see the volume indicator change as you speak. Also check the IDE\Cognitive\General options page and verify your Azure Speech Service API key is entered correctly, and the Azure Speech Region matches the region setting established for your key on the Azure portal (both of these Azure fields need valid values). Bring up Visual Studio's Output tool window, in the Show output from combobox switch to the "Voice" output page, and look for error messages here.

I see a "No audio detected!" message on the IDE\Cognitive\General options page.

Check your microphone to make sure it is not muted. Check your Windows sound settings (right-click the speaker icon in the system tray and choose "Open sound settings").

When you press the Ctrl key, CodeRush listens to the default sound input device (microphone) selected on this Windows settings page. This page includes a "Test your microphone" UI where you can verify your microphone is sending audio to Windows.

Voice Feedback UI hides unexpectedly while talking.

Voice Features are designed to work when the Ctrl key is held down and no other keyboard or mouse input actions are performed. So make sure the mouse isn't moving significantly or being clicked while you speak.

Voice Recognition Seems to Have Difficulty Getting My Words or Does Nothing When I Speak

Some microphones reset their volume to a lower level after a reboot or when the machine awakes from a sleep state. If the volume indicator on the Voice Feedback window is low, try turning up the sensitivity on your microphone.

Generated code/dictation sometimes misses the last spoken word.

Try keeping the Ctrl key down just a moment longer as you finish speaking.

Generated code isn't quite right.

Suggestions:

Try a second time (make sure you're holding the Ctrl key down for the entire time you are speaking).
If there is phonetic ambiguity, try disambiguating by saying the words you might normally omit (e.g., "dot" to separate qualifiers, "with" to enter parens and specify arguments).
Bring up the Output tool window and switch to the "Voice" page, and review the data there to see if the words heard (listed in a column with timing data) match what was said.
If the words in the Voice Output are correct but CodeRush still fails to generate the expected code, bind a shortcut to the GetVoiceTestCaseData command on the CodeRush IDE\Shortcuts options page, and try the Voice to Code again.

If you can duplicate the issue, now press the shortcut bound to the GetVoiceTestCaseData command, then paste the clipboard text into an email and review it (it will contain some code from where you tried the voice command and the data we need to reproduce). Send it to support@devexpress.com (feel free to edit the included code to remove anything sensitive, or better yet, try to duplicate in a method that contains code you don't mind sharing).

Voice Features do not work in certain CodeRush text boxes.

This is a known limitation we hope to resolve in a future release.

Voice Features do not work when IntelliRush is up.

This is a known limitation. For now we recommend closing IntelliRush by pressing Escape before invoking voice features.

Voice Features sometimes do not work when a tool window has focus.

Voice features will not work when some of the older Visual Studio tool windows (built under WinForms technology) are active.

The work around is to give the editor focus first by pressing Escape (or clicking on the editor).

Some of the older Visual Studio tool windows that block Voice Features include:

Breakpoints
Properties (for winforms projects)
Resources
Toolbox

Voice to Code seems to have problems when there are long pauses in the middle of an expression.

Due to architectural and performance challenges, this is an issue that we may not be able to fix. We recommend trying again without the long pauses, or breaking the expression into two or more smaller expressions.

I see an error message - "Cognitive features enabled but OpenAI Key is missing"

This error message can occur if the "Enable Cognitive Features" checkbox is checked but the field for the OpenAI API key is empty.

We recommend adding a valid OpenAI Key on the IDE\Cognitive\API Keys options page, or clearing the "Enable Cognitive Features" checkbox on the IDE\Cognitive\General options page.

I see an error message - "OpenAI rejected your authorization, most likely due to an invalid API Key"

This error message can occur if the "Enable Cognitive Features" checkbox is checked but the API key is invalid.

We recommend double-checking that your OpenAI Key has been correctly entered (on the IDE\Cognitive\API Keys options page), or clearing the "Enable Cognitive Features" checkbox on the IDE\Cognitive\General options page.

I see an error message - "Error at completions..."

This error may indicate your OpenAI model name is incorrect or has been deprecated by OpenAI ("NotFound" appears at the end of the message). This error message can also happen when the OpenAI model name has not been specified ("BadRequest" appears at the end).

We recommand bringing up the IDE\Cognitive\General options page and verifying the text in the OpenAI Model Name text box represents a valid OpenAI model name:

Voice to Code takes longer than it should to generate code.

This can happen when there are many possible code paths to consider, which seems to be caused by long spoken expressions containing multiple methods calls, each with many possible overloads. The workaround for now is to break the expression into two or more smaller expressions (e.g., start with the outermost method call, and work your way in).

Voice Feedback UI has an unexpected color or label (which may lead to unexpected results).

Let us know how to reproduce. We are still working on integrating voice into all the CodeRush refactorings and templates. If you find one we've missed or got wrong, please let us know.

And if you're still having trouble, please contact our Support Center (support@devexpress.com).

More Voice Features

This release contains powerful features that support voice interaction in Visual Studio. Other posts documenting voice features in CodeRush:

Your Feedback Matters!

Jump Codes in CodeRush for Visual Studio

Mark Miller (DevExpress) — Wed, 21 Jun 2023 09:00:00 Z

We've released a new navigation feature for CodeRush that helps you move to any code (in any programming language) that you can see onscreen (even code in code windows dragged onto other monitors) in just a few keystrokes. The feature also helps you select code blocks with the fewest keystrokes.

The feature is called Jump Codes, and here's how it works:

Look at the location onscreen (inside any visible code window) where you would like to move.
Press Caps+Tab to bring up the JumpCodes UI (enable Caps as a Modifier feature if needed).
Enter the displayed jump code at the target location.
Press Enter to land the caret at the target.

Simple enough.

Caps+Tab to invoke, Enter to land the caret (and a jump code in between).

However, as you might expect from the CodeRush team, there is more power here, allowing you to cut, copy, select and get anywhere onscreen, using a ridiculously small number of keystrokes. The rest of this post will dive into that power.

Landing Variations

After entering your Jump Code, pressing Enter will land the caret on the left side of the active token. You can combine the Enter key with one or more keyboard modifiers for different landing results.

For example, if you want to select the token under the JumpCode, hold down the Shift key while landing (Shift+Enter).

If brackets follow the token, hold down the Ctrl key while landing (Ctrl+Enter) to place the caret inside those brackets.

If you want the caret on the right side of the token (or the right inside of the brackets), hold down the Alt key while landing (Alt+Enter).

And all of these modifiers work with each other. So for example, if you want to land selecting the text inside brackets to the right of a token, press Ctrl+Shift+Enter.

Using the Arrow Keys

You can change the active token (and the active line) using the arrow keys if you like. Left & Right activate the token on either side and the Up & Down keys activate the row above or below. The active token is emphasized and surrounded by a red rectangle.

Correcting Mistakes

If you unintentionally select the wrong row, you can press Backspace to return to the initial row selection mode.

If you have selected the correct row and have selected the wrong token, keep yours eyes on that token - it will tell you what keys to press to activate it.

You can also drop the Jump Codes UI and return to the code window and location where you started by pressing Escape.

Working with Multiple Visible Code Windows

If you are working with more than one visible code windows (e.g., floating TextViews scattered across multiple monitors), you can activate an inactive TextView by pressing the number key associated with any jump code on that view (all jump codes in a view will start with the same number key).

You can also activate code windows by pressing Tab (and Shift+Tab) to cycle through them.

Landing at the End (or Start) of a Line

You can immediately land at the end of the active line by pressing Ctrl+End.

Similarly you can immediately land at the start of the active line by pressing Ctrl+Home.

If you want to select the entire line, just combine one of these shortcuts with the Shift key (e.g., Ctrl+Shift+Home).

And you can always change the active line using the arrow keys or by entering a jump code.

Creating Selections

There are a few ways to create selections.

Land with the Shift Key

As mentioned earlier, you can hold down the Shift key whlle landing to select the token (Shift+Enter) or the line (Ctrl+Shift+Home).

You can also select all the parameters in a method declaration or all the arguments passed to a method by activating the previous token (e.g., the method name token) and pressing Ctrl+Shift+Enter.

Selection Expand

You can press the CodeRush shortcut for Selection Increase (e.g., Ctrl+W or the Num Plus key) to immediately drop the Jump Codes UI and invoke Selection Expand starting at the selected token. You can continue to invoke Selection Expand as needed to shape the selection.

Dropping an Anchor

You can drop an anchor by pressing Space over an active token. This marks the end of the selection. An anchor icon indicates the anchored token. You can now enter a new Jump Code to indicate the other side of the selection. Pressing Enter when a token is anchored will land and create a selection running from the anchored token to the token that was active when you pressed Enter.

Anchored selections also work with CodeRush's Smart Cut and Copy (more details below).

Smart Cut/Copy

Jump Codes enhaces the behavior of a cut or copy operation to save you some steps. To see how this works, lets start with an example. Let's say you're inside a document near the bottom of the view and you want to copy some text from the top and paste it right where you are. Here's how you do that without reaching for the mouse:

Caps+Tab
Activate the token that starts the block you want to cut/copy (or create a selection with an anchor).
Press the Copy key. The block will be copied and the caret will return to place where you were right before.
Press Paste.

This even works across different open code windows.

If you want to override CodeRush's Smart Cut/Copy and only copy or cut the active token, you can press Space before pressing the cut/copy key.

Smart Cut works in the same way, but it will also drop a transient marker at the cut location so you can return later if needed. This can be useful when moving or exchanging methods between two different locations in a single code window (or between two different code windows).

Highly Optimized Efficiency

Landing shortcuts are highly optimized and designed to get you get anywhere inside any code window you can see with the smallest amount of physical effort. So not only can you get anywhere using the fewest key presses, you do this with the shortest finger travel distance. That means for many locations your fingertips will stay on the home row. And a single letter key press on the home row is all it takes to move the caret to the beginning of most lines in view.

If you are working with a non-Qwerty keyboard layout (such as Dvorak or Colemak), you will want to select your keyboard layout on the Jump Codes Options page.

Scalable to Extremes

Developers know more than most that it doesn't make sense to place hard coded limits in your products. And the CodeRush team fully embraced the idea of Extreme Scalability in developing JumpCodes. JumpCodes works regardless of how tiny your font is or how many lines of code you have onscreen or how many editor views you have distributed across multiple monitors.

The steps are the same regardless of scale. You simply look where you want to be, enter the JumpCodes shown at that location, and you are done.

In scenarios where a screen contains more than 26 lines of code (or when a line contains more than 25 tokens), you may have to press a letter key more than once (for example, in extreme situations a jump code might look line "aaabb". In situations like this, just keep your eyes on the target and it will tell you what keys you need to press to activate it, even if you overshoot it.