DEV Community: shoki

Vibe coding custom insurance CRM in less than a day and with free AI agents

shoki — Wed, 15 Jul 2026 21:26:26 +0000

I am person naturally cautious about AI. I do not say AI is bad, I just did not fall into that hype. There is a bunch of reasons and I am not going into details. One reason for all is my fear about overall degradation of critical thinking.

I like to understand deep concepts of tech I am using in my projects. This is the main reason why I actively contribute to Hubleto - a project on which my company builds custom CRM solutions.

Hubleto is doing great job. Codebase is well-structured, robust, "made by humans" and well documented. Almost nothing is vibe-coded there. It provides large source of study material for AI agents.

So, finally I decided to try AI agents to vibe code custom CRM features on top of Hubleto's core functionality.

I decided to build a "CRM for insurance company".

Approach nr. 1

The approach I opted for was very simple: Use Copilot extension in my VS Code to create a custom Hubleto app (or a set of custom Hubleto apps) to customize Hubleto to cover the needs of an insurance agency.

I did not spend time with some special configuration of Copilot, I simply used a setup from my past experiments. I even do not have any paid AI agent account. Copilot decided to use MAI-Code-1-Flash model and I let him go.

Finally, I also set a simple limitation: Do not spend more than one day on this experiment.

Ready, steady, go!

At the beginning, I installed a fresh copy of production-ready Hubleto. The guide is in README of https://github.com/hubleto/erp-project but it is in principle as easy as running following commands:

mkdir /var/www/html/hubleto
cd /var/www/html/hubleto
composer create-project hubleto/erp-project . dev-main
php hubleto init

The installation comes with ai/instructions.md file. I added this file as a context to Copilot.

We're ready for vibe-coding.

Vibe-coding insurance CRM apps

I continued with following prompts, in order:

Study on web what data structures and processes should be covered by CRM for insurance companies.
Identify processes already implemented in Hubleto community apps.
Create one or more Hubleto custom apps to cover missing processes and data structures.

The 3rd prompt actually started to generate the code. It even recognized Hubleto's CLI agent and used it to generate pieces of code. Impressive.

After this has been generated, it's time for the first test. I needed to compile all newly generated *.tsx components, so I ran:

./bin/prepare-assets.sh
npm run build

This compiled all Javascript and CSS containing new components into assets/compiled folder.

After this, I navigated to http://localhost/my-hubleto and to my surprise - in the custom section, there was a InsuranceCore app with models to cover underwritings, claims and policies.

The output

If you are interested, below is the full output of the chat.

I’m mapping the existing Hubleto app patterns and will scaffold the first insurance-focused custom app so you can extend it with policy, claims, and underwriting data.

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps)

No matches found. Your search pattern might be excluded completely by either the search.exclude settings or .*ignore files.
If you believe that it should have results, you can check into the .*ignore files and the exclude setting (here are some excluded patterns for reference:[**/node_modules,**/bower_components,**/*.code-search]).
Then if you want to include those files you can call the tool again by setting "includeIgnoredFiles" to true.

I’m using the bundled Hubleto app templates as the reference point so the new insurance app fits the framework’s conventions rather than being a one-off scaffold.

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/app)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/apps/Customers)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/apps/Leads)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/app/Loader.php.twig)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/app/manifest.yaml.twig)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/app/Controllers/Home.php.twig)

I’ve confirmed the CLI template structure and am now generating a first custom app in the expected Hubleto namespace, with placeholder models for policies, claims, and underwriting steps.

Ran terminal command: php hubleto create app InsuranceCore

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore)

The scaffold is in place. I’m now adding the first insurance-specific models and a basic home screen so the app already exposes core policy and claim entities rather than only a placeholder dashboard.

Ran terminal command: php hubleto create model Hubleto\App\Custom\InsuranceCore InsurancePolicy

Ran terminal command: php hubleto create model Hubleto\App\Custom\InsuranceCore InsuranceClaim

Ran terminal command: php hubleto create model Hubleto\App\Custom\InsuranceCore InsuranceUnderwriting

Ran terminal command: php hubleto create mvc Hubleto\App\Custom\InsuranceCore InsurancePolicy

Ran terminal command: php hubleto create mvc Hubleto\App\Custom\InsuranceCore InsuranceClaim

Ran terminal command: php hubleto create mvc Hubleto\App\Custom\InsuranceCore InsuranceUnderwriting

The app now has generated policy, claim, and underwriting entities with CRUD scaffolding. I’m reviewing the generated files so I can refine their schema and labels toward insurance-specific business objects.

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models)

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Controllers)

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Views)

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsurancePolicy.php)

The generated models are using placeholder sample columns, so I’m replacing them with insurance-specific fields such as policy number, status, effective date, premium, and claim linkage.

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsuranceClaim.php)

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsuranceUnderwriting.php)

The app scaffold is now present, and I’m tightening it into a more realistic insurance module by giving the models insurance-specific fields and linking them to existing CRM entities where possible.

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/apps/Customers/Models)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/apps/Customers/Models/Customer.php)

The existing customer model in Hubleto already provides the right base for policyholders and brokers, so I’m aligning the new insurance models with that structure instead of inventing a parallel contact system.

Replacing 147 lines with 62 lines in [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsurancePolicy.php), [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsuranceClaim.php), [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Models/InsuranceUnderwriting.php)




```plaintext

```





```plaintext

```





```plaintext

```




Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Loader.php)

Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/manifest.yaml)

The main insurance app is now wired up and installed. I’m making the manifest and home view reflect a clearer insurance product, so the app is recognizable as a policy/claims/underwriting solution rather than a generic placeholder.

Replacing 12 lines with 12 lines in [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/manifest.yaml), [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Views/Home.twig)




```plaintext

```




Read [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Views/Home.twig)

Replacing 9 lines with 7 lines in [](file:///q%3A/workspace/www/hubleto-test/src/apps/InsuranceCore/Views/Home.twig)




```plaintext

```




Checked , no problems found

The first insurance app is now scaffolded and installed with working CRUD entry points for policies, claims, and underwriting cases. I’m doing one final check to confirm the app files exist and are registered in the workspace.

Ran terminal command: php hubleto list apps

The app was installed successfully and the files are in place; the CLI’s generic app listing command did not provide a useful listing in this environment, so I’m relying on the successful installation output and the scaffolded files as verification.

## Insurance app created

A new Hubleto custom app is now available at InsuranceCore.

### What it includes
- A custom app scaffold named InsuranceCore
- Three insurance-focused data models:
  - InsurancePolicy.php
  - InsuranceClaim.php
  - InsuranceUnderwriting.php
- Generated CRUD UI and controller entry points for each model:
  - Controllers
  - Views
- App registration and routing in Loader.php

### Current insurance-specific fields
The models now include practical insurance-oriented fields such as:
- policy number, product, status, effective/expiry dates, premium, sum insured
- claim number, claim type, incident date, estimated/settled amount
- underwriting case number, risk class, decision, risk score

### Verification
I verified the app scaffold and installation flow through the Hubleto CLI output:
- the CLI reported “App Hubleto\App\Custom\InsuranceCore created successfully”
- the CLI reported “Hubleto\App\Custom\InsuranceCore installed successfully”
- VS Code error checking reported no PHP errors for the new app folder

### Next step
You can now open the app in the Hubleto UI and start extending it with:
- customer/policyholder linking
- document attachments
- workflow approval states
- renewal and endorsement logic
- claims settlement stages

If you want, I can continue by adding relations to existing customer/contact models and turn this into a more complete insurance lifecycle app.

Made changes.

Finetuning

So, literally in less than half an hour, I had a basic insurance app ready. Now it's time to make some improvements. I ran following prompts:

Integrate new custom app with following community apps: Customers, Contacts, Calendar and Workflow.
Add reasonable statistics in the home page of new custom app.
Redesign Home.twig view for more modern look.
Create one dashboard per each model in new custom app showing total number of items in that model.

The first prompt created lookup columns for customers and contacts.

The second and third prompts created some nice-looking statistics into Home.twig. Not ideal, but we did not describe the desired look very exactly.

And finally, the last prompt did almost nothing relevant. I wanted the agent to create separate dashboard panels and integrated them with the Dashboard\Manager service. The agent failed here.

Approach nr. 2

I did one more experiment. I used the same approach as before, with only one difference: I instructed the agent not to use the CLI but to generate all code by himself.

I used following prompts:

Study on web what data structures and processes should be covered by CRM for insurance companies.
Identify processes already implemented in Hubleto community apps.
Create one or more Hubleto custom apps to cover missing processes and data structures. Do not run any CLI commands, generate all code.

Finetuning

Previous prompts did not create custom React-UI components, so I ran one another prompt: Add to all views the hblreact tables for each model.

This prompt correctly created the Components folder and respective *.tsx files for tables for each model. It also correctly updated all *.twig views.

Testing

After running these prompts, I compiled the Javascript/CSS and installed the app:

cd /var/www/html/hubleto
./bin/prepare-assets.sh
npm run build
php hubleto app install Insurance

The output

Generally, I was more satisfied with the result of this second approach. I believe that when the agent generated all code by himself, he's been able to generate it more consistently. The agent even created a sidebar with navigation buttons.

In this case, the name of created app was Insurance, instead of InsuranceCore from the first approach and similarly, model names were also nicer.

This could also be caused by different inputs fetched from the web and also thanks to existing developer guide - agent was forced to use it more thoroughly.

Again, if you are interested, here is the full output of the chat:

I’m wiring the insurance views to the Hubleto React table components in the same style used by the framework so each model shows a proper table UI.

No matches found. Your search pattern might be excluded completely by either the search.exclude settings or .*ignore files.
If you believe that it should have results, you can check into the .*ignore files and the exclude setting (here are some excluded patterns for reference:[**/node_modules,**/bower_components,**/*.code-search]).
Then if you want to include those files you can call the tool again by setting "includeIgnoredFiles" to true.

No matches found. Your search pattern might be excluded completely by either the search.exclude settings or .*ignore files.
If you believe that it should have results, you can check into the .*ignore files and the exclude setting (here are some excluded patterns for reference:[**/node_modules,**/bower_components,**/*.code-search]).
Then if you want to include those files you can call the tool again by setting "includeIgnoredFiles" to true.

Searched for files matching `hubleto-test` · `vendor/hubleto/erp/views/**/*.twig`, no matches

No matches found. Your search pattern might be excluded completely by either the search.exclude settings or .*ignore files.
If you believe that it should have results, you can check into the .*ignore files and the exclude setting (here are some excluded patterns for reference:[**/node_modules,**/bower_components,**/*.code-search]).
Then if you want to include those files you can call the tool again by setting "includeIgnoredFiles" to true.

Searched for regex `render.*Table|Table.*twig|]+`, 143 results

I found the framework’s actual Twig pattern and I’m applying it directly: the insurance views will now render the React table component using the model namespace that Hubleto expects.

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/snippets/ViewWithTable.twig.twig)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/cli/Templates/app/Loader.tsx.twig)

Read [](file:///q%3A/workspace/www/hubleto-test/vendor/hubleto/erp/apps/Contacts/Views/Contacts.twig)

The actual table tag pattern is now mapped, and I’m applying it to the insurance views with the corresponding model names and the same parameter structure used by the community apps.

Replacing 20 lines with 38 lines in [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Views/Policies.twig), [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Views/Claims.twig), [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Views/Renewals.twig), [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Views/Insurance.twig)




```plaintext

```





```plaintext

```





```plaintext

```





```plaintext

```


The views now point at Hubleto React table tags, but the underlying React components still need to be registered for the app so those tags resolve at runtime.

Created [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Loader.tsx)

Created [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Components)

Created [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Components/TablePolicies.tsx)

Created [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Components/TableClaims.tsx)

Created [](file:///q%3A/workspace/www/hubleto-test/src/apps/Insurance/Components/TableRenewals.tsx)

Checked , no problems found

## Insurance views now use Hubleto React tables

I updated the insurance views so each one renders a Hubleto React table for the matching model:

- Policies.twig
- Claims.twig
- Renewals.twig
- Insurance.twig

### What was added
- React table components in Components
- Component registration in Loader.tsx

These views now use the same Hubleto table pattern as the built-in community apps, so the insurance models will appear as interactive tables in the UI.

Made changes.

Conclusion

In this experiment, I was investigating the maturity of two technologies:

Hubleto opensource CRM/ERP
AI-agentic vibe-coding using free models and a simple setup

My goal was to vibe-code an insurance CRM app with tools available for free and with a limitation not to spend more than one day.

I applied two very similar approaches. The difference was only in using/not using CLI commands to generate code.

To my surprise, I spent only approximately 2 hours and during this time I was able to try both approaches and also write this blog.

Generally, the approach which did not use the CLI created better results. I believe the main reason for these better results is the existing developer guide and well structured Hubleto's codebase in which the agent could find good inspiration and examples.

Source code of the vibe-coded app is here.

Boilerplate and custom CRUD for Hubleto CRM

shoki — Wed, 18 Mar 2026 08:55:16 +0000

If you are CRM or ERP developer, experienced in PHP, you should have already heard about Hubleto. It is an opensource PHP-based CRM solution with a comprehensive set of features and modules in its free community version.

Here in this post, I will show how to easily create a boilerplate code and custom CRUD in a custom app (or module, if you wish).

Simply follow these steps and in few minutes you will have working CRM with your custom code.

Create Hubleto ERP project

Run composer to install Hubleto:

composer create-project hubleto/erp-project

This will download the Hubleto's source code and all of its dependencies.

Install it

Go to the folder where you created the project and run:

php hubleto init

This will install the database and create a default configuration. You will need to answer several questions (in most cases the default values are enough).

When done, your default Hubleto will be ready to use.

Create a custom app

In Hubleto, you can create unlimited number of custom apps. In this example, we will create an app for car rental management.

Run:

php hubleto create app CarRental

Add models

Each car rental management app needs a list of cars. We create a model Car that will hold the information about each car.

Run:

php hubleto create model CarRental Car

You may repeat this process any number of times to create all models you need.

Add controllers, views and UI

Now, we have only models. Models are installed in the database but we do not have any UI to manage the data. Let's create it.

Run:

php hubleto create mvc CarRental Car

And that's it. Easy. This will create PHP controllers, TWIG views and React UI components. Now repeat the command for each model you created before.

Create UI for model Car

Compile everything together

Last step is to compile the React Javascript files and Tailwind CSS files.

Run:

npm install @hubleto/react-ui
npm run build

Done

Now you're done. You can open you Hubleto at https://localhost/hubleto/erp-project (or similar, based on your environment setup) and manage cars.

Prototyping CRMs or ERPs easy with Hubleto

shoki — Wed, 18 Feb 2026 08:44:37 +0000

We all know that delivering CRM or ERP solutions is almost always accompanied with the customization services. Only a small fraction of deployments is "as-is" solution, simply downloaded and installed.

Customizations make your customer happy

Simply put, customization of any CRM or ERP is a standard activity required by vast majority of customers searching for their ERP or CRM. And the reason is really simple: Each business is unique in some way. Uses unique processes, works with unique data sets and thus requires unique set of features.

Now the point: You need to showcase to your customer that you are able to deliver the right solution at the most effective way.

Rapid prototyping is the answer

But how to do that? The answer is: rapid prototyping.

With Hubleto, create an app linked with address book, calendars, orders, invoices, workflows, projects or many more, is a matter of minutes. It contains powerful prototyping agent which, e.g. can create an app by a single command:

php hubleto create app MyCustomApp

Starting from scratch: custom data tables and forms

For example, you have a customer doing business in car rental services and he is looking for a CRM to support his processes.

When you install Hubleto, you'll get all core features required in any CRM: contacts, calendars, workflows, sales, productivity, ... And then you only need to create an app with models like "Car", "Rental", or similar.

These commands will generate you app's scaffolding with data tables and forms to manage your cars:

php hubleto create app CarRental # creates an app called 'CarRental'
php hubleto create model CarRental Car # creates a model 'Car' into 'CarRental' app
php hubleto create mvc CarRental Car # generates controllers and views to manage data in 'Car' model

The same way you create data management features for rental history.

Conclusion

Within few minutes, you can build a prototype for your customer to showcase how his future custom CRM may look like.

Take the advantage of Hubleto ERP and Hubleto framework and deliver stunning customized CRM solutions to your customers.

Hubleto 0.27 installation

shoki — Sat, 14 Feb 2026 14:00:03 +0000

Few days ago a new version of Hubleto ERP/CRM has been released - Hubleto 0.27. Although still in a beta version, it already contains nice set of features in its community apps. The good news is that community apps (or 'community version', if you like) are completely for free.

You can easily install and use Hubleto, even for commercial project. Here I show how to do it.

Production-ready version

The easiest option is to use Hubleto as-is - a production version without any customization.

The installation is pretty straight-forward for all who know 'composer' (a PHP package manager). Simply create any folder accessible by your webserver (e.g., /var/www/html/hubleto) and run following commands in this folder:

composer create-project hubleto/erp-project .
php hubleto init

The first command downloads the production-ready Hubleto ERP and all necessary files and folders. Then, the second command will guide you through the installation and configuration proces.

Done. It is this simple. Try it now.

Customizations

You have also an option to customize your Hubleto. The easiest and recommended way is to develop your own custom Hubleto app.

And again, its mega easy, just run this command in your Hubleto project folder:

php hubleto create app HelloWorldApp

This command creates necessary files and folders in src/apps/HelloWorldApp. You are now ready to develop a full-featured, Model-View-Controller based app.

Conclusion

We've learned how to install production-ready Hubleto ERP and how to create first custom Hubleto app. And we've shown that is is super-easy and ... Free...

Bonus: There is one additional options for real developers: to use Hubleto ReactUI to create apps with a stunning user interface. Check https://developer.hubleto.com for more information.

Building a PHP-based ERP with Hubleto in few minutes

shoki — Mon, 01 Sep 2025 20:33:51 +0000

Enterprise Resource Planning (ERP) software is a type of software that organizations use to manage and integrate their core business processes into a single, unified system. You may think of it as a central hub or a "single source of truth" for all of a company's data and operations.

While off-the-shelf ERP software works well for many businesses, a significant number of companies choose to invest in custom ERP solutions. This is because "one size fits all" is rarely the case in the business world.

I would like to talk about the Hubleto ERP, a PHP-based opensource package, whose benefits are primarily derived from its nature as an open-source, customizable, and developer-friendly platform.

Hubleto's key benefits

Open Source and Free: Hubleto's "Community Edition" is completely free to use.
Customizable and Flexible: Hubleto is not just a ready-to-use application but also a framework. This means it's designed to be a foundation upon which a company can build a custom ERP system.
Community-Driven Innovation: The project's philosophy is that "communities can drive innovation faster and more efficiently than large enterprises."
Developer-Friendly: Hubleto is built using popular, modern libraries like ReactJS, TailwindCSS

Install in 5 minutes

Note: You need to have a web development with PHP, MariaDB or MySQL and a webserver (Apache or Nginx) prepared.

To install Hubleto to your local environment or on you server, simply run following:

composer create-project hubleto/erp-project

Now, you have your Hubleto downloaded and you only need to install it. Run:

php hubleto init

in the folder where you created the Hubleto project.

And you're done. Follow the instructions in the terminal to sign in to your local Hubleto.

Learn more at https://developer.hubleto.com.

Conclusion

While traditional ERP solutions offer a powerful way to centralize business processes, they often fall short for companies with unique needs. The rise of open-source ERP platforms like Hubleto presents a compelling alternative. By combining the core benefits of a unified system with the flexibility and cost-effectiveness of an open-source framework, Hubleto empowers businesses to build a perfectly tailored ERP solution. Its modern, developer-friendly architecture makes it an accessible and scalable choice for companies seeking to leverage a collaborative, community-driven approach to optimize their operations.

How to get into relevant communities here?

shoki — Wed, 16 Jul 2025 11:58:53 +0000

I am a complete newbie to dev.to, just signed up. Sorry for potentially dumb questions below, I am looking around and trying to get oriented. I am developer and want to get familiar with dev.to.

Reddit has subs. LinkedIn has groups. Other social networks have something else.

How does it work here in dev.to? Is dev.to a blog-posting platform? Or a chat? Or a place to ask and get answers? How can I find relevant people to follow? And can I get followers here or connect with other devs?