Sign in Subscribe

Automating Development: A Hands-On Look at GitHub Copilot Coding Agent

Sze Wong

• 4 min read

In the ever-evolving landscape of AI-powered development tools, GitHub Copilot continues to push boundaries. Recently, I had the chance to explore its new "Coding Agent" feature, and it's an intriguing step towards more asynchronous, AI-driven software development. This agent aims to take on development tasks directly within your GitHub workflow, working on issues and submitting pull requests much like a human team member.

Let's dive into a practical demonstration of how it works.

What is the GitHub Copilot Coding Agent?

Think of the GitHub Copilot Coding Agent as an AI pair programmer that operates asynchronously. You assign it tasks via GitHub Issues, and it gets to work in the background, eventually submitting its changes as a Pull Request (PR). This is similar in concept to tools like OpenAI's Codex, functioning as a "vibe coding tool" that leverages the cloud and doesn't necessarily require you to have a local development environment running for every task (unless you're testing the output, of course).

The real magic is its tight integration with the GitHub ecosystem.

The Demo: Enhancing a Greenhouse Management System (GMS)

For this demonstration, I used a Next.js-based "Greenhouse Management System" (GMS) – a project I've worked on previously with other AI tools.

Our First Task: Improving the Demo Login Experience

The GMS application has a login page that, for demo purposes, displays text credentials for different user roles (Admin, Inspector, Reviewer). Manually typing these in every time is a bit tedious.
My goal: Replace the text credentials with clickable buttons that automatically log in the respective demo user.

Here's how I tasked the Copilot Coding Agent:

  1. Create a GitHub Issue: I opened a new issue in the GMS repository titled "Create demo buttons."
  2. Assign to Copilot: Crucially, I assigned the issue to "Copilot" – the AI agent appears as an assignable user once the Coding Agent feature is enabled for your repository.

Provide Context: In the issue description, I uploaded a screenshot of the current login page and wrote:

"Instead of using the demo credential to log in, please create 3 demo login buttons for the 3 different roles so one can just click on the button to log in."

Almost immediately, Copilot acknowledged the assignment and created a Work-In-Progress (WIP) Pull Request. After a short while, the PR was ready for review.

(Video Result Shown Later) The agent successfully modified the login page, replacing the text with three distinct buttons: "Admin," "Inspector," and "Reviewer." Clicking these buttons now logs you in as the corresponding demo user – a much smoother experience!

(Merging the Changes) Satisfied with the result, I merged the pull request, just like I would with a human developer's contribution.

Setting Up the GitHub Copilot Coding Agent

Before we move to the next task, let's quickly cover how to enable this feature:

  1. Enable in Settings:
    • Go to your GitHub settings (click your profile picture).
    • Navigate to "Your Copilot."
    • Scroll down to "Features" and find "Copilot Coding Agent" (often marked as "Preview"). Ensure it's enabled. This usually requires acknowledging pre-release terms.
  2. Configure Repository Access:
    • In the left sidebar of your GitHub settings, under "Copilot," click on "Coding agent."
    • Here, you can choose which repositories the Coding Agent should have access to. You can select "All repositories" or specific ones.

Subscription: Currently, the Coding Agent is available with the GitHub Copilot Pro+ plan (around $39/month for individuals) or the GitHub Copilot Enterprise plan (around 

39/user/monthforbusinesses).It′santicipatedthismighteventuallyrollintothestandardProplan(39/user/monthforbusinesses).It′santicipatedthismighteventuallyrollintothestandardProplan(

10/month).

Once configured, "Copilot" will be available as an assignee for issues in the enabled repositories.

Our Second Task: Implementing the Missing "Inspections" Page

The GMS app had a navigation link for an "Inspections" page, but the page itself was missing (returning a 404 error). My next task for the Copilot Agent was to implement this page based on existing design specifications in a 2-ScreenBreakdown.md document within the repository.

  1. Create a GitHub Issue: Titled "Implement the /inspections screen."
  2. Assign to Copilot.

Provide Specifications: In the description, I wrote:

"Please implement the inspections screen according to the 2-ScreenBreakdown.md."

Again, Copilot picked up the task and started working.

An Interesting Hiccup and a Learning Moment:

After the initial implementation and merging, I found that navigating to /inspections still resulted in a 404 error.

  • Attempt 1 (Reopening Issue): I reopened the original issue (#10) and commented, "@Copilot Please take a look," hoping it would pick up the bug. However, the agent didn't seem to respond to this follow-up on a closed-then-reopened issue.

Attempt 2 (New Issue): I then created a new issue (#12) specifically for the bug: "/inspections returns 404." In this new issue, I referenced the original ticket #10 for context:

"Please refer to ticket #10. After the implementation, /inspections still returns 404."
I assigned this new, focused issue to Copilot.

This time, the agent successfully addressed the problem!

(Video Result Shown Later) The /inspections page now loads correctly. The Copilot Agent implemented:

  • A tabbed interface within Project Details (for Details, Inspections, Samples, Documents).
  • An inspections list view with columns for ID, Project, Type, Status, Date, Location, and Actions.
  • Color-coded status indicators.
  • Sorting functionality.
  • A "New Inspection" button leading to a form for creating new inspections.

Key Takeaways

  • Seamless GitHub Integration: The Coding Agent works naturally within the existing GitHub issue and PR workflow. This is a huge plus for teams already using GitHub for project management.
  • Asynchronous Power: It can work on tasks in the background, freeing up human developers for more complex problem-solving or architectural decisions.
  • Documentation Matters: Providing clear specifications, screenshots, and references to existing documentation (like our ScreenBreakdown.md) seems to greatly improve the agent's success.
  • Iterative Refinement: Like working with any developer, sometimes the first attempt isn't perfect. The process of identifying bugs and re-tasking the agent is part of the workflow.
  • Issue Management Nuance: My experience suggests that for follow-up fixes or bugs found in previously "completed" work, creating a new, specific issue and assigning it to Copilot might be more effective than reopening and commenting on an old one. This could be a current limitation or a best practice to adopt.

The Future is Collaborative (with AI)

The GitHub Copilot Coding Agent is a powerful glimpse into the future of software development. While it's not (yet) a replacement for human developers, it's shaping up to be an incredibly capable assistant that can handle well-defined tasks, accelerate development, and even help with bug fixing.

The ability to delegate tasks through a familiar issue-tracking system and receive PRs for review is a compelling proposition. As these AI agents become more sophisticated, they will undoubtedly become even more integral parts of our development teams.

Have you tried the GitHub Copilot Coding Agent? What are your thoughts? Share your experiences in the comments below!

Sign up for more like this.

Enter your email
Subscribe