How to use GitHub Copilot on github.com: A power user’s guide

You’ve been using GitHub Copilot in your IDE for autocomplete and code suggestions. But here’s what I discovered recently: there’s a whole other side of Copilot that lives on github.com, and it’s designed for different problems entirely.

While your IDE handles the day-to-day coding, GitHub Copilot on github.com helps you tackle project management, team coordination, and rapid prototyping. I can file issues from screenshots, assign AI agents to fix bugs, and spin up working demos without opening VS Code. Check it out in the video below 👇

No extensions to install, no setup required. Just go to github.com/copilot and start working. This becomes your AI-powered command center, and here’s how you can use it strategically:

File issues from screenshots

Got a bug report with a screenshot? Don’t write it manually, let Copilot do it. Here’s how:

1. Take a screenshot of the bug (e.g., a misaligned icon or layout problem)
2. Drag it into the Copilot chat on github.com/copilot. 
3. Add a prompt like:

Create a new issue using the 'bug' label. Use this screenshot and describe the overlapping arrow icon. Apply the UI issue template from this repo.

Copilot reads the image, generates a clear title and description, applies the right labels, and uses your repository’s issue templates. It’s faster than manual transcription and often catches details I might miss.

Let Agents handle routine work

Once your issue is created, you can assign it to the Copilot coding agent to start working on a solution.

To assign an agent:

In the chat thread, tell Copilot: Assign yourself to this issue and draft a fix.

The agent will analyze your codebase, identify the root cause, and submit a draft pull request with the fix. You can monitor progress in the task pane and review the pull request when ready.

This works well for routine bugs, documentation updates, and dependency upgrades. For more complex features, I still prefer hands-on development in the IDE.

Use Spark to prototype live

When I need to test how a component behaves or validate a design idea, I use GitHub Spark to:

• Rapidly scaffold working code 
• Preview and interact with the output
• Share the work via a link with collaborators

Example prompt:

Create a feature comparison table for an API pricing page. Show Free, Pro, and Enterprise tiers with checkmarks for features.

Within minutes, I get working code with a live preview. I can edit directly in Spark, GitHub Codespaces, or VS Code, see changes immediately, and publish and share the prototype with teammates.

Choose the best model for the task

You can get access to multiple AI models and switch between models on github.com. In my experience:

To switch models:

1. In a thread, click the model name.
2. Select a different model and reload the response.
3. Compare answers and choose the best one for your use case.

Navigate conversation branches

GitHub Copilot groups multiple responses under each message you send, especially when you switch models. It’s not threading in the Slack sense, but it acts like it — each group works like a separate “branch” of your conversation, completely isolated from the others.

Here are a few use practical use cases:

• Compare different refactoring approaches by switching models for the same question.
• Test multiple architectural patterns by reviewing several AI-generated answers.
• Explore alternative explanations side-by-side without mixing contexts.

Combine web and IDE strategically 

Copilot is most powerful when you use both github.com and your IDE together, leveraging each for what they do best.

Example workflow: I’ll start a project discussion on github.com, prototype the solution in Spark, create issues for the team, then switch to VS Code for implementation.

Build your AI-native dev workflow

Here’s what a full day might look like:

1. Land at github.com/copilot.
2. Check assigned pull requests and issues.
3. Use chat to summarize project status and recent team activity.
4. Assign an agent to a newly created issue.
5. Prototype a new idea in Spark.
6. Use thread conversations and switch models mid-thread.
7. Push final changes via pull request.

The key insight is that github.com Copilot handles the coordination and exploration work, while your IDE handles the detailed implementation. Used together, they can cover the full development workflow.

Ready to try it?

Copilot on github.com turns your browser into your personal development mission control. It’s time to stop thinking of Copilot as just autocomplete and start using it as your workflow orchestrator.

Written by

Andrea Griffiths

@AndreaGriffiths11

Andrea is a Senior Developer Advocate at GitHub with over a decade of experience in developer tools. She combines technical depth with a mission to make advanced technologies more accessible. After transitioning from Army service and construction management to software development, she brings a unique perspective to bridging complex engineering concepts with practical implementation. She lives in Florida with her Welsh partner, two sons, and two dogs, where she continues to drive innovation and support open source through GitHub's global initiatives. Find her online @alacolombiadev.