Jira plugins

Automate HR operations including recruiting, onboarding, performance reviews, compensation analysis, and policy guidance. Upload HR data for headcount and attrition reports or query company policies via Slack, Jira, Notion, or Benchling.

Generate sales call prep briefs, research prospects and companies, draft personalized outreach emails and LinkedIn messages, and build deal strategy assets like battlecards, landing pages, and forecasts using CRM data and web enrichment

Automate legal workflows: draft briefs, triage NDAs, review contracts against playbooks, run compliance checks, prepare e-signature documents, and track vendor agreements across CLM, CRM, email, and chat systems.

Generate competitive analysis briefs, brainstorm product ideas, plan roadmaps, write feature specs and PRDs, synthesize user research, plan sprints, review product metrics, and send stakeholder updates — all connected to tools like Linear, Jira, Asana, Notion, Slack, Figma, Amplitude, Pendo, and Intercom.

Audit designs for WCAG compliance, critique UI usability, generate developer handoff specs from Figma, manage design system tokens, synthesize user research, and write UX copy — all within a design-to-development workflow.

Run the full engineering lifecycle from a chat interface: review code, debug issues, design systems, document decisions, manage incidents, and generate standups. Connects to Linear, Jira, Slack, Notion, Datadog, PagerDuty, and Benchling for project management, monitoring, and incident response.

Sync tasks from GitHub, Linear, Monday.com, ClickUp, Asana, Jira, and Notion into a local TASKS.md file, then manage them with Active/Waiting/Someday/Done sections. Decode acronyms, nicknames, and project context into a persistent memory system that keeps your work organized across calendar, email, and chat.

Manage business operations including team capacity planning, change management, compliance tracking (SOC 2, ISO 27001, GDPR, HIPAA, PCI DSS), process documentation with SOPs and RACI matrices, operational risk assessment, vendor evaluation, and runbook generation. Integrates with Asana, Slack, Jira, Confluence, Notion, and Benchling for project and data management.

Automate customer support workflows by triaging tickets, researching customer context from multiple sources (Slack, Jira, HubSpot, Intercom, Notion, GetGuru, Benchling), drafting professional responses, and converting resolved issues into knowledge base articles. Prioritize and escalate issues with impact assessments.

Query and synthesize answers across company tools (Slack, Notion, Jira, Confluence, Asana, Benchling, Guru) from a single natural language search, with automatic deduplication, citation, and configurable digest summaries.

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.

Automates product launch legal review by calibrating risk tolerance, reviewing PRDs and marketing copy for claims needing substantiation, flagging upcoming launches in Jira/Linear, and triaging Slack questions — all within configurable practice profiles.

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.

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.

Manage Jira issues directly from the CLI: search, create, update, transition, comment, log work, and manage sprints/boards with auto-detection of issue keys. Convert Markdown to Jira wiki markup and validate syntax for descriptions and comments.

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.

Sets up a complete AI-assisted development workflow: bootstraps CLAUDE.md, formatters, and test infrastructure, then guides structured brainstorming, TDD cycles, code review, refactoring, test coverage, and git operations — all tailored to your actual codebase.

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 loop: draft specs and plans, enforce TDD and code coverage, run multi-dimensional code reviews, generate deployment checklists, track status, and produce standup summaries from git and Jira activity.

Turn any Obsidian vault into a searchable, syncable second brain that ingests content from Confluence, Google Docs, and GitHub, auto-links entities, answers natural-language questions, and enforces a code-review gate on session stop.

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).

Turkish product law compliance reviews for launch documents, marketing claims, PRDs, and feature risk assessments, with integrations to Jira/Linear/Asana for pre-launch legal radar and Slack/Google Drive for triage workflows.

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.

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.

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.

Connect Claude Code to Atlassian's remote MCP server via SSE for seamless integration with Jira, Confluence, Compass, and Bitbucket. Manage issues, update documentation, access components, and automate workflows directly from your IDE. Requires authentication.

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.

Orchestrate structured software development workflows: plan with work items and architecture decisions, implement with multi-agent analysis, review with quality lenses, and manage projects via Jira/Linear integration.

Develop and maintain Red Hat Developer Hub (RHDH) plugins and ecosystem — scaffold, test, debug, package, version-check, manage CI/CD, releases, and Jira workflows.

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.

Build, deploy, and troubleshoot Atlassian Forge apps with pre-release readiness reviews, cost optimization audits, automated security reviews, and remote MCP connections to Atlassian services for Jira and Confluence development.

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.

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 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.

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.

Generate comprehensive project handoff documents by synthesizing status, ownership, context, tribal knowledge, open items, and next steps from Jira, Git repos, documents, meetings, Asana, and directories using Glean tools.

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.

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.

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.

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.

Converts raw project inputs—client messages, transcripts, Jira data, Figma designs—into structured PM artefacts: charters, PRDs, sprint plans, roadmaps, risk assessments, and stakeholder updates. Chains multiple PM skills automatically to produce decision-ready documents across the full delivery lifecycle.

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

Audit code, APIs, and tests for quality issues across dimensions — type safety, error handling, test robustness, API compliance, and accessibility — using specialized agents that review diffs, verify OpenAPI specs, mutate tests, and enforce coding standards.

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.

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.

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.

Connect Claude to a full-stack sales intelligence stack: query HubSpot, ZoomInfo, Notion, Microsoft 365, Clay, Fireflies, Slack, Atlassian, and Close.com through pre-configured MCP servers for automated lead enrichment, CRM workflows, meeting analysis, and deal tracking.

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.

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.

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.

Enforces a structured development lifecycle from planning to release: ingests tickets from Jira/Linear/Notion/Figma, grounds them in codebase context, produces TDD-first plans, runs pre-commit quality gates (tests, lint, SOLID checks), verifies Figma pixel-perfect implementation via browser automation, performs structured PR reviews with full context, and generates changelogs with semver bumps.

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.

Aggregate tasks, updates, and notifications from email, meetings, Slack, issue trackers (Jira, Linear, Asana, ClickUp), CRMs, and design tools into a kanban board that auto-updates, so you never miss a task and can track progress across all your tools.

Orchestrate the full product development lifecycle with phase-aware multi-agent skills: design debate, parallel implementation, cross-specialty review, security scanning, deployment gating, and production incident response — all recovered from workflow state on restart.

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, and apply persistent session knowledge across Claude Code sessions using a five-phase lifecycle. Promotes approved insights to a tag-indexed markdown base, runs pre-mortems on plans and retrospectives on shipped work with evidence sourcing, and enforces change-decision hooks on edits.

Orchestrates an AI-assisted development workflow with specialized agents for planning, coding, testing, documentation, and code review. Manages tasks, specs, git operations, Jira integration, and release automation through structured commands and multi-agent coordination.

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.

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.

Automates legal workflows: triage NDAs, review contracts against playbooks, generate templated responses for common inquiries, and prepare structured briefings by connecting communication and document management systems.

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.