GitHub Copilot for Developers: A Step-by-Step Approach

One of the tools I use daily and that has genuinely helped my productivity is GitHub Copilot. My company purchased accounts for our team, so we can use it in development. But through real experience, I’ve learned that using Copilot wisely is a skill in itself. This post is about that.

How I Use Copilot in Daily Development

I mainly work in VS Code with Copilot active for tasks like:

  • Writing new functions or classes
  • Refactoring and improving existing code
  • Understanding complex code someone else wrote
  • Writing unit tests
  • Solving common problems quickly

But here’s the key part: I don’t just write one big prompt and wait for Copilot to magically solve everything. Instead:

  1. I explain the problem to myself first before asking Copilot
  2. I explain the architecture or approach to Copilot
  3. Then I break the work into small pieces
  4. I ask for each piece separately

Simple approach, but surprisingly effective.

Why Asking for Everything at Once Doesn’t Work

If I tell Copilot: “Please write a complete user management system”, one of these usually happens:

1. Code is huge and hard to review

When Copilot generates thousands of lines, reading and understanding it becomes a real task:

  • Which parts are good? Which parts are questionable?
  • What assumptions exist about data structures?
  • Is all error handling correct?

2. Mistakes hide and surface late

The more code, the more subtle bugs slip through:

  • Security issues discovered weeks later
  • Edge case bugs that shouldn’t exist
  • Incorrect execution order

If we had reviewed smaller pieces, we’d catch these earlier.

3. Wrong direction means throwing away work

If Copilot’s approach turns out to be wrong, you might have to rewrite everything.

Step-by-Step Approach: It Works

Now if I break the same work into small pieces:

Example: User Management System

Instead of one big prompt:

Copilot, write a complete user management system

I go with this:

Step 1: Write a User model (name, email, password)

Copilot generates a small piece of code. I review it. Good.

Step 2: Write register() function to create a new user

One function. I understand it. Better.

Step 3: Write login() function for authentication

Again, one function. I can easily read what Copilot generated.

Step 4: Let's look at them together and verify everything works

Why This Approach Is Better

✓ Easier to review and understand

Small code is readable. You can follow every line.

✓ Mistakes get caught early

If Copilot made a mistake in step 1, I catch it before going forward.

✓ Changing direction is easy

If the approach isn’t right, I only redo one small piece. Not the whole thing.

✓ Better learning

When you read code in small chunks, you learn and understand why it’s written that way.

✓ More control

I’m in control. Copilot is a suggestion, not the final solution.

Copilot Models: Which One to Choose

Copilot now offers multiple models. Each is suited for different tasks:

Auto (Automatic)

  • Good default choice if you don’t want to think
  • Copilot decides which model to use
  • Best for: General and everyday tasks

Claude Haiku 4.5

  • Fast and lightweight
  • Best for: Simple questions, small refactoring, quick explanations, everyday tasks

Claude Sonnet 4.5

  • Good balance between speed and quality
  • Best for: Coding, debugging, refactoring, explaining existing code

Gemini 2.5 Pro

  • Strong for reasoning and analysis
  • Best for: Complex problems, analyzing large context, understanding difficult issues

GPT-4.1

  • Good for coding and reasoning
  • On my account it shows 0x (might not be available or older version)

GPT-5 mini

  • Smaller and faster model
  • Best for: Medium tasks, quick coding help, simple analysis

GPT-5.3-Codex

  • Best for coding-focused work
  • Best for: Code generation, refactoring, debugging, working with software projects

Practical tip

  • If I’m writing code: Sonnet or Codex works well
  • If I’m asking a simple question: Haiku is enough
  • If I have a complex problem: Try Gemini or Sonnet

Practical Tips for Developers

1. Provide clear explanations

Don’t do this:

Write an API

Do this instead:

I want to write a REST API for task management.
Each task has a title, description, and status.
I need an endpoint to create a new task.

2. Review the code

Copilot makes mistakes. Read every line before using it.

3. Experiment with different models

Sometimes Sonnet is better, sometimes Haiku is enough. Try them.

4. Think one step ahead

Before asking Copilot, think to yourself: “What are the possible solutions to this problem?”

Then ask Copilot.

5. Write tests

If Copilot wrote code, write tests for it to make sure it actually works.

Conclusion

GitHub Copilot is a powerful tool, but it’s just a tool.

It’s not a replacement for thinking. It’s not a replacement for code review. It’s not a replacement for testing.

Copilot works best when:

  • We know the solution, but writing it is repetitive
  • We generate small code that we review
  • We’re clear with Copilot about what we want
  • We go step-by-step, not all at once

The step-by-step approach takes less time, not more, because:

  • Smaller mistakes are caught earlier
  • Less refactoring and rewriting
  • Final code is better and more understandable

If you want to work with Copilot, try this approach. I’ve found it very effective.

Questions about Copilot or how I use it? Feel free to ask.