---
name: jira-task
description: >
  Creates Jira tasks and epics following Prowler's standard format. Trigger: When user asks to create a Jira task, ticket, issue, epic, or large feature.
license: Apache-2.0
metadata:
  author: gentleman-programming
  version: "2.0"
  compacted-from: jira-task, jira-epic
enabled: false
source: github:JuanJoseGonGi/skills
imported-from: github:JuanJoseGonGi/skills
---

## When to Use

Use this skill when creating Jira work items:
- **Tasks:** Bug reports, feature requests, refactoring, documentation
- **Epics:** Large features spanning multiple components, new views/pages, major refactoring initiatives

## Multi-Component Work: Split into Multiple Tasks

**IMPORTANT:** When work requires changes in multiple components (API, UI, SDK), create **separate tasks for each component**.

### Why Split?
- Different developers can work in parallel
- Easier to review and test
- Better tracking of progress
- API needs to be done before UI (dependency)

### Bug vs Feature: Different Structures

#### For BUGS: Create separate sibling tasks
Bugs are typically urgent fixes, so create independent tasks per component:

**Task 1 - API:**
- Title: `[BUG] Add aws_region field to AWS provider secrets (API)`
- Must be done first (UI depends on it)

**Task 2 - UI:**
- Title: `[BUG] Add region selector to AWS provider connection form (UI)`
- Blocked by API task

#### For FEATURES: Create parent + child tasks
Features need business context for stakeholders, so use a parent-child structure:

**Parent Task (for PM/Stakeholders):**
- Title: `[FEATURE] AWS GovCloud support`
- Contains: Feature overview, user story, acceptance criteria from USER perspective
- NO technical details
- Links to child tasks

**Child Task 1 - API:**
- Title: `[FEATURE] AWS GovCloud support (API)`
- Technical details, affected files, API-specific acceptance criteria

**Child Task 2 - UI:**
- Title: `[FEATURE] AWS GovCloud support (UI)`
- Technical details, component paths, UI-specific acceptance criteria
- Blocked by API task

## Task Template

```markdown
## Description

{Brief explanation of the problem or feature request}

**Current State:**
- {What's happening now / What's broken}
- {Impact on users}

**Expected State:**
- {What should happen}
- {Desired behavior}

## Acceptance Criteria

- [ ] {Specific, testable requirement}
- [ ] {Another requirement}

## Technical Notes

- {Implementation hints}
- {Affected files with full paths}
- {Dependencies or related components}

## Testing

- [ ] {Test case 1}
- [ ] {Test case 2}

## Priority

{High/Medium/Low} ({justification})
```

### Parent Task Template (Features Only)

```markdown
## Description

{User-facing description of the feature - what problem does it solve?}

## User Story

As a {user type}, I want to {action} so that {benefit}.

## Acceptance Criteria (User Perspective)

- [ ] User can {do something}
- [ ] User sees {something}

## Out of Scope

- {What this feature does NOT include}

## Design

- Figma: {link if available}

## Child Tasks

- [ ] `[FEATURE] {Feature name} (API)` - Backend implementation
- [ ] `[FEATURE] {Feature name} (UI)` - Frontend implementation

## Priority

{High/Medium/Low} ({business justification})
```

### Child Task Template (Features Only)

```markdown
## Description

Technical implementation of {feature name} for {component}.

## Parent Task

`[FEATURE] {Feature name}`

## Acceptance Criteria (Technical)

- [ ] {Technical requirement 1}
- [ ] {Technical requirement 2}

## Technical Notes

- Affected files:
  - `{file path 1}`
  - `{file path 2}`

## Testing

- [ ] {Test case 1}
- [ ] {Test case 2}

## Related Tasks

- Parent: `[FEATURE] {Feature name}`
- Blocked by: {if any}
- Blocks: {if any}
```

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

### {Section 2: Another Major Area}

#### {Subsection}
- Requirement 1
- Requirement 2

## Technical Considerations

### Performance
- {Performance requirement 1}

### Data Integration
- {Data source}
- {Integration points}

### UI Components
- {Component 1}

## Implementation Checklist

- [ ] {Major deliverable 1}
- [ ] {Major deliverable 2}
- [ ] {Major deliverable 3}

## Diagrams

{Mermaid diagrams for architecture, flow, data model}
```

### Splitting Epic into Tasks

After creating the epic, generate individual tasks:

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 bulk actions - mute/suppress (API + UI)`
- `[FEATURE] Findings search functionality (API + UI)`

Each task should include:
```markdown
## Related Tasks
- Epic: [EPIC] Findings View
- Blocked by: [task if any]
- Blocks: [task if any]
```

### Epic Diagrams

Use Mermaid for architecture, data flow, state, and ER diagrams:

```mermaid
graph TB
    UI[UI Components] --> API[API Endpoints]
    API --> SDK[Prowler SDK]
    SDK --> Cloud[Cloud Providers]
```

## Title Conventions

Format: `[TYPE] Brief description (components)`

**Types:**
- `[BUG]` - Something broken that worked before
- `[FEATURE]` - New functionality
- `[ENHANCEMENT]` - Improvement to existing feature
- `[REFACTOR]` - Code restructure without behavior change
- `[DOCS]` - Documentation only
- `[CHORE]` - Maintenance, dependencies, CI/CD
- `[EPIC]` - Large feature spanning multiple components

**Components (when multiple affected):**
- `(API)` - Backend only
- `(UI)` - Frontend only
- `(SDK)` - Prowler SDK only
- `(API + UI)` - Both backend and frontend
- `(Full Stack)` - All components

## Priority Guidelines

| Priority | Criteria |
|----------|----------|
| **Critical** | Production down, data loss, security vulnerability |
| **High** | Blocks users, no workaround, affects paid features |
| **Medium** | Has workaround, affects subset of users |
| **Low** | Nice to have, cosmetic, internal tooling |

## Component-Specific Sections

### API Tasks
Include: Serializer changes, View/ViewSet changes, Migration requirements, API spec regeneration needs

### UI Tasks
Include: Component paths, Form validation changes, State management impact, Responsive design considerations

### SDK Tasks
Include: Provider affected, Service affected, Check changes, Config changes

## Checklist Before Submitting

### Tasks
1. Title follows `[TYPE] description (components)` format
2. Description has Current/Expected State
3. Acceptance Criteria are specific and testable
4. Technical Notes include file paths
5. Testing section covers happy path + edge cases
6. Priority has justification
7. Multi-component work is split into separate tasks

### Epics
1. Title follows `[EPIC] Feature Name` format
2. Feature Overview explains what/who/why
3. Requirements 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. Suggested tasks table provided at the end

## Output Format

### For BUGS (sibling tasks):

```markdown
## Recommended Tasks

### Task 1: [BUG] {Description} (API)
{Full task content}

---

### Task 2: [BUG] {Description} (UI)
{Full task content}
```

### For FEATURES (parent + children):

```markdown
## Recommended Tasks

### Parent Task: [FEATURE] {Feature name}
{User-facing content, no technical details}

---

### Child Task 1: [FEATURE] {Feature name} (API)
{Technical content for API team}

---

### Child Task 2: [FEATURE] {Feature name} (UI)
{Technical content for UI team}
```

### For EPICS:

```markdown
## Epic: [EPIC] {Title}

{Full epic content following template}

---

## Suggested Tasks

| # | Title | Component | Blocked By |
|---|-------|-----------|------------|
| 1 | [FEATURE] Task name | API | - |
| 2 | [FEATURE] Task name | UI | Task 1 |
```

## Reference Documentation

| Reference | When to Use |
|-----------|-------------|
| [references/jira-mcp-integration.md](references/jira-mcp-integration.md) | MCP fields, wiki markup, commands, workflow transitions |

## Keywords
jira, task, ticket, issue, bug, feature, epic, initiative, prowler
