{"slug": "how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider", "title": "How I Stopped Fighting AI Context: JetBrains AI vs. Copilot in Rider", "summary": "A developer using JetBrains AI Assistant and GitHub Copilot in Rider 2026 found that treating both tools as interchangeable, all-knowing oracles led to context-blind code suggestions and wasted debugging time. After encountering a `NullReferenceException` caused by AI-generated code that ignored existing dependency injection patterns, the developer established a pragmatic division of labor: using GitHub Copilot for fast, narrow inline completions and boilerplate, while reserving JetBrains AI Assistant for tasks requiring broader project context.", "body_md": "Last Tuesday, I was staring at a `System.NullReferenceException: Object reference not set to an instance of an object. (Parameter 'serviceProvider')`\n\nin a new `Program.cs`\n\nfile, trying to boot up a .NET 9 API. The kicker? The code came almost entirely from an AI assistant. I'd been trying to leverage JetBrains AI Assistant and GitHub Copilot in Rider 2026 to speed up a legacy .NET 7 service migration, and honestly, the context dance between them was driving me a little nuts.\n\nFor a while, I felt like I was spending more time debugging AI output than writing actual code. My goal was simple: use AI to offload boilerplate, understand unfamiliar patterns in a large codebase, and generally accelerate my daily work. What I ended up with initially was a chaotic mix of half-baked suggestions and context-blind refactors. It took some serious trial and error, but I think I've finally settled on a pragmatic approach that works for me.\n\nMy initial mistake was treating both JetBrains AI Assistant (powered by Claude Sonnet 4.6) and GitHub Copilot (the latest Copilot for Workspaces version) as interchangeable, all-knowing oracles. I'd ask a question in the chat window, or expect an inline completion to magically understand my entire project structure. This almost never worked.\n\nFor instance, I'd ask JetBrains AI Assistant to \"add a new `AuditLogService`\n\nto this project\" and get back a barebones class definition that completely ignored my existing DI setup, `appsettings.json`\n\nconventions, or even the `ILogger`\n\npattern I was using everywhere else. It was technically correct C#, but utterly useless in my context. Copilot, meanwhile, would often complete a line based purely on syntax and local variables, completely missing the architectural implications. I even got a code block where `_dbContext`\n\nwas used before it was injected, leading to that nasty `NullReferenceException`\n\nI mentioned.\n\nHere’s a simplified example of the kind of output I was getting, which compiled but didn't quite fit:\n\n```\n// Asking JetBrains AI Assistant to \"Add a new AuditLogService\"\npublic class AuditLogService\n{\n    public void LogAction(string user, string action)\n    {\n        Console.WriteLine($\"User {user} performed {action}\");\n    }\n}\n\n// And then Copilot suggesting usage without context\npublic class MyController\n{\n    private readonly AuditLogService _auditLogService; // No constructor injection\n\n    public MyController() // Missing dependency\n    {\n        // ...\n        _auditLogService.LogAction(\"current_user\", \"some_action\"); // NRE waiting to happen\n    }\n}\n```\n\nThe issue wasn't the AI's intelligence, but my *prompting strategy* and expectation of its context awareness. While MCP (Model Context Protocol) support in Rider 2026 does a great job of feeding relevant code snippets, it's not a mind-reader. **I learned that explicit context is king.**\n\nWhat I ended up with is a clearer division of labor, treating them less as rivals and more as complementary tools. Your mileage may vary, but this has drastically improved my productivity.\n\n**GitHub Copilot in Rider:** This is my fast-twitch muscle memory. For quick, inline completions, generating boilerplate, writing unit tests for a specific method, or even just filling out XML documentation comments, Copilot is incredibly efficient. It excels when the context is narrow and immediately visible in the current file or surrounding lines. I use it constantly for things like `if (string.IsNullOrWhiteSpace(value))`\n\nor generating switch expressions. I've also found Copilot Edits surprisingly useful for quick refactors within a single method, like extracting a local function or simplifying a LINQ query.\n\n```\n// Using Copilot for quick completion and test generation\npublic interface IOrderService\n{\n    Task<bool> ProcessOrderAsync(Guid orderId);\n}\n\n// After defining IOrderService, Copilot often suggests this:\npublic class OrderService : IOrderService\n{\n    public async Task<bool> ProcessOrderAsync(Guid orderId)\n    {\n        // TODO: Implement order processing logic\n        return await Task.FromResult(true); \n    }\n}\n\n// If I then navigate to the test project and create a new test file:\n[TestFixture]\npublic class OrderServiceTests\n{\n    [Test]\n    public async Task ProcessOrderAsync_ValidId_ReturnsTrue()\n    {\n        // Copilot will often suggest this test setup:\n        var service = new OrderService();\n        var result = await service.ProcessOrderAsync(Guid.NewGuid());\n        Assert.That(result, Is.True);\n    }\n}\n```\n\n**JetBrains AI Assistant (with Claude Sonnet 4.6) in Rider:** This is where I go for deeper understanding, architectural refactoring, or when I need more nuanced code generation. Its strength lies in its chat interface, allowing for multi-turn conversations and explicit context feeding. When I need to understand a complex legacy class, I'll paste the entire file into the chat, ask \"Explain the dependencies and responsibilities of this `LegacyOrderProcessor`\n\n,\" and then follow up with \"Suggest a strategy to refactor this using a CQRS pattern for .NET 9.\" It takes more effort to craft the prompt, but the quality of the output is significantly higher for complex tasks. I've even used Claude Opus 4.7 via the assistant for particularly thorny problems, though it's slower.\n\n```\n// Prompting JetBrains AI Assistant for a refactor\n// (Imagine I've pasted the entire 'LegacyOrderProcessor' class into the chat window first)\n\"Refactor the provided `LegacyOrderProcessor` class to use an `IOrderStategy` pattern. \nCreate a new interface `IOrderProcessingStrategy` and at least two concrete implementations\n(`StandardOrderStrategy`, `PremiumOrderStrategy`). Explain the changes step-by-step and \nshow how to update the processor to use a strategy factory.\"\n\n// Partial example of the kind of detailed response I get back:\n// (AI Assistant would provide full code, explanations, and factory logic)\npublic interface IOrderProcessingStrategy\n{\n    Task<bool> ProcessAsync(Order order);\n}\n\npublic class StandardOrderStrategy : IOrderProcessingStrategy\n{\n    public async Task<bool> ProcessAsync(Order order)\n    {\n        // Standard processing logic here\n        return await Task.FromResult(true);\n    }\n}\n```\n\nThis dual-tool approach means Copilot handles the small, localized tasks, while JetBrains AI Assistant tackles the bigger picture, aided by more explicit context from me.\n\nI'm still figuring out the best way to leverage Copilot for Workspaces' broader context features without feeling overwhelmed by its suggestions, especially when dealing with early .NET 10 preview features. If you've managed to integrate both JetBrains AI Assistant and GitHub Copilot effectively in Rider for large-scale .NET refactoring, I'd love to hear your strategies and any pitfalls you've encountered.", "url": "https://wpnews.pro/news/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider", "canonical_source": "https://dev.to/dotnetwithai/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider-3lhi", "published_at": "2026-05-28 12:13:39+00:00", "updated_at": "2026-05-28 12:22:38.997101+00:00", "lang": "en", "topics": ["ai-tools", "generative-ai", "large-language-models", "artificial-intelligence"], "entities": ["JetBrains AI Assistant", "GitHub Copilot", "Rider", "Claude Sonnet", "Copilot for Workspaces", ".NET", "AuditLogService"], "alternates": {"html": "https://wpnews.pro/news/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider", "markdown": "https://wpnews.pro/news/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider.md", "text": "https://wpnews.pro/news/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider.txt", "jsonld": "https://wpnews.pro/news/how-i-stopped-fighting-ai-context-jetbrains-ai-vs-copilot-in-rider.jsonld"}}