AI Workspace Demo Challenge

with AIDA 

Step 1: Refine requirement with PO

1. Paste the raw requirement into the AI workspace.

2. Ask AI to flag ambiguities, missing acceptance criteria, and edge cases.

3. Convert those gaps into a short, prioritized question list for the PO.

4. Discuss with PO, then feed their answers back into the AI.

5. Ask AI to produce a clean, final version (e.g., Given/When/Then format).

6. Get PO sign-off on this refined version — it becomes the source of truth.

Step 2: Generate test cases

7. Prompt AI to create test cases (positive, negative, boundary, edge) strictly from the confirmed requirement.

8. Use a consistent format: ID, Title, Preconditions, Steps, Expected Result, Priority, Type.

9. Ask AI to map each test case to an acceptance criterion — this catches missing coverage or scope creep.

10. Export to your test tool (Xray, TestRail, Excel, etc.).

AI Workspace 

AI Workspace 

I use AI as a productivity tool, but I always validate the output with the Product Owner and project requirements.

First, I provide the user story, acceptance criteria, and business requirements to an AI workspace. AI helps me identify ambiguities, missing scenarios, dependencies, edge cases, and generates clarification questions.

Before discussing with the Product Owner, I review those AI-generated questions and prioritize the important ones. During the refinement meeting, I confirm the business rules, validations, workflows, error messages, and expected behavior.

Once the requirements are finalized, I use AI to generate an initial draft of the test cases. Then I manually review and refine them to ensure they cover positive, negative, boundary, validation, integration, and regression scenarios.

Finally, I map the test cases to the acceptance criteria to ensure complete requirement coverage. AI helps speed up the process, but the final review and validation are always done by me.

• Capture raw requirements first — Paste the PO's user story, acceptance criteria, or Jira ticket into the AI workspace as-is, without editing, so nothing gets lost before analysis begins.
• Ask AI to identify ambiguities and gaps — Prompt it to flag vague terms, missing edge cases, undefined error states, or conflicting acceptance criteria — these become the actual discussion points to raise with the PO, rather than guessing.
• Generate clarifying questions for the PO — Have the AI draft a structured list of questions (e.g., "What happens if the user submits with an empty field?") so the conversation with the PO is targeted and time-efficient rather than open-ended.
• Run a refinement session using AI-generated questions as the agenda — Walk through those questions live with the PO, capturing answers directly back into the same workspace/thread so context isn't lost.
• Ask AI to rewrite the requirement in testable format — Once clarified, have it restate the requirement as clear Given/When/Then or precise functional statements, removing ambiguity introduced by natural language.
• Validate the rewritten requirement against original intent — Share the AI's rewritten version back with the PO for a quick sign-off, confirming nothing was misinterpreted during refinement.
• Generate a first-pass test case list from the finalized requirement — Prompt the AI to produce positive, negative, and boundary test cases directly from the confirmed requirement text.
• Review AI-generated cases for domain-specific gaps — Apply your own QA judgement (compliance rules, security, accessibility, regulatory needs — especially relevant for public sector systems) since AI won't know unstated organizational standards.
• Convert into BDD/Gherkin or framework-specific format — Ask the AI to reformat the finalized test cases into Cucumber/Gherkin scenarios (or whatever your framework is — SpecFlow, Playwright, etc.) ready for direct implementation.
• Maintain traceability back to the requirement — Keep the AI workspace thread (or export it) linked to the original story/ticket ID, so test cases remain auditable back to the exact requirement version they were derived from — important for regulated environments needing evidence of coverage.

Step 1 – Analyze the Requirement

When a user story is created in Jira, AI Workspace reviews it to identify missing business rules, ambiguities, edge cases, and validation gaps. It also generates clarification questions for the Product Owner, helping the team finalize clear and testable acceptance criteria.

Step 2 – Generate and Review Test Cases

Once the requirements are refined, AI Workspace generates functional, negative, boundary, and API test scenarios, along with detailed test cases. As the QA Engineer, I review the AI-generated output, add any domain-specific scenarios, and approve the final test cases before they are synced to the test management tool.

Benefits

• Better collaboration between QA and Product Owner
• Clearer and more complete requirements
• Faster test case creation
• Improved test coverage with human validation
• Earlier defect detection and reduced rework

Part 1 — Refining Requirements with the Product Owner

Step 1: Bring the raw requirement into AI Workspace
Paste or upload the Product Owner's initial requirement/user story (however rough) into the workspace. It doesn't need to be well-formed yet — that's the point of this step.

Step 2: Let the AI surface ambiguities and gaps
Ask the workspace to analyze the requirement for:

Missing acceptance criteria
Undefined edge cases (what happens on invalid input, boundary values, empty states)
Ambiguous terms (e.g., "fast," "user-friendly," "valid" — anything not measurable)
Non-functional requirements that were implied but not stated (performance, security, accessibility)

This gives you a concrete list of specific questions to bring to the Product Owner, rather than a vague "can you clarify this?" — which makes the PO conversation shorter and more productive.

Step 3: Review with the Product Owner (human-in-the-loop)
Walk through the AI-surfaced gaps together. This is the step that should stay human — the PO owns the business intent, and the AI's job is to make the conversation efficient, not replace it. Capture their answers directly back into the workspace.

Step 4: Have the AI re-draft the requirement
With the PO's answers folded in, ask the workspace to regenerate a clean, structured requirement — clear acceptance criteria, explicit scope boundaries, and any non-functional constraints now made explicit. Tricentis' tools support iterative refinement here (their docs describe Regenerate, Elaborate, and Summarize actions for exactly this kind of back-and-forth tightening).

Step 5: Get sign-off
Have the PO confirm the refined version is what they meant. This becomes your baseline requirement — the artifact test case generation will be built from.

Part 2 — Generating Well-Defined Test Cases

Step 6: Feed the refined requirement into agentic test case generation
Tricentis' qTest layer includes Agentic Test Creation, which autonomously builds test cases directly from requirements (and can even use images/mockups as input) — not generic outlines, but production-quality manual test cases informed by SDLC best practices.

Step 7: Scope the generation with context
If your workspace supports custom field scanning (as Tricentis Test Management for Jira does), specify relevant fields/context — this tunes the generated test cases to your specific project rather than producing generic boilerplate.

Step 8: Review and refine each generated test case
For each case, use the same Customize menu actions:

Elaborate — add missing detail to a step that's too thin
Summarize — trim a step that's overly verbose
Re-generate — get different wording if the first pass didn't land right

Step 9: Validate coverage against the requirement's acceptance criteria
Cross-check: does every acceptance criterion from Step 4 have at least one test case? This is where you catch generation gaps before they become testing gaps — the AI is a strong first draft, not the final QA gate.

Step 10: Save and link back to the requirement
Save the approved test cases with traceability back to the original (refined) requirement — this is what gives you a genuine Requirement Traceability Matrix, not just a pile of disconnected test cases.

AI Workspace is an orchestration of multiple AI agents working together on a defined workflow. For example, one agent analyzes and refines requirements with the Product Owner, while another agent generates comprehensive test cases from the refined requirements. This helps ensure better requirement clarity, coverage, and quality throughout the SDLC.

This approach is more effective than using a single AI agent because each agent specializes in a specific activity and follows a defined workflow. As a result, requirements become clearer, test coverage improves, and the overall quality of delivery increases.

Flow: Requirement → Requirement Analyzer Agent → Refined Requirement/Acceptance Criteria → Test Case Creator Agent → Test Cases.

1. PO drafts requirement. Nothing changes here — the PO still owns the user story or epic in Jira. The AI layer starts at the next step, not before.

2. AI gap analysis. Before you meet the PO, feed the story into Claude (or Rovo, since it's already wired into your Jira/Confluence at ZPE) and ask it to flag missing acceptance criteria, undefined edge cases, ambiguous terms ("fast", "should"), and untestable statements. This turns your refinement session from "read the ticket together" into "here are 8 specific gaps to close."

3. Refinement session with PO. Walk through the AI-flagged gaps live with the PO. This is the one step that stays human — AI surfaces the questions, but negotiating priority, scope, and business intent is a conversation. Push for acceptance criteria in Given-When-Then form here; it pays off directly in step 4.

4. AI generates test cases. Once AC is locked, prompt the AI to generate a first-pass test suite directly from the Jira epic — positive paths, negative paths, and boundary conditions per criterion. This is the same pattern you've already used for CLOUD-26124 with Rovo.

5. QA review and edge cases. Treat the AI output as a draft, not a deliverable. Check for domain-specific edge cases the AI wouldn't infer (e.g., settlement timing, ETL failure states) and prune anything generic or redundant.

6. Publish and link. Push reviewed cases into TestRail/Zephyr with traceability back to the Jira story, so coverage is auditable later.