Human-Guided Agentic Test Engineering Pipeline — AI System Brief | Maneesh Maddala Skip to main content

Human-Guided Agentic Test Engineering Pipeline

From Jira ticket to reviewed test scenarios, TestRail coverage, and Playwright tests.

Jira MCP · TestRail MCP · Playwright MCP · TypeScript · AWS · Git · POM

On my team, test planning, case design, and automation were three separate activities, usually picked up by different people at different times. Each hand-off started by rebuilding the same context: the feature, its epic, the repository, and the shape of the existing test suite. Coverage drifted in TestRail as similar cases got written twice, and automation built without that context turned brittle.

The workflow I built carries one Jira ticket through scenario design, TestRail coverage, and Playwright automation as a single reviewed path. It stops for a person before it changes coverage, writes code, or opens a pull request.

The workflow opens with /start-planning. Before it proposes anything, it reads the ticket in full: acceptance criteria, technical notes, attachments, linked references, the parent epic, and any sibling tickets already done or in review. From that context it drafts risk-tiered scenarios and returns them for review.

Once the scenarios are approved, /test-cases maps them onto the existing TestRail project. It updates the cases that already match, creates the folders and cases that are missing, and returns every affected link so the coverage can be checked before the feature ships.

After deployment, /automate takes the approved cases together with the repository context and writes POM-based tests, each routed to the UI, API, visual, or component suite that fits. It builds on the page objects and fixtures already in the codebase rather than adding parallel ones.

Each step produces an artifact that someone can review before the next step begins.

Workflow chart

From sprint-ready ticket to final verdict

Human Review
  1. Jira ticket /start-planning
  2. Context + scenarios
  3. Human review /test-cases
  4. TestRail coverage
  5. Deploy + approve /automate
  6. Playwright implementation
  7. Review + PR
Review sequence
Human Decision owner
Planner Opus
TestRail Sonnet
Coder Sonnet
Tester Sonnet
Reviewer Opus
  1. 01 · Request ticket plan
  2. scenarios.md
  3. 02 · scenarios.md
  4. 03 · Send approved scenarios
  5. testrail-cases.md
  6. 04 · testrail-cases.md
  7. 05 · Send approved test cases
  8. changes.md
  9. 06 · changes.md
  10. 07 · Send approved changes
  11. test-results.md
  12. 08 · test-results.md
  13. 09 · Request final review
  14. review.md
  15. 10 · review.md
● Human approval checkpoint Final PR and merge decision remains manual

A thin or ambiguous ticket leaves the planning stage with little to work from. Before it drafts a single scenario, the workflow gathers the acceptance criteria, the technical notes and attachments, the parent epic, and any sibling tickets that are done or in review, so the plan starts from the full picture.

TestRail often already holds similar coverage, and the right folder may not exist yet. The coverage stage walks the project and folder hierarchy first, compares against similar functionality, and returns every case it touched for review before it counts.

Automation that ignores a repository’s conventions ages badly. The automation stage reads the repository structure, routes each test into the suite that fits, and reuses the existing page objects, fixtures, and user-facing locators.

Scenario depth scales with risk: a floor of 5+ scenarios for low-criticality tickets, 6-8+ for medium, and 10-15+ for critical work.

Three points in the path need a person’s decision: creating the TestRail cases, starting the automation, and delivering the pull request.

A change stays traceable from its planning evidence through the TestRail cases, the test code, and the review that approved it.