AI Prompt to Generate Release Notes From Jira Tickets Using Atlassian's MCP Server

ROLE
You are an engineering triage assistant with access to a Linear workspace through its MCP server integration.

CONTEXT
Team or project: [TEAM_OR_PROJECT_NAME]
Time window: issues updated or opened in the last [TIME_WINDOW]
Priority scale in use: [PRIORITY_SCALE_DEFINITION]
Current sprint or cycle goal: [SPRINT_GOAL]

TASK
1. Pull all open issues matching the team, project, and time window above through the Linear MCP connection.
2. Group the issues into: blocked, in progress, and not started.
3. For each issue, assess severity using this rubric: [SEVERITY_RUBRIC], customer or revenue impact, how long it has been open, and whether it blocks other issues.
4. Flag any issue missing a priority, assignee, or label, and list it separately as a hygiene issue rather than ranking it.
5. Produce a prioritized list of the top [NUMBER] issues the team should work on next, with a one-line justification for each ranking.
6. Note any issues that appear to duplicate each other or contradict the stated sprint goal.

CONSTRAINTS
- Do not invent issue data that is not present in the Linear workspace; if a field is missing, say so explicitly.
- Keep each justification to one sentence.
- Do not take any write actions (status changes, reassignments) unless I explicitly confirm each one.

OUTPUT FORMAT
1. Hygiene issues (missing priority, assignee, or label) - bullet list
2. Blocked issues - bullet list with blocker noted
3. Prioritized list of top [NUMBER] issues - numbered, with one-line justification each
4. Possible duplicates or conflicts with sprint goal - bullet list

ROLE: You are a senior engineer writing a technical design document for team review.

CONTEXT:
- Feature or change: [WHAT IS BEING BUILT OR CHANGED]
- Problem it solves: [THE CONCRETE PROBLEM OR PAIN POINT]
- Current system constraints: [EXISTING ARCHITECTURE, TEAM SIZE, DEADLINE, OR OTHER LIMITS]
- Proposed approach: [HIGH-LEVEL DESCRIPTION OF THE SOLUTION]
- Known alternatives considered: [ANY OTHER APPROACHES ALREADY DISCUSSED, IF ANY]

CONSTRAINTS:
- Do not invent specific performance numbers, benchmarks, or capacity figures that were not provided
- Include at least one alternative approach and explain why it was not chosen
- Flag any open questions or risks explicitly rather than glossing over them
- Keep the document scannable: short paragraphs, no filler language

OUTPUT FORMAT:
1. Problem statement (what's broken or missing today)
2. Proposed solution (the approach, at a level engineers outside the immediate team can follow)
3. Alternatives considered (at least one, with reasons it was rejected)
4. Risks and open questions
5. Rollback plan (what happens if this needs to be reverted)

Write the design document now using only the information provided above.

Role: You are a backend engineer designing a resilient API error-handling and retry strategy.

Context:
- API being called: [API_NAME_OR_DESCRIPTION]
- Language/framework: [LANGUAGE_OR_FRAMEWORK]
- Known behavior: [RATE_LIMITS_TIMEOUTS_ERROR_CODES]
- Call pattern: [SINGLE_REQUEST_OR_BATCH_OR_HIGH_VOLUME]
- Idempotency: [IS_THE_OPERATION_SAFE_TO_RETRY]

Task:
1. Classify likely failure modes for this API call into retryable and non-retryable categories.
2. Recommend a specific retry strategy (backoff type, max attempts, max total wait, jitter) for the retryable category.
3. Recommend how non-retryable errors should be handled (fail fast, surface to caller, alert).
4. Note where a circuit breaker or rate limit guard would help if call volume is high.
5. Provide implementation code in [LANGUAGE_OR_FRAMEWORK] that applies this strategy to the described call.

Constraints:
- Do not retry non-retryable errors.
- Include logging at each retry attempt and final failure.
- Keep the retry logic isolated so it can be reused across multiple API calls.

Output format:
- A short table of failure modes (error type, retryable: yes/no, handling)
- The recommended retry parameters
- The implementation code in a fenced code block