jira-epic — Claude Code skill: what it does, how to install
Drafts structured Jira epics following Prowler conventions, complete with Mermaid diagrams and task breakdown tables.
Apache-2.0 138 installs ★ 678 updated 2026-03-28
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a claude-codeWhat jira-epic does
This skill guides the AI to structure multi-component features, major redesigns, and refactoring efforts into a unified format. The generated document contains an overview answering what is built and why, a detailed requirements list organized by functional zones, technical constraints, and a sequenced implementation checklist.
It embeds Mermaid diagrams directly into the issue text for sequence flows, architecture boundaries, entity relationships, and state transitions. When provided with Figma URLs, it pins them to the header and links specific frame IDs to their related UI sections. A summary table at the bottom suggests child feature tickets ordered by API and UI dependencies.
Keep in mind the project specifics: direct submission through Jira MCP uses project key PROWLER, mandates the team field customfield_10359 set to UI, API, or SDK, and formats description text with Jira Wiki syntax inside customfield_10363.
What it helps with
- format multi-component initiatives into standard Jira epics
- split large epics into ordered child tasks with clear dependencies
- embed Mermaid architecture and sequence diagrams into ticket drafts
- populate required custom Jira fields and wiki markup when calling Jira MCP
Example prompts for the agent
- Create a Jira epic for the findings view with filtering and bulk actions
- Draft an epic for the GovCloud support feature using the Prowler template
- Build a multi-tenant support epic and suggest child tasks for API and UI
How to install jira-epic
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a claude-code2Manually: put the files in place
~/.claude/skills/jira-epic/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/jira-epic/
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a codex2Manually: put the files in place
.agents/skills/jira-epic/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a cursor2Manually: put the files in place
.cursor/skills/jira-epic/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Gentleman-Programming/Gentleman-Skills curated/jira-epic/SKILL.md2Manually: put the files in place
.github/skills/jira-epic/SKILL.md1Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a gemini-cli2Platform CLI
gemini skills install https://github.com/Gentleman-Programming/Gentleman-Skills --path curated/jira-epicManually: put the files in place
.devin/skills/jira-epic/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about jira-epic
How to install jira-epic in Claude Code?
Run npx skills add Gentleman-Programming/Gentleman-Skills --skill jira-epic -a claude-code in your terminal. The configuration writes to ~/.claude/skills/jira-epic/SKILL.md.
What does the jira-epic skill do?
It structures prompts to produce Markdown epics headed by [EPIC] Feature Name, detailing technical requirements, Mermaid flowcharts, and suggested subtasks.
What custom fields does the Jira MCP mode expect?
It targets project PROWLER with mandatory team field customfield_10359 (UI, API, or SDK) and puts Jira Wiki formatted copy into customfield_10363.
Source text
SKILL.md · Apache-2.0
---
name: jira-epic
description: >
Creates Jira epics for large features following Prowler's standard format.
Trigger: When user asks to create an epic, large feature, or multi-task initiative.
license: Apache-2.0
metadata:
author: gentleman-programming
version: "1.0"
---
## When to Use
Use this skill when creating Jira epics for:
- Large features spanning multiple components
- New views/pages in the application
- Major refactoring initiatives
- Features requiring API + UI + SDK work
## Epic Template
```markdown
# {Epic Title}
**Figma:** {figma link if available}
## Feature Overview
{2-3 paragraph description of what this feature does and why it's needed}
## Requirements
### {Section 1: Major Functionality Area}
#### {Subsection}
- Requirement 1
- Requirement 2
- Requirement 3
#### {Another Subsection}
- Requirement 1
- Requirement 2
### {Section 2: Another Major Area}
#### {Subsection}
- Requirement 1
- Requirement 2
## Technical Considerations
### Performance
- {Performance requirement 1}
- {Performance requirement 2}
### Data Integration
- {Data source}
- {Integration points}
### UI Components
- {Component 1}
- {Component 2}
## Implementation Checklist
- [ ] {Major deliverable 1}
- [ ] {Major deliverable 2}
- [ ] {Major deliverable 3}
## Diagrams
{Mermaid diagrams for architecture, flow, data model, etc.}
```
## Epic Title Conventions
Format: `[EPIC] Feature Name`
**Examples:**
- `[EPIC] Findings View`
- `[EPIC] Multi-tenant Support`
- `[EPIC] Compliance Dashboard Redesign`
- `[EPIC] GovCloud Support`
## Required Sections
### 1. Feature Overview
Brief but complete description of:
- What the feature does
- Who uses it
- Why it's needed
### 2. Requirements
Organized by functional area:
- Group related requirements together
- Use clear headers and subheaders
- Be specific and testable
### 3. Technical Considerations
Always include:
- **Performance**: Large dataset handling, pagination, caching
- **Data Integration**: Data sources, APIs, relationships
- **UI Components**: Reusable components, design system usage
### 4. Implementation Checklist
High-level deliverables that will become individual tasks:
- Each checkbox = potential Jira task
- Order by dependency (API before UI)
- Include testing milestones
## Diagrams
Use Mermaid for:
### Architecture Diagrams
```mermaid
graph TB
UI[UI Components] --> API[API Endpoints]
API --> SDK[Prowler SDK]
SDK --> Cloud[Cloud Providers]
```
### Data Flow Diagrams
```mermaid
sequenceDiagram
User->>UI: Apply filters
UI->>API: GET /findings?filters
API->>DB: Query findings
DB-->>API: Results
API-->>UI: JSON response
UI-->>User: Render table
```
### State Diagrams
```mermaid
stateDiagram-v2
[*] --> Pending
Pending --> InProgress: Start triage
InProgress --> Resolved: Mark resolved
InProgress --> Pending: Reset
Resolved --> [*]
```
### Entity Relationship Diagrams
```mermaid
erDiagram
FINDING ||--o{ RESOURCE : affects
FINDING }|--|| CHECK : "belongs to"
RESOURCE }|--|| ACCOUNT : "belongs to"
ACCOUNT }|--|| PROVIDER : "belongs to"
```
## Splitting Epic into Tasks
After creating the epic, generate individual tasks using the `jira-task` skill:
### Task Naming Pattern
From epic `[EPIC] Findings View`, create:
- `[FEATURE] Findings table with pagination (UI)`
- `[FEATURE] Findings filters - provider and account (UI)`
- `[FEATURE] Findings detail panel - Overview tab (UI)`
- `[FEATURE] Findings detail panel - Resources tab (UI)`
- `[FEATURE] Findings bulk actions - mute/suppress (API + UI)`
- `[FEATURE] Findings search functionality (API + UI)`
### Task Dependencies
Always specify in each task:
```markdown
## Related Tasks
- Epic: [EPIC] Findings View
- Blocked by: [task if any]
- Blocks: [task if any]
```
## Figma Integration
When Figma links are provided:
- Include main Figma link at top
- Reference specific frames in relevant sections
- Example: `https://www.figma.com/design/xxx?node-id=1830-44712&m=dev`
## Output Format
```markdown
## Epic: [EPIC] {Title}
{Full epic content following template}
---
## Suggested Tasks
Based on this epic, create the following tasks:
| # | Title | Component | Blocked By |
|---|-------|-----------|------------|
| 1 | [FEATURE] Task name | API | - |
| 2 | [FEATURE] Task name | UI | Task 1 |
| 3 | [FEATURE] Task name | UI | Task 2 |
Would you like me to generate the full task descriptions?
```
## Checklist Before Submitting
1. ✅ Title follows `[EPIC] Feature Name` format
2. ✅ Feature Overview explains what/who/why
3. ✅ Requirements are organized by functional area
4. ✅ Technical Considerations cover performance, data, UI
5. ✅ Implementation Checklist has high-level deliverables
6. ✅ Diagrams included where helpful (Mermaid format)
7. ✅ Figma links included if available
8. ✅ Suggested tasks table provided at the end
## Formatting Rules
**CRITICAL:** All output MUST be in Markdown format, ready to paste into Jira.
- Use `#` for epic title, `##` for main sections, `###` for subsections
- Use `**bold**` for emphasis
- Use `- [ ]` for checkboxes in Implementation Checklist
- Use ``` for code blocks and Mermaid diagrams
- Use `backticks` for file paths, commands, and code references
- Use tables for Suggested Tasks section
- Use `---` to separate epic from suggested tasks
## Jira MCP Integration
**CRITICAL:** When creating epics via MCP, use these exact parameters:
### Required Fields
```json
{
"project_key": "PROWLER",
"summary": "[EPIC] Feature name",
"issue_type": "Epic",
"additional_fields": {
"customfield_10359": {"value": "UI"}
}
}
```
### Team Field (REQUIRED)
The `customfield_10359` (Team) field is **REQUIRED**. Options:
- `"UI"` - Frontend epics
- `"API"` - Backend epics
- `"SDK"` - Prowler SDK epics
### Work Item Description Field
**IMPORTANT:** The project uses `customfield_10363` (Work Item Description) instead of the standard `description` field for display in the UI.
**CRITICAL:** Use **Jira Wiki markup**, NOT Markdown:
- `h2.` instead of `##`
- `*text*` for bold instead of `**text**`
- `* item` for bullets (same)
- `** subitem` for nested bullets
After creating the epic, update the description with:
```json
{
"customfield_10363": "h2. Feature Overview\n\n{overview}\n\nh2. Requirements\n\n*{Section 1}*\n* {requirement 1}\n* {requirement 2}\n\n*{Section 2}*\n* {requirement 1}\n* {requirement 2}\n\nh2. Technical Considerations\n\n*Performance:*\n* {consideration 1}\n\n*Data Integration:*\n* {consideration 2}\n\nh2. Implementation Checklist\n\n* [ ] {deliverable 1}\n* [ ] {deliverable 2}\n* [ ] {deliverable 3}"
}
```
### Linking Tasks to Epic
When creating child tasks, use the epic key as parent:
```json
{
"additional_fields": {
"parent": "PROWLER-XXX"
}
}
```
### Workflow Transitions
```
Backlog (10037) → To Do (14) → In Progress (11) → Done (21)
→ Blocked (10)
```
### MCP Commands Sequence
1. **Create epic:**
```
mcp__mcp-atlassian__jira_create_issue (issue_type: "Epic")
```
2. **Update Work Item Description:**
```
mcp__mcp-atlassian__jira_update_issue with customfield_10363
```
3. **Create child tasks:**
```
mcp__mcp-atlassian__jira_create_issue with parent: EPIC-KEY
```
4. **Assign and transition:**
```
mcp__mcp-atlassian__jira_update_issue (assignee)
mcp__mcp-atlassian__jira_transition_issue (status)
```
## Keywords
jira, epic, feature, initiative, prowler, large feature
© gentleman-programming · Apache-2.0 · Gentleman-Programming/Gentleman-Skills