I've recently been talking with a number of small and medium-sized business owners, and I've noticed they're all diving enthusiastically into vibe coding. They get an idea, open up an AI tool, describe what they want, generate the code, tweak the UI. Things that used to require hiring an engineer, negotiating a budget, and fitting into a schedule can now be turned into a decent-looking prototype over a few evenings of their own time.
That feeling of "wow, I can actually do this myself" is genuinely appealing. Especially for owners, whose heads are full of improvement ideas accumulated over years, ideas that used to get stuck on budget constraints or never made it high enough on the development priority list. Now they finally have a chance to try building them themselves.
But then everyone starts getting stuck in roughly the same place. The screens are built, but the workflow doesn't connect. Individual features work fine, but drop them into real work and things break everywhere. Some systems only run on the owner's own machine. Others barely make it into production, but nobody knows how to maintain them. The moment data goes wrong, requirements change, or a colleague hits an edge case, it's back to the owner to sort it out.
The barrier to building a prototype really has come down. But getting a system to be used reliably by a group of people still requires a different kind of capability.
After the prototype is where systems experience starts to matter
AI has dramatically accelerated development, that's been obvious in my own use. But once things speed up, you realize what companies lack often isn't just people who can write code, but the experience to break a requirement down into a complete workflow.
Owners usually know exactly what problem they want to solve, which is an advantage outside engineers rarely have. But there's still a gap between "I want to solve this problem" and "ten people can use this system every day."
That gap is filled with problems that never show up in the first version's pretty screens. Who gets to see which data, can sales reps see other people's customers? When an order is modified, how does accounting get updated, or does someone have to remember to change it manually? If a colleague clicks the wrong button, can it be undone, or is the data just gone? When the person currently operating it leaves, who takes over, and will that person be able to understand what this system is even doing?
These questions don't normally announce themselves. They tend to surface all at once, after the system has been in use for a while and accumulated real data. And it's exactly these details that determine whether a system actually becomes part of daily work, or stalls at the demo stage and gets shelved after the presentation.
Better tooling genuinely saves development time, and in doing so, makes workflow design, permission planning, and exception handling far more conspicuous. When a prototype can be finished over a few evenings, the time you invest next usually goes into filling in those details one by one.
Incentives between owners and employees aren't aligned yet
Another gap shows up between owners and their staff.
Owners are eager to adopt AI because they're looking at cost, competition, and survival over the next few years. That perspective makes sense, and it explains why they're in more of a hurry than everyone else.
But employees are dealing with a different set of things every day: the report due today, the orders still unprocessed, and a way of working they already know so well they could do it with their eyes closed. For them, learning a new tool first and foremost means extra work, extra work piled on top of a workload that hasn't gotten any smaller. Even if efficiency really does improve, it's not clear what happens to the time saved. It won't necessarily translate into better pay or a lighter load; sometimes it just means more things to handle.
More practically, during a rollout you often have to run the new system and maintain the old process at the same time, covering both. What employees feel at that point is mostly just hassle.
So when colleagues aren't as enthusiastic as the owner, I don't immediately read that as resistance to change. Sometimes the benefits of the change simply haven't reached them yet. They bear the cost of the transition without knowing whether they'll share in the returns.
That's why I think for an AI rollout to go the distance, beyond picking the right tools and building the system, you also have to deal with division of labor, accountability, and incentives, things that look like they have nothing to do with technology. Who's responsible for maintaining the data? Who handles it when something breaks? After switching to the new process, how does the existing workload get redistributed? Get these spelled out, and the rollout has a much better chance of moving forward.
Clarify data and workflows before automating
In the traditional-industry cases I've encountered, there's plenty of room for improvement in everyday work.
Among the travel agencies and freight forwarders I've worked with, some companies hit NT2.5 billion in revenue running on Excel, a lot of manual labor, and the experience of senior staff. Let me be clear: these are a few cases I've personally encountered. They don't represent the whole industry, and they don't mean this approach is inherently flawed, after all, it did build a real business.
These companies have mature customer relationships and strong sales and on-the-ground execution. It's just that the information supporting daily operations may be scattered across different people's spreadsheets, email, chat apps, and the heads of a few senior colleagues.
On the surface, this looks like an ideal automation scenario. Repetitive data entry, manual reconciliation, report compilation, progress tracking, every one of them sounds like it could save time.
It's only once you actually start the rollout that you discover you first need to align how different departments understand the data and the process.
The same field means different things to different departments. For example, sales and finance may place "case closed" at entirely different points in time. The same type of case gets handled differently by different people, everyone gets the job done, but the steps differ. Plenty of edge cases have never been documented; the handling procedure is "ask so-and-so, they know more about this."
When existing tools and processes are already this fragmented, automation has nothing solid to connect to. You have to first clarify where the data comes from, who's responsible for verifying it, and under what conditions it gets handed off to the next person, only then does AI have a chance to reliably take over part of the work. This kind of work is hard to show off in a demo, but it's the foundation of a system that runs reliably.
Otherwise it's easy to end up building a little tool for each department, where each one looks fine on its own but collectively creates even more places where someone has to manually move data from A to B. More systems, and more manual work.
A prediction for the next five years, and what I've built up myself
What follows is my personal prediction, not something that has already happened.
Looking out five years, I think vibe coding will likely become a fairly common skill, no longer concentrated mainly among people with technical backgrounds. Domain experts, even high school or middle school students, may be able to use AI to turn their ideas into prototypes, and build systems usable by a small group of people.
When the cost of producing software drops, needs that were previously shelved for lack of budget may start getting met. From that angle, demand for software won't necessarily shrink, it may actually grow. It's just that who builds it, and how, will look different than before.
But when more people can build things, value shifts too.
Do you understand the problem that actually needs solving? Can you tell which features shouldn't be built at all? Can you consolidate scattered requirements into a coherent workflow? Will other people actually want to use what you built, and can the next person pick it up? These differences used to be obscured by the barrier of "can you write code." With that barrier lowered, they'll only become more visible.
One more thing worth reminding yourself: AI compresses development cost, but if the way you work doesn't change, maintenance and operating costs can still be high. Code being generated quickly doesn't mean there's less responsibility afterward. Every system you add brings another set of data, permissions, and deployments to maintain, plus user expectations attached to it. Without pruning and prioritization, the easier development gets, the faster problems can pile up.
I've been playing with AI for close to a year now, spent nearly US$2,000 on subscriptions, and bought an RTX 5090 to study local models. From AI applications and multi-agent applications to model training, building APIs and MCP, I've tried the whole range, and eventually got AI agents to genuinely tie my entire workflow together.
Along the way, I've felt more and more strongly that "one person can be a team" is actually possible, and I've also gotten much clearer on what it takes to get there. For me, what supports this is ten years of accumulated technique, experience, and workflow. The problems I've run into, the decisions I got wrong, the systems I've maintained, all of it shapes how I brief AI today, how I evaluate what it produces, and when to stop and rethink.
Subscribing to a few tools, taking a few courses, copying a few skills, that can help you get started. But assembling them into a way of working that keeps running still comes down to your own practice and accumulation.
AI can amplify a person's capability, but it can't replace experience and judgment built over time.
When ideas can become products faster, a person's taste, depth, and accumulated experience show up more directly in the work. You can see it in what problems they choose to solve, how they structure the workflow, and how they handle the details that are easy to overlook.
I'm looking forward to seeing more people start vibe coding. And I hope that after building their first prototype, they're willing to keep going: get colleagues actually using it, face the real edge cases, clean up the workflow, and make it something another person can take over.
That's when AI really starts to change a company.


























Comments