Short answers to what readers ask most about this topic.
Where AI coding agents genuinely help on an ERP codebase, from scaffolding modules to MCP integrations, and where a human who knows the business must stay in charge.
Matthews Wong
Software Engineer
Key Takeaway
AI coding agents help ERP developers where the work is repetitive and rule-heavy: scaffolding modules, wiring integrations through MCP, drafting approval-workflow logic, and generating reports from a schema. The win is not autonomy over business rules, which still need human judgment, but speed on the plumbing that surrounds every ERP feature.
ERP development is a particular kind of grind. Every feature is wrapped in the same plumbing: a form, a validation layer, an approval chain, an audit log, a report, and an integration with two other modules that were written a decade apart. Most of that code is not hard; it is just voluminous and repetitive.
That shape is exactly where AI coding agents earn their keep. This piece looks at concrete places an agent helps on an ERP codebase, drawn from the day-to-day of building enterprise systems, and where you should still keep a firm hand on the wheel.
The best agent tasks are the ones with a clear pattern and a clear check. A lot of ERP work fits that description, because the domain is full of repeated structure: the tenth approval form is not conceptually different from the first.
Look for the parts of an ERP feature that are mechanical rather than judgment-heavy:
The clearest early win is scaffolding. Given an existing module as a pattern and a schema for the new one, an agent can generate the entity, the repository, the service, the controller, and a first pass at validation that matches your house style. You review and correct rather than type it all out.
The key is to point the agent at a real example in your codebase, not a generic template, so the output matches your conventions. A short instruction plus a reference module goes a long way:
Use src/modules/purchase-order as the reference module.
Generate a new module "goods-receipt" with the same structure:
entity, repository, service, controller, and DTOs, matching the
validation style and naming you see there. Do not invent any
business rules — leave a TODO where a rule is needed and ask me.Give the agent one of your existing modules as the template and tell it to match this structure exactly. ERP codebases are highly patterned, and an agent that copies your real conventions produces code your team will accept, while a generic scaffold produces code you spend an afternoon reworking.
ERP systems are integration hubs, and this is where a protocol like MCP becomes useful. The Model Context Protocol lets an agent talk to external systems through a standard interface, so instead of the agent guessing at your APIs, you expose them as tools it can call:
Two ERP staples suit agents well once the rules are written down. Approval-chain logic is fiddly but pattern-based: given a clear description of the hierarchy and the thresholds, an agent can draft the state machine and the routing code, which you then verify against the real policy.
Reports are similar. Handed a schema and a description of the output, an agent can generate the query, the aggregation, and the export in far less time than writing them by hand, and you spend your effort checking the numbers rather than assembling the plumbing.
Never let an agent invent business rules. Tax logic, approval thresholds, and posting rules come from finance and compliance, not from a plausible-sounding guess, and in an ERP a wrong rule is not a bug, it is a financial or legal problem. The agent writes the code; a human who knows the policy owns whether it is correct.
The pattern across every ERP use case is the same: let the agent handle structure, keep judgment with the people who know the business:
AI agents will not replace ERP developers, but they change the mix of the job, taking over the repetitive plumbing so you spend more time on the business logic that actually needs a human. Point them at your real conventions, expose your systems through clean interfaces like MCP, and keep every rule that matters under human review.