AI coding assistants in a PCI-scoped codebase
By Sam Rivera, Founder, SentinelPanda · October 24, 2026 · 4 min read · AI Governance
The assistant is not a new requirement. It is a new author — and Requirement 6 has opinions about authors.
What actually changes
Very little in the standard, and that is the point. Requirement 6 asks that software be developed securely, that developers be trained, that code be reviewed before release, and that components be inventoried. None of those clauses care whether a human or a model produced the first draft. What changes is the shape of the work behind each clause, and the assumptions a team carries into it.
The failure mode is not that an assistant writes insecure code. It is that the surrounding process was calibrated for a human author who could explain their reasoning, and quietly stops working when the author cannot.
Who is the author?
Requirement 6.2.3 expects bespoke and custom software to be reviewed before release to production. Where that review is manual, 6.2.3.1 adds that it must be performed by someone other than the originating author, and by someone knowledgeable in secure coding practices.
A developer who accepts a generated block has authored it for this purpose. They are the one who put it in the branch, and they cannot be their own reviewer on the grounds that a model wrote it. Teams that treat accepted suggestions as pre-reviewed because a machine produced them have removed a control without recording the decision.
Review gets harder, not easier
Human-written code carries intent you can interrogate. A reviewer can ask why a query was built that way and get an answer that reveals whether the risk was considered. Generated code arrives with fluent structure, plausible naming and no reasoning behind it, which makes review feel faster while giving the reviewer less to work with.
Requirement 6.2.4 asks for software engineering techniques that prevent or mitigate common attacks — injection, insecure deserialisation, broken access control and the rest. Those techniques are satisfied by the code that ships, not by the tool that drafted it. The assistant may produce parameterised queries by default. It may also produce string concatenation if the surrounding file does, because it matches context rather than policy.
The inventory problem
Requirement 6.3.2 expects an inventory of bespoke and custom software and third-party software components, so vulnerabilities and patches can be managed. Generated code introduces dependencies — a helper library, a date parser, a crypto wrapper — chosen because they were common in training data rather than because anyone evaluated them.
That is how a package nobody selected ends up in a payment service. The inventory requirement is the control that catches it, but only if the inventory is produced from what is actually in the build rather than from what the team remembers adding.
Where the real exposure sits
- Secrets in prompts. Pasting a config file, a stack trace or a connection string into an assistant sends it to a third party. If the snippet contains a live key, the key is disclosed, and rotating it is the only remedy.
- Test data that is not test data. Asking for help with a failing payment test tends to involve pasting the payload. Real card numbers used as fixtures become real card numbers in someone else's logs.
- Plausible-looking crypto. Generated code that calls a cipher with a hardcoded IV, or rolls its own token comparison, reads correctly to a reviewer skimming for syntax.
- Silent licence drift. Suggested code can carry the shape of a licensed project, which is a legal question rather than a PCI one but lands on the same team.
Training is still annual, and still yours
Requirement 6.2.2 asks that software development personnel be trained at least annually in secure software design and secure coding, including how to avoid common vulnerabilities. If assistants are part of how your team writes code, the training that mentions them is the training that matches reality.
The practical content is short: what may not be pasted into a prompt, that accepting a suggestion makes you its author, and that generated dependencies go through the same approval as any other.
A reasonable position
None of this argues for banning the tools. It argues for not letting them quietly remove a control that was already in place. Write down that the accepting developer is the author, keep review independent of that person, generate the component inventory from the build rather than from memory, and tell people plainly what must never go into a prompt.
That is a short policy, and it leaves Requirement 6 answerable in the same terms it was answerable in before.