Agent Skills for QA Engineers

You have probably seen the n8n version: a chat trigger feeds an AI Agent, a chat model does the thinking, and a Jira tool acts. We are going to rebuild that pattern as a portable agent skill that GitHub Copilot (or any skill-aware agent, per agentskills.io) can pick up on its own, then have it produce shareable PDF and XLSX test plans.

1. What is an agent skill?

A skill is a folder with a SKILL.md file plus optional scripts. The SKILL.md has a short front-matter (name + description) and a body of instructions. When your request matches the description, the agent loads the instructions and follows them, running the bundled scripts as needed. It is the cleanest way to teach GitHub Copilot a repeatable, multi-step workflow like "turn this Jira story into a test plan."

2. The flow

Here is the whole pipeline. Compare it to the n8n graph: the "AI Agent" is Copilot, the "Chat Model" is Copilot's model, and instead of a Jira create-issue tool we use a Jira fetch step plus two export steps.

3. Skill anatomy

The skill is just three files in a folder. Copilot reads SKILL.md, and the two scripts do the Jira call and the file export.

4. Build it step by step

1. Create the folder. In your repo (or ~/.config/github-copilot/skills/ for a global skill): mkdir -p test-plan-from-jira/scripts.
2. Add SKILL.md with the front-matter and steps (full text below). The description is what makes Copilot pick the skill automatically.
3. Add the two scripts into scripts/. Install deps once: pip install requests reportlab openpyxl.
4. Set three env vars (never hard-code secrets): JIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN. Create the token at id.atlassian.com → Security → API tokens.
5. Ask Copilot: "create a test plan from QAJB-42". It matches the skill, fetches the story, drafts the plan, and exports both files.

5. The full SKILL.md

This is the whole brain of the skill. Copy it verbatim into test-plan-from-jira/SKILL.md.

---
name: test-plan-from-jira
description: Fetch a Jira story or epic by key and generate a complete QA test
  plan (scope, scenarios, positive / negative / edge cases with steps and expected
  results), then export it to a polished PDF and a filable XLSX. Use whenever the
  user says "create a test plan from <JIRA-KEY>", "write test cases for this story",
  "turn this ticket into a test plan", or asks to export a test plan to PDF / Excel.
---

# Test Plan from Jira

Turn one Jira issue into a review-ready QA test plan and shareable files.

## Steps

1. Get the Jira key(s) from the user (e.g. `QAJB-42`). If none given, ask for one.
2. Fetch the story:
   `python scripts/fetch_jira.py <KEY> > story.json`
   This returns summary, description, acceptance criteria, type, priority, labels.
3. Read `story.json` and design the test plan. Cover, at minimum:
   - **Scope + assumptions** (what is / is not tested)
   - **Test scenarios** grouped by feature area
   - For each scenario: `id`, `title`, `type` (positive / negative / edge / boundary),
     `priority` (P1..P3), `preconditions`, numbered `steps`, `expected_result`
   - Derive negative + boundary cases from every acceptance criterion, do not just
     restate the happy path.
4. Write the plan as JSON to `plan.json` (schema below).
5. Export both files:
   `python scripts/export.py plan.json`
   -> writes `test-plan-<KEY>.pdf` and `test-plan-<KEY>.xlsx`.
6. Tell the user the file paths and give a 3-line summary (scope + case count by type).

## plan.json schema

```json
{
  "key": "QAJB-42",
  "title": "Coupon code at checkout",
  "scope": "Applying, validating, and removing coupon codes at checkout.",
  "out_of_scope": ["Payment gateway", "Inventory"],
  "cases": [
    {
      "id": "TC-01", "title": "Valid coupon applies discount",
      "type": "positive", "priority": "P1",
      "preconditions": "Cart has 1 eligible item; coupon SAVE10 is active",
      "steps": ["Open checkout", "Enter SAVE10", "Click Apply"],
      "expected_result": "10% discount shown; total updates; success toast"
    }
  ]
}
```

## Rules

- Never hard-code the Jira token. `fetch_jira.py` reads `JIRA_*` env vars.
- Every acceptance criterion must map to at least one positive AND one negative case.
- Keep steps atomic and imperative; expected results must be verifiable.
- If the story is thin, list the assumptions you made at the top of the plan.

6. Script: fetch from Jira

Pulls the issue over the Jira Cloud REST API (v3) and prints a clean JSON the model can reason over. Auth is Basic (email + API token) over HTTPS.

# Fetch one Jira issue and print normalized JSON. Usage: python fetch_jira.py QAJB-42
import os, sys, json, base64, urllib.request

def adf_to_text(node):
    # Atlassian Document Format -> plain text (recursive, best-effort).
    if node is None: return ""
    if isinstance(node, str): return node
    out = []
    if node.get("text"): out.append(node["text"])
    for ch in node.get("content", []) or []:
        out.append(adf_to_text(ch))
    sep = "\n" if node.get("type") in ("paragraph", "listItem", "heading") else ""
    return sep.join(p for p in out if p)

def main():
    key = sys.argv[1]
    base = os.environ["JIRA_BASE_URL"].rstrip("/")   # https://your.atlassian.net
    email = os.environ["JIRA_EMAIL"]
    token = os.environ["JIRA_API_TOKEN"]
    auth = base64.b64encode(f"{email}:{token}".encode()).decode()

    url = f"{base}/rest/api/3/issue/{key}" \
          "?fields=summary,description,issuetype,priority,labels,customfield_10000"
    req = urllib.request.Request(url, headers={
        "Authorization": f"Basic {auth}", "Accept": "application/json"})
    with urllib.request.urlopen(req) as r:
        data = json.load(r)

    f = data["fields"]
    story = {
        "key": data["key"],
        "summary": f.get("summary", ""),
        "type": (f.get("issuetype") or {}).get("name"),
        "priority": (f.get("priority") or {}).get("name"),
        "labels": f.get("labels", []),
        "description": adf_to_text(f.get("description")),
    }
    print(json.dumps(story, indent=2))

if __name__ == "__main__":
    main()

7. Script: export PDF + XLSX

Takes the model's plan.json and writes both a formatted PDF (reportlab) and a spreadsheet (openpyxl) with one row per test case, ready to paste into a test-management tool.

# Render plan.json to test-plan-<KEY>.pdf and .xlsx. Usage: python export.py plan.json
import sys, json
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment

plan = json.load(open(sys.argv[1]))
key = plan["key"]; cases = plan.get("cases", [])

# ---------- XLSX ----------
wb = Workbook(); ws = wb.active; ws.title = "Test Cases"
cols = ["ID","Title","Type","Priority","Preconditions","Steps","Expected Result"]
ws.append(cols)
for i, c in enumerate(ws[1], 1):
    c.font = Font(bold=True, color="FFFFFF"); c.fill = PatternFill("solid", fgColor="7C3AED")
for t in cases:
    ws.append([t.get("id"), t.get("title"), t.get("type"), t.get("priority"),
               t.get("preconditions",""), "\n".join(t.get("steps",[])), t.get("expected_result","")])
for col, w in zip("ABCDEFG", [10,34,12,10,30,44,40]):
    ws.column_dimensions[col].width = w
for row in ws.iter_rows(min_row=2):
    for cell in row: cell.alignment = Alignment(wrap_text=True, vertical="top")
wb.save(f"test-plan-{key}.xlsx")

# ---------- PDF ----------
doc = SimpleDocTemplate(f"test-plan-{key}.pdf", pagesize=A4, title=f"Test Plan {key}")
st = getSampleStyleSheet(); flow = []
flow += [Paragraph(f"Test Plan &mdash; {key}", st["Title"]),
         Paragraph(plan.get("title",""), st["Heading2"]),
         Paragraph("<b>Scope:</b> " + plan.get("scope",""), st["Normal"]), Spacer(1,12)]
head = ["ID","Title","Type","Pri","Steps","Expected"]
rows = [head] + [[t.get("id"), Paragraph(t.get("title",""), st["BodyText"]), t.get("type"),
        t.get("priority"), Paragraph("<br/>".join(t.get("steps",[])), st["BodyText"]),
        Paragraph(t.get("expected_result",""), st["BodyText"])] for t in cases]
tbl = Table(rows, colWidths=[40,110,48,32,150,140], repeatRows=1)
tbl.setStyle(TableStyle([
    ("BACKGROUND",(0,0),(-1,0),colors.HexColor("#7C3AED")),
    ("TEXTCOLOR",(0,0),(-1,0),colors.white),
    ("FONTSIZE",(0,0),(-1,-1),8), ("VALIGN",(0,0),(-1,-1),"TOP"),
    ("GRID",(0,0),(-1,-1),0.5,colors.HexColor("#d0d5dd")),
    ("ROWBACKGROUNDS",(0,1),(-1,-1),[colors.white, colors.HexColor("#f6f4fe")])]))
flow.append(tbl)
doc.build(flow)
print(f"wrote test-plan-{key}.pdf and test-plan-{key}.xlsx ({len(cases)} cases)")

8. Use it in GitHub Copilot

With the folder in place and env vars set, just ask in Copilot Chat:

create a test plan from QAJB-42

Copilot matches the skill by its description, runs fetch_jira.py QAJB-42, drafts the plan against every acceptance criterion, writes plan.json, runs export.py, and hands you test-plan-QAJB-42.pdf + test-plan-QAJB-42.xlsx. Follow-ups work too: "add security and performance cases", "make it a regression suite", "also do QAJB-43".

Where to go next

• Swap the model: point Copilot at any model (GPT, Claude, or a Groq-hosted Llama, exactly like the graph above).
• Add a step that pushes the generated cases back into a Jira Test issue type (the "create issue" half of the n8n flow).
• Template the PDF with your team's header and a traceability matrix (AC → test case).