Vibe Coding Acumatica Customizations
====================================
I have been experimenting with something I am calling vibe coding Acumatica customizations.
Not "type one magic prompt and let AI build an ERP system."
I mean using an AI coding assistant as a fast pair programmer while I bring the Acumatica context: real screens, DACs, graph files, ASPX, SQL, screenshots, notes, and publish feedback.
And honestly, it has been a lot of fun.
I used this workflow to help build real Acumatica customization work:
- A shop-floor kiosk for production employees.
- Production scheduling screens that publish dates back to manufacturing operations.
- A PayCor punch queue connected to kiosk day punches.
- A tracked mass email system with personalized links, batching, response tracking, and a dashboard.
These examples are coming in the next posts.
The bigger point is this: AI became useful when I stopped treating it like a magic answer machine and started treating it like a project teammate that needed real Acumatica evidence.
The Workflow That Worked
========================
Here is the basic loop I used.
First, I created a project folder for the thing I wanted to build.
For example:
- `Acumatica/Kiosk Screen`
- `Acumatica/Scheduling`
- `Acumatica/MassEmail`
Then I put the real working material in that folder:
- Existing Acumatica code.
- `.cs` graph files.
- DAC files and DAC extensions.
- `.aspx` screen files.
- SQL scripts.
- Generic Inquiry XML.
- Screenshots.
- Notes about the business workflow.
- Publish feedback from Acumatica.
That folder became the workspace.
Instead of asking, "Can you build me an Acumatica screen?", I could ask something much more useful:
"Here is the screen I am building. Here are the existing files. Here is the workflow. Here are the fields I know are real. Propose the screen plan before writing code."
That changed everything.
The Plan Came First
===================
Before letting the assistant write a lot of code, I had it describe the shape of the customization.
I wanted it to name things like:
- Screen IDs.
- Graph names.
- DACs.
- DAC extensions.
- Views.
- Grids.
- Actions.
- SQL changes.
- Virtual fields.
- Commit buttons.
- Publish order.
That gave me a chance to steer the work before it got too far.
If the plan matched the business flow, then I had it draft the graph, ASPX, SQL, and supporting files.
Then I used Acumatica's customization tools to create the screen shell, dropped in the generated files, published, tested, and fed the results back into the assistant.
It was not one big prompt.
It was a loop:
1. Give the assistant real Acumatica context.
2. Ask for a plan.
3. Correct the plan.
4. Generate the files.
5. Publish in Acumatica.
6. Test the workflow.
7. Paste the feedback back in.
8. Keep building.
What Made It Click
==================
The cool part was how much faster the work felt once the assistant had enough context.
It could compare files.
It could follow existing Acumatica patterns.
It could draft repetitive graph and ASPX pieces.
It could update SQL and DAC extensions together.
It could read publish messages and help adjust the code.
It could help keep the screen contract visible while the workflow kept evolving.
The human still matters a lot. I still had to know what the business process should be. I still had to verify field names. I still had to decide how the screen should behave.
But instead of staring at a blank file, I had something useful to react to, edit, and improve.
The Examples
============
The next posts show the actual examples.
Post 2 is the manufacturing side:
- A kiosk screen for shop-floor employees.
- Production scheduling screens.
- A PayCor punch workflow connected to kiosk day punches.
Post 3 is the marketing side:
- A tracked mass email system inside Acumatica.
- A `Send Tracked` action.
- A dispatcher that sends in batches.
- Response tracking.
- A Generic Inquiry dashboard.
Different workflows, same pattern:
Build the folder. Add real Acumatica context. Ask for the plan. Generate the files. Publish. Test. Feed the results back in. Keep going.
That is the part I want more Acumatica users to try.
There is a lot of cool stuff we can build when we combine Acumatica knowledge, business process knowledge, and AI-assisted development.
If you are working on Acumatica customizations and want to compare notes, I would love to build with more people who are experimenting this way.
