How to Assign Jira Tickets to GitHub Copilot

If you're like most development teams, you've probably experienced the friction of managing work across Jira and GitHub. You write detailed requirements in Jira, then manually recreate that context when starting development. What if you could skip that step entirely and let GitHub Copilot pick up your Jira tickets directly?

That's exactly what we built with GitHub Copilot for Jira. In this tutorial, I'll walk you through how to set it up and start assigning your Jira tickets to Copilot in just a few minutes.

Why Connect Jira to GitHub Copilot?

Before we dive in, let's talk about the problem this solves. When you assign a Jira ticket to GitHub Copilot, the app automatically:

• Creates a GitHub issue with all your Jira ticket details
• Assigns that issue directly to GitHub Copilot
• Links everything back to your original Jira ticket
• Tracks any pull requests that get created

The magic happens when Copilot picks up that GitHub issue—it has all the context it needs to start working on your task.

Getting Started: Installation

First things first, you'll need to install the app. Head over to the Atlassian Marketplace and click "Get it now."

The installation process is straightforward—just follow the prompts and grant the necessary permissions. You'll need admin access to your Jira Cloud instance.

Setting Up Your GitHub Connection

Once installed, navigate to your project settings and find the GitHub Copilot Configuration section. Here's what you'll need to configure:

Your GitHub Token

You'll need a Personal Access Token from GitHub. Create one at github.com/settings/tokens.

If you're using a classic token, enable the repo scope for full repository access.

For fine-grained tokens (recommended), you'll want:

• Actions: Read and Write
• Contents: Read and Write
• Issues: Read and Write
• Pull Requests: Read and Write

Paste your token into the configuration panel and save. The app will validate it automatically.

Adding Your Repositories

Next, add the repositories where you want Copilot to create issues. Use the owner/repo format—for example, mycompany/web-frontend or myorg/api-backend.

You can add multiple repositories if your project spans several codebases. This becomes useful later when setting up automation rules.

Your First Assignment: The Manual Way

Now for the fun part! Open any Jira issue and look for the GitHub Copilot panel on the right sidebar.

If you've configured just one repository, simply click "Assign to GitHub Copilot" and you're done. The app creates a GitHub issue, assigns it to Copilot, and adds a comment to your Jira ticket with the link.

Got multiple repositories? No problem—just select which one you want from the dropdown before clicking the button.

That's it! Your Jira ticket is now a GitHub issue assigned to Copilot, ready for AI-powered development.

Level Up: Automated Assignments

Manual assignment is great, but the real power comes from automation. Imagine this: your product manager moves a ticket to "Ready for Development," and Copilot automatically picks it up. No clicks required.

Here's how to set that up:

1. Go to your project's GitHub Copilot Configuration
2. Find the Automation Rules section
3. Click Add New Rule
4. Select the status that should trigger assignment (like "Ready for Development")
5. Choose which repository to use
6. Enable "Skip if already assigned" to prevent duplicate issues

Now, whenever a Jira issue transitions to that status, the app automatically creates a GitHub issue and assigns it to Copilot. You'll see a comment appear in Jira confirming the assignment.

Pro tip: Choosing the right trigger status

Think about your workflow. Common trigger points include:

• "Ready for Development" — when requirements are approved
• "Sprint Ready" — when issues are pulled into a sprint
• "In Progress" — when development actually starts

Pick a status that makes sense for when you want Copilot to get involved.

What Your Team Will See

When an assignment happens (manual or automated), here's the flow:

In GitHub: A new issue appears with your Jira ticket's title and description. The issue includes the Jira ID (like [PROJ-123]) and is assigned to GitHub Copilot.

In Jira: A comment is added showing the GitHub issue was created, with a direct link. The "Previous Assignments" section in the Copilot panel tracks all assignments and any linked PRs.

PR Tracking: When Copilot creates pull requests from that GitHub issue, they show up in your Jira ticket's assignment history—complete with status badges (open, merged, or closed).

Tips for Better Results

Here's something I've learned from using this workflow: the quality of your Jira tickets matters. Copilot works with whatever context you provide in the GitHub issue, which comes from your Jira ticket.

Write your tickets like you're explaining the task to a new team member:

• Be specific about what needs to happen
• Include acceptance criteria as a checklist
• Mention the tech stack or patterns to follow
• Reference any related code or APIs

The more context you provide, the better Copilot can help.

Handling Common Hiccups

Running into issues? Here are the usual suspects:

"GitHub token not configured" — Double-check that you've added your PAT in project settings and that it has the right permissions.

"Failed to create GitHub issue" — Make sure the repository exists, you have access to it, and it's spelled correctly in owner/repo format.

"Failed to assign to Copilot" — Verify that GitHub Copilot is enabled for that repository in your GitHub settings.

Automation not triggering — Check that your rule matches the exact status name in Jira and that you haven't enabled "skip duplicates" for an issue that was already assigned.

A Real-World Workflow

Let me paint a picture of how this works in practice:

1. Monday morning: Your team reviews the sprint backlog. The PM moves approved tickets to "Ready for Development."

2. Behind the scenes: For each ticket that moves to that status, the app creates a GitHub issue and assigns it to Copilot.

3. Development starts: Developers see the GitHub issues in their repos, already assigned to Copilot and ready for AI-assisted coding.

4. Full traceability: As PRs get created and merged, everything links back to the original Jira ticket. Stakeholders can track progress without leaving Jira.

No context-switching. No copy-pasting requirements. Just a smooth flow from ticket to code.

Ready to Try It?

Setting up GitHub Copilot for Jira takes about 10 minutes, and once it's running, you'll wonder how you worked without it.

Install GitHub Copilot for Jira →

Give it a shot with a few tickets and see how it fits your workflow. And if you have questions, drop us a line at support@flowsprinter.com—we'd love to hear how it's working for your team.