Skip to content

Business Rule Change

This guide is meant to help you understand what the AI assistant does when it runs this playbook. The idea is that you can read it, understand what happens at each step, and know what information you need to give the assistant so the work turns out well β€” without needing to know how to code.

In short

  • What it's for: updating only the tests affected by a business rule that changed on purpose, without redoing the whole module and without losing the old cases.
  • When to use it: when a rule that was already documented and tested changed because of a business decision and the user story is already updated.
  • What you need: the updated story, the module's previous test plan and test suite, which rule changed (before and after) and someone who can confirm the decisions.
  • What you get: the plan and suite up to date, the obsolete cases archived with their reason, the module regression and a report with the "before" and the "after".
  • Steps: 5 β€” detect what changed, regenerate the plan, archive what's obsolete and regenerate the suite, run and repair, and report (with two human review pauses in between).

Functional name

"Business rule change". It's used when a rule that was already documented and tested changes intentionally (it's not a bug, it's a business decision) and you need to update only what that change affects.

What is a playbook? (if this is your first time using one)

It's like, for example, the checklist a pilot follows before takeoff: they don't improvise every time, they follow a proven sequence of steps. A playbook is that same idea applied to testing an application: a written recipe that tells the AI model, step by step, what to do using different elements/tools called "skills".

A skill is the specific tool that carries out each step of the playbook. You interact with the playbook β€” the assistant takes care of using the right tool at each moment.


1. Key concepts before you start

If any of these terms is new to you, open it to see the explanation:

Business rule and \"test basis\"

A business rule is a condition the application must meet no matter what because the business decided so (business = the area that requests the requirement to be built) β€” it's not a design preference, it's a rule. Examples: "the password must have at least 8 characters", "a transfer of more than $50,000 requires a second authentication factor", "when roaming, the first 500MB are free".

The document (or set of documents) where that rule is written down is a user story; in testing terminology, the test basis: it's the material against which you decide whether the application is right or wrong, the material the tester/QA would use as the basis of their analysis to create all the test cases they would then run (if they didn't have an agent). When the rule changes, the first thing that changes is the test basis (the story is updated and, therefore, the test cases).

User story and acceptance criterion (AC)

A user story describes a feature from the point of view of whoever uses it, without going into technical details of how it's built. Inside a story there are several specific rules: each of those rules is an acceptance criterion (AC) β€” think of it as a single line in a car inspection checklist ("the handbrake holds on a slope"). When a business rule changes, what usually changes specifically is one or more ACs of the story: they're added, rewritten or removed.

Test case

A test case is a specific, concrete test: it has input steps, a starting condition, and an expected result β€” it's designed to check a single thing, usually a single acceptance criterion. It's like a single exam question: it doesn't assess the whole subject, it assesses one specific point of the syllabus.

When a rule changes, the test cases that validated the old rule become outdated β€” not because they're badly written, but because they ask about something that's no longer the current rule, so they should always be updated.

Regression testing

A regression test means running the tests that already existed again, after a change, to confirm that the change didn't break anything that was already working (previous, existing test cases not related to this current user story). It's like when the mechanic, after fixing your brakes, also checks the lights and the steering β€” not because they suspect them, but to confirm that touching one part of the car didn't knock another out of place.

This playbook runs a regression of the complete module (not just the cases that touch the rule that changed), because a rule change can have effects on neighboring flows in the same module that at first glance don't seem related. It doesn't run the entire application β€” the scope is limited to the module of the user story that changed.

Maintaining and retiring test cases (archiving)

Test maintenance is the task of keeping existing test cases up to date as the application (or the rule they describe) changes β€” so they keep detecting real problems and don't end up talking about a behavior that no longer exists.

Part of that maintenance is retiring test cases that have become obsolete: when a case no longer corresponds to any current rule, it's archived β€” moved to a separate folder with the reason it's no longer in effect β€” but it isn't deleted. Keeping it (instead of deleting it) preserves traceability: in the future, anyone can open that file and understand which rule it validated and why it stopped applying, instead of finding an unexplained gap.

Automatic test repair (\"self-healing\")

It's the ability to detect when a test case failed for a minor, expected reason (for example, the correct result changed value because the rule changed) and adjust it on its own, without a person having to rewrite the test code by hand. This ability is called automatic repair or "self-healing".

It's a real help β€” it saves hours of manual work β€” but it's not infallible: that's why this playbook includes a specific human check to review what the automatic repair decided (see "Human oversight" below).

False negative (and why \"all green\" isn't always enough in reports)

A false negative is when a test accepts as fine a situation that's actually wrong: the test "passes" (it's green), but not because the application is correct β€” because the test stopped requiring what it should require. It's like a smoke detector with the battery removed: it doesn't go off, but not because there's no smoke β€” it doesn't go off because it can't detect anything.

This is the concrete risk of automatic repair: if it adjusts a test so it passes, but the new value it accepts doesn't match what the updated rule actually requires, the whole suite turns green while hiding a real problem. That's why, in this playbook, every automatic adjustment is reviewed by hand before it's accepted.

Human oversight (why some steps aren't delegated)

Not every decision in this process should be left in the hands of the assistant. Deciding which test case to archive (is it really obsolete, or does it still serve another purpose?) and validating that an automatic adjustment is correct (does the new value really match the new rule?) are judgments that require business criteria β€” context the assistant doesn't always have in full. That's why this playbook has two control points marked as manual, where the work stops until a person confirms before continuing.


2. What does this playbook do?

It's the playbook you use when a business rule that was already documented and tested changed β€” on purpose, because of a business decision β€” and the user story was already updated to reflect that change.

Instead of redoing the module's entire test plan from scratch, this playbook:

  1. Detects exactly what changed by comparing the updated story against the previous test plan (the "before" against the "after").
  2. Regenerates only the test cases for the new or modified rules β€” it leaves untouched the ones that weren't affected.
  3. Archives (doesn't delete) the test cases the new rule made meaningless, with the reason documented.
  4. Runs the module's complete suite to confirm that the rule change didn't cause side effects in other parts.
  5. Delivers a report that records, in a single document: which rule changed (before β†’ after), which cases were archived and why, and what ended up covered.

3. When should I use this playbook (and when not)?

Situation This playbook?
A business rule changed intentionally and the story is already updated βœ… Yes
An acceptance criterion was rewritten, added or removed βœ… Yes
You need to update only the affected test cases, without redoing the whole module βœ… Yes
You need a record of which cases became obsolete and why, without losing them βœ… Yes
What changed is an unintentional behavior (something broke on its own) ❌ No β€” it's a bug: use the bug reproduction playbook or the bug fix cycle playbook
The code was refactored but the business rule is still the same ❌ No β€” it's enough to run that module's existing suite again with lippia-neo-run-and-heal
The module doesn't have any test plan or suite yet ❌ No β€” first use the project setup playbook

Important

  • This playbook doesn't start from scratch: it needs a previous test plan and an earlier suite for the module to already exist. If they don't exist, there's nothing to compare the change against.
  • The decision about which test cases to archive and the one about validating the automatic adjustments are manual β€” the assistant prepares the information, but you give the final confirmation (see "Human oversight" in the key concepts).

4. Real business examples

E-commerce β€” TechStore strengthens password security

Previous rule The password had to have a minimum of 8 characters.
New rule The password must have at least 12 characters, with at least one uppercase letter, one number and one symbol.
Why it changed A security decision by the product area, after an audit.
What the playbook does Archives the cases that tested the 8-character limit, generates new cases for the 12 characters and the three added requirements, and confirms that the rest of the sign-up form still works the same.

Telecommunications β€” free roaming data limit

Previous rule The first 500MB of roaming data were free.
New rule The free limit goes up to 1GB, and from there on each additional MB is charged.
Why it changed A new commercial promotion in effect starting the following month.
What the playbook does Archives the cases that validated the 500MB cutoff, generates new cases for the 1GB cutoff (including the exact boundary: 999MB, 1000MB, 1001MB), and runs the regression of the usage module to confirm that the overage charge still works properly.

Banking β€” maximum transfer amount without two-factor authentication

Previous rule Transfers of up to $50,000 didn't require a second authentication factor.
New rule The amount free of a second factor drops to $20,000, due to a new fraud prevention policy.
Why it changed A risk decision by the bank's security area.
What the playbook does Archives the cases that tested the $50,000 limit, generates new cases for the $20,000 limit (including transfers of exactly $19,999, $20,000 and $20,001), and validates that transfers below and above the new limit keep behaving as they should.

4.1 Before you start: what you need to have on hand

Information Example (TechStore)
Which rule changed, in simple words, before and after "The password went from requiring at least 8 characters to requiring at least 12, with an uppercase letter, a number and a symbol"
The already-updated user story, with the new acceptance criteria user-stories/TS-US-14.md
Where the module's previous test plan is test-plans/TS-US-14-test-plan.md (the project's plans folder)
Where the module's previous test suite is tests/playwright/TS-US-14/ (a folder with the story ID, inside the project's tests folder)
A story identifier (US-ID) TS-US-14
The project already initialized to work with the QA assistant (a base stack configuration exists, qa-stack.yaml) If the project doesn't have it yet, you need to run the project setup playbook first
(Recommended, not mandatory) The findings from a previous exploration of that module They're in execution/TS-US-14/. If they exist, the assistant reuses them so it doesn't have to explore the screen again; if the new rule added or moved elements on screen, a targeted exploration will be needed anyway (see Step 3)
Someone who can confirm which test cases to archive and validate the automatic adjustments The QA or product lead for the affected module

If you don't have some of this information on hand (for example, you don't know the exact path of the previous plan), that's fine β€” you can ask the assistant and it will help you find it.

Original playbook

The general playbook can be found in the NEO-releases repository.


4.2 How to start

Before Step 1, tell the assistant which rule changed and where the updated story is:

πŸ’¬ Prompt for the assistant
Business rules changed in user-stories/TS-US-14.md.
Which rule changed: the password went from a minimum of 8 characters to a minimum of 12,
with an uppercase letter, a number and a symbol.
The module's previous plan and suite are already in test-plans/ and tests/playwright/TS-US-14/.
Just record this context. Don't read files, don't run any step, don't call any skill,
don't save anything to memory. Confirm in one line which rule changed and wait for my next instruction.

With that context, the assistant can go through all the following steps without you having to repeat it every time.


4.3 Step by step

Step 1 of 5 β€” Reread the story and detect what changed

Skill used: lippia-neo-read-user-story

What happens: the assistant rereads the updated story, extracts the current acceptance criteria, and compares them against the previous test plan. It assigns each criterion a label:

Label What it means
New It didn't exist before β€” test cases need to be created from scratch
Modified It already existed, but the rule changed β€” the cases that covered it need to be regenerated
Unchanged It stays the same β€” it isn't touched
Removed / superseded The new rule made it meaningless β€” a candidate for archiving

Ask for the comparison explicitly

The skill reads the story as it is today β€” it doesn't compare versions on its own. You have to ask for the comparison against the previous plan in the same message; otherwise, the assistant extracts the criteria but doesn't label anything.

πŸ’¬ Prompt β€” Step 1
/lippia-neo-read-user-story

Then read test-plans/TS-US-14-test-plan.md, compare it with the criteria you just extracted
and classify each one: new / modified / unchanged / removed.

What you have at the end of this step: a clear list of what changed and what didn't. With TechStore, for example: "the minimum 8 characters criterion is REMOVED, and four NEW criteria are added: minimum 12 characters, mandatory uppercase letter, mandatory number and mandatory symbol".

Checkpoint β€” Labeled criteria

You have the list of labeled criteria and, for each one, which test files cover it today (in tests/playwright/TS-US-14/). Without this list, the archiving in Step 3 would be done blindly.


Step 2 of 5 β€” Regenerate the plan for the affected flows

Skill used: lippia-neo-create-test-plan

What happens: with the list from Step 1, the assistant rewrites the test plan: it adds scenarios for the new and modified criteria, leaves the scenarios for the unchanged criteria untouched, and removes from the plan the scenarios for the removed criteria.

By default, the skill builds the plan from scratch for all the criteria. That's why you have to tell it explicitly to read the existing plan, to limit itself to what changed and to rewrite the same file:

πŸ’¬ Prompt β€” Step 2
/lippia-neo-create-test-plan
Read the current plan in test-plans/TS-US-14-test-plan.md, regenerate the scenarios for the
new and modified criteria (according to the diff), keep the scenarios for the unchanged
criteria intact (according to the diff), and completely rewrite the file you read.

Confirm the rewrite

Since the plan already exists, the assistant will warn you before overwriting it (it never overwrites it silently). Tell it yes.

With TechStore, this means the plan ends up with new scenarios for "11-character password" (must be rejected), "exactly 12-character password" (must be accepted), "password without an uppercase letter", "without a number" and "without a symbol" β€” and without any scenario that mentions the old 8-character limit.

Checkpoint β€” Plan regenerated

The regenerated plan has at least one scenario for each new and modified criterion, covers the boundary cases of the new rule (for example, right at the exact number that separates "valid" from "invalid"), and no longer mentions the scenarios of the removed criterion.


πŸ”΄ Human checkpoint β€” Decide what gets archived (pause, can't be delegated)

What happens: first you ask the assistant for the list of candidates to archive β€” the test cases that covered a removed or superseded criterion β€” with the reason for each one:

πŸ’¬ Prompt β€” Candidates to archive
Given the criteria diff from Step 1, list all the files in tests/playwright/TS-US-14/
that cover criteria classified as REMOVED or SUPERSEDED.
For each file: the criterion it covers, the full path of the file,
and one sentence with the reason it became obsolete.

Mandatory pause β€” the assistant doesn't make this decision alone

The assistant's list is only a suggestion. For each candidate, someone on the team confirms one of these three options:

Decision What it means
Archive The case validates a rule that no longer exists β†’ it's archived, with its reason
Keep The case is still valid for something else the new rule didn't touch β†’ it isn't touched
Regenerate It's from the same flow, but the new rule changed what's expected β†’ Step 3 covers it, it isn't archived

With TechStore, the case that tested "an 8-character password is valid" is archived β€” that rule no longer exists β€”, while a case that tested, for example, "the password field can't be left empty" is kept, because that rule didn't change.

What you have at the end: a closed list of the files to archive, each one with its reason in one sentence. For example:

ARCHIVE:
- tests/playwright/TS-US-14/tc-002-password-longitud-min-8.spec.js
  Reason: the minimum 8-character password rule was replaced by multiple
  requirements (AC-02 removed, sprint 2026-06).

Why it's manual

Telling "this is no longer useful for anything" apart from "this is still useful, though in a different way" requires knowing the business β€” it's not something that can be reliably automated (see "Human oversight" in the key concepts).


Step 3 of 5 β€” Archive what is obsolete and regenerate the suite

Skill used: lippia-neo-generate-test-suite (to regenerate the suite; the assistant does the archiving directly, without a specific skill)

What happens: with the decision from the previous checkpoint already made, the assistant:

  1. Moves (doesn't delete) the cases marked as "archive" to a separate folder called _deprecated/, inside the same suite folder (tests/playwright/TS-US-14/_deprecated/), writing the date and the reason on the first line of the moved file.
  2. Generates the new and regenerated test cases according to the plan from Step 2.

Part a β€” Archive. Since you made the checkpoint decision, the assistant doesn't know it: you have to paste your ARCHIVE list into the message. Paste only those entries β€” the ones you decided to keep or regenerate don't go here, and the assistant doesn't decide again what to archive.

πŸ’¬ Prompt β€” Step 3a: archive
Archive the tests in this list (move, don't delete):

ARCHIVE:
- tests/playwright/TS-US-14/tc-002-password-longitud-min-8.spec.js
  Reason: the minimum 8-character password rule was replaced by multiple
  requirements (AC-02 removed, sprint 2026-06).

For each entry:
1. Create the directory tests/playwright/TS-US-14/_deprecated/ if it doesn't exist.
2. Move the file there with git mv.
3. Insert at the top of the moved file the header:
   // [DEPRECATED <today's date YYYY-MM-DD>] <the reason for that entry>

Part b β€” Regenerate the suite. The skill reads the regenerated plan from Step 2, the findings from the previous exploration (in execution/) and qa-stack.yaml, and generates one test file per case in the plan in tests/playwright/TS-US-14/, with names like tc-<nΓΊmero>-<descripciΓ³n>.spec.js (or .spec.ts, depending on the project's language).

Ask it to limit itself to what changed

The skill doesn't limit itself to the criteria that changed. If you don't give it the list of tests that already exist in the module, tell it explicitly to generate only the scenarios for the new and modified criteria.

With TechStore: the old "8 characters" case is kept in the archive folder, with a note saying when and why it stopped being used β€” and the new cases are created for the 12 characters and the three added requirements.

Why the application isn't explored again here

A rule change changes the logic, not the screens: the assistant reuses the buttons and fields it had already identified in the previous exploration. Exception: if the new rule added or moved elements on screen, that data will be missing and the tests will end up with TODO (pending) marks. In that case, before regenerating, ask the assistant for a guided exploration of the affected flow with lippia-neo-run-manual-testing (as in Step 3 of the Feature - New End-to-End playbook) and then regenerate.

Checkpoint β€” Archiving done and suite regenerated

  • Each file in the ARCHIVE list is in _deprecated/, with its header, and the ones you decided to keep or regenerate were not touched.
  • The archived files are effectively out of the normal run (they won't be run by mistake).
  • The new cases match exactly the new and modified criteria from Step 1.
  • No active test is left with TODO marks. Don't leave it for Step 4: there the assistant would fill them in by "guessing" before the first run.

Step 4 of 5 β€” Run and repair the module's complete suite

Skill used: lippia-neo-run-and-heal

What happens: the assistant runs all the module's test cases (not just the new ones), because a rule change can affect neighboring flows that at first glance don't seem related. If a case fails for an expected reason β€” for example, a case that compared against the old value of the rule β€”, the assistant tries to repair it automatically (see "Automatic repair" in the key concepts), adjusting the expected result to the value the new rule dictates.

πŸ’¬ Prompt β€” Step 4
/lippia-neo-run-and-heal
Run the module's complete suite with include_dirs=["TS-US-14"] and max_iterations=2

Why 2 attempts and not 3

In a rule change, many failures are expected: the password that used to be valid is now rejected. In the first attempt the assistant updates those expected values; in the second it confirms everything is green. Two attempts are enough for that without leaving room to disguise a real problem as if it were an intentional change. If it isn't green after 2 attempts, don't raise the number of attempts to "force it": it may be a real regression or a criterion the plan didn't cover.

What you have at the end of this step: how many cases passed and how many failed in the end, how many of the 2 attempts were used, which cases were repaired and with what new value, and the final state of the suite:

Final state What it means
βœ… All green All the cases passed (some perhaps after an adjustment)
⚠️ Stopped because it stopped improving The second attempt didn't fix any more cases
❌ The 2 attempts ran out Some cases are still failing β€” read the details of the reason before continuing

πŸ”΄ Human checkpoint β€” Validate the automatic adjustments (pause, can't be delegated)

Mandatory pause β€” before accepting the suite as good

Someone on the team reviews, one by one, each adjustment the automatic repair made in Step 4. For each adjustment, the questions are always the same:

Question If the answer is "no"
Does the new value match what the updated rule requires? It's a false negative β€” you need to revert the adjustment and report it as a real problem (a defect)
Does the case still test what it claimed to test? The automatic adjustment drifted β€” it needs to be corrected by hand
Did the boundaries of the new rule end up with the correct value? A boundary scenario is missing β€” you need to go back to Step 2

Why it matters

"All green" isn't enough if some adjustment was done wrong β€” it would be a false negative hiding a real problem (see "False negative" in the key concepts). Green with bad adjustments is worse than red. This check is the reason the complete process isn't 100% automated.


Step 5 of 5 β€” Report: rule change + impact on coverage

Skill used: lippia-neo-write-test-report

What happens: the assistant puts together a single report that records, in the same document:

  • The rule that changed, expressed as "before" and "after".
  • The test cases that were archived, with their reason and their new location.
  • The automatic adjustments made during the repair, already validated in the previous checkpoint.
  • The final result of the module's complete regression.

By default, the skill builds the standard sections of the report and doesn't know which rule changed or what you decided in the two checkpoints (you made those decisions outside the chat). That's why you have to paste it into the message:

πŸ’¬ Prompt β€” Step 5
/lippia-neo-write-test-report
Use us_id: TS-US-14

In addition to the standard sections, record in the report:

- UPDATED RULES (as "before" and "after").
- ARCHIVED TCs (from the post-plan checkpoint).
- ASSERTIONS VALIDATED DURING HEALING (from the post-heal checkpoint):
  - <paste here the adjustments you confirmed as correct>

Repeat the rule change even if you already said it

You mentioned it at the start, but paste it again here: if the conversation was summarized or resumed in another window, the assistant may not have it in mind. The same goes for the acceptance criteria from Step 1: without them, the coverage section of the report ends up as "not assessable". Since there was no manual exploration in this flow, the report states "no exploratory testing in this run" β€” that's expected.

What you have at the end of this step: a single document, with date and time, in the project's reports folder (by default test-results/reports/, for example TS-US-14-test-report-2026-06-25-1430.md), which serves as formal evidence that the rule change was covered and that nothing else broke in the process β€” ideal for attaching to the ticket or showing to a stakeholder. It never overwrites a previous report.

Overall report status What it means
βœ… Passed The rule change was covered and the rest of the module keeps working
❌ Failed There are cases failing because of a real application problem
⚠️ Blocked The failures come from the environment or the configuration (for example, credentials); there's no evidence of an application defect

4.4 What do I end up with after all the steps?

What you get What it's for
The updated test plan, with the new rule reflected Documents, once and for all, which rule is in effect today
The new and regenerated test cases They cover exactly the updated rule, boundaries included
The obsolete cases archived (not deleted), with their reason Complete traceability of what used to be tested and why it stopped being tested
Confirmation that the rest of the module keeps working The rule change didn't cause side effects
A single report with the "before" and the "after" Formal evidence to close the ticket or inform the team

5. Common problems (and what to do)

What you see Why it can happen What to do
A case for the old rule keeps running and failing It was archived, but it wasn't excluded from the normal run Confirm with the technical team that the file is outside the group of tests that gets run
The whole suite is green, but the new rule doesn't seem well covered The automatic repair adjusted a case to a value that doesn't match the new rule (false negative) Review that specific adjustment in the post-repair checkpoint, revert it and regenerate the case correctly (for example, the test accepts a password without a symbol because the repair treated it as valid)
When generating the suite, some cases end up marked as pending (TODO) The new rule moved or added elements on the screen that haven't been explored yet Ask for a guided exploration of the affected flow (lippia-neo-run-manual-testing) before generating again
After the 2 repair attempts, something still doesn't pass It may be a real regression, or a criterion the plan didn't cover β€” not just an expected adjustment Read the details of the reason before forcing it to be green β€” don't raise the number of attempts, there may be a genuine problem
No removed criterion is detected The previous plan isn't available or is outdated Recover the previous plan (for example, from the repository history) before starting, or reconstruct by hand what changed
The assistant says it can't generate the suite because the testing tool is "in STUB state" The testing tool configured in the project isn't fully supported yet Let the technical team know
The tests fail at login The project's test credentials (.env.tests file) are empty or incomplete Ask someone on the technical team to fill in the real values β€” they're never written by hand inside the tests β€” and repeat Step 4

6. Visual summary of the flow

flowchart TD
    A([πŸ“ Business rule changed<br/>e.g.: TechStore raises the<br/>password requirement]) --> B
    B["<b>Step 1</b> β€” Reread the story<br/>and detect what changed"] --> C
    C["<b>Step 2</b> β€” Regenerate the plan<br/>for the affected flows"] --> D
    D["πŸ”΄ <b>Human checkpoint</b><br/>Decide what gets archived"] --> E
    E["<b>Step 3</b> β€” Archive what is obsolete<br/>and regenerate the suite"] --> F
    F["<b>Step 4</b> β€” Run and repair<br/>the module's complete suite"] --> G{πŸ”΄ Are the automatic<br/>adjustments correct?}
    G -->|No| H["Revert the adjustment<br/>and report it as a defect"]
    G -->|Yes| I
    H --> I["<b>Step 5</b> β€” Report: rule<br/>change and coverage impact"]
    I --> J([βœ… New rule covered,<br/>obsolete cases archived<br/>with traceability])