I tested 5 AI models in GitHub Copilot's Agent Mode within Visual Studio 2026 to answer one question: which model completes real coding tasks the fastest?
No marketing fluff. No theoretical benchmarks. Just the same practical task given to each model: fix identical data access implementation errors across 6 repository classes.
Models Tested
Premium Tier:
- Claude Sonnet 4.5
- ChatGPT 5
- Claude Haiku 4.5
Free Tier:
-
Grok Fast
-
ChatGPT 5 Mini
The Test Setup
Each model received identical instructions through Copilot Agent Mode in Visual Studio 2026. The task was straightforward but realistic: refactor data access logic in 6 repository classes where the implementation was wrong. Each class had the same three methods that needed updating.
The specific issue? Converting synchronous data access code to proper async/await patterns with Entity Framework Core optimizations. Here's what the models had to fix:
The Before (Wrong):
public IQueryable<ResultCheckSumSa> GetAll()
{
return _repository.Query<ResultCheckSumSa>();
}
public ResultCheckSumSa GetByItemID(int itemID)
{
return _repository.Query<ResultCheckSumSa>()
.FirstOrDefault(x => x.ItemID == itemID);
}
The After (Correct):
public async Task<IReadOnlyList<ResultCheckSumSa>> GetAll()
{
return await GetAllQuery().ToListAsync()
as IReadOnlyList<ResultCheckSumSa>;
}
public async Task<ResultCheckSumSa> GetByItemID(int itemID)
{
return await GetAllQuery()
.FirstOrDefaultAsync(x => x.ItemID == itemID);
}
private IQueryable<ResultCheckSumSa> GetAllQuery()
{
var itemsQuery = _repository.GetAll<ResultCheckSumSa>()
.AsNoTracking();
return itemsQuery;
}
The changes needed: add async/await, switch from Query<T>() to GetAll<T>(), add .AsNoTracking() for read-only queries, introduce a helper method to avoid duplication, and update return types. This pattern had to be applied consistently across all 6 files.
A human developer familiar with async patterns could knock this out in 15-20 minutes. Let's see how the AI models compared.
To eliminate bias from potential cold starts or backend caching, I ran Grok Fast first as a warm-up round that wouldn't count toward the official results. I don't know the technical details of how Copilot constructs API requests or whether it caches queries for optimization, so the warm-up run accounts for this uncertainty.
Speed Results
Grok Fast (Warm-up run):~5 minutes
This first run served purely to warm up any backend systems. As expected, it was slow.
Claude Sonnet 4.5:~90 seconds
The premium model lived up to its reputation. Extremely focused execution—no wandering, no unnecessary actions. Just clean, targeted fixes across all 6 files. Cost: approximately $0.02 for this task.
ChatGPT 5 Mini:~4 minutes 15 seconds
The free model struggled with focus. It kept exploring other projects that weren't part of the request, which added significant time. Eventually got the job done, but took a scenic route.
ChatGPT 5:~90 seconds
Matched Claude Sonnet's speed but showed different behavior. This model was noticeably chatty, wanting to suggest additional improvements beyond the specified task. Fast, but less disciplined.
Claude Haiku 4.5:~2 minutes 30 seconds
The budget-friendly Claude model appeared to complete the task in under 2 minutes, then hung for about 30 seconds. Not sure if it was performing background checks or just stuck. Either way, still respectable performance for a cheaper option.
Grok Fast (Second run):~2 minutes 30 seconds
Significant improvement after the warm-up, dropping from 5 minutes to 2.5 minutes. This suggests backend optimization or caching played a role.
The Clear Winners
Two premium models tied at approximately 90 seconds: Claude Sonnet 4.5 and ChatGPT 5.
However, execution style matters. Claude Sonnet 4.5 distinguished itself with laser-focused execution—no noise, no tangents, just the requested fixes. Applied the async/await pattern, repository method changes, and AsNoTracking optimization consistently across all 6 files without deviation.
ChatGPT 5 was equally fast but more verbose, suggesting additional changes beyond the scope. It wanted to comment on code style, propose extra optimizations, discuss alternative approaches. Some developers might appreciate the extra suggestions; others might find it distracting when you just need a specific fix.
For developers who value clean, predictable behavior, Claude Sonnet 4.5 edges ahead despite the identical completion time.
What Each Model Actually Did
Claude Sonnet 4.5: Razor-sharp focus. Completed only what was asked, nothing more. No wasted actions. If this were a human developer, they'd be the one who reads the ticket, fixes exactly what's specified, submits the PR, and moves on. Efficient.
ChatGPT 5: Very capable but chatty. Got the work done in 90 seconds but spent time explaining what it was doing, suggesting improvements, discussing tradeoffs. The work quality was good—it just came with commentary you didn't ask for.
Claude Haiku 4.5: Solid mid-tier option. Correctly applied all the refactoring patterns but took longer to process. The unexplained hang after finishing was odd, but at roughly 2.5x the time of premium models and significantly cheaper, it's a reasonable budget choice.
ChatGPT 5 Mini: Struggled with focus. Instead of just fixing the 6 specified files, it wandered into other parts of the solution, exploring unrelated projects. This added ~3 extra minutes. Free, but you pay with your time.
Grok Fast: Improved dramatically after warm-up (5 min → 2.5 min). Correctly applied all the refactoring patterns but took longer to process. Competitive with budget options but still 3x slower than premium models.
Bonus Round: Web-Based Chat Models
Out of curiosity, I tested how long web-based chat interfaces would take with the same task. This required manually copying files from Visual Studio, pasting into the chat, waiting for responses, then manually updating files back in the IDE.
Important: This isn't a fair comparison to Copilot Agent Mode since it lacks IDE integration and requires manual file handling. It also doesn't scale—imagine doing this with dozens of files.
Results:
- DeepSeek: 55 seconds (processing time only)
- Claude Sonnet 4.5 (web): ~10 minutes
The web results aren't conclusive since they depend heavily on traffic load. Claude Sonnet 4.5's web version took 10 minutes versus 90 seconds in Copilot Agent Mode, likely due to higher demand on the free web interface compared to API access.
DeepSeek's 55-second completion is impressive, but remember: this doesn't include the manual overhead of copying 6 files in and out of your IDE, which would add several minutes to the real-world workflow.
When Premium Models Are Worth It
The math is straightforward:
- Claude Sonnet 4.5: 90 seconds, $0.02
- Free alternatives: 2.5-4.5 minutes, $0.00
If you're doing this once, free models work fine. The time difference isn't make-or-break for a one-off task.
If you're doing this multiple times per day, premium models pay for themselves. At $0.02 per simple task, you'd need to run 50 tasks to spend $1. For developers billing at professional rates, saving 2-3 minutes per task easily justifies the pennies spent.
For small to medium refactoring tasks—the kind of work that's tedious but not intellectually challenging—premium models save substantial time. This is exactly where AI coding assistants shine: handling the repetitive work that humans find boring but that still requires careful attention to detail.
Test Limitations
This was an intentionally simple, repetitive task designed to measure pure execution speed and focus. I gave every model the same straightforward refactoring work that wouldn't take a human developer long to complete.
More complex scenarios—like architectural decisions, debugging subtle issues, or creative problem-solving—might produce different results. This test establishes a baseline for speed and behavior patterns but doesn't evaluate reasoning capability or handling of ambiguous requirements.
Think of this as a sprint test, not a marathon. The task tests pattern recognition, consistency, and focus—not deep problem-solving ability. Different models might shine in different scenarios.
Practical Recommendations
For speed-critical work: Claude Sonnet 4.5 or ChatGPT 5. Both complete tasks in ~90 seconds with reliable performance.
For focused execution: Claude Sonnet 4.5. Stays on task without suggestions you didn't ask for. Perfect for "just fix this specific thing" scenarios.
For budget-conscious developers: Claude Haiku 4.5 offers decent performance at lower cost. The 2.5-minute completion time is acceptable for non-urgent work.
For learning/exploration: ChatGPT 5's verbose style might actually be helpful. If you want to understand why changes are being made, the commentary could be educational.
For free tier users: Grok Fast improved significantly after warm-up. ChatGPT 5 Mini's tendency to explore unrelated code makes it harder to recommend unless you don't mind the extra time.
For occasional use: Free models work fine. The time difference isn't significant for infrequent tasks.
For daily heavy use: Premium models become cost-effective quickly. Saving 2-3 minutes multiple times per day adds up to hours per week.
The Bottom Line
Claude Sonnet 4.5 emerged as the best overall choice for GitHub Copilot Agent Mode in Visual Studio 2026, combining speed, focus, and reasonable cost. At 90 seconds and $0.02 per simple refactoring task, it delivers professional-grade performance without breaking the bank.
ChatGPT 5 matches the speed but with more verbose behavior. Whether that's good or bad depends on your preferences and the situation. Sometimes you want the extra context; sometimes you just want the fix.
Free models can work but expect 2-3x longer completion times and less focused execution. For developers who code professionally and use these tools multiple times daily, the time savings from premium models quickly justify the minimal cost.
The real insight? Speed isn't everything. Claude Sonnet 4.5's disciplined, focused execution matters as much as its 90-second completion time. In coding assistants, staying on task is a feature worth paying for. When you ask for a specific refactoring, you don't want a philosophical discussion about alternative approaches—you want the work done cleanly and efficiently.
That's what Claude Sonnet 4.5 delivers.
Watch Video on YouTube
Watch the full speed test video: Video on CodeLess Developer
Full playlist: GitHub Copilot Agent Mode tutorials
Connect: GitHub • LinkedIn • Upwork
What's your experience with different AI models in Copilot? Which one do you use and why? Drop a comment—I'm curious to hear how these results match up with your real-world usage.