Jira plugins

Manage the full employee lifecycle — recruiting, onboarding, performance reviews, compensation analysis, and policy guidance — by generating structured plans, reports, and documents from HR data and connected tools like Notion, Slack, and Jira.

Automate sales prospecting, outreach, and pipeline management by researching leads, generating call prep and follow-up, creating competitive battlecards and assets, forecasting deals, and analyzing pipeline—with integrations to CRM, enrichment, and collaboration platforms.

Automate legal contract review, NDA triage, compliance checks, legal briefings, meeting prep, e-signature preparation, and vendor agreement tracking, with integrations to Slack, DocuSign, Jira, and Box.

Manage the full product lifecycle from Claude: write feature specs and PRDs, plan roadmaps with prioritization frameworks, synthesize user research into actionable themes, run competitive analyses via web research, review product metrics, plan sprints with capacity estimation, and generate stakeholder updates—all while pulling context from connected project management, analytics, collaboration, and design tools.

Audit designs for WCAG compliance, critique UI usability, generate developer handoff specs, manage design systems, synthesize user research, write UX copy, and connect to Figma, Notion, Slack, Asana, Jira, Linear, and Intercom to centralize design workflows.

Run structured engineering workflows — standups, code reviews, architecture decisions, incident response, debugging, and technical documentation — with optional integrations for GitHub, Notion, Slack, Asana, Linear, Jira, PagerDuty, and Datadog.

Manage tasks in TASKS.md with Active/Waiting/Someday/Done sections, sync with GitHub Issues, and connect to project management tools (Linear, Jira, Asana, Monday.com, ClickUp), Notion, and Slack. Build persistent memory for people, projects, and internal terms.

Manage business operations including capacity planning, change management, compliance tracking, process documentation, risk assessment, vendor evaluation, and runbook generation, with integrations to Notion, Slack, Asana, and Atlassian for project management and communication.

Triage support tickets, research customer context across CRM and chat tools, draft responses and knowledge base articles, and escalate issues with structured briefs—all integrated with Slack, Jira, Notion, and Intercom.

Query chat, email, documents, task trackers, and wikis in a single search, with decomposed sub-queries and synthesized, cited answers across all connected enterprise tools.

Automatically discovers brand materials across Notion, Confluence, Google Drive, Box, SharePoint, Figma, Gong, Granola, and Slack, distills them into enforceable AI guardrails, and applies brand voice to sales and marketing content like emails, proposals, and pitch decks with compliance validation.

Search Jira and Confluence, create and triage issues, manage sprints, generate backlog from spec pages, produce status reports, and build sprint dashboards — all within your development workflow.

Orchestrate complex developer task workflows via CLI commands: plan executions with agents, search and manage tasks across statuses, sync status with git commits, log progress to Jira/GitHub/Obsidian, generate reports, and resume interrupted orchestrations.

Automate GRC engineering workflows: map IaC (Terraform, Kubernetes, CloudFormation) to compliance controls (SOC2, NIST, ISO27001), generate policy-as-code (Rego, Sentinel, Checkov), collect audit evidence from AWS/Azure/GCP/K8s via scripts, scan IaC/PRs for violations with fixes, test control effectiveness, resolve framework conflicts, and transform risks into Jira tickets.

Analyze OpenShift team and component health by listing teams/components from mappings, querying JIRA for bug summaries and raw data, fetching regressions for grading and reports, scanning GitHub repos for CodeRabbit config compliance and adoption metrics, and automating fix PRs.

Sets up a project for AI-assisted development with optimized CLAUDE.md files, coding guidelines, formatter hooks, and code-quality agents — then guides structured brainstorming, spec-driven design, TDD cycles, code review, refactoring, test coverage, and git workflows (branching, commit, PRs) tailored to the actual codebase.

Manage Jira tickets directly in your IDE: create issues interactively with project prompts, search via JQL or text, fetch details with checklists and comments, add markdown-formatted comments, start progress with auto-comments, validate acceptance criteria via evidence checks, and transition to Done—all powered by official Atlassian MCP server with zero-config OAuth.

Automate product execution workflows: generate daily/weekly Amplitude briefs on metrics/anomalies, synthesize meetings into action items/DRIs, draft release notes from Jira/GitHub issues, stakeholder updates, knowledge base fixes, and stress-test ideas into design docs via skills and commands.

Manages Jira issues (search, create, update, transition, comment, log work, sprints) directly from the command line, auto-detects issue keys in URLs, and converts Markdown to Jira wiki markup with validation and templates.

Automate JIRA operations conversationally with 14 skills powered by jira-as CLI: manage issues, agile workflows, time tracking, bulk updates, project admin, and ITSM service desks. Setup connections, discover project metadata and skills, plus audit skill documentation accuracy using reviewer agents and commands.

Sync task trees between Jira and the beads issue tracker with bidirectional synchronization — import issues, subtasks, epics, and linked issues from Jira, then push local beads state back to Jira.

Enforce a structured, context-driven development workflow: spec and plan before coding, track progress with TDD, review code against architecture, manage incidents, and gate deployments with checklists.

Transform Obsidian vaults into a queryable Second Brain by ingesting content from Confluence, Google Docs, GitHub, and local files, then auto-managing entities, backlinks, and sync with external sources.

Automate end-to-end product management workflows for discovery (personas, market sizing, competitor scans), build (PRDs, user stories, roadmaps, prioritization), measure (A/B tests, feedback/metrics analysis), and communicate (stakeholder updates, release notes, decision docs) using 20 specialized Claude Code skills that output structured Markdown files, tables, and Python/Bash analyses.

Drives a complete feature-development workflow from Slack — clarify, design, plan, implement, PR, and test — using the /process command with optional task-manager integration (Linear, Jira, GitHub Issues, Notion).

Review product launches, marketing claims, and PRDs for compliance with Turkish product law (KVKK, advertising, e-commerce). Automates legal triage, risk assessment, and integration with Jira/Linear/Asana for launch radar.

Delegate SDLC security workflows to AI agents that generate compliance reports with metrics visualizations and GitHub/Jira integrations, perform multi-jurisdiction privacy assessments like GDPR/CCPA, design behavioral enforcement strategies for team adoption, and architect zero-trust systems with threat modeling.

Ingest documents from local files, URLs, GitHub, Confluence, and Jira into a knowledge base, then query it with hybrid search and cited answers that flag gaps, conflicts, or staleness.

Orchestrate the entire AI-assisted development lifecycle with enforced quality gates at every stage—from ticket creation and brainstorming through TDD implementation, parallel code review, PR management, and postmortem analysis.

Supercharge Claude Code with a plugin ecosystem: diagnose CI/CD failures, investigate incidents, review code and architecture, design cloud infrastructure, optimize costs, and automate TODO workflows—all through reusable agents and skills.

Orchestrates structured, multi-phase software development workflows with interactive planning, design analysis, code review, issue tracking (Jira/Linear), commit management, and pull request automation.

Automate Rootly incident management in Claude: create/triage/resolve incidents, manage alerts/workflows/services/on-call schedules, generate blameless postmortems with AI analysis, track action items, and check service health/status.

An AI-powered operating system for product managers that automates the entire PM workflow — from strategy, OKRs, and PRDs to prioritization, sprint planning, launch checklists, and stakeholder updates — by reading your codebase, knowledge files, and project management tools.

Build, deploy, troubleshoot, and secure Atlassian Forge apps — from scaffolding and manifest configuration to deployment, cost optimization, and automated security review. Includes MCP connections to Atlassian's Forge and ADS servers for remote tooling.

Automate end-to-end feature development in Claude Code: route ideas/bugs/issues by complexity to swift/standard/thorough AI workflows for spec generation via multi-agent debate, parallel task execution with reviews, git branching/PR creation, PR feedback/fixes, batch multi-feature planning/implement/merge, codebase assessment, and retroactive doc catch-up.

Install, initialize, configure, and update Pappardelle workspaces in Git repositories using interactive slash-command wizards and TUIs. Set up VCS hosts like GitHub/GitLab, Jira integration, profiles, hooks, keybindings; generate YAML configs; monitor active worktree spaces by status (FIRE, WORKING, IDLE) for Claude development sessions.

Discover brand materials across Notion, Confluence, Google Drive, Box, SharePoint, Slack, Gong, and Granola, then generate LLM-ready brand guidelines and validate AI-generated content like sales emails and marketing copy for voice compliance.

Orchestrate Harness CD deployment pipelines using state-machine workflows with agentic patterns. Initiate deployments from git repos/branches/envs, monitor status/history, validate Kubernetes/Helm configs and prereqs, approve production releases, and execute safe rollbacks across environments.

Develop, debug, and maintain OpenStack Kubernetes operators by analyzing must-gather reports and Zuul CI logs, reviewing PRs against conventions, applying Go code best practices, validating CVEs, and planning features or bug fixes with Jira integration for structured task execution.

Integrates with Jira to refine tickets into Gherkin-format acceptance criteria, generates a 3-tier documentation system from codebase analysis, and guides product managers in writing elaboration-ready epics with KPIs and rollout plans.

Drive structured software design and delivery: stress-test plans against domain models, generate PRDs, decompose specs into actionable issues, guide TDD with red-green-refactor loops, deepen module design for testability, and journal work from git history — all while maintaining living documentation (CONTEXT.md, ADRs) and handing off context across sessions.

Automate product management workflows by generating PRDs, OKRs, outcome-focused roadmaps, user stories, sprint plans, retrospectives, stakeholder maps, prioritization analyses, pre-mortems, release notes, meeting summaries, test scenarios, and realistic fake datasets directly from ideas, tickets, specs, or designs in your IDE.

Automate end-to-end feature development from Linear/Jira issues using a structured workflow: create git branches, define audited requirements/specs, implement code increments with multi-agent teams, run code reviews/tests/security checks, manage PRs until approval, and update issue status.

Automate Figma-to-Jira design handoff: analyze frames against epics/Confluence/Google Docs for scope categorization and behavior questions, post Q&A as pinned comments, generate/refresh shell stories, and write full Gherkin user stories with AC/NFRs.

Enterprise Jira orchestration with 81 agents, 16 teams, and 46 commands for automating the full issue lifecycle — triage, sprint planning, subtask decomposition, code implementation, PR management, Confluence documentation, and Harness CI/CD deployments — with multi-agent reasoning patterns and compliance tracking.

Enforce ticket-driven Git development by validating GitHub, GitLab, Jira, or Linear tickets in commit messages and branch names before commits; document project intentions, explorations, and learnings in structured INTENT.md files; apply guided workflows with GitHub Flow, Git Flow branching strategies, conventional commits, and PR templates.

Triage issues end-to-end on Azure DevOps and Jira across all archetypes (Bug, Incident, Story, Feature, Task, Spike) with a single diff-and-confirm gate that investigates, refines, assigns, sets metadata, links related work, and posts Slack/Teams summaries.

Generate Google-SRE-style blameless incident postmortems from a tracker URL. The agent gathers evidence from Slack, Datadog, and pull requests, builds a chronological timeline with evidence tags, and writes a markdown document with summary, impact, timeline, root cause, and action items.

Automate Jira issue management, Git release and conflict resolution, performance analysis and optimization, and Chinese documentation tasks using structured multi-stage workflows.

Automates the generation of decision-ready project management artefacts from raw inputs (briefs, transcripts, Jira data, messages) across the delivery lifecycle: charters, PRDs, roadmaps, sprint plans, release checklists, and executive updates.

Run code review, security audits, type analysis, and test validation on diffs and PRs; write structured specs and documentation; enforce API contracts; manage Jira tickets; and evaluate UX surfaces for accessibility, performance, and design quality.

Auto-detects Azure DevOps or Jira MCP and routes issue read/write verbs through a vendor adapter with a diff-and-confirm gate, enabling investigation of bugs and incidents by searching chats, docs, Datadog, and the codebase to produce evidence-tagged reports.

Decompose technologies, market signals, or global events into 6 structured layers of business insights using Socratic questioning, generating value chain diagrams, mindmaps, research notes, and PDFs. Autonomously discover Indian proxy companies across value chains. Manage research libraries, domain knowledge, watchlists with monitoring alerts, and integrate personal sources like Notion, Drive, Gmail, Jira for compliant analysis.

Automate end-to-end AI-driven engineering workflows: refine Linear issues into PRDs and task plans, execute implementations in isolated git worktrees, finalize GitHub PRs with conflict resolution and merges, capture learnings in docs, and enable browser automation—all synced to Linear.

Automate the full Jira development lifecycle within Claude Code: create and discover issues, design approaches, implement code, run tests, review changes, create pull requests, merge branches, and generate status reports, all synced with Jira project management.

Manage HyperFleet Jira sprints and tickets via CLI: validate readiness and completeness, estimate story points from complexity analysis, create structured issues with acceptance criteria, track assignments and progress across statuses, generate weekly updates and health reports, audit triage readiness, and verify code implementation against criteria.

Automate full bug lifecycle workflow syncing Git repos with Notion databases: invoke /bug-start to create templated entries with git-detected project/owner, log investigations with logs/SQL/screenshots/judgments, extract fix details from git diffs on 'bug-close' commits for root cause updates, reopen closed bugs via git matching/search, setup Notion DBs/projects/knowledge base on first run.

Auto-generate and maintain CLAUDE.md files with project-aware context, query NIH-funded research projects and publications, extract metadata from scientific repositories, and manage Synapse biomedical data platform operations via CLI or Python SDK.

Automate end-to-end git workflows with semantic commits, branch creation, and GitHub PRs; analyze repos to generate CLAUDE.md and detailed docs; research technical docs and APIs; refactor code for readability and simplicity; create specs from JIRA/Linear issues; optimize CLAUDE.md for AI models; coordinate multi-agent tasks.

Automates developer workflows with specialized agents for debugging, CI/CD, database migrations, code reviews, and security audits, plus commands that aggregate daily standups and weekly reviews from Git, GitHub, Jira, and Notion.

Connect a sales intelligence MCP server and 9 remote connectors (HubSpot, Slack, MS365, Notion, Fireflies, Clay, ZoomInfo, Atlassian, Close) so Claude can pull B2B data, enrich leads, transcribe meetings, and manage CRM workflows in one conversation.

Automate standardized GitHub PR reviews by validating linked JIRA tickets, enforcing HyperFleet architecture standards, analyzing code diffs and existing comments, and delivering interactive recommendations for improvements.

Automate autonomous GitHub workflows by decomposing tasks into structured issues with acceptance criteria, batch-reviewing and squash-merging dependent PR stacks, resolving merge conflicts and CI failures in isolated worktrees, handling PR feedback with fixes and descendant tasks, and generating Jira subtasks from context or investigations.

Orchestrate the full product development lifecycle within Claude Code using phase-aware multi-agent teams that handle design debates, parallel implementation, security reviews, deployment readiness checks, and post-release monitoring — all with guardrails, state recovery, and shared knowledge capture.

Transform raw ideas, todos, brainstorms, and feature requests into structured Agile plans by uncovering hidden requirements and applying design patterns. Decompose into epics, user stories, technical tasks; generate Markdown plans; create fully-contextual tickets in Linear or Jira; review test suites and git changes against task criteria for quality and compliance.

Query your Context Engine knowledge graph from an agent using ctx-cli to investigate services and dependencies, compute blast radius of changes, search entities, manage Jira and Linear issues, and assess change risks for safer deployments.

Enforce a disciplined end-to-end development lifecycle: plan with acceptance tests and TDD, verify designs against Figma, run quality gates before commits, capture documentation drift, and generate release-aware PRs and changelogs.

Streamline HyperFleet development workflows by generating conventional commit messages from git changes with JIRA tickets, analyzing code diffs across components to identify architecture doc update needs, and designing black-box E2E test cases for cluster lifecycle features using epics, repo tests, and docs.

Plugin that watches email, meetings, Slack, and issue trackers across 20+ services, automatically extracting tasks, tracking updates, and keeping a kanban board current so you can stay focused on shipping.

Automate pull request quality gates with an ensemble of agents that perform security scans for SQLi/XSS vulnerabilities, enforce code maintainability and DoD criteria, execute Jest/Vitest/Pytest/RSPEC tests, analyze coverage and flakiness, triage bugs from GitHub/Jira, and orchestrate debugging/fixes for merge approval.

Capture, govern, promote, and apply session knowledge using a five-phase lifecycle. Automatically extract insights and decisions, manage backlogs, generate pre-mortems and retrospectives, and enforce change hooks — all persisted to a tag-indexed knowledge base accessible via slash commands.

Orchestrate AI-assisted development workflows with specialized agents for task planning, code review, testing, documentation, and infrastructure. Manage work items, automate git and Jira operations, and enforce quality standards through TDD, architecture decisions, and automated checks.

Interactively create technical specifications for new features or projects: gather requirements, explore codebases, run planning interviews, draft Mermaid diagrams, iterate with expert review. Review specs using expert personas to identify gaps, risks, verify against repositories, discuss resolutions, and apply updates.

Manage Jira workflows from your terminal: list sprint and assigned issues in markdown tables, create/update/close/link issues via bash scripts. Triggers automatically on keywords like 'sprint' or 'issues', or Jira keys like ACM-xxx for quick actions without leaving the shell.

Automate safe, conventional Git commits after task completion: detects tickets from GitHub, GitLab, or Jira; generates semantic messages; runs branch protection checks; requires user confirmation before local commit—never pushes to remote.

Automate Jira issue management and querying as a local workflow, running via Podman container with authentication and SSL verification.

Orchestrate AI agent workflows across multiple git repositories by aggregating beads, managing contexts, and coordinating distributed work with cross-repo dependencies.

Attach screenshots, PDFs, files, and documents to Jira issues and Confluence pages via Atlassian REST API. Connect remotely via SSE to MCP server for tools and data access across Jira issues, Confluence pages, Bitbucket repos, and related services.

Automate go-to-market workflows including account research, persona development, competitive intelligence, outreach sequences, content creation, and deal reviews by connecting CRM, analytics, and communication tools to Claude.

Enforce DPF-native agent skills for backlog management, architectural decisions, pull requests with DCO-signed commits, and isolated git worktrees with per-session MCP configs and docker-compose project names.

Automate legal contract review, NDA triage, and compliance workflows by flagging deviations from playbooks, generating redlines, assessing risk severity, and preparing briefings from connected sources.

Manage Jira issues and queries directly from Claude Code using the Atlassian JIRA API, running locally as a Podman container for secure issue tracking and project management.

Automate end-to-end Jira workflows: detect duplicates with JQL and codebase scans before creating tickets, triage backlogs by priority and type, optimize ticket quality via scoring and enhancements, plan sprints with capacity calculations and velocity insights, generate retrospective reports from time tracking and Jira data.

Orchestrate AI agent workflows across multiple git repositories by aggregating beads, managing contexts, and coordinating polyrepo microservices with cross-repo dependencies.