Saturday evening, a head of sales with an AI assistant and an idea: orders from the online shop should no longer be retyped but land in the ERP automatically. He describes what he wants, the assistant writes a script, an error message gets pasted back, the assistant fixes it. By midnight it works. On Monday he proudly shows it to the team, and it really is impressive.
Three months later, on a Tuesday, 23 orders appear twice in the ERP, because the shop resent them after a timeout. The script runs on his laptop, and he is on holiday. The source code contains the password of an ERP user with full rights, and a copy of the script sits in the shared Teams channel.
Nobody did anything stupid here. The AI built exactly what was described. What was missing was someone who knows what you don't describe, because it goes without saying when you build software for operations.
Why it's so tempting right now
Honestly: because it works. For what Andrej Karpathy dubbed "vibe coding" in early 2025, building software by describing what you want and trying the result rather than reading it, today's tools are good enough. A script that queries an API, maps fields and writes into another system is an easy task for a current model.
Add the impatience every mid-sized company knows. IT is fully booked, the vendor needs to write a quote, the ERP partner has time next quarter. And the solution seems to be just a weekend away.
That is no reason to demonise AI. We work with coding agents every day ourselves. But it is a reason to look closely at where the difference between "it runs" and "it holds" lies.
The core problem: you can't check what you can't read
AI-generated code is plausible. It looks like code an experienced person would have written, it runs, and in the normal case it does the right thing. A developer still reads it and asks: What happens if the connection drops? If the same order arrives twice? If the ERP renames a field? Where are the credentials stored, and who can do what with them?
Without a developer background, you're left with one test: it runs. And "it runs" only means that the case you tried works.
For many tools that's acceptable. For integrations it's the worst possible place, for two reasons. First, failures there are silent: an interface that does nothing doesn't report itself. Second, it moves things that cost money: orders, stock, invoices, customer data. How integrations typically fail, including those built by professionals, is covered in detail in ERP Integration for SMEs.
What typically goes wrong without a developer background
We see the following points in almost every home-built integration script that lands on our desk. None of them is the AI's fault. Each is a requirement nobody stated.
Credentials in the code. API keys and passwords sit right in the script, because that was the quickest way to make it work. The script gets emailed, pasted into a chat or uploaded to a repository, and the credentials travel with it.
Too many permissions. The script logs into the ERP as an administrator, because that worked on the first try. A bug in the script can then change anything, not just create orders.
Only the happy path. Timeout, duplicate message, half-processed file, a customer that doesn't exist in the ERP: there is no rule for any of it, because nobody asked. The result is duplicate orders or orders that simply vanish.
Runs on your machine. The script hangs off a scheduled task on a laptop or office PC. Holiday, reboot, new device, and the integration stops. There is no monitoring that notifies anyone.
Outdated and invented packages. The code uses libraries that are never updated and eventually have known vulnerabilities. Sometimes a model even suggests packages that don't exist. Attackers now register such names deliberately, and anyone who installs them unchecked brings someone else's code into the company.
Data in the prompt. To find a bug, real customer data or ERP extracts get pasted into a cloud service. That hands personal data and trade secrets to a provider with whom there is no data processing agreement.
Compliance nobody thought of. As soon as an integration moves accounting-relevant data in Germany, the GoBD rules apply: transactions must be traceable and immutable. A script that creates documents and logs nothing becomes an issue at the next tax audit.
Nobody can take it over. The only person who knows the script is the one who built it, and really, he doesn't know it either. For the next change he asks the AI again, which rewrites half of the script and breaks something else that only surfaces weeks later.
Where doing it yourself with AI is perfectly fine
It would be dishonest to conclude "hands off". There are cases where a home-built AI script is exactly the right solution, and cases where it is a risk you don't see.
| Well suited | Poorly suited |
|---|---|
| A prototype to clarify what you actually need | Anything that writes to the ERP or another production system |
| A one-off data cleanup or migration whose result you check | Anything that moves money, documents or stock |
| Read-only analyses and reports for yourself | Anything that processes personal data |
| Personal helpers with no access to production systems | Anything that runs regularly and unattended |
| Throwaway tools with a clear expiry date | Anything other people depend on in their work |
If you're unsure, four questions are enough:
- Does it write to a system other people work with?
- Does it run without you sitting next to it?
- Would you notice a failure the same day?
- Could someone else take it over tomorrow?
If the answer to either of the first two is "yes", or to either of the last two is "no", it's no longer tinkering but software in production. And that needs someone who can read it.
What a software vendor gives you that no prompt replaces
First, to avoid a wrong impression: we write our code with AI too. Today the difference between a home-built script and a professional integration isn't the tool, but who wields it and what happens around the code. Specifically, you get:
Judgement. Every line is read by someone who knows how integrations fail in operation. An experienced developer spots when AI code looks plausible but makes an assumption that isn't true for your ERP. How reviews work with coding agents is described in Code Reviews in the Age of Coding Agents.
The right pattern from the start. File exchange, vendor API or events, with protection against duplicate processing, restart and an error queue. These parts don't appear because the AI suggests them, but because someone requires them.
Security by default. Credentials in a vault instead of in the code, a technical user with exactly the rights it needs, dependencies automatically checked for known vulnerabilities.
Operations. The integration runs on a managed platform, not on a laptop. There is monitoring that notifies a human, and someone who responds, even on a Friday afternoon.
Experience with your environment. We know the interfaces of common ERP systems, talk to your ERP partner and raise the licensing question about indirect use before it gets expensive.
Accountability that is settled. There is a contract, a named owner and a warranty. When something goes wrong, it's clear who fixes it.
No dependency on us. The code lives in your version control, is documented and built so that another developer could take it over. You buy a solution, not a permanent contract.
And because we develop with AI ourselves, this safety doesn't cost a fortune. Realistically, implementation becomes cheaper, if by less than many hope. Why is worked out in our ERP integration guide.
The middle way: you build the prototype, we make it production-ready
The script from Saturday night isn't worthless, quite the opposite. It is the best requirements description you can give a vendor: it shows which data should flow from where to where, which fields matter to you and what the result should look like. In a project, that often saves the first rounds of alignment.
The path from there to a production integration looks like this with us:
- Review. We read your code and tell you what is solid and what is missing, prioritised by risk.
- Harden. Credentials out, permissions down, error handling, protection against duplicate processing and logging in. What's good stays.
- Operate. The integration moves from the laptop to a managed platform, with monitoring and a person who is responsible.
That way you keep the speed AI gave you and get what it lacks: someone who knows what happens when things go wrong.
Keep building with AI. Just make sure that whatever writes to your ERP has been read by someone who understands it.
