5 Atlassian MCP Hacks to supercharge your workflow

I hate to be switching over and over between the IDE, the task in Jira to review details, Confluence, or other docs to ensure I have the details, finding sometimes outdated docs, so I was curious how I could save time on that through AI. Every time we jump from writing code to updating a ticket or checking a requirement, we lose focus and momentum.

After some weeks testing, configuring, failing, and enjoying the process, I bring you here 5 situations that I found useful and saved me time. Your time is also important, so I added TL;DR in all the sections!

The case: During a recent migration of a microservice from Node.js to Kotlin, I put this to the test. Basically, the AI should help not only to do a plan for migration, but also we needed ideas for a safe rollout, a list of all the endpoints, business rules, external dependencies, and adapt the plan for the team size, etc. I created a single workspace in my IDE containing the legacy Node.js project, the new Kotlin boilerplate, and another small service we were absorbing to provide all the context I thought relevant for once I start prompting in the IDE. By giving the agent access to this full context, along with a link to our "Backend Guidelines" page in Confluence, I could kickstart the documentation process. A migration is a big topic, with several steps:

1. Create a plan to migrate it, and add it to somewhere easy to edit, share, review with the team, update, comment -> a Confluence page

2. Divide the work according to the team size to achieve in a determined time -> a Feature in Jira with all the tasks related

3. Follow our internal guidelines and avoid generic results -> use the current documentation in Confluence to consider them in the code

4. Ensure the information in the tickets: Edit tasks descriptions, info, and adding comments with the info in the code

5. Code fast small features or tech debt -> Implementing a Jira ticket

1. Documentation on Autopilot: From Code to Confluence

TL;DR: Use the AI to analyze projects (or specific pull requests) to generate or update technical documentation in Confluence, provide it with the best context, ask it to improve the prompt; this will help to have your docs sync with your code with minimal effort.

Generating and updating documentation is a task many of us postpone or sometimes defer to the bottom of the backlog. With an integrated AI agent, you can delegate a significant portion of this work.

Why in a document? Because it's easier to read and review than in the agent chat, and I can edit what I want to precise or correct easily.

Why a conversation? Because I involved the agent in the decisions.

Why did you mention a conversation? Because I shared my idea with Gemini 2.5 Flash in the web to help me generate the best prompt for the Cursor Agent (which primarily runs on Gemini 2.5 Pro for coding tasks) with my ideas, and I asked it to ask me questions to ensure the best result.

After refining the prompt and editing some things, I ended with a big prompt with around 4k characters. It’s big, but needed to have a good start. Having the output in Confluence helped me to edit easily some sections, add or remove parts, add comments in some parts, and copy-paste some of the text to ask the AI if that was an assumption or something in the code (and guess what, there were some wrong assumptions, AI is not perfect, folks, yet).

Here is the final, structured prompt used to generate the migration plan:

You are a Senior Solutions Architect tasked with creating a comprehensive 
and actionable migration plan. 

Project: Migrate the existing [Legacy Service Name] microservice 
(Node.js/TypeScript, GraphQL, REST) to the new [Target Service Name] microservice 
(Kotlin, Ktor, GraphQL). 

Primary Goal: Complete the migration and have the new service fully operational 
in Production within a three-month timeline. 

Key Context & Constraints: 
Team: The project will be executed by a team of 4 backend developers. 
Technology: We must maintain GraphQL compatibility. 
The goal is to reuse the existing GraphQL schema and as much of the domain logic 
and DTOs as possible to ensure a smooth transition for frontend clients. 
Development Velocity: 
The plan should incorporate the use of AI-powered code generation tools 
to accelerate the translation of business logic from TypeScript to Kotlin 
and to generate boilerplate code. 
Standards: The entire plan, architecture, and proposed implementation must 
strictly adhere to the best practices documented in the [Your Company Name] 
Backend Guidelines found here: [Link to Backend Guidelines] 

Required Plan Structure: Please generate the plan with the following 
distinct sections: 
1. Executive Summary 
2. Gap Analysis & Feature Parity Strategy 
3. Development & AI-Assisted Strategy 
4. Phased Rollout Strategy (Zero-Risk Production Deployment) 
5. Monitoring, Logging, and Alerting Strategy ([Observability Platform]) 
6. Timeline: Sprints & Milestones (3 Months) 
7. Risks & Dependencies. 

Write the output in **Confluence**, in the space for 
[Wiki Space ID] > [Parent Page], called "[Project Name] Node <> KT migration".

🔖 Add this to your prompts to improve results:

Ask me any questions you find relevant have better information.

Then add them to a Google Doc or similar, it will be easier to answer. Then just copy all the question and answers

‼️ I prefer to be specific with the destination link. Vague instructions can sometimes lead the AI to edit the wrong page. Double-check the target, I edited wrong documentation because there were two pages with the same title in different folders!

2. Intelligent Task Creation, Right From the Codebase

TL;DR: Define high-level constraints (time, team size) to have the AI decompose epics into manageable tasks. When you spot bad code, select it and instantly create a detailed tech debt ticket in Jira.

Whether you're breaking down a massive epic or flagging unexpected tech debt, you can create perfectly detailed Jira tickets without ever leaving your code.

For the migration project, I tasked the AI with planning. Here is the prompt used to decompose the epic into manageable, one-week tasks:

Act as a senior project manager responsible for planning a microservice migration.

**Context:**
Based on the migration plan from Node.js to Kotlin for the [microservice A] to [microservice B] that we just finalized in our previous conversation, your task is to generate a detailed list of Jira tasks required to execute this plan.

**Jira Target Information:**
- Jira Feature/Epic Link to associate tasks with: [Link to Feature/Epic]

**Rules and Constraints:**
1.  **Adherence to Plan:** All tasks must directly correspond to the phases and steps we previously agreed upon.
2.  **Team & Timeframe:** Remember, our team consists of 4 developers and the target timeframe is 12 weeks.
3.  **Task Granularity:** No single task should exceed one week of effort for a single developer. If a step from our plan is too large, break it down into smaller, logical sub-tasks.
4.  **Dependencies:** Identify and order the tasks logically.

**Final Step (Review):**
Before you execute the creation in Jira, please present the full list of proposed tickets here in the chat for my review and final approval. This is a dry run.

After a bit of back-and-forth, I gave the final command to execute the creation in Jira.

A more powerful feature is on-the-fly tech debt flagging. We've all been there: you're working on a feature and stumble upon a piece of convoluted "spaghetti code." Instead of letting it slide, I now select the code block and prompt the agent:

Create a tech debt ticket in Jira to refactor this. 
Explain that it has high complexity and doesn't follow our guidelines. 
Reference the file @path/to/the/problematic/file.js 
in the description and propose a solution explaining the why and how.

Using the @ symbol (formerly # in some tools) to reference specific files is always better if you want to tag several files, try always to provide the best context for best results. It gives the AI precise, unambiguous context, leading to faster and more accurate results. You're not making it search; you're telling it exactly where to look. This focused context approach is a key feature of modern AI IDEs, allowing you to scope the AI's attention precisely.

3. Weaving Confluence Knowledge into Your Code

TL;DR: Provide the AI with links to relevant Confluence pages (e.g., coding guidelines, business logic) to use as context when generating or refactoring code.

How many times have you had to dig through Confluence to find that one specific business rule or coding standard? I don’t remember 100% of things, and I hate to be searching some specific info in Confluence, switching over and over screens. Now, you can bring that knowledge directly to the agent that writes your code.

When I need the AI to generate code that must adhere to complex business logic documented in Confluence (or follow several internal guidelines), I start a conversation by providing the link. I first verify it has understood the content with a prompt like

Summarize the key business rules from this document regarding user authentication.

Once I confirm the agent has "ingested" the knowledge correctly, I can proceed with my code generation request, confident that it will respect the documented constraints.

🔖 If you don’t trust the AI answers 100% like me, I recommend you to ask something like

Explain to me how you took the info provided and how you adapted it 
and considered it in the code

This is currently the best way to provide external knowledge through Atlassian MCP. While Atlassian Intelligence is moving towards a future where the AI can automatically index and understand your entire Confluence space, the "link and verify" method is the best practice at the moment of writing this.

4. The IDE as Your Jira Cockpit

TL;DR: Use natural language commands in your IDE to add comments to tickets, change their status, or clarify descriptions, drastically reducing the need to switch to the Jira web UI.

Small, repetitive Jira actions add up, pulling you out of your coding mindset. You can execute most of these tasks with a single command from your editor.

The actions that save me the most time are:

• Adding Contextual Comments: Highlighting a discrepancy in the code and telling the agent, "Add a comment to ticket XYZ explaining that the current implementation doesn't fit our business rules and requires extra development not considered in the task."

• Changing Status: Simple commands like Move this ticket to 'In Progress' and give me a summary of the app or Move this ticket to 'Code Review' and push the code (I don’t waste tokens just to move a ticket, I do it with a relevant action).

• Clarifying Ticket Descriptions: Sometimes a ticket's description is too vague or you forgot to mention something, or you have to correct a wrong assumption (yes, all of that sometimes happens). After discovering the necessary technical details, I'll ask the agent to update it. This is a great practice for enriching the ticket with implementation details.

‼️ However, be mindful of when editing a description is appropriate.

• Good Practice (Clarification): Adding technical notes, like "The new field must be encrypted in the database using AES-256." This is the precise command used for ticket refinement:

Edit the description removing assumptions and adding only things in the code

• Bad Practice (Scope Creep): Changing the core requirement, like turning "Add a 'First Name' field" into "Add 'First Name' and 'Date of Birth' fields and a new validation flow." The latter should be a new ticket.

Jira ticket created with generic description, generated in a bundle with several tasks:

A different task, but this with detailed description after asking to improve it with code, links and relevant info:

5. From Jira Ticket to Code, and Beyond with Automation

TL;DR: For simple and well-scoped Jira tickets, you can ask the AI to generate the code just by providing the ticket link. This opens the door to automating entire parts of your development lifecycle.

For well-defined, simple tasks, you can go from a Jira ticket link to functional code in minutes. This is where we can start thinking about true workflow automation.

This works best for tasks like:

• Adding a new optional field to an API endpoint.
• Changing UI label text for clarity or rewording.
• Adding missing translations.
• Generating unit tests for a function or improving test coverage.

🔖 The prompt is as simple as

Implement the changes described in this Jira ticket: [link].

The most important thing is to ensure a good description in the ticket.

This leads to the next logical step: automation. For example, here is a powerful multi-action prompt that links code analysis, documentation, and task creation:

Document the endpoints of the [Legacy Service Name] Node.js project for migration. 

Follow these steps to generate a **Confluence** page and a **Jira** task. 

1. **Confluence** Page Documentation: 
Generate a new page at the URL: [link here] 
For each endpoint in the [Legacy Service Name] project, create a new section with a descriptive title. Within each section, provide the following details: Route, Method, Parameters, Response Example, OpenAPI Link. 
At the end of the page, create a sortable table with the following columns: Status, Method, Endpoint, and Link to openapi. Use the sortable table macro or a similar feature if available in **Confluence** to enable sorting. 

2. **Jira** Task Creation: 
Create a new **Jira** task with the following specifications: 
Parent Epic: [link here] 
Title: Endpoints to migrate from [Legacy Service Name] 
Description: Include a TLDR section with a brief summary of the task. After the TLDR, include the same table you generated for the **Confluence** page.

This is the next frontier: a truly automated, intelligent development environment.

6. Setting Up Your AI Cockpit: MCP Atlassian Integration

TL;DR: Install the specific Atlassian Marketplace Connect Program (MCP) agent/plugin in your preferred editor (Cursor, IntelliJ, VS Code) and authenticate with your Atlassian workspace.

As always, there are requirements, some steps to follow depending on the IDE you use, etc. Here you'll see the instructions for all the IDEs. Let's see the example for Cursor

A. Cursor

Since Cursor is built with AI capabilities from the start, the integration is often seamless. The Cursor agent uses Gemini 2.5 Pro as its underlying model for the deep reasoning and code generation tasks described. (you also can add it easily from the cursor mcp list).

1. Open Settings: Navigate to Settings (usually Cmd+, or Ctrl+,).

2. Find Integrations: Look for "MCP".

3. Connect Atlassian: Select the Atlassian integration option (Jira/Confluence) and follow the prompts to sign in with your Atlassian credentials. This connects the internal atlassian-mcp-server to your agent, granting it read access to your permitted documentation and ticketing.

Yes, if you have troubles installing the mcp in your ide, you can ask to your favourite model in your IDE copy pasting the errors or explaining the problems! Or, of course, you can comment in this post and we'll try to help

Conclusion

Integrating Atlassian's AI tools into your IDE isn't about replacing the developer. It's about augmenting our abilities by removing friction, having the developer focus on development, and avoid the satellite tasks that are repetitive and from what you learn little to nothing. By handling the overhead of documentation, task management, and context gathering, it allows us to dedicate our most valuable resource—our focused brainpower—to what we do best: building bold and ingenious software.

What are your favorite AI-driven workflows? Share them in the comments below!

AI created, Human-enhanced.

Daniel Artola.