Coding agents are different from in-editor chat and agent modes for AI assisted programming. They run asynchronously—often in the cloud—tackling tasks while you focus locally. I rely heavily on the GitHub Copilot coding agent and its VS Code integration to spin up multiple parallel workflows. Below are five everyday patterns I use to offload work, speed up development, and keep my repos in top shape.

1. Assign Issues Directly to GitHub Copilot

When a new issue or idea lands, I immediately hand it off to Copilot so it can start coding while I tackle higher-level planning or work on any tasks. I have worked on huge issues, small bugs, and complete re-designs with this flow. What is great is that you can give it a lot of context in the issue to help guide it along. You can see everything directly in VS Code, stop it, ask it for changes, and even get a diff view without leaving the code editor.

By assigning an issue to the coding agent:

• Checks out the base branch (usually main) and creates a feature branch named after your issue.
• It installs dependencies, runs any setup workflows, and begins implementing the requested feature or fix.
• A pull request pops up automatically, complete with commit history, a description of what was done, and live session logs you can follow.
• I can review diffs right in VS Code’s Agent sessions view or directly on GitHub before merging.

Key benefits:

• Parallelize work: start multiple issues at once without context-switching overhead.
• Instant feedback: see what Copilot built, ask follow-up questions in the same session.
• Consistency: every branch follows your CI/CD and code-style rules from day one.

Easy setup:

• Simply turn on in your Copilot settings: https://github.com/settings/copilot
• Then decide which repositories it is enabled on: https://github.com/settings/copilot/coding_agent
• Additional settings and MCP servers can be setup at the repo level in settings.

Learn more: • GitHub Copilot Coding Assistant overview: https://docs.github.com/en/copilot/concepts/agents/coding-agent • VS Code integration with GitHub Pull Requests & Issues: https://code.visualstudio.com/docs/copilot/copilot-coding-agent

2. Delegate Ad-Hoc Tasks from VS Code Chats

Spotted an improvement in your code or UI? Instead of stopping to implement it, or open an issues, you can simply delegate from your chat panel or from GitHub.com and get back to flow. This is maybe one of my favorite ways to use coding agents as I can even spin up a

How it works:

• In VS Code, open Chat Sessions (enable via Settings > Chat: Agent Sessions View Location and set to view).
• Under
• Type a request like “When user clicks Hacker News, auto-load articles in content-feed.” or whatever else you want it to do. You can even reference files and documents.
• Click Delegate to coding agent send button —Copilot spins up a background session, generates code, and opens a pull request.
• Monitor progress in the Chat Sessions view or jump into the PR on GitHub.

Why I love it:

• Lightweight delegation and works of a specific branch that you choose.
• Rich context: chat history and your codebase give Copilot full visibility.
• Notification-driven: get pinged when the PR is ready, so you only interrupt flow once.

Tip: You can also trigger these tasks from the mobile apps, GitHub.com on your repo, or the Copilot dashboard at https://github.com/copilot/agents without hopping into each repo.

3. Continue Work Across Branches and Chat Sessions

Sometimes I am working on a bug or new features and I have it half-implemented locally. Or sometimes I ideate in Ask mode and don't really want to open up an issue or work on it right now. Well, you can simply push your local changes and chat context into a new agent session so Copilot can finish while you move on.

Step by step:

1. On your feature branch (or main), start a Copilot chat to outline next steps (e.g., add docs, refactor helpers).
2. Make local edits but don’t commit everything.
3. Click Delegate to coding agent, choose Include changes, and let Copilot fork a sibling branch with your pending code.
4. Copilot completes the work—documentation, tests, cleanup—and issues a pull request ready for review.

Advantages:

• Seamless handoff: your uncommitted work becomes the starting point for the agent.
• Branch-of-branch workflow: keep your main branches tidy while Copilot wraps up.
• No more “oh right, I forgot to finish that” moments—wake up to a completed PR.

4. Iterate on Pull Requests with Interactive Comments

When I work with the coding agents it isn't always going to get it right the first time. Sometimes it is the coding agent, sometimes it is because I didn't give it enough context, and sometimes I just ended up wanting it a bit different . I like to treat Copilot like a teammate and file a review comment and then watch it push fixes in real time.

Workflow:

• Open a PR that Copilot has been working on in GitHub or in the chat sessions in VS Code and comment @copilot with error messages or changes you want.
• Copilot launches a new agent session, applies fixes or enhancements, and updates the same branch.
• You can reply to the agent’s comments, request tweaks, or approve and merge when satisfied.

Perks:

• Instant turn-around on feedback.
• Team-like collaboration: follow the same comment-reply flow you’d use with a colleague (or yourself in my case often).
• Full history: every change is tracked in the PR conversation and commit log.

Docs to explore: • Using Copilot in pull requests: https://docs.github.com/en/copilot/extend-your-editor-with-copilot-chat#use-copilot-in-pull-requests

5. Keep Dependencies Secure and Up-to-Date with Dependabot

Dependabot isn’t AI-driven, but it embodies the same “background agent” principle. It quietly opens PRs to bump libraries and fix vulnerabilities.

Setup highlights:

• In your GitHub repos Settings > Security > Advanced Secuirty, enable Dependency graph, Dependabot alerts, and Dependabot security updates.
• Create a .github/dependabot.yml to specify package ecosystems (npm, NuGet, etc.), directory paths, and update schedules.
• Dependabot will open pull requests whenever a new version is available or a security issue is discovered.
• Review, merge, or auto-merge based on your repo’s policies.

Why it matters:

• You don’t have to remember every library you depend on—they get updated for you.
• Security vulnerabilities get flagged and patched without manual intervention.
• Your CI/CD stays green with minimal overhead.

Get started: https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically

Setting Up Your Environment for Background Coding Agents

Before you reap these benefits, configure both GitHub and your local IDE:

1. Enable the Copilot Coding Agent
   • Simply turn on in your Copilot settings: https://github.com/settings/copilot
   • Then decide which repositories it is enabled on: https://github.com/settings/copilot/coding_agent
2. Install VS Code Extensions
   • GitHub Copilot
   • GitHub Pull Requests and Issues
3. Activate Chat & Agent Sessions
   • In VS Code Settings, search “Agent Sessions View Location” and switch from Disabled to View.
   • This adds the Chat Sessions icon for monitoring all local and active background tasks.
4. Add Copilot Setup Workflows (optional but recommended)
   • Place a .github/workflows/copilot-setup-steps.yml in your repo.
   • Define steps to checkout code, install runtimes (e.g., .NET, npm), and any CLIs your project uses. https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/customize-the-agent-environment
5. Configure Dependabot
   • Add a .github/dependabot.yml specifying ecosystems, directories, and schedules.
   • Enable security updates and auto-merge rules under Settings > Advanced Security.

With those pieces in place, you’ll have a fleet of coding agents— GitHub Copilot and Dependabot—working around the clock to keep your code moving forward.

How are you leveraging background agents in your workflow? Hit me on X or leave a comment on YouTube and let me know.