GitHub Copilot Models - Quick Speed Test - Visual Studio 2026

# githubcopilot# ai
GitHub Copilot Models - Quick Speed Test - Visual Studio 2026Incomplete Developer

Using GitHub Copilot in Visual Studio 2026 (or VS Code) provides the developer with the convenience...

Using GitHub Copilot in Visual Studio 2026 (or VS Code) provides the developer with the convenience of using the single subscription to have access to almost ALL the AI coding models.

And not all models are equal, some cost more premium requests than others, while at the same time others are categorized as "FREE".

I love FREE valuable stuff but at some point got tired of the AI hype train of messing around with quick meaningless demos. How a

Because when you're shipping code on a deadline, marketing doesn't matter. What matters is: which model actually gets the work done?

So I ran an experiment. Same task. Same files. Five different AI models in GitHub Copilot's Agent Mode (Visual Studio 2026).

Let me show you what happened. πŸ‘‡


πŸŽ₯ Watch Video On YouTube


🎯 The Challenge

I gave each model the same boring but realistic task: refactor 6 repository classes from synchronous to async patterns with proper Entity Framework Core optimization.

Here's what the old code looked like:

public IQueryable<ResultCheckSumSa> GetAll()
{
    return _repository.Query<ResultCheckSumSa>();
}

public ResultCheckSumSa GetByItemID(int itemID)
{
    return _repository.Query<ResultCheckSumSa>()
        .FirstOrDefault(x => x.ItemID == itemID);
}
Enter fullscreen mode Exit fullscreen mode

And here's what it needed to become:

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;
}
Enter fullscreen mode Exit fullscreen mode

Changes needed:

  • Add async/await patterns
  • Change Query<T>() to GetAll<T>()
  • Add .AsNoTracking() for read-only queries
  • Extract a helper method to avoid duplication
  • Update return types to Task<T>

A human developer could probably do this in 15-20 minutes. Let's see how AI stacks up. ⏱️


πŸ€– The Contestants

Premium Tier:

  • Claude Sonnet 4.5
  • ChatGPT 5
  • Claude Haiku 4.5

Free Tier:

  • Grok Fast
  • ChatGPT 5 Mini

To avoid cold-start bias, I ran Grok Fast once as a warm-up before officially timing anything.


πŸ“Š The Results

Here's how long each model took:

Model Time Notes
Claude Sonnet 4.5 ~90 sec Laser-focused, zero waste
ChatGPT 5 ~90 sec Fast but chatty
Claude Haiku 4.5 ~2.5 min Solid budget option
Grok Fast ~2.5 min* *After warm-up (first run: 5 min)
ChatGPT 5 Mini ~4.25 min Wandered off-task

But raw speed isn't the whole story... πŸ€”


🎭 The Personalities

Claude Sonnet 4.5: The Silent Assassin 🎯

Time: 90 seconds

Cost: $0.02

This model just... did the work. No commentary. No exploring random files. It read the instruction, fixed all 6 classes exactly as specified, and stopped.

If this were a human developer, it'd be that senior engineer who reads the ticket, makes the changes, submits the PR, and moves on. Efficient. Clean. Beautiful.

ChatGPT 5: The Overachiever πŸ—£οΈ

Time: 90 seconds

Same speed as Claude, but completely different vibe.

It finished in 90 seconds but couldn't stop talking:

"Here's what I'm doing. Have you considered this alternative? By the way, here are 3 other improvements..."

The work was correct. The speed matched. But it felt like working with a developer who can't fix a bug without refactoring the entire codebase.

Sometimes helpful. Sometimes distracting.

Claude Haiku 4.5: The Budget Pick πŸ’°

Time: 2.5 minutes

Respectable performance at a lower price point. Applied all changes correctly but hung for ~30 seconds after finishing (maybe running validation checks?).

At 2.5x the time of premium models but significantly cheaper, it's a solid choice if you're not in a rush.

Grok Fast: The Slow Starter πŸ’βž‘οΈπŸ‡

First run: ~5 minutes

Second run: ~2.5 minutes

Fascinating! The first run was painfully slow, but the second attempt dropped to 2.5 minutes. Backend caching or optimization kicking in?

Still 3x slower than premium models, but usable after warm-up.

ChatGPT 5 Mini: The Distracted One πŸ˜΅β€πŸ’«

Time: 4+ minutes

This one frustrated me. It kept exploring unrelated parts of the solutionβ€”files I didn't mention, projects that weren't relevant.

Eventually got it done. But free doesn't feel free when you're watching the clock. ⏰


🌐 Bonus: Web Chat Experiment

Out of curiosity, I tested web-based chat interfaces (manual copy/paste workflow):

  • DeepSeek: 55 seconds processing
  • Claude Sonnet (web): ~10 minutes

But these numbers are misleading! They don't include the manual overhead of copying 6 files in and out of your IDE.

Key insight: IDE integration matters more than raw model speed. πŸ”Œ


πŸ’° When Is Premium Worth It?

Let's do the math:

Claude Sonnet 4.5:

  • 90 seconds
  • $0.02 per task

Free alternatives:

  • 2.5-4.5 minutes
  • $0.00

If you do this once a day? Free is fine.

If you do this 10 times a day?

  • Premium saves ~20-30 minutes daily
  • Cost: under $0.20
  • Time saved: 2.5 hours per week

For professional developers, that ROI is insane. πŸ“ˆ

But there's also a cognitive load benefit: free models that take 4+ minutes force context switching. You check Slack, read an article, then struggle to re-engage. With Claude Sonnet, you stay in flow.


⚠️ Important Limitations

This was a simple, repetitive task. It tested:

  • βœ… Pattern recognition
  • βœ… Execution speed
  • βœ… Focus
  • βœ… Consistency

It did NOT test:

  • ❌ Complex problem-solving
  • ❌ Architectural decisions
  • ❌ Debugging ambiguous issues
  • ❌ Creative solutions

Think of this as a sprint benchmark, not a marathon. Different models might excel at different problem types.


🎯 My Recommendations

For speed-critical work: Claude Sonnet 4.5 or ChatGPT 5 (~90 seconds)

For focused execution: Claude Sonnet 4.5 (no noise, just work)

For budget-conscious devs: Claude Haiku 4.5 (decent speed at lower cost)

For learning/exploration: ChatGPT 5 (the commentary might be helpful)

For occasional use: Free models are fine

For daily heavy use: Premium models pay for themselves quickly


🏁 The Bottom Line

Claude Sonnet 4.5 emerged as the winner: fast (90 sec), focused, and cheap ($0.02).

But here's the real insight: focus matters as much as speed.

When you ask for a specific refactor, you don't want philosophy or extra suggestions. You want clean execution.

That's what stood out most in this test.


πŸ’¬ Your Turn!

What's your experience with AI coding assistants?

  • Do you prioritize speed? Focus? Cost?
  • Have you noticed differences between models?
  • What's your go-to model in Copilot?

Drop a comment belowβ€”I'd love to hear your real-world experiences! πŸ‘‡


πŸŽ₯ Watch the full video test:
Comparing Different Model Speeds


πŸ”— Connect with me:


Did you find this helpful? Hit that ❀️ button and share with other developers!