How I Vibe Coded My Own ERP: A Practical Guide to AI-Assisted Software Development
At ECF Live, we had several presentations about AI and using AI coding tools to create different tools for automation, content creation, and more. One question I kept hearing was: "Can I vibe code my own ERP?"
I've used AI coding tools extensively over the past year on projects both small and large. Yes, you have to wrangle them a lot, and they make plenty of silly mistakes. But overall, I'd still call it a 10x productivity booster. However, I had never used AI to build a large, production-ready project from the ground up. Until now.
The Backstory: Why Build a Help Scout Replacement?
We've used Help Scout as our customer support ticketing system for over 10 years. It works like ZenDesk—shared inbox, ticket management, the usual. Recently, they introduced some mediocre AI tools and decided to change their pricing from per-seat to per-ticket-resolved. Our new price? 10x what we pay now.
Naturally, I asked myself: Could AI build me Help Scout?
It seemed like a good candidate—not super complex but not trivial either. This is the story of how that went and the lessons learned.
The Short Answer
Yes, it's possible. We now have a kick-ass tool that my team loves and costs very little to host. But it was MUCH harder than anticipated.
I have a software engineering background, and I wouldn't have attempted this without AI assistance. With AI, it took about 60-80 hours to reach a working state. That's much longer than anticipated but still roughly 1/10 of what it would have taken otherwise.
The AI-Assisted Development Workflow
graph TD
A[Analyze Existing Solutions] --> B[Create Architecture Docs]
B --> C[Set Up Guidelines & Rules]
C --> D[Build with AI Assistance]
D --> E[Regular Code Reviews]
E --> F[Testing & Refinement]
F --> G[Soft Launch & Iteration]
G -->|Issues Found| F
subgraph "Lesson 1: Lean Into AI Strengths"
A
B
C
end
subgraph "Lesson 2: Plan for AI Weaknesses"
D
E
F
end
subgraph "Lesson 3: Don't Give Up"
G
end
Lesson 1: Lean Into AI Strengths
Setup: Let AI Analyze Existing Code
AI is excellent at looking at existing code, regardless of language. I found two GitHub repos for customer support software I liked: Chatwoot and Uninbox.
I had Claude Code check out both into a temp folder and analyze the software deeply to understand how it all worked. It examined both backend and frontend, creating detailed markdown files with its observations. This let me pull the best features from each.
Plan: Establish Guidelines First
For a project like this, AI will churn out crazy amounts of code—it's very hard to spot mistakes even for an experienced person. Establishing guidelines upfront is critical.
I had Claude write rules files that enforced:
- Always follow software engineering best practices
- Avoid anti-patterns
- Always use web search when facing problems
- Commit changes often
- Incorporate good architectural practices from the reference repos
Infrastructure: Choose AI-Friendly Technologies
AI excels at writing TypeScript. It can be used for both frontend and backend, and Claude handles build and deployment processes well. It's a modern stack that AI was trained heavily on.
My technology choices:
- Fastify for the backend (fast and resource efficient)
- PostgreSQL for the database (Claude can run the CLI, see the database, and directly edit what it needs)
- React for the frontend
Claude is good at using tools natively, so picking technologies with good CLI support makes everything smoother.
Lesson 2: Plan for AI Weaknesses
Revise, Refine, Refactor, Optimize
Between sessions—even with session resumption—AI can lose context and completely forget instructions. I made it a point to stop frequently and tell it to:
- Take a step back
- Review large sections of the code
- Look for repeated code
- Think like a senior software engineer
- Look for optimizations
- Follow software engineering best practices
Test More Thoroughly Than You Think
I thought I did a lot of testing as we went along. Things looked great on the surface, but once I started using the app, things fell apart. Even with proper setup, AI still made very basic mistakes that took a long time to untangle.
Key insight: I needed to be much more thorough with testing and regularly go back to sections to make sure everything still worked.
Plan for a Soft Transition
I'll be honest—for the first week, the team hated the new tool. There were so many problems. It wasn't getting basic message threading right.
I should have done a lot more testing and created a week or two of transition planning with an increasing number of users testing real-world scenarios. We got very lucky we didn't lose any important data in the process.
Lesson 3: Don't Give Up
Use Examples When Stuck
To fix all the problems, sometimes Claude would spin its wheels going in circles—maddeningly frustrating. What always got us past the issue was:
- Web searches for answers
- Referring back to the initial repos used as examples
Even though we used the repos as guides from the beginning, Claude would sometimes do its own dumb things. By asking it to look at how Chatwoot or Uninbox solved a specific problem, Claude often got past the issue.
Was It Worth It?
Absolutely yes. We now have:
- ✅ A tool that is fast
- ✅ Better features than what we had before
- ✅ AI integration that actually makes sense (it connects to our FAQ, orders, customer info—everything a CS rep would have at their disposal)
- ✅ New features can be added in minutes
- ✅ Most importantly: WE OWN ALL OUR DATA
In an AI future where data is king, I don't want Help Scout or any other vendor owning a treasure trove of knowledge like our customer emails.
The Future of Software Development
I believe this will be the future of software development. All these tools will keep improving. I think you'll eventually be able to say:
"I like these few SaaS apps. Take a look at their repos, grab these features, add these features, and deploy it for me."
Get the Code
I open-sourced the project so you can see the end product. I'll continue to maintain it and add new features as the team requests.
GitHub Repository: github.com/bookatechie/support-inbox
Feel free to fork it and have Claude add what you need!
Key Takeaways
| Phase | AI Strength | Human Strength |
|---|---|---|
| Research | Analyzing existing codebases | Choosing which solutions to study |
| Architecture | Writing boilerplate, following patterns | Establishing guidelines and rules |
| Implementation | Rapid code generation | Quality control and testing |
| Debugging | Referencing documentation | Knowing when to use reference examples |
| Deployment | Build scripts and automation | User transition planning |
Practical Tips for Your Own Project
- Find good reference implementations on GitHub before starting
- Create detailed guidelines in markdown files AI can reference
- Choose AI-friendly technologies (TypeScript, PostgreSQL, modern frameworks)
- Schedule regular refactoring sessions to keep code clean
- Test continuously, not just at the end
- Plan your user transition carefully
- Keep reference repos handy for when AI gets stuck
- Budget 2-3x more time than you initially estimate
Have you built software with AI assistance? Share your experiences and lessons learned!