I did not plan to become a web developer. I am a controls engineer. I think in ladder logic, PLC tags, and P&IDs, not React components and REST APIs. But when a project called for a real-time equipment monitoring dashboard and the IT queue stretched out for months, I decided to try something different: vibe coding, the practice of describing what you want to an AI app builder and iterating your way to a working product.
What followed was equal parts impressive and humbling. Some things came together faster than I ever expected. Other things broke in ways the demo videos absolutely do not prepare you for. This post is an honest build log of the whole experience, including the vibe coding examples that actually worked, the ones that quietly failed, and the uncomfortable gap between a slick-looking prototype and something you could responsibly connect to live equipment.
If you are a controls engineer, an automation professional, or anyone sitting at the IT/OT intersection wondering whether these tools are ready for serious work, this is the writeup I wish I had found before I started.
Why a Controls Engineer Tried Vibe Coding in the First Place
Let me be direct about what triggered this experiment: friction that added up to real lost time every week.
The legacy SCADA HMI at the plant was fine at the workstation it was designed for in 2011. On a phone or tablet, it was unreadable. Remote monitoring required VPN plus a licensed client seat, which meant a shift supervisor calling in on a weekend had two options: drive in, or fly blind. Trend data required the historian client, which required a seat license, which required waiting for someone else to not be using it. None of these problems were catastrophic individually. Together, they added up to several hours of friction per week across the team.
That’s what motivated the experiment. Not curiosity about AI. A specific, boring, operational annoyance.
What “vibe coding” actually means for an OT audience
Vibe coding is natural language-first development. You describe what you want conversationally, and an AI app builder generates the application structure, layout, and logic from that description. No HTML, no CSS, no JavaScript. Automation World has flagged it as a legitimate shift in how manufacturing software gets built, not just a demo-circuit novelty.
The mental model closest to something a controls engineer will recognize: imagine writing a functional specification, except instead of handing it to a developer and waiting three weeks, the specification generates the application directly. Whether that holds up under industrial requirements is what this build log is about.
Why existing tutorials miss the controls engineer entirely
Search for low-code tutorials and you’ll find content written for IT business analysts building CRM tools or approval workflows. Controls engineers think in PLC scan cycles, historian tags, OPC-UA address spaces, and deterministic timing requirements. Those concepts don’t appear in any low-code tutorial I found. If you want a step-by-step workflow for getting started as a non-developer, Atsu’s guide to building your first app with vibe coding covers the general workflow well. The OT-specific friction it doesn’t cover is the reason this build log exists.
The market context that made it worth trying
By 2026, roughly 70% of new applications are projected to use low-code or no-code tools, up from under 25% in 2020. A talent shortage projected to reach 85.2 million workers by 2030 makes self-service tooling a strategic response, not just a convenience. Controls engineers who can build their own monitoring tools don’t wait in the same queue as everyone else.
One honest framing before we go further
This is not a success story. It’s also not a cautionary tale. It’s a build log documenting what worked and what broke, because the gap in existing content isn’t more marketing copy about what these tools can do. It’s the absence of honest post-mortems from people with actual OT domain knowledge.
The Project: Scope, Stack, and Starting Conditions
So here’s what I actually set out to build, because scope matters before anything else.
The dashboard requirements were deliberately modest. Five production assets, each needing a live status indicator (running, faulted, stopped). Trend charts for temperature and pressure tags, pulling historical and real-time data from the plant historian. An alarm banner across the top with an acknowledgment workflow. And a basic authentication layer with three roles: read-only for operators, acknowledge-capable for supervisors, and admin for the controls team. Nothing exotic by SCADA standards.
The data source is where things immediately diverged from every vibe coding example I found during my research. Every tutorial I read assumed a REST API, a cloud database, or at worst a clean JSON file. My tags lived in an OPC-UA server on a plant historian sitting inside the OT network with no public endpoint and no HTTP interface out of the box. OPC-UA (standardized under IEC 62541) is the industrial interoperability standard precisely because it handles the complexity of real field devices, but that complexity is invisible to any generic web tool. That gap is the whole story, and it starts before the first prompt.
My starting skill profile: comfortable writing structured text and ladder logic, capable of running SQL queries against the historian to pull tag history, and completely unfamiliar with React, REST APIs, or how component-based front-end frameworks are structured. I had never written a line of JavaScript intentionally. That is the exact persona this experiment was designed to represent, and I suspect it describes a large portion of working controls engineers who are curious about low-code tooling but have no entry point into the tutorials that exist.
Lovable was selected as the AI app builder for straightforward reasons. It runs entirely in the browser, requires no local development environment, generates deployable front-end applications from natural language prompts, and the conversational interface felt closer to writing a functional specification than writing code. For someone whose comfort zone is documentation and logic blocks, that interaction model was genuinely accessible.
“Done” for this prototype had a specific, testable definition: a shift supervisor opens a URL on a plant tablet, sees five asset status indicators and two live trend charts refreshing every five seconds, and can acknowledge an active alarm without installing anything or holding a SCADA client license. That’s the bar. Everything else is out of scope for phase one.
What Actually Worked: The Vibe Coding Wins
With the scope and starting conditions established, here is where the experiment actually delivered.
The layout came together faster than anything I’d experienced before. The first prompt was almost embarrassingly simple: “Create a dashboard with a status grid at the top, trend charts in the middle, and an alarm list at the bottom.” In under two minutes, Lovable returned a responsive, three-panel layout with sensible proportions and clean spacing. For a controls engineer who had never touched raw HTML, producing that same result manually would have been a multi-day detour through tutorials. That single exchange justified the experiment before anything else happened.
Iterative refinement worked exactly the way the demos promise. Swapping the background to dark mode, nudging the status grid to four columns instead of six, adjusting the alarm list font size, moving the trend charts to a tabbed panel rather than stacked rows: all of it happened through follow-up prompts. No hunting through a stylesheet. No inspecting nested div elements. The feedback loop felt like talking to a junior developer who executes quickly and asks clarifying questions when the instruction is vague. If you’ve ever tried to explain an HMI layout requirement to a vendor over email and watched it get misinterpreted twice, this felt like a significant upgrade.
The alarm acknowledgment workflow was the most impressive single output. One prompt asked for a status badge that cycled through “Active,” “Acknowledged,” and “Cleared,” with a confirmation modal before the state change committed. It generated correctly on the first pass with no manual edits required. That’s a non-trivial UI interaction involving conditional rendering and state management, and it worked out of the box.
The four-hour benchmark is real, with an important caveat. First prompt to visually complete prototype took roughly four hours across two sessions. That aligns with the up-to-90% development time reduction Forrester attributes to low-code approaches, at least for the UI construction phase. The caveat matters: “visually complete” means no live data, no real authentication, no error handling. Those gaps are covered in the next section.
The non-obvious win was the stakeholder conversation it enabled. Before a single real tag value appeared in the dashboard, the prototype went in front of operations management. A clickable mockup on a tablet closed the scope approval discussion faster than any Visio diagram ever had. For anyone writing for an audience like the one at Engineering For Fun, Atsu Bedjean’s controls engineering blog, that communication ROI is worth naming explicitly: vibe coding’s first real payoff may not be the finished tool, it may be getting alignment before committing to build one.

What Broke: The Vibe Coding Examples No One Shows You
The wins were real. But here’s what the demos don’t show you.
The OPC-UA wall hits immediately. Lovable builds front-end applications. It has no OPC-UA client, no historian adapter, and no concept of what a tag path like Site1.Unit3.TIC101.PV means. To get live data into the dashboard at all, I had to build a separate REST API layer in Python that polled the historian and served tag values over HTTP. That middleware work is not a vibe coding task. It took longer than everything else in the project combined, and the AI builder couldn’t help with a line of it. If your tags live in an OPC-UA server, budget for this before you open the app builder.
The polling architecture was quietly wrong. The generated dashboard fetched data on a five-second interval, which sounds fine until you notice that each component ran its own independent fetch. Five assets, a trend chart, and a pressure gauge all firing separate requests on slightly offset timers created real load on the historian query layer. A proper implementation uses one shared subscription that pushes updates to all components. An AI app builder with no OT context will always default to the simpler pattern, and it won’t tell you there’s a better one.
Authentication looked complete and wasn’t. The generated login screen worked visually: enter credentials, get access. Under the hood, the token sat in localStorage with no expiry logic, the “remember me” checkbox had no actual behavior, and the alarm acknowledgment action had no role-based route guard on it. Any authenticated user could acknowledge any alarm regardless of their assigned role. Each issue is fixable individually; together they constitute a security review failure.
The data-binding hallucination cost an hour. I prompted: “connect the temperature trend chart to the historian API endpoint.” The generated code mapped to a field called value. My API returned pv. The chart rendered completely empty with no error, no console warning, and nothing to trace. A wrong field name in a compile-time language throws an error. Here, it just showed a blank chart that looked like a working chart with no data. That debugging experience is genuinely worse than a compiler telling you what’s wrong.
Session context degrades over long builds. The first 20 or so exchanges produced clean, consistent output. After roughly 30 prompts in a single session, the AI started re-introducing styling inconsistencies it had corrected earlier. Once, when I asked it to “clean up the layout,” it deleted the entire alarm list component. Session context limits are a real constraint for any complex vibe coding application, and there’s no warning before the drift starts.
The IT/OT Gap: Where Generic App Builders Stop Short
Those individual failures from the previous section all trace back to a single root cause: the AI builder was trained on web application patterns. It has never seen an OPC-UA browse tree, doesn’t know what a scan cycle is, and has no concept of the difference between a historian compressed value and a raw sample. That’s not a criticism of the tool. It’s a category mismatch that matters more in industrial contexts than almost anywhere else.

The vocabulary gap is wider than it looks. When a web developer says “loading state,” they mean the half-second between a button click and an API response. When a controls engineer says a tag is stale, they mean communication to the field device was lost and the last-known value is sitting in memory with no timestamp update. Those are architecturally different conditions. The generated dashboard treated both identically: a zero was a zero, whether the transmitter was reading zero or the PLC had stopped responding entirely. In a monitoring application, that distinction is safety-relevant. A shift supervisor staring at a pressure reading of 0.0 PSI needs to know whether the vessel is actually at atmospheric or whether the instrument loop is dead.
Alarm management is where the compliance gap becomes unavoidable. A notification badge is a web pattern. ISA-18.2 alarm management is a different discipline entirely. The standard covers alarm priority classification, shelving during maintenance windows, suppression logic, and rationalization workflows. None of those concepts exist in a general-purpose vibe coding app tool’s training data. Getting even a basic compliant alarm workflow into the generated dashboard required dropping out of the AI builder entirely and editing the code manually.
The network layer is invisible to the builder but non-negotiable in the plant. The historian lived on a server inside the plant network with no public endpoint. Reaching it from a browser-based dashboard meant building a reverse proxy or routing through a VPN tunnel. That decision sits completely outside what any AI app builder can advise on or generate.
And that infrastructure decision is actually the shallow end. Before a single tag value renders in a browser, someone with OT security knowledge has to make calls about DMZ architecture, data diodes, historian replication strategy, and read-only API credential scoping. The ISA-18.2 standard’s scope assumes those layers exist beneath the display layer. The dashboard is genuinely the easy part.
Prototype to Production: The Gap the Demos Do Not Show
Getting past the IT/OT integration hurdles is genuinely satisfying. Then you show the prototype to your plant’s IT security team, and the conversation changes completely.
The gap between a working prototype and a production-ready monitoring tool is not about adding a better color scheme. It is a structural rebuild of nearly every layer the AI builder touched: authentication, error handling, data integrity, and deployment infrastructure. The generated output works visually. It does not work operationally.
Authentication was the most urgent problem. The login screen looked correct and functioned correctly in testing. Under the hood, the session token lived in localStorage with no expiry, no refresh logic, and no server-side validation. Role-based access control existed only at the UI layer, meaning a motivated user could call the alarm acknowledgment API endpoint directly without ever touching the dashboard. Control room tablets are shared hardware. A session that never times out and never triggers a lock screen is not an acceptable configuration in that environment. Every one of those gaps required manual rework that the AI builder had no mechanism to generate.
Error and failsafe states were almost entirely absent. The generated dashboard had no loading skeleton, no “communication lost” banner, and no logic for partial data scenarios. When three of five assets were responding and two were not, the dashboard showed blank panels. In a web application, a blank chart reads as a loading state. In a monitoring dashboard, it is indistinguishable from a working chart displaying a genuine zero value. That distinction is not cosmetic. A null value and a zero value must render differently, and the generated output treated them identically.
Audit trail requirements added backend scope the AI builder could not touch. In regulated facilities, alarm acknowledgment is a traceable action: who acknowledged, which alarm, at what time, from which session. The generated acknowledgment workflow updated a status badge and nothing else. Adding tamper-evident logging required database schema decisions, backend write logic, and an understanding of the regulatory context driving the requirement. None of that lives in a front-end scaffolding tool.
Deployment assumptions are baked in from the first generated file. A vibe coding application scaffolded for public cloud hosting carries implicit dependencies on external services, public DNS, and outbound internet access. Plant cybersecurity policy frequently prohibits all three. Air-gapped or on-premise deployment requires deliberate configuration choices that must be made before the prototype is built, not discovered afterward when the security review returns a rejection.
What I’d Do Differently: A Revised Build Approach
Knowing where the build broke is only useful if it changes how the next one starts. Here is what I would do differently.
Build and test the REST API layer before opening the AI app builder. The entire vibe coding workflow assumes you have a clean, documented data contract to hand the UI. When I discovered mid-build that my historian returned a field called pv instead of value, I had to retrofit every data binding in the generated code. That is compounding rework. Spend an afternoon in Postman first: confirm your endpoints, nail down the JSON shape, document the field names, and only then start prompting for a UI.
Write a one-page requirements document before the first prompt. Not because Lovable reads it, but because writing it forces the discipline that keeps your session from drifting. List your tags, your refresh rate, your user roles, your alarm priority levels, and what a “communication lost” state should look like on screen. That 30-minute exercise prevents the scope creep that causes prompt degradation by exchange 25. I skipped it, and I paid for it.
Break the build into short, scoped sessions with explicit checkpoints. The context degradation problem I hit during long sessions is real and largely avoidable. Treat each major component as its own session: status grid, trend chart, alarm list, authentication. Save and manually test the output from each session before starting the next. When something breaks later, you have a known-good state to fall back to instead of an entangled 40-message conversation thread.
Treat the generated code as a scaffold, not a finished product. This is the mental model shift that matters most for industrial use. Lovable produces a high-quality starting point for the UI layer, and that is genuinely valuable. A controls engineer with basic Python or JavaScript familiarity then manually hardens the data binding, adds real error states, and fixes the security layer. The AI does the visual heavy lifting; you own the integration seams.
The honest case for Lovable as an AI app builder is not “build production SCADA tools without coding.” It is “go from blank page to stakeholder-ready mockup in an afternoon.” That is a real capability, worth using for exactly that purpose, and not worth overselling beyond it.
Is Vibe Coding Actually Viable for Controls Engineers?
So here’s the straight answer: yes, vibe coding is viable for controls engineers, but only for prototyping. The distance between a working prototype and something you’d run in production is longer than any platform demo will show you, especially when your data lives in an OPC-UA server inside a plant network rather than a cloud database with a clean REST endpoint.
The 38% Fortune 500 no-code adoption figure gets cited as proof that this technology is production-ready. It is, for enterprise IT teams with mature cloud infrastructure, SSO, and governed data layers. Controls engineering adds a different set of constraints: OT network segmentation, safety-relevant display requirements, ISA-18.2 alarm management, and in regulated facilities, audit trail and compliance requirements that most IT deployments simply do not face. That statistic does not transfer.
The friction point is also more specific than most people expect. Vibe coding examples from web and SaaS contexts fail in the data layer, not the UI layer. The AI builder handles layout, visual design, and interaction patterns genuinely well. It falls apart at industrial data semantics: it does not know what a historian compressed value is, cannot distinguish a stale tag from a zero value, and has no concept of alarm rationalization. The UI is the easy part. It was always the easy part.
That said, the talent shortage argument for continuing to explore this is real. With an 85.2 million worker shortage projected by 2030, a controls engineer who can prototype a monitoring screen, show it to operations management, and articulate clear requirements to a developer is more useful than one who cannot. Vibe coding builds that capability even when the output never goes to production. The prototype from this build got scope approved faster than any Visio diagram had managed. That value is independent of production readiness.
The technology is also moving fast enough that a verdict today should not be permanent. OT-aware AI tooling is an emerging category, and the gap between a generic AI app builder and something purpose-built for SCADA contexts is a product opportunity the market is starting to recognize. Re-evaluating every six to twelve months is a reasonable posture. What the tools cannot do today is a shorter list than it was a year ago.
Takeaways Before You Start Your Own Build
If the previous section answered whether vibe coding is viable, here’s what to actually do before your first prompt.
1. Build the data bridge first. A clean REST API over your historian is the hard prerequisite, and the AI builder will not help you with it. Every vibe coding example you’ll find online assumes a cloud database with a tidy JSON endpoint. Your historian does not look like that. Solve the data layer, document the endpoint shapes and field names, and test it with Postman before you open the builder. If you start with the UI and figure out the API later, you will rebuild data bindings at least twice.
2. Use the prototype for stakeholder alignment, not deployment. The fastest return on a vibe coding session is a clickable mockup that gets a scope conversation moving. Show it to operations management before a single real tag is connected. That is where the four-hour build pays off immediately. Production hardening, including authentication, error states, and audit logging, is a second project with a separate timeline and different skills involved. Conflating the two is where most of the pain in this build came from.
3. Write your requirements before your first prompt. Spend 30 minutes writing a plain-language list: tag names, refresh rate, user roles, and what the screen should show when a field device stops responding. Not because the AI needs formal documentation, but because the discipline surfaces contradictions in your own thinking before they become mid-session rework. Prompt degradation is real; a clear scope going in limits how far a long session can drift.
4. Know where the production gap lives before you start. Authentication, error handling, audit logging, and OT network architecture are where a working demo stops being a deployable tool. In regulated facilities, alarm acknowledgment logging and role-based access are not optional polish; they are compliance requirements. Understanding that boundary upfront means you treat the prototype as exactly what it is, not as something nearly done.
5. Start smaller than you think you need to. One asset, one data source, one screen. Get that working end-to-end, including real data flowing through a tested API. That bounded scope teaches you more about where the tool helps and where it stops helping than any demo will. Expand from a working foundation, not from a sprawling prototype with unfilled gaps in every corner.
Vibe coding is a real capability multiplier for controls engineers. Use it to move faster on the parts it is actually good at.
Conclusion
Vibe coding is not a shortcut around engineering judgment; it is a tool that amplifies it. The engineers who will get the most from it are the ones who understand their domain deeply enough to know when the AI is helping and when it is quietly leading them somewhere wrong.
The core lessons from this build are straightforward: prototype value is real, but production readiness is a separate project. The IT/OT boundary is not a detail to figure out later. Requirements written before the first prompt save hours of mid-session drift. And a small, working end-to-end build teaches more than any polished demo.
If you are a controls engineer considering this approach, start your next small internal tool using these methods. Build one screen. Connect one data source. Ship something real. That experience will tell you exactly where vibe coding fits in your workflow.
Frequently Asked Questions
What is vibe coding and how does it differ from traditional development?
Vibe coding is natural language-first development where you describe what you want conversationally, and an AI app builder generates the application structure, layout, and logic from that description. Unlike traditional development that requires HTML, CSS, and JavaScript, vibe coding allows you to write a functional specification that directly generates the application. For controls engineers, it's conceptually similar to writing a functional specification and having it automatically build itself, rather than handing it to a developer and waiting weeks for results.
What were the biggest challenges encountered when building the monitoring dashboard?
The primary challenges fell into three categories: (1) OPC-UA integration—the AI builder couldn't connect to the plant historian's OPC-UA server, requiring a separate REST API middleware layer built in Python; (2) Polling architecture—the generated dashboard used inefficient independent component fetches instead of a shared subscription model; (3) Production gaps—authentication lacked expiry logic, data-binding errors went silent, and role-based access control only existed at the UI layer. The data integration layer took longer than everything else combined.
Is vibe coding ready for production use in industrial/OT environments?
Vibe coding is viable for prototyping in OT environments but not for direct production deployment. The AI builders work well for UI layout and visual design but struggle with industrial data semantics, ISA-18.2 alarm management standards, audit trail requirements, and network security architecture. For Fortune 500 IT teams with mature cloud infrastructure, adoption is higher, but controls engineering adds specific constraints around OT network segmentation and safety-relevant display requirements that exceed typical web application scope.
What should a controls engineer do before starting their first vibe coding project?
Follow these steps in order: (1) Build and test the REST API layer first—confirm endpoints, document JSON shapes, and test with Postman before opening the AI builder; (2) Write a one-page requirements document covering tag names, refresh rates, user roles, and error states; (3) Design a smaller scope than you think necessary (one asset, one screen); (4) Treat the generated code as a scaffold, not a finished product; (5) Use the prototype for stakeholder alignment rather than planning for production deployment. This disciplined approach prevents mid-session drift and rework.
What is the actual value proposition of vibe coding for controls engineers despite its limitations?
The primary value of vibe coding for controls engineers is time-to-prototype for stakeholder alignment and capability building. Going from blank page to a clickable, responsive mockup in four hours is genuinely faster than manual development or waiting in IT queues. This enables faster scope approval conversations with operations management. Additionally, controls engineers who learn to prototype with these tools become more valuable in mixed teams—they can articulate clear requirements to developers and understand where engineering judgment is needed. With an 85.2 million worker shortage projected by 2030, this rapid prototyping skill multiplier is strategically relevant, even if individual prototypes require hardening before production deployment.

Leave a Reply