Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: QA scope discovery.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “QA scope discovery” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to qa scope discovery.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: QA scope discovery
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Product risk inventory.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Product risk inventory” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to product risk inventory.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Product risk inventory
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Test strategy document.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test strategy document” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test strategy document.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test strategy document
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Acceptance criteria review.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Acceptance criteria review” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to acceptance criteria review.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Acceptance criteria review
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Stakeholder test interview.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Stakeholder test interview” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to stakeholder test interview.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Stakeholder test interview
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Testing levels selection.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Testing levels selection” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to testing levels selection.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Testing levels selection
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Test environment matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test environment matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test environment matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test environment matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Entry and exit criteria.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Entry and exit criteria” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to entry and exit criteria.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Entry and exit criteria
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: Risk-based test priority.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Risk-based test priority” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to risk-based test priority.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Risk-based test priority
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in qa discovery & test strategy. Your assignment is: QA effort estimate.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “QA effort estimate” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the qa discovery & test strategy angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to qa effort estimate.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: QA effort estimate
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Functional test scenarios.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Functional test scenarios” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to functional test scenarios.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Functional test scenarios
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Positive and negative cases.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Positive and negative cases” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to positive and negative cases.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Positive and negative cases
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Boundary value tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Boundary value tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to boundary value tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Boundary value tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Equivalence class tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Equivalence class tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to equivalence class tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Equivalence class tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Decision table tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Decision table tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to decision table tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Decision table tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: State transition tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “State transition tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to state transition tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: State transition tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Exploratory test charter.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Exploratory test charter” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to exploratory test charter.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Exploratory test charter
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Cross-browser test matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Cross-browser test matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to cross-browser test matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Cross-browser test matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Mobile responsiveness tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Mobile responsiveness tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to mobile responsiveness tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Mobile responsiveness tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in manual testing & test design. Your assignment is: Accessibility manual checks.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Accessibility manual checks” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the manual testing & test design angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to accessibility manual checks.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Accessibility manual checks
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Detailed test case suite.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Detailed test case suite” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to detailed test case suite.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Detailed test case suite
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Given When Then scenarios.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Given When Then scenarios” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to given when then scenarios.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Given When Then scenarios
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Test data boundary matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test data boundary matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test data boundary matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test data boundary matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Synthetic user datasets.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Synthetic user datasets” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to synthetic user datasets.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Synthetic user datasets
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Data masking plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Data masking plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to data masking plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Data masking plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Traceability matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Traceability matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to traceability matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Traceability matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Test case deduplication.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test case deduplication” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test case deduplication.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test case deduplication
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Prerequisite and cleanup steps.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Prerequisite and cleanup steps” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to prerequisite and cleanup steps.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Prerequisite and cleanup steps
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Parameterized test cases.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Parameterized test cases” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to parameterized test cases.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Parameterized test cases
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in test cases & test data. Your assignment is: Test review checklist.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test review checklist” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the test cases & test data angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test review checklist.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test review checklist
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Reproducible defect report.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Reproducible defect report” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to reproducible defect report.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Reproducible defect report
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Expected versus actual analysis.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Expected versus actual analysis” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to expected versus actual analysis.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Expected versus actual analysis
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Severity and priority rubric.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Severity and priority rubric” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to severity and priority rubric.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Severity and priority rubric
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Minimal reproduction steps.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Minimal reproduction steps” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to minimal reproduction steps.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Minimal reproduction steps
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Intermittent defect investigation.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Intermittent defect investigation” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to intermittent defect investigation.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Intermittent defect investigation
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Screenshot evidence checklist.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Screenshot evidence checklist” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to screenshot evidence checklist.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Screenshot evidence checklist
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Regression bug classification.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Regression bug classification” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to regression bug classification.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Regression bug classification
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Root cause hypothesis list.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Root cause hypothesis list” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to root cause hypothesis list.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Root cause hypothesis list
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Developer handoff note.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Developer handoff note” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to developer handoff note.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Developer handoff note
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in bug reporting & triage. Your assignment is: Release blocker decision.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Release blocker decision” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the bug reporting & triage angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to release blocker decision.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Release blocker decision
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Selenium test design.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Selenium test design” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to selenium test design.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Selenium test design
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Playwright browser test.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Playwright browser test” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to playwright browser test.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Playwright browser test
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Cypress test specification.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Cypress test specification” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to cypress test specification.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Cypress test specification
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Stable locator strategy.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Stable locator strategy” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to stable locator strategy.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Stable locator strategy
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Page object model plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Page object model plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to page object model plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Page object model plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Form validation automation.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Form validation automation” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to form validation automation.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Form validation automation
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Login flow automation.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Login flow automation” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to login flow automation.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Login flow automation
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: File upload test plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “File upload test plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to file upload test plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: File upload test plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Wait and retry strategy.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Wait and retry strategy” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to wait and retry strategy.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Wait and retry strategy
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in web ui automation. Your assignment is: Flaky UI test stabilization.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Flaky UI test stabilization” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the web ui automation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to flaky ui test stabilization.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Flaky UI test stabilization
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: REST API test matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “REST API test matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to rest api test matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: REST API test matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: HTTP error response tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “HTTP error response tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to http error response tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: HTTP error response tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Authentication API testing.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Authentication API testing” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to authentication api testing.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Authentication API testing
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Pagination and filtering tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Pagination and filtering tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to pagination and filtering tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Pagination and filtering tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Contract testing plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Contract testing plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to contract testing plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Contract testing plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Webhook delivery test.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Webhook delivery test” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to webhook delivery test.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Webhook delivery test
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Idempotency test suite.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Idempotency test suite” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to idempotency test suite.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Idempotency test suite
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Rate limit test plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Rate limit test plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to rate limit test plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Rate limit test plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: API negative cases.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “API negative cases” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to api negative cases.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: API negative cases
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in api & integration testing. Your assignment is: Service dependency mock plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Service dependency mock plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the api & integration testing angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to service dependency mock plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Service dependency mock plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Smoke suite selection.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Smoke suite selection” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to smoke suite selection.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Smoke suite selection
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Regression suite audit.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Regression suite audit” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to regression suite audit.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Regression suite audit
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Release gate checklist.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Release gate checklist” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to release gate checklist.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Release gate checklist
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Pull request QA plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Pull request QA plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to pull request qa plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Pull request QA plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Parallel test execution.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Parallel test execution” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to parallel test execution.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Parallel test execution
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: CI failure triage.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “CI failure triage” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to ci failure triage.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: CI failure triage
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Test report dashboard.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test report dashboard” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test report dashboard.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test report dashboard
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Test suite maintenance.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test suite maintenance” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test suite maintenance.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test suite maintenance
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Rollback verification plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Rollback verification plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to rollback verification plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Rollback verification plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in regression & ci/cd. Your assignment is: Deployment sanity checks.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Deployment sanity checks” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the regression & ci/cd angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to deployment sanity checks.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Deployment sanity checks
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Load test scenario.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Load test scenario” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to load test scenario.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Load test scenario
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Stress test scenario.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Stress test scenario” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to stress test scenario.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Stress test scenario
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Spike test scenario.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Spike test scenario” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to spike test scenario.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Spike test scenario
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Soak test scenario.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Soak test scenario” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to soak test scenario.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Soak test scenario
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Performance baseline.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Performance baseline” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to performance baseline.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Performance baseline
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Latency percentile analysis.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Latency percentile analysis” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to latency percentile analysis.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Latency percentile analysis
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Bottleneck hypothesis.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Bottleneck hypothesis” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to bottleneck hypothesis.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Bottleneck hypothesis
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Capacity test plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Capacity test plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to capacity test plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Capacity test plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Recovery and resilience test.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Recovery and resilience test” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to recovery and resilience test.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Recovery and resilience test
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in performance & reliability. Your assignment is: Performance result summary.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Performance result summary” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the performance & reliability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to performance result summary.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Performance result summary
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Security acceptance tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Security acceptance tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to security acceptance tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Security acceptance tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Role-based access tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Role-based access tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to role-based access tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Role-based access tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Input validation checks.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Input validation checks” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to input validation checks.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Input validation checks
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Session management tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Session management tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to session management tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Session management tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Privacy consent test plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Privacy consent test plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to privacy consent test plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Privacy consent test plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: PII redaction QA.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “PII redaction QA” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to pii redaction qa.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: PII redaction QA
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: WCAG keyboard navigation.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “WCAG keyboard navigation” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to wcag keyboard navigation.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: WCAG keyboard navigation
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Screen reader test script.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Screen reader test script” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to screen reader test script.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Screen reader test script
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Contrast and zoom review.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Contrast and zoom review” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to contrast and zoom review.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Contrast and zoom review
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in security, privacy & accessibility qa. Your assignment is: Safe vulnerability reporting.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Safe vulnerability reporting” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the security, privacy & accessibility qa angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to safe vulnerability reporting.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Safe vulnerability reporting
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Android device matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Android device matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to android device matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Android device matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: iOS device matrix.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “iOS device matrix” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to ios device matrix.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: iOS device matrix
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Offline and poor-network tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Offline and poor-network tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to offline and poor-network tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Offline and poor-network tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Orientation change tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Orientation change tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to orientation change tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Orientation change tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Push notification tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Push notification tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to push notification tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Push notification tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Battery and resource checks.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Battery and resource checks” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to battery and resource checks.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Battery and resource checks
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Internationalization test plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Internationalization test plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to internationalization test plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Internationalization test plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Localization QA checklist.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Localization QA checklist” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to localization qa checklist.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Localization QA checklist
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Usability task scripts.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Usability task scripts” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to usability task scripts.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Usability task scripts
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in mobile, cross-platform & usability. Your assignment is: Compatibility risk report.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Compatibility risk report” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the mobile, cross-platform & usability angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to compatibility risk report.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Compatibility risk report
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: AI generated test review.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “AI generated test review” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to ai generated test review.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: AI generated test review
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: LLM application evaluation rubric.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “LLM application evaluation rubric” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to llm application evaluation rubric.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: LLM application evaluation rubric
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: Prompt injection defense tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Prompt injection defense tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to prompt injection defense tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Prompt injection defense tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: Hallucination evaluation set.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Hallucination evaluation set” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to hallucination evaluation set.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Hallucination evaluation set
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: Nondeterministic output tests.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Nondeterministic output tests” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to nondeterministic output tests.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Nondeterministic output tests
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: RAG citation verification.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “RAG citation verification” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to rag citation verification.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: RAG citation verification
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: Dataset quality audit.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Dataset quality audit” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to dataset quality audit.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Dataset quality audit
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: AI bias evaluation plan.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “AI bias evaluation plan” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to ai bias evaluation plan.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: AI bias evaluation plan
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: Human-in-the-loop review.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Human-in-the-loop review” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to human-in-the-loop review.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Human-in-the-loop review
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in ai-assisted qa & evaluation. Your assignment is: AI QA limitations statement.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “AI QA limitations statement” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the ai-assisted qa & evaluation angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to ai qa limitations statement.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: AI QA limitations statement
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: QA portfolio case study.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “QA portfolio case study” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to qa portfolio case study.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: QA portfolio case study
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: GitHub test repository README.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “GitHub test repository README” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to github test repository readme.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: GitHub test repository README
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: Remote QA resume bullets.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Remote QA resume bullets” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to remote qa resume bullets.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Remote QA resume bullets
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: QA interview practice.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “QA interview practice” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to qa interview practice.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: QA interview practice
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: Freelance QA proposal.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Freelance QA proposal” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to freelance qa proposal.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Freelance QA proposal
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: Client onboarding checklist.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Client onboarding checklist” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to client onboarding checklist.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Client onboarding checklist
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: Daily QA status update.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Daily QA status update” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to daily qa status update.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Daily QA status update
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: QA handoff package.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “QA handoff package” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to qa handoff package.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: QA handoff package
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: Test automation demo storyboard.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “Test automation demo storyboard” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to test automation demo storyboard.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: Test automation demo storyboard
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.

Act as a senior software QA engineer specializing in client delivery & remote qa career. Your assignment is: 30-day QA learning roadmap.

PROJECT INPUTS
Product/feature: [PRODUCT_OR_FEATURE]
Requirements or user story: [REQUIREMENTS]
Audience and critical workflows: [TARGET_USERS]
Technology and test tools: [TECH_STACK]
Test environment and available evidence: [ENVIRONMENT]
Risks, constraints, deadlines: [RISK_AND_CONSTRAINTS]

INSTRUCTIONS
1. Translate the assignment “30-day QA learning roadmap” into a concrete, executable QA deliverable for this project, not a generic explanation. State assumptions and mark any missing details as questions; never invent observed test results.
2. Focus on the client delivery & remote qa career angle. Identify the most important success path, negative path, edge case, and failure or recovery path relevant to 30-day qa learning roadmap.
3. Provide an ordered implementation or test procedure with setup, input/action, expected result, evidence to capture, and cleanup where applicable. Include example test data with safe fictional values.
4. Explain which parts can be automated, what needs human judgment, and how to avoid brittle tests or false positives. When code is useful, use [TECH_STACK], include readable comments and explain how to run it; do not assume tools or endpoints exist.
5. Include a compact coverage and prioritization table, review checklist, blockers, and clear acceptance criteria. Protect secrets and personal data, and only test systems with authorization.

OUTPUT FORMAT
A. Objective and assumptions
B. Deliverable: 30-day QA learning roadmap
C. Numbered test steps / implementation details
D. Expected outcomes and evidence checklist
E. Risks, gaps, and follow-up questions
F. Definition of done.
Write in practical professional English. Distinguish proposed tests from executed tests.