Before putting AI-generated code into production you must check the behaviour of the process, permissions and error handling. A screen that works during the demo shows one successful path; it does not show that all relevant cases have been checked.
AI can help you write and modify code. The amount produced, though, does not measure how complete the software is. The useful question is understanding what has been checked, with which tests and what limitations remain open.
Write the expected result before reviewing the code
Imagine a form that creates a request and a task. The code can do both operations without following the business rule: it might assign the wrong team, accept incomplete data or show a confirmation before everything is saved.
Define the conditions first: which fields are mandatory, when the request is valid and which rule determines the assignment. Also specify what the person should see when the process cannot go on.
In its guide to reviewing AI-generated code, GitHub recommends comparing the result against the requirements and project context, plus running tests and code analysis. The check concerns what the software must do, not just the absence of syntax errors.
Test what the demo does not show
Use test cases drawn from the expected work. For a form, do not stop at a complete submission. Remove a required field, enter an unexpected value and try to reopen the record after saving.
An illustrative example of verification
Condition: the request has been saved but the service creating the task does not respond.
Decision to make: does the request stay on hold? Who sees it? How is the work completed without creating a second form?
Test: simulate the interruption and check the saved status, the message shown and the behaviour after service recovery.
The right answer depends on the project. The point is to make it explicit and test it, rather than letting it surface for the first time with a live request.
Distinguish a new submission from a repeat of the same one
A double click, a reloaded page or a lost response can lead to repeating an operation. Disabling the button in the interface helps the experience, but duplicate checking must exist in the service that saves the data.
Check both a repeat of the same request and a new request with identical values. Two people can order the same product in the same quantity: comparing only the fields risks rejecting a legitimate operation.
When the outcome of a request sent to an external service is uncertain, the system must distinguish uncertainty from confirmed failure. The recovery procedure depends on the verification options and guarantees offered by the service involved.
Check who can see and modify the information
Test the flow with different roles. Who can open the form? Who can change assignment? What happens if someone tries to view a request outside their scope?
Hiding a button is not enough to prevent an operation: authorisation must be checked by the service that performs it. Tests must therefore also cover data access and direct requests to application functions.
Also check what ends up in error logs. A useful diagnosis does not need to write passwords, tokens or full copies of received data. Define necessary information, access and log retention based on the project.
A passing test must be read alongside what it checks
A test suite can pass even if an important case is missing. If the code and test start from the same wrong interpretation they can be consistent with each other but not with the requirement.
So ask which behaviours are covered and which remain to be tested. Also review the dependencies introduced: origin, maintenance and compatibility with the project. GitHub documentation explicitly calls out these checks and asks you to pay attention to tests removed or skipped during changes.
Human review also serves to read the process from outside: someone who knows the task should be able to recognise the agreed rules in the tests. AI can help with review, but a positive answer from it does not replace this check.
Before go-live
Prepare an identifiable release, listing the changes included, the tests run and the open limitations. Check backup and recovery options, especially if data or file structures change. Clarify who watches the first results and how to pause operations if a problem emerges.
A useful question for the supplier is concrete: “Which cases have you tested, and what happens when one of the steps fails?” The answer should be verifiable, not left to a generic reassurance.
Digital Titan develops software and integrations for companies. Before expanding a flow, it is useful to focus on the process to verify and define the conditions that make it ready for use.
Let’s talk about the process you want to put into production

