AI agents for QA: 11 pipeline skills

Architecture of a Multi-Agent AI System for Automating the QA Process

Testing lags behind development: automated tests don't cover new scenarios, manual regression grows, and engineer rotation requires a month of onboarding. Analysis of QA time shows that 80% of tasks are systematizable—from requirement analysis to automation. A system of 11 AI agents handles this routine, leaving the engineer in control for adjustments.

Concept: The QA Engineer as an Exoskeleton Operator

The engineer's role shifts: instead of manually executing stages, they set rules, assign tasks to agents, and review artifacts. Principles include integration into the existing stack (Jira, Zephyr, GitLab, pytest), transparent formats, full auditability, and scalability.

Before: manual test design, individual prompts, unstructured data.

After: standardized artifacts, parallel execution, predictable costs.

Overall Architecture: 11 Agents in a Unified Pipeline

The system, built on Claude Code Skills, implements a pipeline from requirement loading to MR with automated tests. An orchestrator manages parallel execution, checking quality at each stage.

Jira/Confluence → Loading → Decomposition → Scenarios → API/UI Automation → Validation → GitLab MR / Zephyr

List of 11 Skills

• jira-fetch: Loads tasks, attachments, and subtasks from Jira/Confluence.
• requirements-decomposer: Decomposes into User Stories and Tasks with functional/non-functional requirements and acceptance criteria.
• scenarios-generator: Generates scenarios using ISTQB methods (equivalence partitioning, boundary values).
• scenario-data-fix: Collects test data with Global Context.
• scenario-discrepancies-fix: Fixes discrepancies with UI/API.
• selectors-collector: Collects CSS/Playwright selectors for POM.
• automation-api: pytest + requests for API tests.
• automation-ui: pytest + Playwright for UI tests.
• automation-compare: Compares scenarios with automated test code.
• zephyr-uploader: Uploads test cases to Zephyr Scale.
• mr-creator: Creates Merge Requests in GitLab.

Stage Details: From Requirements to Scenarios

Loading and Decomposition

jira-fetch parses unstructured data: text, tables, PDF/DOCX. requirements-decomposer structures it:

testing/requirements/DEVAI-258/
├── US-001.md
├── TASK-001.md
├── NOTES-classification.md
└── _index.json

Example decomposition:

## Functional Requirements
- F-DEVAI-283-BE-01: POST /api/v1/integrations/confluence/connect

## Acceptance Criteria
- AC-DEVAI-283-01: success: true with valid data

Global Context provides project context (API contracts, environments).

Scenario Generation

scenarios-generator applies the testing pyramid: e2e for User Stories, unit for tasks. JSON format ensures traceability:

{
  "testSuite": {
    "name": "US-001: Authorization",
    "testCases": [{
      "id": "TC-001-001",
      "testSteps": [{
        "action": "POST /api/auth/login",
        "expectedResult": "HTTP 200, JWT token"
      }],
      "traceability": {"requirementIds": ["F-DEVAI-258-01"]}
    }]
  }
}

An RTM is created for requirement coverage:

| ID | Name | Status | Tests | Coverage |

|---|------|--------|-------|----------|

| F-DEVAI-258-01 | Authorization | Covered | 2 | 100% |

Integration with Figma via MCP analyzes mockups: elements, states, discrepancies.

Orchestration and Integrations

The orchestrator runs agents in parallel: API/UI automation simultaneously. Integrations:

• Jira/Confluence: REST API.
• Figma: MCP for UI analysis.
• Zephyr: JSON test case import.
• GitLab: MR creation with pytest projects.

selectors-collector generates SELECTORS.json for Page Object Model.

Technical Challenges and Solutions

Pitfalls:

• Unstructured requirements—solved with decomposition templates.
• UI/API discrepancies—fixed by agents with ERROR_DISCREPANCIES.md.
• Automated test coverage—automation-compare with reports.

Scaling: one engineer manages multiple projects without quality loss.

Key Takeaways

• 80% of QA routine automated: analysis, scenarios, automated tests, MR.
• Transparency: all artifacts in standard formats (JSON, pytest, Zephyr).
• Traceability: RTM shows requirement coverage by tests.
• Scalability: parallel execution, integration into the stack without changes.
• Control: engineer adjusts at stages, audit available.

— Editorial Team