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: Premium Tier: Claude Sonnet 4.5
ChatGPT 5
Claude Haiku 4.5 Claude Sonnet 4.5 ChatGPT 5 Claude Haiku 4.5 Free Tier: Free Tier: Grok Fast


ChatGPT 5 Mini Grok Fast Grok Fast ChatGPT 5 Mini 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): 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);
} 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): 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;
} 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. Query<T>() GetAll<T>() .AsNoTracking() 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 minutesThis first run served purely to warm up any backend systems. As expected, it was slow. Grok Fast (Warm-up run): Claude Sonnet 4.5:~90 secondsThe 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. Claude Sonnet 4.5: ChatGPT 5 Mini:~4 minutes 15 secondsThe 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 Mini: ChatGPT 5:~90 secondsMatched 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. ChatGPT 5: Claude Haiku 4.5:~2 minutes 30 secondsThe 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. Claude Haiku 4.5: Grok Fast (Second run):~2 minutes 30 secondsSignificant improvement after the warm-up, dropping from 5 minutes to 2.5 minutes. This suggests backend optimization or caching played a role. Grok Fast (Second run): 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. Claude Sonnet 4.5: 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. ChatGPT 5: 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. Claude Haiku 4.5: 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. ChatGPT 5 Mini: 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. Grok Fast: 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. Important: Results: DeepSeek: 55 seconds (processing time only)
Claude Sonnet 4.5 (web): ~10 minutes DeepSeek: 55 seconds (processing time only) DeepSeek: Claude Sonnet 4.5 (web): ~10 minutes Claude Sonnet 4.5 (web): 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 Claude Sonnet 4.5: 90 seconds, $0.02 Claude Sonnet 4.5: Free alternatives: 2.5-4.5 minutes, $0.00 Free alternatives: 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 speed-critical work: 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 focused execution: 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 budget-conscious developers: 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 learning/exploration: 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 free tier users: For occasional use: Free models work fine. The time difference isn't significant for infrequent tasks. For occasional use: For daily heavy use: Premium models become cost-effective quickly. Saving 2-3 minutes multiple times per day adds up to hours per week. For daily heavy use: 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 GitHub AI Models Speed Tests GitHub AI Models Speed Tests Watch the full speed test video: Video on CodeLess Developer Watch the full speed test video: Video on CodeLess Developer Full playlist: GitHub Copilot Agent Mode tutorials Full playlist: GitHub Copilot Agent Mode tutorials Connect: GitHub • LinkedIn • Upwork 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. 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.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Upwork

Claude vs ChatGPT in Copilot Agent Mode: Which AI Model Finishes Refactors Fastest?

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

AI Code Review Is Great at Nitpicks, Terrible at Systems

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

AI Code Review Is Great at Nitpicks, Terrible at Systems

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps