How to use Claude Code for Jira - Complete integration guide
Every time you need to check a Jira ticket, you're breaking your flow. Browser tab. Search for the issue. Read the requirements. Copy the acceptance criteria. Back to your IDE. Context switch complete - and you've just lost 15 minutes of deep work.
This guide shows you how to connect Claude Code directly to Jira using the official Atlassian Rovo MCP server. We'll use API token authentication, which is stable and doesn't require re-authentication mid-session. The older OAuth/SSE approach is also covered briefly, but it's no longer recommended for daily Claude Code use — and the SSE endpoint itself is being retired after June 30, 2026.
You'll learn how to query tickets, create issues, and update statuses without ever leaving your terminal. More importantly, we'll walk through the exact workflow step-by-step, not just the setup.
Claude Code is Anthropic's command-line AI coding assistant that runs in your terminal with full codebase access. The Model Context Protocol (MCP) is what makes the Jira integration possible - it's an open standard that connects Claude to external tools and APIs.
For Jira specifically, the MCP server lets Claude query tickets, create issues, add comments, and transition statuses through natural language - all without leaving your terminal.
This tutorial uses the official Atlassian Rovo MCP server with API token authentication - the stable, recommended approach that doesn't disconnect mid-session. OAuth 2.1 is still available for interactive scenarios, but API tokens are better for command-line workflows.
If you're new to Claude Code, read our complete setup guide first. For Jira integration specifically:
Install Claude Code:
npm install -g @anthropic-ai/claude-codeVerify installation:
claude --versionYou'll need an Anthropic API key. Get one at console.anthropic.com.
Set your API key:
export ANTHROPIC_API_KEY='your-api-key-here'Add this to your ~/.bashrc or ~/.zshrc to persist across sessions.
Before connecting Claude Code, you need an API token for authentication.
Create your personal API token:
- Visit https://id.atlassian.com/manage-profile/security/api-tokens
- Click Create API token
- Give it a label (e.g., "Claude Code MCP")
- The system will show you the token - copy it immediately (you won't see it again)
- If your organization requires specific scopes, click Back and manually select scopes
Base64-encode your credentials:
You need to encode your email and API token together. Run this command (replace with your actual email and token):
echo -n "your-email@company.com:your-api-token-here" | base64Save the output - you'll use it in the next step.
Important: Your organization admin must enable API token authentication in the Atlassian Rovo MCP server settings. If it's disabled, you'll need to use OAuth 2.1 instead (covered later in troubleshooting).
Now configure Claude Code to use the Atlassian Rovo MCP server with your API token.
Using the new HTTP endpoint (recommended, stable):
Create or edit your Claude MCP configuration file:
- Mac/Linux:
~/.config/claude/mcp.json - Windows:
C:\Users\[username]\AppData\Roaming\Claude\mcp.json
Add this configuration:
{
"mcpServers": {
"atlassian-rovo-mcp": {
"url": "https://mcp.atlassian.com/v1/mcp",
"headers": {
"Authorization": "Basic YOUR_BASE64_ENCODED_CREDENTIALS"
}
}
}
}Replace YOUR_BASE64_ENCODED_CREDENTIALS with the base64 string you created in Step 2.
What this does:
- Connects to Atlassian's hosted Rovo MCP server at the new
/mcpendpoint - Authenticates using your API token (no browser-based OAuth flow needed)
- Registers Jira, Confluence, and Compass tools
- Stores configuration persistently - no re-authentication required
Important: The older /sse endpoint (https://mcp.atlassian.com/v1/sse) is deprecated and will stop working after June 30, 2026. Always use /mcp for new setups.
Start Claude Code:
claudeAsk Claude to list your Jira projects:
List my Jira projectsIf authentication succeeded, you'll see your Jira projects listed with their keys and names.
If you get an error, the most common issues are:
- "Unauthorized": Your API token may be incorrect, or API token authentication may be disabled by your org admin
- "Tool not found": The MCP server configuration wasn't loaded properly. Check your
mcp.jsonsyntax - Connection issues: Verify your organization's IP allowlisting settings if you use them
The API token approach doesn't have the session disconnection issues that plagued the old OAuth/SSE method - once configured, it works consistently.
We'll cover troubleshooting in depth later.
Before diving into examples, let's understand how Claude actually uses Jira tools. This is critical for writing effective prompts.
The interface is conversation itself - you don't interact with these tools through commands, menus, or special syntax; you simply talk to Claude the way you would talk to a knowledgeable colleague who has access to your systems.
When you ask Claude to interact with Jira, here's what happens:
- You send a natural language request: "Create a bug ticket for the login issue"
- Claude interprets your intent: Identifies that you need the
create_issueJira tool - Claude gathers required parameters: Project key, issue type, summary, description
- Claude may ask clarifying questions: "Which project should I create this in?"
- Claude calls the Jira API: Via the MCP server
- Claude returns formatted results: With the ticket number and URL
You never see the API calls - just the conversation.
Behind the scenes:
The Atlassian MCP server provides these core tools:
search_issues- Find issues using JQL or natural language filterscreate_issue- Create new tickets (bugs, tasks, stories)update_issue- Modify existing issuesadd_comment- Add comments to ticketstransition_issue- Move issues through workflow states (To Do → In Progress → Done)get_issue- Fetch full details for a specific issueget_project- Get project metadata and configuration
Tool Categories:
Example workflow:
search_issues→ Find "login bugs"get_issue→ Read ENG-123 detailsadd_comment→ "Working on fix"transition_issue→ "To Do" → "In Progress"- Code implementation...
add_comment→ "Ready for review"transition_issue→ "In Progress" → "In Review"
MCP servers can expose resources that you can reference using @ mentions - type @ in your prompt to see available resources from all connected MCP servers, and resources appear alongside files in the autocomplete menu.
The key insight: Be specific about context, but let Claude handle the API details.
Good prompts:
- "Create a high-priority bug in project ENG for the login timeout issue. Users are getting logged out after 5 minutes instead of 30."
- "Show me all unresolved issues assigned to me in the current sprint"
- "Add a comment to ENG-123 with the test results from the last run"
Bad prompts:
- "Create a ticket" (Missing: which project? What type? What's it about?)
- "Fix the bug" (Claude doesn't know which bug)
- "Update status" (Which issue? What status?)
Claude can infer some details from context, but explicit project keys, issue numbers, and descriptions save time.
Prompt Quality Comparison:
| ❌ Bad Prompt | ✅ Good Prompt |
|---|---|
"Create a ticket" | "Create a high-priority bug in project ENG for the login timeout issue. Users are getting logged out after 5 minutes instead of 30." |
"Fix the bug" | "Add a comment to ENG-123 with the fix approach: implement rate limiting using express-rate-limit library" |
"Update status" | "Transition ENG-456 from To Do to In Progress" |
"Show my tasks" | "Show me all unresolved issues assigned to me in the current sprint for project ENG" |
Key Principle: Be specific about what (action), where (project/ticket), and why (context). Let Claude handle the how (API details).
Let's walk through a real workflow: taking a Jira ticket and implementing it using Claude Code.
End-to-End Workflow:
You're assigned ticket ENG-456: "Add rate limiting to login endpoint". Your task is to understand the requirements, implement the feature, write tests, and update the ticket.
Start Claude in your project directory:
cd ~/projects/backend-api
claudeAsk Claude to pull the ticket:
Show me the details for ENG-456Claude uses the get_issue tool and returns:
Issue: ENG-456 - Add rate limiting to login endpoint
Type: Story
Priority: High
Status: To Do
Assignee: You
Description:
Implement rate limiting on the POST /auth/login endpoint to prevent brute
force attacks. Limit to 5 login attempts per IP address per 15-minute window.
Acceptance Criteria:
- Login endpoint rejects requests after 5 attempts from same IP
- Returns 429 status code with Retry-After header
- Rate limit resets after 15 minutes
- Does not affect successful logins
- Add integration tests for rate limit behavior
Story Points: 3
Sprint: Sprint 23Claude now has full context. You didn't need to open a browser.
Ask Claude to create a plan:
Based on this ticket, what files do we need to modify and what's the implementation approach?Claude reads your codebase and responds:
I'll help implement rate limiting for ENG-456. After reviewing the code:
Files to modify:
1. src/routes/auth.ts - Login route handler
2. src/middleware/rateLimiter.ts - New middleware (needs creation)
3. package.json - Add express-rate-limit dependency
4. tests/integration/auth.test.ts - Add rate limit tests
Implementation approach:
- Use express-rate-limit library (industry standard)
- Create middleware that tracks attempts by IP
- Apply to login route only
- Return 429 with Retry-After header
- Add Redis store for production (optional but recommended)
Should I proceed with this approach?Notice: Claude read your existing code structure and suggested a plan that fits your project.
Approve the plan:
Yes, proceed. Use in-memory store for now, we'll add Redis later.Claude implements the changes:
- Installs
express-rate-limitdependency - Creates
src/middleware/rateLimiter.tswith 15-minute window, 5-attempt limit - Updates
src/routes/auth.tsto apply middleware to login route - Adds integration tests covering:
Ask Claude to run the test suite:
Run the auth integration testsClaude executes:
npm test -- tests/integration/auth.test.tsIf tests pass:
✓ Login rate limiting › should allow 5 login attempts (45ms)
✓ Login rate limiting › should block 6th login attempt with 429 (38ms)
✓ Login rate limiting › should include Retry-After header (41ms)
All tests passed!If tests fail, Claude debugs automatically by reading error output and adjusting the implementation.
Now that the feature is complete, update the ticket:
Add a comment to ENG-456 with:
- Implementation complete
- Used express-rate-limit library
- All acceptance criteria met
- Tests passing
- Ready for code review
Then transition the ticket to "In Review"Claude makes two API calls:
- Adds comment (via
add_commenttool) - Transitions status (via
transition_issuetool)
Response:
Comment added to ENG-456:
Implementation complete:
- Used express-rate-limit library (industry standard)
- Applied to POST /auth/login endpoint only
- Limits to 5 attempts per IP per 15-minute window
- Returns 429 status with Retry-After header
- All acceptance criteria met
- Integration tests passing (3 new test cases)
- Ready for code review
Ticket transitioned: To Do → In Review
View ticket: https://your-company.atlassian.net/browse/ENG-456The entire workflow - reading the ticket, implementing the feature, testing, and updating Jira - happened without leaving your terminal.
Once you've mastered the basics, here are more advanced patterns.
Advanced Pattern Library:
You found a bug while coding:
I just discovered that the password reset email is using an expired template.
Create a high-priority bug in project ENG. Include:
- Current template path: src/email/templates/password-reset-old.html
- Expected path: src/email/templates/password-reset.html
- Impact: Users see old branding in reset emailsClaude creates the ticket with all context included, formatted properly for your team.
Show me all unresolved issues in project ENG that are in the current sprint,
grouped by assignee and sorted by priorityClaude uses search_issues with JQL filters to return a formatted report - perfect for standup meetings.
After committing code:
I just committed the rate limiting feature with commit hash abc123.
Add a comment to ENG-456 with the commit hash and a link to GitHub.Claude formats the comment with proper links, maintaining your team's documentation standards.
Find all issues in project ENG with label "tech-debt" that haven't been
updated in 30 days. List them with last update date.Claude processes the query and returns actionable data for backlog grooming.
The API token authentication method is stable and reliable. Here's how to handle common setup and connection issues.
Jira MCP Troubleshooting Decision Tree:
Symptoms: Claude can't connect to the Atlassian Rovo MCP server, or you get "Unauthorized" errors.
Check these first:
1. Verify API token authentication is enabled
Your organization admin must enable API token authentication in Atlassian settings:
- Go to Atlassian Administration
- Select Apps > AI settings > Rovo MCP server
- In the Authentication section, ensure API token is turned on
If it's disabled, you'll need to either ask your admin to enable it or use OAuth 2.1 authentication instead (see Issue 5 below).
2. Verify your base64 encoding
Re-encode your credentials to ensure they're correct:
echo -n "your-email@company.com:your-api-token-here" | base64The -n flag is critical - it prevents a newline character that would break authentication.
3. Check your mcp.json configuration
Ensure your configuration file has the correct format:
{
"mcpServers": {
"atlassian-rovo-mcp": {
"url": "https://mcp.atlassian.com/v1/mcp",
"headers": {
"Authorization": "Basic YOUR_BASE64_STRING_HERE"
}
}
}
}Common mistakes:
- Missing
Basicprefix in the Authorization header - Extra spaces or newlines in the base64 string
- Using the old
/sseendpoint instead of/mcp
4. Verify API token scopes
When creating your API token, you may need to manually select scopes if your organization restricts them. Go back in the token creation flow and ensure you've granted access to:
- Jira (read/write as needed)
- Confluence (read/write as needed)
- Compass (if you use it)
Symptoms: Claude doesn't show Atlassian tools, or mcp.json changes don't take effect.
Fixes:
- Verify file location:
- Mac/Linux:
~/.config/claude/mcp.json - Windows:
C:\Users\[username]\AppData\Roaming\Claude\mcp.json
- Mac/Linux:
- Check JSON syntax: Use a JSON validator to ensure your configuration is valid. Common mistakes:
- Missing commas between entries
- Extra trailing commas
- Unmatched braces or quotes
- Restart Claude Code: Configuration changes only load when Claude starts:
# Exit current session
exit
# Start fresh
claudeSymptoms: Authentication works, but tool calls fail with permission errors.
Fix:
If your organization uses IP allowlisting for Atlassian Cloud products, MCP server requests must come from allowed IP addresses.
For organization admins:
- Go to Atlassian Administration
- Check Security > IP allowlist settings
- Ensure the IP addresses where Claude Code runs are allowed
For users: If you're working from a new location (home, coffee shop, etc.) and suddenly can't access Jira through Claude, your IP may not be allowlisted. Contact your admin to add it.
Important: IP allowlisting applies to both OAuth 2.1 and API token authentication methods.
Symptoms: Jira queries take 20+ seconds or timeout completely.
Fixes:
- Increase MCP timeout:
MCP_TIMEOUT=30000 claude- Be more specific in queries - avoid broad searches:
# Slow
"Show me all Jira issues"
# Fast
"Show me my assigned issues from the last week in project ENG"- Check Jira API rate limits - your organization may have rate limiting enabled
When to use this: Your organization admin has disabled API token authentication, or you prefer interactive OAuth flows.
Important: The old /sse endpoint is deprecated and will stop working after June 30, 2026. If you must use OAuth, use the /mcp endpoint with mcp-remote proxy.
Setup with OAuth 2.1:
- Install mcp-remote (Node.js proxy for OAuth):
npx mcp-remote https://mcp.atlassian.com/v1/mcp- Follow the OAuth flow: The tool will open your browser for authentication
- Keep the session running: OAuth tokens are session-based and may expire
Configuration for Claude Desktop (if using the desktop app):
{
"mcpServers": {
"Atlassian-Rovo-MCP": {
"command": "npx",
"args": ["-y", "mcp-remote@latest", "https://mcp.atlassian.com/v1/mcp"]
}
}
}Limitations of OAuth 2.1:
- Tokens may expire during long sessions, requiring re-authentication
- Requires browser access for the OAuth flow
- Less suitable for headless/automated workflows
- The older SSE transport is being retired
Recommendation: If possible, ask your admin to enable API token authentication for a more stable experience.
If you want a more integrated visual development experience with AI-powered coding, Builder.io Fusion offers a modern alternative with Jira integration built-in.
Fusion lets you start builds where work happens: @mention Builder in Slack or assign Jira tickets, get progress updates as the agent works, then jump into Fusion to review and ship through your existing pipeline.
Unlike Claude Code (which is terminal-only), Fusion provides:
- Visual IDE - See changes rendered in real-time as AI codes
- Built-in Jira MCP - No setup, no authentication issues
- Team collaboration - Multiple roles (PM, designer, developer) in one workspace
- Direct GitHub integration - Creates PRs, manages branches
- Figma plugin - Import designs directly into code
Once connected, the AI automatically leverages these services when relevant to your tasks, with MCP servers enhancing Projects capabilities in the background - for example, when working on a development task, Projects can automatically access related Jira tickets, understand the requirements, and even implement fixes based on the ticket context.
The workflow is simpler than Claude Code:
- Connect Jira - One-click OAuth in Fusion settings, no CLI commands
- Assign a ticket - Jira ticket assigned to you appears in Fusion
- AI implements - Fusion AI reads the ticket and builds the feature
- Visual review - See the implementation rendered live
- Create PR - One-click pull request creation
Key difference: Builder Agent integrates with Slack and JIRA, so you can trigger work directly from Jira without even opening Fusion.
Use Claude Code when:
- You prefer terminal-only workflows
- You want complete control over every file change
- Your team isn't collaborating on the same feature simultaneously
- You're comfortable with configuration files and command-line tools
Use Builder.io when:
- You want visual feedback as code is written
- Multiple team members need to collaborate (PM, designer, dev)
- You're building UI-heavy features
- You prefer GUI-based setup over configuration files
- You need Figma-to-code workflows
Best of both worlds: Use Claude Code for backend/API work and Fusion for frontend features with Jira tickets.
Comparison: Claude Code vs Builder.io Fusion
| Feature | Claude Code | Builder.io Fusion |
|---|---|---|
Interface | Terminal only | Visual IDE + AI chat |
Jira Setup | Manual config file + API token | One-click OAuth in UI |
Real-time Preview | None (terminal output) | Live rendering as code changes |
Team Collaboration | Single developer | Multi-role (PM, designer, dev) |
Code Review | Text diffs in terminal | Visual diffs + rendered output |
GitHub Integration | Via CLI commands | Built-in PR creation |
Figma Import | Not supported | Direct Figma plugin |
Best For | Backend/API work, CLI lovers | Frontend/UI features, visual review |
Jira Trigger | Manual: Start Claude → ask | Auto: Assign Jira ticket → builds |
Authentication Stability | Stable (API token, no re-auth) | Stable (persistent tokens) |
Recommendation: Use Claude Code for backend work where visual feedback isn't critical. Use Fusion for frontend features where you want to see rendered output and collaborate with non-technical team members.
Fusion's Team plan includes the Builder Agent in Slack and JIRA, custom MCP servers, and built-in MCP servers. The Free tier supports basic GitHub integration, and Pro tier adds pay-as-you-go usage.
For teams already using Jira extensively, the Team plan provides a visual, collaborative workspace that bridges product, design, and engineering in one platform.
Regardless of whether you use Claude Code standalone or Builder.io Fusion, these patterns improve your workflow.
Claude works better when you're explicit:
# Good
"Create a bug in project ENG for the login issue"
# Better
"Create a high-priority bug in ENG for login timeout. Users report being logged out after 5 minutes instead of 30."Even when using Claude to update tickets, maintain the habit:
git commit -m "feat: Add rate limiting to login endpoint (ENG-456)"This creates an audit trail outside of Jira.
Don't try to write Jira Query Language yourself:
# Instead of:
"Search with JQL: project = ENG AND status = 'In Progress' AND assignee = currentUser()"
# Just ask:
"Show me my in-progress tasks in project ENG"Claude translates natural language to JQL automatically.
For recurring ticket types, give Claude a template:
When I say "create API bug", use this template:
- Type: Bug
- Priority: High
- Labels: api, backend
- Component: API
- Include environment details and stack trace in descriptionClaude remembers this within the session (or use Claude's persistent memory features for cross-session templates).
The most powerful pattern is connecting code and tickets:
Look at src/auth/login.ts and check if the implementation matches
the acceptance criteria in ENG-456Claude reads both the code and the ticket, then reports on gaps.
Claude Code is Anthropic's command-line AI coding assistant that runs in your terminal with full access to your codebase. It connects to Jira through the Model Context Protocol (MCP) — an open standard that lets Claude communicate with external tools and APIs using natural language. Once the Atlassian MCP server is configured, Claude can query tickets, create issues, add comments, and transition statuses through conversation, without you ever opening a browser tab or switching context out of your terminal.
The Atlassian MCP server exposes six core tools: searching issues via JQL or natural language, creating new tickets (bugs, tasks, stories), updating existing issues, adding comments, transitioning issues through workflow states (To Do → In Progress → In Review → Done), and fetching full details for a specific issue. That covers the vast majority of what a developer needs to manage their work queue during a coding session — all without leaving the terminal.
Install Claude Code via npm install -g @anthropic-ai/claude-code, then run:
claude mcp add --transport sse atlassian https://mcp.atlassian.com/v1/sseStart Claude with claude, type /mcp to verify the server loaded, and complete the OAuth flow when prompted. The first authentication opens a browser window — complete it there, then return to your terminal. After that, you can start querying Jira immediately.
This is a widely reported issue. The Atlassian MCP server uses short-lived OAuth tokens that Claude Code can't refresh, so it works for a bit and then fails — and often gets stuck in a permanently failed state. Atlassian Community Multiple teams report having to re-authenticate every one to four hours. The root cause is architectural: the SSE-based OAuth flow was designed for interactive browser sessions, not persistent terminal connections.
Yes, and this is the most important recent update to the setup described in this article. Atlassian has now announced API token authentication for the Atlassian Rovo MCP Server — a new way to connect without an interactive consent screen, designed specifically for machine-to-machine and automated use cases. Atlassian Community Instead of the OAuth browser flow, you generate a personal API token from your Atlassian account security settings and pass it as a Basic Auth header. This is the preferred approach for terminal-based tools like Claude Code where a human can't keep clicking through OAuth prompts. The new endpoint to use is https://mcp.atlassian.com/v1/mcp (not the old /v1/sse).
Yes. After June 30, 2026, usage of https://mcp.atlassian.com/v1/sse as a server endpoint will no longer be supported. Atlassian recommends updating any configured custom clients to point to /mcp: https://mcp.atlassian.com/v1/mcp. Atlassian Support If you set up your integration using the SSE URL described in older guides — including the one this article was based on — you should migrate to the new endpoint and switch to API token authentication before that deadline.
It matters if you're running a self-hosted or community MCP server. The old search endpoint /rest/api/3/search was deprecated and traffic to it was blocked after October 31, 2025. The updated endpoint is /rest/api/3/search/jql. GitHub The official Atlassian Rovo MCP server handles this transparently, but community-built MCP servers may need to be updated if they haven't migrated yet. If you're seeing unexpected search failures on a self-hosted setup, this is the likely cause.
The acli (Atlassian CLI) approach replaces the MCP server entirely with a locally authenticated command-line tool. You install it, authenticate once via acli auth login, and those credentials persist indefinitely without re-authentication. You then write a small wrapper shell script and give Claude instructions to use it. This approach is more stable than the MCP OAuth flow because it uses standard API authentication stored locally, not short-lived SSE tokens. It's worth considering if you're hitting frequent disconnections and the new API token MCP authentication doesn't resolve them.
Three main failure modes come up repeatedly. First, "Connection closed" — the SSE connection dropped; re-run /mcp and authenticate again. Second, "Unauthorized" — the OAuth token expired; authenticate again. Third, "Tool not found" — the MCP server isn't loaded, usually because it was added to the wrong scope; verify with claude mcp list and re-add if needed. For teams on the old SSE endpoint, switching to the new /v1/mcp endpoint with API token auth resolves the first two failure modes entirely, since the tokens don't expire mid-session.
The principle is: be specific about what, where, and why — and let Claude handle the API details. Weak prompts like "create a ticket" or "show my tasks" are missing enough context that Claude either has to ask clarifying questions or make assumptions. Strong prompts include the project key, the issue number if referencing an existing ticket, the priority, and enough description of the problem that Claude can write a useful summary and description. For example: "Create a high-priority bug in project ENG for the login timeout issue. Users are being logged out after 5 minutes instead of 30. Include steps to reproduce." You also never need to write JQL yourself — just describe what you want in plain English and Claude will translate it.
The workflow the article walks through — and it genuinely works — is: start Claude in your project directory, ask it to pull a ticket by key, ask it to plan the implementation based on what it reads in your codebase, approve the plan, let it implement and run tests, then ask it to add a comment and transition the ticket status when you're done. The entire loop from reading requirements to updating Jira happens without leaving the terminal. The key insight is that Claude has simultaneous access to your codebase and your Jira instance, so it can cross-reference the acceptance criteria against the actual code it writes — something no amount of browser-tab-switching achieves.
Claude Code is the right choice for developers who prefer terminal-only workflows, want full control over every file change, and are primarily working on backend or API features where visual output isn't relevant. Builder.io makes more sense when you're building UI-heavy features, need multiple team roles (designers, PMs, developers) working on the same task, want to see rendered output as code is generated, or want zero-config Jira integration without managing MCP authentication. A reasonable split for many teams: Claude Code for backend work, Builder for frontend features where the visual feedback loop matters.
Having Claude Code connected to your Atlassian workspace means your AI assistant can ride shotgun and help you be more efficient - no more browser tabs, no more context switching between Jira and your IDE.
The setup is straightforward:
- Install Claude Code
- Create an Atlassian API token
- Configure the Atlassian Rovo MCP server with API token authentication
- Start using natural language to manage tickets
With API token authentication, the connection is stable - no mid-session disconnections, no repeated OAuth flows. Just configure once and you're set.
The future isn't about memorizing Jira shortcuts or mastering JQL syntax - it's about having natural conversations, and with the Atlassian Rovo MCP server in Claude Code, that future is already here.
Ready to eliminate those browser tabs? Start with the API token setup above, and if you want visual coding with team collaboration, check out Builder.io for a modern alternative that brings Jira, Figma, and GitHub into one workspace.
