When a line changes over to a different model, the inspection station usually stops. The time does not go into fixturing and alignment; it goes into reprogramming: setting an inspection box for each reference designator, tuning thresholds, building templates. This is often treated as a usability problem, and buyers compare interfaces. It is not a usability problem. The previous generation must be reprogrammed because of how it stores its criteria, and a different interface does not change that.
ACI in this article stands for Automated Cognitive Inspection — the next-generation term for AI AOI: keep the A and the I, and replace the O (optical) with C (cognitive), because the decision basis is cognition rather than the imaging method. The full argument is set out in From AI AOI to ACI.
1. What is actually redone at changeover
Unpack reprogramming and it is three things, done once per reference designator: draw an inspection box, set a group of thresholds for each defect class, and prepare a template image for comparison.
One property of this is easy to miss: the workload grows with the <strong>number of reference designators</strong>, not with the <strong>number of component types</strong>. A board with eight hundred designators drawn from forty part numbers is reprogrammed eight hundred times, not forty.
That property is itself the clue. If the program held knowledge about components, forty part numbers would need teaching forty times. It counts in eight hundreds, which says what is stored is not knowledge about components.
2. What it means to hang a criterion on coordinates
What the previous generation stores is not “what this capacitor normally looks like” but “at this coordinate on this board, draw a box of this size, and the pixels inside it must not differ from this template by more than this number”. The criterion is indexed by position.
Change the board and every clause fails: the coordinate is different, the neighbourhood of the box is different, the reflections and shadows cast by surrounding components are different, and even the silkscreen orientation of the same part may differ. The index is void, and with it the content.
A criterion indexed by position empties out when the board changes — not laziness in the software, but a direct consequence of how it is stored.
3. A test that brings the problem into view
No brochure is needed. Take a part number you have already tuned on the outgoing model, have it appear at a different position on the incoming model, and ask whether the previous generation's program can carry that work across.
It cannot. And that settles the question: it never learned anything about the component; it learned a set of settings about a position. Settings do not transfer. Knowledge does.
4. What changes once the criterion hangs on the component
If the model learns what a class of component normally looks like, that criterion is independent of which board and which coordinate it appears at. The board layout then returns to its proper role: telling the system where to look, not defining what counts as good.
The nature of changeover changes with it — from redefining criteria to redirecting attention. The first must be done designator by designator; the second is one geometric alignment.
5. Redirecting is something a line can already do automatically
What redirection needs is already on the line: the designator list and placement data exist for the pick-and-place machine, not as extra preparation for inspection; panel repetition, rotation and mirroring can be derived by aligning the first article.
- The designator-to-part-number correspondence comes from existing production data and need not be transcribed by hand.
- Draw one sub-board of a panel and the system finds the rest and aligns them position by position.
- First-article confirmation shifts from “check every designator's settings” to “check that the pointing is right” — a different order of magnitude.
What is left for a person is confirmation, not programming. The two sit on different time scales, and conflating them makes the conversation impossible.
6. So zero-code changeover is not “faster programming”
It is not three hours compressed into thirty minutes; it removes the step of defining criteria designator by designator altogether. The difference can be measured without relying on either party's own figures:
The previous generation's changeover time grows with the number of designators. Once the criterion hangs on the component, changeover time grows with the <strong>number of component types appearing for the first time</strong>. In a parts library that has been accumulating for a while, a new model usually contains only a few genuinely unseen types, so that quantity approaches a baseline. This is a testable difference, not a slogan.
7. State the costs plainly
The route is not free, and all three costs sit on the human side:
- A part number appearing for the first time still needs one good sample — nothing can know what an unseen thing normally looks like.
- Special-process parts (irregular, transparent, dark and highly specular) still need a person to look and decide; automatic modelling only proposes a candidate here.
- Alignment depends on correct placement data. If the data is wrong, the system will look diligently in the wrong place and report nothing.
The third deserves its own note, because it fails silently. Once criteria hang on components, pointing becomes the sole source of position; a wrong pointing trips no threshold and simply misses good and bad parts alike. That is exactly what first-article confirmation after a changeover is for.
8. How to test whether a supplier really does this
A demo board proves little, because demo boards have usually been tuned. What works is to bring a board they have not seen, containing some part numbers they have modelled before, and measure two things: how long until the first inspection result, and what a person contributed during that time.
The second matters more than the first. If the contribution is “confirm the box position for each designator”, that is still programming with a different interface. If it is “one good sample for each of these few new component types” plus one first-article confirmation, then the criterion really does hang on the component.
One more thing is easy to omit: change back to the outgoing model. Reversibility of changeover matters as much as its speed; a line that can only move forwards cannot cope with high-mix, low-volume production.
9. When the previous generation is enough
The cases where this does not apply deserve the same clarity:
- A single model in long-run production: programming cost is amortised once, changeover is not the bottleneck, and the money buys more elsewhere.
- Very infrequent changeover: at twice a year, the time saved does not show up in the annual account.
- The criterion is itself a geometric quantity: coplanarity and height difference are specifications rather than appearance judgements, and a rule layer answers them more reliably.
If any of these holds, staying with the previous generation is right. Zero-code changeover addresses the specific difficulty of frequent changeover across many designators; it is not a general solution to every inspection problem.
On why the decision basis can be decoupled from the imaging method, see One decision logic across imaging modalities.
On learning what right looks like, see Defects are an open set, good parts are a closed one.
What this automatic-programming step looks like in the product: AI auto-programming.
FAQ
Does zero-code changeover mean no person is involved at all?
No. It removes the step of defining criteria designator by designator; what remains is confirmation. A part number appearing for the first time needs one good sample, special-process parts need a person to look, and every changeover needs a first-article confirmation. Confirmation and programming sit on different time scales, but confirmation cannot be skipped — especially alignment, because pointing at the wrong place trips no threshold and fails silently.
What happens the first time an unseen part number appears?
It needs one good sample. Nothing can know what an unseen thing normally looks like. The difference is that this investment buys knowledge about a class of component, reusable the next time it appears on another model at another coordinate, whereas the previous generation invests in settings about one position, void as soon as the position changes.
How do you tell real zero-code changeover from a nicer interface?
Measure two things. Bring a board the supplier has not seen; note how long until the first inspection result and what a person contributed in that time. If a person is confirming box positions designator by designator, it is still programming. If the contribution is one good sample for each of a few new component types plus one first-article confirmation, the criterion hangs on the component. Also change back to the outgoing model once — reversibility matters as much as speed.
Full solution for this scenario: AI AOI Software industry solutions
This article was generated by AI. Customer cases are simulated scenarios based on real product capabilities and figures are illustrative; see product pages for official benchmarks.