Best AI Code Generation Tools for C# Developers in 2026

Last updated: October 13, 2026 · Workflow and IDE support reviewed against official documentation · Pricing below was captured on September 27, 2026; check the linked vendor pages before subscribing · Sample code rerun on .NET 10 (SDK 10.0.401, runtime 10.0.12)

Which AI is best for C# coding? Start with your development workflow: GitHub Copilot for assistance inside Visual Studio; JetBrains AI with Junie for Rider; or Claude Code and Codex for repository tasks that involve edits, builds and tests. Claude Code and Codex also have IDE integrations. Compare the tools on a small task in your own solution before choosing a subscription.

This guide compares six C# AI coding tools by editor support, task workflow and dated pricing. Its original evidence is three generated C# samples compiled and run locally: a cache, a retry helper and request validation. The examples show what to check in generated code. The tool recommendations below use documented capabilities; there is no controlled six-tool benchmark in this article.

AI Code Generation Tools for C# in 2026: Comparison Table

Tool	Where it runs	Individual price	Free tier	Best for C# developers who…
GitHub Copilot	Visual Studio, VS Code, JetBrains, CLI, GitHub.com	Pro $10/mo · Pro+ $39/mo · Max $100/mo	Yes: 2,000 completions + 50 chat requests a month	…live in Visual Studio and want agent mode in the IDE
Claude Code	Terminal, VS Code, JetBrains, desktop app and web	Included in Claude Pro $20/mo · Max from $100/mo	No	…want an agent that runs dotnet build and dotnet test itself
Codex (OpenAI)	CLI, desktop app, web, VS Code-family editors and JetBrains integrations	Included in ChatGPT Plus $20/mo · Pro from $100/mo	Limited, on the free ChatGPT plan	…already pay for ChatGPT and want cloud tasks that open a PR
Cursor	Its own editor (a VS Code fork)	Pro $20/mo, higher tiers above that	Yes (Hobby, limited agent requests)	…prefer a VS Code-family editor with integrated AI workflows
JetBrains AI + Junie	Rider and every other JetBrains IDE	AI Pro from $10/mo, Junie included	Yes (small monthly quota)	…use Rider and want an agent alongside the IDE’s inspections
Kiro (replaces Amazon Q Developer)	Its own IDE, CLI, web	Pro $20/mo · Pro+ $40/mo · Power $200/mo	Yes: 50 credits a month	…build on AWS and want spec-driven development

For an agent workflow, check which tools the product can actually use in your environment: file editing, command execution, test access and approvals. Evaluate autocomplete separately if it is part of your workflow; an agent and an inline completion tool serve different needs.

1. GitHub Copilot: Still the Default for Visual Studio

Copilot is a practical starting point when your C# workflow is already in Visual Studio. Its agent mode can edit files, invoke tools and respond to build or test failures, subject to the tools and approvals available in your project. Microsoft documents agent mode for Visual Studio 2022 version 17.14 or later. See the official Visual Studio agent-mode guide for prerequisites and how to review or revert edits.

The 2026 plans are Free, Pro ($10 a month), Pro+ ($39) and Max ($100), and the paid plans now come with a monthly allowance of AI credits that agent tasks draw down, which replaced the older per-request quota in June 2026. The free tier gives you 2,000 completions and 50 chat requests a month, which is enough to try agent mode on a real project before you pay. Business seats are $19 per user and Enterprise seats $39, both with pooled credits.

The following generated cache example was compiled and run; its limitations are discussed below:

// Generate a thread-safe in-memory cache with expiration
public class MemoryCache<TKey, TValue> where TKey : notnull
{
    private readonly ConcurrentDictionary<TKey, CacheEntry> _store = new();
    private readonly TimeSpan _ttl;

    public MemoryCache(TimeSpan ttl) => _ttl = ttl;

    public bool TryGet(TKey key, out TValue? value)
    {
        value = default;
        if (_store.TryGetValue(key, out var entry) && entry.ExpiresAt > DateTime.UtcNow)
        {
            value = entry.Value;
            return true;
        }
        _store.TryRemove(key, out _);
        return false;
    }

    public void Set(TKey key, TValue value) =>
        _store[key] = new CacheEntry(value, DateTime.UtcNow.Add(_ttl));

    private readonly record struct CacheEntry(TValue Value, DateTime ExpiresAt);
}

Best for: Visual Studio users, teams already on GitHub, and anyone who wants agent mode without changing editor. If you are setting it up for the first time, my GitHub Copilot in Visual Studio guide walks through the configuration and the custom instructions file.

2. Claude Code: The Terminal Agent That Runs Your Tests

Claude Code is Anthropic’s coding agent. It runs in a terminal (and through VS Code and JetBrains extensions), reads your solution, and works in a loop: edit files, run dotnet build, run dotnet test, read the failures, fix them. Give it a CLAUDE.md file at the root of the repo with your conventions (“nullable enabled, xUnit, no .Result, EF Core 10″) and it follows them across sessions. It is included with the Claude Pro plan at $20 a month and with Max from $100 a month, so the entry price is the same as a chat subscription.

For C# projects, give the agent a bounded task with the affected projects and the commands it should run. Claude Code is available in the terminal, VS Code and JetBrains integrations, a desktop app and the web. Choose the surface that makes reviewing the changes easiest for you; the terminal is one option. These surfaces are listed in the official Claude Code overview.

Best for: developers comfortable in a terminal, larger refactors, and anyone who wants the agent to prove its change compiles before they read it.

3. Codex: OpenAI’s Agent Bundled With ChatGPT

Codex can work on repository tasks through its CLI and IDE integrations, and can delegate longer tasks to a cloud workflow. In VS Code and compatible editors, use the Codex extension; in supported JetBrains IDEs such as Rider, open AI Chat and select Codex. OpenAI documents these integrations in its IDE guide. Select a workflow that can access your solution and test dependencies, and review the resulting changes before accepting them.

Best for: teams already paying for ChatGPT, and delegated tasks (dependency bumps, test coverage, small features) that can run in the background.

4. Cursor: The AI-First Editor

Cursor is a VS Code fork rebuilt around AI, with its own agent, cloud agents and background “Bugbot” reviews. It indexes your whole solution, so prompts like “add validation to every controller endpoint” work across files, and you review the multi-file diff before applying it. Pro is $20 a month, with Pro+ and Ultra tiers above that for heavy agent use, and the free Hobby tier has limited agent requests.

The catch for C# developers is the editor itself. C# in VS Code-family editors relies on the C# Dev Kit extension, which is good but not Visual Studio: no designer, weaker profiling, and some debugging gaps. If your day is ASP.NET Core APIs and class libraries, that is fine. If it is WPF, WinForms or MAUI, you will miss Visual Studio.

Best for: developers who prefer a VS Code-family editor and want to evaluate its integrated AI workflow on their solution.

5. JetBrains AI and Junie: Native to Rider

If you use Rider, JetBrains AI is the natural pick and it now includes Junie, JetBrains’ autonomous agent, in the same subscription. Junie plans a multi-file change, writes it, runs the tests and self-corrects, and you can review generated changes against Rider’s inspections and your project’s nullable settings. Check feature support for your IDE: JetBrains currently documents Junie Debug mode for IntelliJ IDEA Ultimate, so this article does not promise that feature in Rider. See the Junie documentation. There is a free tier with a small monthly quota, and paid plans start at $10 a month for individuals; heavier agent use consumes credits, while basic completion is not metered.

Best for: Rider and ReSharper users who want an agent that understands the IDE’s refactorings instead of fighting them.

6. Kiro: What Replaced Amazon Q Developer

This is the biggest change since the 2025 version of this list. AWS has ended Amazon Q Developer: new signups were blocked on May 15, 2026 and the IDE plugins reach end of support on April 30, 2027. The replacement is Kiro, an “agentic development environment” (its own IDE plus a CLI) built around spec-driven development: you write a spec, Kiro turns it into tasks, and hooks run your checks automatically. Plans are Free (50 credits a month), Pro at $20, Pro+ at $40, Pro Max at $100 and Power at $200, with extra credits at $0.04 each.

For .NET teams there is a real cost here. Q Developer had a Visual Studio plugin. Kiro is a VS Code-family IDE, so moving means leaving Visual Studio. The .NET Framework porting feature that lived in Q Developer has moved to AWS Transform, which ports .NET Framework apps to modern .NET from Visual Studio or a web console at no charge as of June 2026.

Best for: teams building on AWS who like a structured spec-first workflow, and current Q Developer users who need to migrate before April 2027.

What I Actually Ran: Three AI-Generated Samples on .NET 10

Every sample in this post was pasted into a .NET 10 console project and run, because “looks right” is the most expensive phrase in AI-assisted development. Here is the retry helper, generated from the prompt “write a C# extension method that retries an async operation with exponential backoff”:

public static class RetryExtensions
{
    public static async Task<T> WithRetryAsync<T>(
        this Func<Task<T>> operation,
        int maxAttempts = 3,
        TimeSpan? baseDelay = null)
    {
        var delay = baseDelay ?? TimeSpan.FromMilliseconds(200);
        for (int attempt = 1; ; attempt++)
        {
            try
            {
                return await operation();
            }
            catch (Exception) when (attempt < maxAttempts)
            {
                await Task.Delay(delay);
                delay *= 2; // exponential backoff
            }
        }
    }
}

And a validated request record from “generate a nullable-aware order request with validation”:

public sealed record CreateOrderRequest
{
    public required string CustomerEmail { get; init; }
    public required IReadOnlyList<OrderLine> Lines { get; init; }

    public bool IsValid(out string? error)
    {
        if (string.IsNullOrWhiteSpace(CustomerEmail) || !CustomerEmail.Contains('@'))
        {
            error = "A valid customer email is required.";
            return false;
        }
        if (Lines is null || Lines.Count == 0)
        {
            error = "At least one order line is required.";
            return false;
        }
        error = null;
        return true;
    }
}

public readonly record struct OrderLine(string Sku, int Quantity);

The build was clean (0 warnings, 0 errors on SDK 10.0.201) and this is the real console output. The cache entry expires after its 300 ms TTL, the retry waits 200 ms and then 400 ms before the third attempt succeeds, and it rethrows once the attempts are used up:

Runtime: 10.0.5
cache  t=0ms   TryGet -> True value=42
cache  t=400ms TryGet -> False value=0
retry  t=   1ms attempt 1
retry  t= 214ms attempt 2
retry  t= 621ms attempt 3
retry  t= 621ms result=ok after 3 calls
retry  gave up after 2 attempts: db
valid  bad  -> False (A valid customer email is required.)
valid  good -> True (no error)

Gotchas I Hit in the Generated Code

• The cache never evicts on its own. Expired entries are only removed when someone reads that key. Write ten thousand keys once and never read them again and they stay in memory forever. The one-line prompt does not mention eviction, so the generated class does not have any; you have to ask for a sweep timer. In production use IMemoryCache from Microsoft.Extensions.Caching.Memory instead.
• Use a distinct cache name. This example’s MemoryCache<TKey, TValue> is a custom type. Give it a descriptive name so a reviewer can distinguish it from the framework cache. Adding a caching package alone does not establish an ambiguous-reference error.
• The retry catches everything. catch (Exception) retries ArgumentNullException and OperationCanceledException too, which are never worth retrying. Tell the tool which exceptions are transient, or pass a predicate.
• No cancellation token. Neither the retry helper nor the cache takes a CancellationToken. In ASP.NET Core that means a client disconnect does not stop the retries. Add “accept a CancellationToken” to your prompt as a habit.
• Timing drifts. The 200 ms delay measured 213 ms and the 400 ms delay 407 ms. That is normal Task.Delay behaviour on Windows, but if you ever assert on exact timings in tests, an AI-written test will be flaky.

How to Get Good C# Out of Any of These Tools

• Give the version and the constraints. “EF Core 10 query that translates to SQL and avoids client evaluation” beats “write a query”. Most bad output comes from an unstated target framework.
• Write the signature first. Define the return type and parameters, then let the tool fill the body. It anchors the model to your API surface and stops it inventing overloads.
• Ask for tests in the same prompt. “Include xUnit tests for null, empty and boundary cases” forces the model to think about edge cases, and in agent mode it will run them.
• Keep a conventions file. Copilot instructions, CLAUDE.md, Cursor rules and Kiro steering files all do the same job. Ten lines about nullable, async and naming save you from correcting the same thing every day.
• Review the diff, not the chat. Agent mode hides the changes behind a summary. Read the actual diff before accepting, the same way you would a junior developer’s pull request. If you want that review automated too, see AI code review in C#.

How to Compare C# AI Coding Tools on Your Own Project

Use the same small task, repository state and acceptance criteria for each tool. A useful trial is adding request validation to an existing endpoint with tests for an empty value, an invalid value and a valid request. Keep the project target framework and package versions fixed.

1. State the constraints. Name the .NET version, nullable settings, test framework and permitted files. Ask the agent to use existing packages unless a new dependency is necessary.
2. Require evidence. Ask for the exact build and test commands, their output, and any steps that could not run in its environment.
3. Check the diff. Review public API changes, cancellation handling and unrelated edits. A successful build alone does not establish correct behavior.
4. Track the work you do. Record the fixes you made, total elapsed time and quota consumed. Compare those results on your task instead of choosing from a generic model ranking.

When the task involves HTTP retries, use the tested HttpClient retry and timeout guide as a reference for reviewing the generated code.

Which AI Code Generation Tool Should a C# Developer Choose?

• Visual Studio, one tool, lowest friction: GitHub Copilot. Check the current free-tier allowance before starting.
• You want an agent that finishes tasks and proves they build: Evaluate Claude Code or Codex using the task checklist above; confirm that the selected surface can run your build and tests.
• Rider: JetBrains AI with Junie.
• Happy to switch editors: Cursor.
• AWS shop, or a current Amazon Q user: Kiro, and start the migration before April 2027.

Most working developers end up with two: an in-IDE assistant for the minute-to-minute completions and a terminal or cloud agent for the bigger delegated tasks. If you want to go further and build AI features into your own .NET apps rather than just use them to write code, start with Semantic Kernel in C#, the Azure OpenAI C# tutorial, and the overview of generative AI architecture in .NET.

FAQ

Which AI model is best for C# coding? The examples here do not establish a model ranking. Compare the models available in your chosen tool on the same task, record the model and date, and check compilation, test results and the corrections you make. Choose from that evidence for your workload.

Which AI is best for C# coding? For a Visual Studio workflow, evaluate GitHub Copilot first. For Rider, compare its available agents in AI Chat. For repository-wide work, try Claude Code or Codex on the same bounded task and review the build, tests and diff. Editor integration and the quality of the result on your project are more useful selection criteria than an unsupported overall ranking.

Is there a free AI code generator for C#? Yes. Copilot’s free tier gives 2,000 completions and 50 chat requests a month, Cursor’s Hobby tier and Kiro’s free tier include limited agent use, and JetBrains AI has a free quota in Rider. Codex has a limited free mode through ChatGPT.

Does Amazon Q Developer still work for .NET? Existing installs keep working until April 30, 2027, but new signups closed on May 15, 2026. AWS points new users to Kiro, and the .NET Framework porting feature has moved to AWS Transform.

Can these tools use .NET 10 and C# 14 features? Give the tool your target framework, SDK and language-version constraints, then compile the result against that configuration. The samples in this article were rerun on .NET 10, but they do not test every listed tool or every C# 14 feature. For actual language examples, see the tested C# 13 and C# 14 guide.

Which AI coding tool works in Rider? JetBrains documents Junie, Claude Agent, Codex and GitHub Copilot among the agents available through Rider’s AI Assistant. Availability and authentication depend on the installed version and configuration; check the current Rider documentation.

Verification update, October 13: the existing sample project ran on SDK 10.0.401 / runtime 10.0.12. Cache expiry, retry success and failure, and validation outcomes matched the original run; measured timings changed slightly. The console output shown above remains the original .NET 10.0.5 capture.

Conclusion

Choose a C# AI coding tool by where you develop, which tasks you want to delegate and the evidence from a trial in your own solution. Copilot offers agent mode inside Visual Studio; Rider provides several agent choices; Claude Code and Codex support repository tasks across multiple surfaces. Compile generated code, exercise edge cases, and review the changes before relying on them. The cache and retry examples above show why those checks matter even when the first build succeeds.

Sources: GitHub Copilot plans · Copilot agent mode in Visual Studio · Claude plans · ChatGPT and Codex plans · Cursor pricing · JetBrains AI plans · Kiro pricing · Amazon Q Developer end-of-support announcement

This article is part of the AI in .NET guide (LLMs, agents, RAG, ML.NET and AI coding tools).