Article
Seven Limits an AI Developer Must Never Break
An AI that writes software needs to be told what it cannot do before it is told what to do. The seven limits below are the ones we enforce on every story, in every installation. They are not aspirations written into a policy. They are configuration, and each one exists because of a specific way AI-written software goes wrong.
We have an AI Developer Platform, installed in the client's own Microsoft Azure. This post takes each limit in turn and explains what it prevents.
1. It never touches production
No AI identity holds a production password, a connection string or a release right. The platform works against a private preview built for the story, with its own test database.
What it prevents: a generated change reaching a live customer because the tool happened to have credentials. The practical consequence is that every change to production passes through a person, which is the only reliable guarantee that a person looked at it.
2. It never merges its own work
A human Code Reviewer approves every change. The platform cannot approve, and it cannot merge.
What it prevents: the reviewer being bypassed by the thing being reviewed. It also removes the most common quiet failure in AI delivery, where a change passes because approving it was easier than understanding it. When the merge requires a named person, somebody has to be able to explain what they approved.
3. It never crosses between products
Each product has its own AI identity, its own work queue and its own network rules. Work on one product cannot see or act on another.
What it prevents: the accidental leak that ends trust. A shared identity across products means a prompt, a log line or a configuration detail from one client can surface in another's work. Separation at the identity level is the only version of this that survives a busy week.
4. It never works without recorded consent
A signed agreement covering AI processing comes before any work on client code.
What it prevents: work starting on a vague verbal understanding and the paperwork being sorted out later. It also gives the client a specific, dated decision they can show their own board.
5. It never reaches the open internet
A firewall allows an approved list of addresses only, and logs every refusal.
What it prevents: dependencies pulled from an unapproved source, data leaving through an unexpected call, and prompt injection arriving through a page the model fetched. The logged refusals are useful evidence: they show the boundary being tested rather than merely described.
6. It never overspends its cost ceiling on a story
Every story carries a ceiling. At the ceiling, the work pauses for a person to decide what happens next.
What it prevents: a runaway task quietly consuming budget. It matters most for the finance director, because it converts AI usage from an open-ended meter into a number attached to a piece of work.
7. It never changes the approved tests
Any attempt is reverted and recorded. Tests approved before implementation stay as they were approved.
What it prevents: the system redefining success to match what it produced. This is the single most important limit for anyone auditing the output later, because it keeps the test suite as independent evidence rather than part of the claim.
| Limit | What it prevents | Evidence a buyer can ask to see |
|---|---|---|
| No production access | Unreviewed changes reaching customers | Access configuration and environment boundaries |
| No self-merge | A reviewer being bypassed | Named reviewer on every merge |
| No crossing between products | Data and code leaking across products | Separate identities, queues and network rules |
| Recorded consent | Work starting on an unclear basis | Signed agreement, dated |
| No open internet | Unapproved dependencies and data movement | Allow list and logged refusals |
| Cost ceiling per story | Unbounded spend on one task | Ceiling setting and story cost record |
| Protected approved tests | Success redefined after the fact | Test approval record and change history |
Every action is logged against its story, with its cost
The story log is what holds all of this together. Every action the platform takes is recorded against the story that authorised it, with what it cost. That one design decision turns a security review from an interview into a document check, because the reviewer reads the record instead of trusting the description.
What this looks like in practice
A Product Owner writes a user story with acceptance criteria. The platform writes the tests, then the code, then builds a private preview with its own test database. It stops. A Code Reviewer reads the change, approves or rejects it, and a person releases. The story's log holds the tests, the approvals, the actions and the cost. The platform cannot merge its own work, so every change waits for a named reviewer. Three organisations run it today, 678 stories delivered. How a reviewer works through a change is its own post.
What to do next
If you are evaluating any AI delivery tool, take these seven limits into the conversation and ask which of them are configuration and which are policy. The answer tells you most of what you need to know. Who is accountable when a limit is tested and what the story log shows an auditor are the next two posts to read.