Back to BlogIndustry at the Edge

Build vs. Buy Is Over. Everybody Is Building Now.

AI agents have made building software cheap, and now every engineer on the plant floor can build their own tools. The question is no longer build or buy, but what you are building on.

Engineers typing at a shared desk in front of a laptop showing an AI assistant chat interface

On this page

Written by

Tags

Share

For twenty years, every software decision in industry started with the same question: do we build it, or do we buy it?

Build meant control and customization, but you had to wait for it to be built and then dedicate a team to keeping it alive. Buy meant speed and support, but you always ended up with a product that covered 80% of what you needed, with the other 20% never quite arriving.

That debate is over, because the cost of building software has collapsed.

With Claude (and a few of its friends), almost any engineer on the plant floor can now build a working prototype of a tool they've needed for months. In an hour. Without involving IT.

So everybody is building now. And honestly, that's great.

But here's my question...

"What are you building on?"

Are you laying bricks directly on the ground, or are you pouring foundations first?

Both are building. Only one of them will still be standing in ten years.

What Changed

I use Claude every day.

It reads my emails and summarizes them. Helps me draft replies. Turns emails into tasks in my favorite to-do app and helps me close them when the work is done. It consolidates my invoices, builds the small productivity tools I always wanted but never had time to create, and drafts documents that I then rewrite (this article is no exception).

And the list goes on.

Meanwhile, I see my colleagues building software at a pace that would have been unthinkable just a couple of years ago.

Building software has become cheap. Laughably cheap. So cheap that it almost feels like cheating.

And that changes everything. Because the people closest to the problem can now build their own solutions, without waiting for someone else to do it for them.

That's productivity. That's independence.

What Didn't Change

Here's the catch:

"The cost of writing code went down. The cost of knowing what to write didn't."

Nobody would vibe-code the control algorithm of a nuclear plant. Nobody would prompt their way to a rocket launch. We all agree on that. But somewhere between "a dashboard" and "a nuclear plant" sits most of what runs an industrial process. And the line between the two is a lot blurrier than it looks.

An agent can write a PID loop in thirty seconds. It probably won't tell you that this particular valve needs anti-windup because of how the upstream tank behaves on a cold start. It can write a perfectly good Modbus client. But it probably doesn't know that the old PLC on Line 2 drops the connection every time someone polls it faster than twice a second.

That knowledge is not in the model. It's in the people who got burned by it, and in the products those people built afterwards.

Because that's what a mature platform is: years of other people's mistakes, fixed, tested, and packaged.

The companies behind PLC runtimes, SCADAs, and historians have spent a decade or more specializing in their respective problems. Every lesson learned, every edge case discovered, every customer issue resolved has made those products a little more reliable. When you build your own version, you start that process from scratch.

I use Claude to read my email. I wouldn't dream of building my own Gmail.

I'd never build my own AWS or my own Kubernetes either. But the way I use them has changed completely: today I lean heavily on Claude to build things on top of them.

The platforms stayed. The way I build on them changed.

Five Things a Platform Gives You That a Prompt Doesn't

Let's make this concrete. When you build the core yourself, this is what you're signing up for.

  1. Field expertise. A platform is built by people who have spent years in the exact environment you're trying to automate. They know what electrical noise does to a serial link, how a brownout can corrupt a database that was "just writing a log", and what an operator goes through when the screen freezes ten minutes before the end of a shift. That knowledge is not in any manual. It's in the product, one scar at a time. You can prompt for code. You can't prompt for ten years on the plant floor.
  2. Maintenance. The day the tool works is the day the real job starts. Bugs, patches, library updates, abandoned dependencies, OS upgrades that break drivers. When you build it, all of that is yours. When you buy a supported product, somebody else maintains the core software. And you benefit from every fix another customer needed and every improvement another plant asked for. Your own tool only improves when you have time. And let's face it: you never have time.
  3. Testing at scale. Claude is remarkably good at writing test plans and running them. But it can only test against the requirements, hardware, and conditions you give it access to. A mature product with thousands of installations has been exposed to hardware, networks, failures, and operating conditions you probably haven't even considered. That's a QA budget and a body of field experience you cannot easily match, no matter how good your agent is.
  4. Certification. Sooner or later, somebody may ask you to demonstrate that the software running your process meets industrial cybersecurity or functional safety requirements (IEC 62443, IEC 61508, pick your sector's). And "we built it ourselves" won't be enough. Demonstrating compliance, let alone achieving certification, takes serious engineering effort and often independent assessment. Good luck doing that for a tool you vibe-coded over a weekend.
  5. Support. When something breaks in a mature platform, you're probably not the first person to experience it. There's a team that knows the product inside out, has seen users struggling with the same issues a hundred times, and is there to help you fix them. When your home-built tool breaks, you're on your own. Claude can help you troubleshoot, but ultimately, the problem is yours to solve.

None of this says the agent is bad. It says the agent is a builder, not a vendor.

Build on Buy: It's Already Happening

Now the good news: you don't have to choose.

  • PLC programming. Let an agent write your IEC 61131-3 Structured Text. CODESYS already has an MCP server that lets an LLM read and modify projects, compile code, and check for errors. Schneider Electric's Automation Copilot generates and tests code using its trusted libraries. And Rockwell's FactoryTalk Design Studio Copilot helps engineers write and understand PLC logic, but it is not allowed to modify safety code.
  • SCADA and HMI. Ignition's new MCP module connects its industrial data with AI agents, and most early users are already using it to write scripts and build screens. What you're not rebuilding is the gateway, the tag engine, the historian, or the redundancy. Those took years to get right.
  • Machine connectivity. N3uron, Kepware, HighByte, pick yours. These platforms handle the hard work of connecting to industrial equipment and making its data available. What you build with Claude is what your operation actually needs: the transformation scripts, the Node-RED flows, the Grafana dashboards, the integration with the ERP that nobody ever had time for.
  • Time-series storage. Nobody should code their own historian or time-series database. But the queries, the reports, the anomaly alerts that turn that data into something useful? That's the last mile. That's where you build.

In every one of those cases, the split is the same. The platform provides the proven capabilities that everyone needs. You build what makes your application different: the custom logic, the integrations, the dashboards.

Buy the foundation. Build the last mile.

How to Draw the Line

Three questions, before you decide what to build yourself.

  1. If this has a bug, could production stop?
  2. Does it need to meet safety, security, or regulatory requirements?
  3. Will someone have to maintain it for years, even after the person who prompted it has left?

Three "no"s? What are you waiting for? Stop reading and go build it. Enjoy every minute of it. A dashboard, an integration, a report, a small app that saves your team two hours a day. That's where building has always been fun and is now also cheap.

Did you get at least one "yes"? Still build. Just not from the ground up. Pick the platform that's already solved the hard parts, and build on top of it.

So, Build or Buy?

Both. That was always the right answer. It's just that now it's cheap enough to be true.

Build freely. Enjoy the process. Just don't reinvent the foundations. Buy the platform someone has spent a decade improving, and spend your afternoon building what makes it yours.

The agent gives you the bricks. Make sure there's something solid underneath.

About Barbara

Barbara enables industrial organizations to deploy, orchestrate, and continuously manage distributed applications and AI models directly at the edge, where latency, bandwidth constraints, and data sovereignty cannot be compromised.

Built for complex environments with SCADA systems, PLCs, legacy protocols, and heterogeneous hardware, Barbara helps IT and OT teams move beyond pilots and scale secure edge deployments to hundreds of nodes.

If you're working on similar challenges or exploring how edge platforms can support your industrial initiatives, explore more insights on our blog or get in touch with our team to continue the conversation.

Alternatively, you can also start using the platform today.

Keep reading

More from Industry at the Edge

Get the latest from the industrial edge.

One email a month: product updates, customer stories and edge AI insights. No noise, unsubscribe anytime.

Try Now

HubSpot form (email + consents) — pending integration

We use cookies

Essential cookies keep the site working. With your consent we also use analytics and marketing cookies. You can change your choice at any time in Cookie Preferences. Read our Privacy Policy.