Picture a VP of Engineering with four product teams and a question from the leadership team: how are we using AI in testing? She asks the QA leads and gets four honest answers, each describing a different practice. The payments team generates API test scaffolding with an assistant in the editor and reviews it like any other code. The onboarding team drafts test cases from tickets in a chat tool, using a prompt one tester has refined for months in her own chat history. The search team pastes failing CI logs into whichever assistant is open, and those logs sometimes contain customer email addresses. The platform team believes it does not use AI for tests at all, while two of its engineers do, quietly. And in every team, a reviewer approving a pull request cannot tell which tests a person wrote and which a tool drafted. The example is illustrative, not a client case.
None of this is reckless on its own. But the VP cannot describe practice she cannot see, cannot onboard people into habits that live in private chat histories, and cannot compare generated tests across teams that work differently.
QA practitioners elsewhere report a related blind spot. In a survey published by DeviQA, a software testing company, 19.4% of the QA practitioners who responded answered “I don’t know” when asked whether their development team uses AI to generate code. The 300 respondents were reached through the company’s internal QA network and took part voluntarily, so read the figure as a signal, not an industry measure.
There is also a European regulatory backdrop. As of November 2026, the European Commission’s AI literacy questions and answers, updated on 20 October 2026, says the amendments to Article 4 of the AI Act brought about by the Digital Omnibus on AI “entered into force in mid-July 2026”. The page summarises the obligation: providers and deployers of AI systems must “take measures to support the development of AI literacy” of their staff and others dealing with the operation and use of AI systems on their behalf. The page says no specific or “sufficient” level is mandated. According to the page, national market surveillance authorities supervise and enforce the rules from 2 August 2026. This article does not say what meets that obligation and is not legal advice; that question belongs with your legal or compliance adviser. The engineering problem exists either way.
How the problem looks from each role
VP of Engineering. Sees teams that each made sensible local choices, and no single account of how AI is used in testing across them. The fears are specific: test data or logs leaving the organisation through an unapproved tool; generated tests of uneven quality passing review because nobody knew they were generated; onboarding that depends on whom a new starter sits beside; and a question from leadership, a customer’s security questionnaire or a due-diligence request that can only be answered with anecdotes. The decisions are what to make common across teams and what to leave to each, who owns the agreement, how much QA-lead time to set aside for the inventory, trial runs and quarterly summaries, and what evidence to ask the QA leads for each quarter. The detail can be delegated; those four decisions cannot.
QA lead or test manager. Sees generated tests arrive in review unmarked, good prompts locked in one colleague’s chat history, and new joiners copying whichever habit they saw first. The fears are being blamed for an escaped defect in a test nobody knew was generated, and being cast as the person who polices colleagues’ tools. The decision is how to turn the team’s real tasks into rules people can follow without slowing down. The QA lead writes and maintains most of the agreement.
Why the usual responses fall short
“Standardise on one tool.” One tool can still be used in four different ways. What matters, such as allowed inputs, how output is reviewed and where good prompts are kept, sits above the tool. Tools and their models also change on the vendor’s schedule, as the model-swap runbook describes, so an agreement tied to one product ages quickly.
“Write an AI policy.” An organisation-wide policy usually covers approved vendors, data classification and acceptable use. It is a necessary input, but it does not tell a tester whether a CI log may be pasted into an assistant, or what to check in a generated test. Teams need guidance at the level of the task.
“Run a training session.” Attendance shows that people were present, not that practice changed. As the handover article argues, the test is whether people can apply the practice to the actual product.
“Commit an instruction file and call it done.” Instruction files for coding agents are now a recognised convention. The AGENTS.md site describes “a simple, open format for guiding coding agents”, used by “over 60k open-source projects” and “now stewarded by the Agentic AI Foundation under the Linux Foundation”. That is evidence of a convention, not a tool recommendation. The same page says the nearest file in the directory tree takes precedence and that explicit chat prompts override everything. A file guides an agent but enforces nothing, and it does nothing for someone pasting text into a chat window.
A practical method: a working agreement built from real tasks
The method produces two artefacts: a working agreement of one or two pages for people, and a shared instruction file with versioned prompts for tools. Both are built from work the teams already do.
1. Inventory real use for two weeks
Ask each QA lead to collect examples, not opinions. For each recurring use, record the task, the kind of tool, the inputs, the output, who reviews it and where the prompt lives. Say clearly that this is not a hunt for wrongdoing, or the platform team’s quiet users will stay quiet.
2. Choose three to five shared tasks
Pick the recurring tasks that appear in more than one team, such as drafting test cases from tickets, generating API test scaffolding, summarising failing runs or drafting bug reports. Write the agreement per task, not per tool: “summarise a failing CI run” stays stable while tools change.
3. Write the agreement in two layers
The cross-team core is owned by the VP of Engineering and stays short:
- Data boundaries per task. Which inputs are allowed, and what must be removed first: personal data, credentials, customer content. Refer to the organisation’s list of approved tools rather than repeating it.
- Marking generated work. One mechanism for every team, such as a pull-request label or a line in the commit message, so reviewers know what a tool drafted. It informs review; it does not rank people.
- A minimum review rule. A generated test is reviewed against the requirement it claims to cover, not the code it was generated from, and the reviewer confirms it would fail if that behaviour broke. Teams may add checks, not remove them.
- Ownership. A named owner, a maintainer in each team and a next review date.
Each team annex is owned by its QA lead: the team’s tasks, worked examples from its own product, shared prompts and any stricter limits.
4. Put the shared instructions in the repository
Keep an instruction file for coding agents at the repository root: how to run the suite, fixture and data patterns, naming, what generated tests must never contain, and a link to the agreement. In a monorepo, teams can add files in their own directories. Under the AGENTS.md convention the nearest file takes precedence; tools may differ in which instruction files they read and how they combine nested ones, so check your tools’ documentation. Keep one canonical core at the root, limit team files to additions, and check in review that no team file contradicts the core. Confirm in the step 5 trial runs that each tool still applies the root rules when working in a team directory; if one does not, pull the core in with that tool’s own include mechanism or copy it into the team file, keeping the root file canonical. Prompts for chat-based tasks go in a versioned folder and are reviewed like code, so a prompt someone refined for months becomes a team asset.
5. Test every rule on a recent task
Before publishing, each QA lead redoes one recent ticket per shared task under the draft rules. A rule that could not be followed, or that nobody could check, is rewritten or removed. This is usually where “use AI responsibly” turns into something specific.
6. Make it part of onboarding
In their first fortnight, a new starter completes two shared tasks with the agreement and shared prompts, and their QA lead reviews the result. If they have to ask where the prompts are, the gap is in the agreement.
7. Review quarterly and keep the history
Each quarter, the QA leads send the VP a short summary: changes to the agreement and why, data-boundary exceptions and how they were handled, the main reasons generated tests were rejected in review, and the share of merged test changes marked as tool-assisted. That share is for visibility, not a target. Version history shows reviewers and new starters why each rule exists, keeps teams working from the same current version, and lets the VP describe practice across teams from one shared account rather than four recollections.
Where this approach stops working
It is not a compliance determination. The agreement describes engineering practice. It does not show that a legal obligation is met, and it does not replace the organisation’s AI, security or data protection policies.
Marking depends on honesty. No label detects unmarked generated code. The agreement makes disclosure normal and cheap; if disclosure is punished, the markers disappear.
Instruction files guide; they do not enforce. Boundaries that really matter need controls outside the file, such as tool approval and access settings.
Risk differs between teams. A team testing payment flows and one testing an internal dashboard should not have identical rules. Keep the core small and let the annexes differ. With a single small team, a page in the repository and a prompt folder may be the whole agreement.
Higher-risk contexts. The Commission’s page notes that, for deployers of high-risk AI systems, the obligation to ensure staff are trained for human oversight remains in place. A working agreement for test tooling does not address that.
What to standardise, and a checklist for the VP
| Element | Common to all teams | Left to each team | Owner |
|---|---|---|---|
| Data boundaries per task | Yes | Stricter limits where the product needs them | VP of Engineering |
| Marking generated work | One mechanism | Nothing | VP of Engineering |
| Minimum review rule | Yes | Additional checks | VP of Engineering; QA leads apply it |
| Approved tools | Set by organisation policy | Which approved tool suits each task | Policy owner |
| Instruction file | Core conventions at the root | Additions in team directories | A named QA lead; core content from the VP’s agreement |
| Shared prompts and examples | Kept in version control | Their content | QA lead |
| Quarterly summary | One format | Its content | QA leads, to the VP |
Ask your QA leads to confirm each of these:
- Each team can list where AI is used in its testing, with a recent example of each use.
- The written agreement has a named owner, a maintainer in each team and a next review date.
- Data boundaries are stated per shared task, and people know what to remove before using a tool.
- Generated tests are identifiable in review through one agreed mechanism.
- Generated tests are reviewed against the requirement and confirmed to fail if that behaviour broke.
- Instruction files and shared prompts are in version control and change through review.
- Every rule was tried on a recent real task before publication.
- A new starter can find and use the agreement in their first fortnight without asking.
- The first quarterly summary is in the calendar.
A working agreement lasts when the people who use it wrote it from their own work. Our QA Enablement & Advisory service starts by identifying one capability gap and the work it affects, such as AI-assisted testing practised differently in every team. It helps your teams write clear working agreements for ownership, reviews, test design, AI usage and escalation, through practical workshops built on representative tasks and artefacts from their daily work, and ends with a sustainable handover so your QA leads can maintain the agreement themselves.
