Artificial intelligence has already entered PLC engineering.

Not as a distant research project.

Not as a vague prediction.

It is here now.

AI tools can generate Structured Text, explain ladder logic, analyse existing PLC projects, create HMI elements, generate documentation and increasingly perform engineering tasks directly inside automation platforms.

That naturally leads to one uncomfortable question:

Will AI replace PLC programmers?

The short answer is:

No — but it will change what a valuable PLC programmer looks like.

The engineers most exposed to automation are not necessarily the least experienced.

They are the engineers whose work consists mainly of repetitive configuration, copying standard logic, manually creating similar devices, editing tags, producing routine documentation and performing tasks that can be clearly described and checked.

At the same time, engineers who understand the process, architecture, safety, commissioning, machine behaviour and how to validate AI-generated work may become considerably more productive.

The real shift is therefore not:

AI versus PLC engineers.

It is:

engineers using AI versus engineers who refuse to adapt.

AI Has Already Moved Beyond Chatbots

A few years ago, using AI for PLC engineering normally meant opening a chatbot and asking:

Write an SCL function block for a conveyor.

The result could be useful, but it had no understanding of your actual machine.

It did not know your tags.

It did not understand your UDT structure.

It did not know your company’s coding standard.

It could not see your hardware.

And it certainly could not modify your TIA Portal project directly.

That model is changing quickly.

In April 2026, Siemens launched the Eigen Engineering Agent, an AI system connected directly to TIA Portal. Siemens says the system can work with project context, create PLC code, generate HMI visualisation, configure devices and execute multi-step engineering tasks rather than merely returning suggestions.

Siemens later expanded the system with capabilities for importing electrical-design information and generating standards-compliant automation-project structures from natural-language machine descriptions.

Rockwell Automation is moving in the same direction. Its industrial AI portfolio includes FactoryTalk Design Studio Copilot, which Rockwell describes as a generative-AI tool capable of converting plain-language ideas into PLC code and engineering insights.

That is a major change.

AI is moving from:

“Help me write code.”

to:

“Understand this engineering environment and perform part of the engineering workflow.”

So Which PLC Tasks Are Most Likely to Be Automated?

Not every engineering task is equally vulnerable.

Some tasks are highly structured, repetitive and easy to verify.

Those are exactly the tasks AI handles increasingly well.

1. Boilerplate PLC code

Consider a typical machine containing:

40 motors;
25 photoelectric sensors;
12 cylinders;
multiple alarms;
repeated interlocks;
standard diagnostic structures;
standard HMI objects.

A controls engineer may spend hours creating nearly identical blocks, tags and calls.

This is an obvious candidate for automation.

If a company has a standard motor function block, a defined tag structure and a known hardware list, an AI-assisted engineering tool can potentially generate large portions of the repetitive implementation.

The engineer’s job becomes less about typing the same pattern 40 times and more about defining the architecture correctly.

2. PLC Code Explanation

One of the most immediately useful applications of AI is understanding unfamiliar code.

Imagine arriving on a commissioning project and opening a PLC program containing:

300 function blocks;
inconsistent naming;
old comments;
undocumented modifications;
logic written by several engineers over ten years.

Traditionally, understanding that system could take days.

A project-aware AI system can increasingly answer questions such as:

What controls Conveyor 17?

Which conditions prevent this motor from starting?

Where is this HMI command used?

Which blocks write to this data structure?

Siemens explicitly positions Eigen’s project-context capability around this kind of use case. It can analyse PLC blocks, data blocks, UDTs, HMI screens and their relationships inside an assigned TIA Portal project.

For commissioning engineers, that may become one of the most valuable uses of industrial AI.

3. Documentation

Documentation is essential.

It is also one of the tasks engineers regularly postpone.

AI is particularly well suited to converting structured engineering information into human-readable documentation.

That could include:

function-block descriptions;
sequence descriptions;
alarm documentation;
I/O summaries;
maintenance instructions;
network descriptions;
change summaries;
commissioning notes.

The important difference is that future documentation may increasingly be generated directly from the actual project rather than manually maintained in a separate Word document.

That has the potential to improve both speed and accuracy.

4. HMI Engineering

HMI development contains a surprising amount of repetitive work.

An engineer may repeatedly create:

faceplates;
tag connections;
navigation;
alarm views;
status indicators;
visibility rules;
JavaScript;
animations.

Siemens lists HMI visualisation and JavaScript generation among the Eigen Engineering Agent’s current capabilities.

This does not mean AI will design a perfect operator interface automatically.

But it may dramatically reduce the amount of manual configuration required to produce the first functional version.

5. Hardware Configuration

Hardware engineering is another structured problem.

Given:

a device list;
network topology;
IP addresses;
device names;
electrical-design information;

software can already automate significant parts of project creation.

AI makes the interface easier because the engineer may no longer need to build a specialised automation script for every workflow.

Instead, the engineer describes the desired result.

Siemens’ newer Eigen capabilities can use ECAD information to populate TIA Portal projects and configure devices based on actual electrical-design data.

This is an important direction because hardware and software engineering have traditionally required significant manual synchronisation.

6. Testing

Testing may eventually become one of the biggest opportunities.

A PLC program can compile perfectly and still be wrong.

For example:

IF SensorClear THEN
    MotorRun := TRUE;
END_IF;

The syntax is valid.

But perhaps the motor should only run when:

automatic mode is active;
the safety circuit is healthy;
no drive fault exists;
the downstream conveyor is available;
the zone is not occupied;
maintenance mode is disabled.

An AI system that understands the project specification could potentially generate tests and compare expected behaviour against simulated behaviour.

Siemens already lists automated testing and validation as part of its industrial-AI engineering direction.

Combine this with PLC simulation and digital twins and the potential becomes much larger.

What AI Is Still Bad At

This is where many discussions about AI and automation engineering become unrealistic.

Generating PLC code is only one part of being a controls engineer.

A real automation project contains enormous amounts of implicit knowledge.

AI does not stand beside a conveyor and hear that the gearbox sounds wrong.

It does not notice that a sensor bracket vibrates every time a pallet hits the stop.

It does not automatically understand why a pneumatic cylinder occasionally fails at low plant pressure.

It does not negotiate with mechanical engineers about a badly positioned photoeye.

It does not decide that the machine sequence is technically correct but operationally unusable.

It does not instinctively understand the difference between:

“the PLC logic works”

and

“the machine works.”

That difference is enormous.

Commissioning Is Much Harder to Automate

Commissioning is where the limits become obvious.

A commissioning engineer works with incomplete information.

The electrical drawings may be outdated.

Mechanical modifications may have happened overnight.

A drive may have been replaced with a different model.

The customer may change the sequence while the machine is already being tested.

A sensor may physically detect something different from what the program expects.

Production operators may use the machine in ways the designer never predicted.

This is not simply programming.

It is engineering under uncertainty.

AI can assist with diagnosis and analysis.

But someone still needs to understand the physical process.

That skill may become more valuable as code generation becomes easier.

Safety Is Another Major Boundary

AI-generated logic can look convincing.

That does not make it safe.

Industrial systems can contain:

high-speed motion;
heavy loads;
robotics;
high temperatures;
hydraulics;
pneumatics;
stored energy;
people working inside hazardous areas.

A mistake can have physical consequences.

That means generated logic must still be validated against:

functional requirements;
risk assessments;
safety architecture;
machine behaviour;
applicable standards;
commissioning tests.

Even Siemens’ own materials continue to position the engineer as the reviewer of generated results rather than removing engineering responsibility entirely.

The more capable AI becomes, the more important competent validation becomes.

The Most Valuable Engineer May Stop Being the Fastest Programmer

Historically, an excellent PLC engineer could differentiate themselves partly by speed.

They knew the instructions.

They knew the libraries.

They knew how to write logic quickly.

They knew the shortcuts inside the engineering software.

Those skills still matter.

But imagine two engineers in 2029.

Engineer A

Writes everything manually.

Very fast programmer.

Knows ladder logic extremely well.

Avoids AI because they do not trust it.

Engineer B

Understands PLC programming just as deeply but also knows how to:

define engineering standards;
structure reusable automation libraries;
describe requirements clearly;
use AI engineering agents;
automatically generate repetitive code;
validate generated logic;
simulate the machine;
run automated tests;
analyse project data;
connect engineering APIs;
diagnose problems using AI-assisted tools.

Engineer B may produce several times more engineering output.

That changes what companies will value.

PLC Programming Could Become More Like Software Architecture

Consider modern software development.

Professional developers still write code.

But senior developers often spend a significant amount of time on:

architecture;
requirements;
reviews;
testing;
integration;
deployment;
debugging;
technical decisions.

Industrial automation may move in the same direction.

Instead of spending hours manually creating every PLC network, engineers may increasingly define:

What should the machine do?

How should the software be structured?

What are the safety constraints?

What interfaces are required?

How will we prove it works?

The AI handles more implementation.

The engineer owns the intent and validation.

Could One Engineer Eventually Do the Work of Three?

Possibly.

And this is where the economic impact becomes important.

Siemens claims its Eigen Engineering Agent can achieve substantial efficiency improvements in selected automation-engineering workflows, including two-to-five-times faster execution for some tasks and efficiency gains of up to 50%. These are vendor-reported figures rather than universal guarantees, but they illustrate the direction the industry is pursuing.

If engineering productivity genuinely doubles, companies may not need twice as many engineers to deliver twice as much work.

But that does not automatically mean half the engineers disappear.

Industrial automation already suffers from skilled-engineering shortages.

Projects are becoming more complex.

Machines contain more software.

Cybersecurity requirements are increasing.

Data integration is growing.

Digital twins are expanding.

Customers expect shorter delivery schedules.

Companies may use AI productivity simply to deliver projects they previously could not resource.

The Junior Engineer Problem

There is, however, a genuine risk.

Many engineers learn through repetitive work.

A junior engineer may begin by:

creating tags;
wiring HMI objects;
writing simple motor logic;
creating alarms;
testing I/O;
documenting code.

Those tasks teach the fundamentals.

If AI performs most of them automatically, how does the next generation develop deep engineering knowledge?

This problem already exists in software development.

If beginners use AI before understanding fundamentals, they can produce code they cannot properly review.

Industrial automation makes this more dangerous because the code controls physical equipment.

Companies therefore need to think carefully about training.

Junior engineers should use AI.

But they should also be required to understand what it generates.

The PLC Engineer Skills That Will Become More Valuable

If you are planning your career through the rest of this decade, these are the areas I would prioritise.

1. Process Knowledge

Understand the machine.

Understand why it exists.

Understand how material moves.

Understand what can fail.

Understand what operators need.

This is difficult for generic AI to replicate because every real installation contains context.

2. Software Architecture

Learn how to structure large PLC projects properly.

Understand:

modularisation;
interfaces;
state machines;
reusable blocks;
UDTs;
naming standards;
libraries;
separation of concerns.

AI becomes much more useful when the architecture is good.

3. Commissioning

Real-world commissioning experience will remain extremely valuable.

Learn how to:

test safely;
diagnose hardware faults;
read electrical drawings;
troubleshoot networks;
tune drives;
analyse sequences;
communicate with mechanical teams;
manage production pressure.

That knowledge is difficult to acquire without being on real projects.

4. Industrial Networking

PLC systems increasingly depend on networks.

Learn:

PROFINET;
EtherNet/IP;
OPC UA;
MQTT;
industrial Ethernet;
VLANs;
routing;
managed switches;
diagnostics.

AI can help configure networks.

But somebody must understand whether the architecture makes sense.

5. Cybersecurity

Cybersecurity is rapidly becoming part of controls engineering.

Understand:

network segmentation;
secure remote access;
user management;
PLC security;
patching;
firmware lifecycle;
backups;
attack surfaces.

As industrial systems become more connected, this knowledge will become increasingly valuable.

6. Simulation and Digital Twins

The more code AI generates, the greater the need to test it efficiently.

That makes simulation extremely important.

Engineers who can combine:

PLC logic

simulation

automated testing

virtual commissioning

will be able to validate much more work before reaching site.

7. Engineering APIs

Learn how engineering platforms can be automated.

For Siemens, that includes technologies such as TIA Portal Openness.

For Rockwell users, engineering APIs and SDK-based workflows can automate project manipulation and data exchange.

An engineer who understands both PLC programming and software automation can build tools that remove huge amounts of repetitive work.

Related Antomatix reading: TIA Portal Openness: Automating Siemens Engineering with an API.

8. Basic Software Development

Controls engineers increasingly benefit from understanding:

C#;
Python;
APIs;
JSON;
databases;
Git;
scripting;
cloud services.

You do not need to become a full-stack developer.

But the boundary between automation and conventional software is disappearing.

9. AI Prompting — But Not Just Prompting

Prompt engineering alone is not a career moat.

The real skill is turning engineering intent into something AI can execute and verify.

That requires:

clear requirements;
structured data;
defined standards;
test criteria;
domain knowledge.

The valuable skill is not:

“I can write clever prompts.”

It is:

“I can define an automation problem precisely enough that AI can help solve it safely.”

Where Antomatix PLC Forge Fits

This is exactly the direction behind Antomatix PLC Forge.

The goal is not to remove the automation engineer.

The goal is to remove repetitive engineering effort.

PLC Forge explores AI-generated logic for both:

Siemens TIA Portal;
Allen-Bradley Studio 5000.

The engineer provides the requirements.

AI generates a starting point.

The engineer reviews, tests and integrates the result.

That workflow is likely to become increasingly normal across industrial automation.

Related reading: Antomatix PLC Forge: AI Code Generation for Siemens TIA Portal and Allen-Bradley Studio 5000.

Siemens Eigen Shows Where the Industry Is Heading

One reason this discussion matters now is that industrial AI has moved beyond experiments.

Siemens’ Eigen Engineering Agent can work directly with TIA Portal project context rather than forcing engineers to manually copy code into a generic chatbot.

Antomatix recently tested Eigen against a real TIA Portal project containing PLC logic, WinCC Unified, structured data and an intentionally introduced software fault.

The interesting question was not:

Can AI write SCL?

We already know it can.

The question was:

Can AI understand an existing automation project?

That distinction is much more important.

Related reading: Siemens Eigen Engineering Agent: TIA Portal AI Tested.

What PLC Engineering May Look Like by 2030

Nobody can predict this perfectly.

But the trajectory is becoming visible.

A future workflow could look something like this:

Step 1 — Requirements

The engineer imports:

functional specification;
device list;
electrical design;
safety requirements;
customer software standard.

Step 2 — Project Generation

AI generates:

hardware;
tags;
UDTs;
software structure;
standard blocks;
HMI architecture.

Step 3 — Logic Generation

The engineer describes machine sequences.

AI creates initial PLC implementation.

Step 4 — Simulation

A digital twin executes the generated software.

Step 5 — Automated Testing

AI generates test cases and looks for sequence failures.

Step 6 — Engineering Review

The controls engineer reviews:

architecture;
safety;
abnormal conditions;
machine behaviour.

Step 7 — Commissioning

The engineer goes to site with a project that has already been tested against thousands of simulated scenarios.

Step 8 — Operations

AI assists maintenance engineers with diagnostics using live project context and machine history.

Parts of this workflow already exist separately.

The major change will come when they become connected.

Does This Mean Fewer PLC Programming Jobs?

Some roles will probably change significantly.

A job focused almost entirely on manually producing standard PLC code may become less valuable.

But the demand for people who understand industrial systems is unlikely to disappear simply because code becomes easier to generate.

In fact, easier code generation may create more automation.

Projects that were previously too expensive may become viable.

Smaller manufacturers may automate more processes.

System integrators may deliver projects faster.

Existing plants may modernise legacy control systems more aggressively.

That creates new engineering work.

The Bigger Risk Is Staying Narrow

The biggest career risk for a PLC programmer may not be AI.

It may be defining yourself too narrowly.

If your entire professional identity is:

I know how to write ladder logic.

then automation tools could gradually reduce the value of that specific skill.

If instead you can say:

I understand how to design, program, simulate, commission, diagnose and improve industrial automation systems.

then AI becomes another tool.

A very powerful one.

Will Ladder Logic Disappear?

Probably not anytime soon.

Ladder remains widely used because:

electricians understand it;
maintenance teams understand it;
it is easy to monitor online;
enormous installed bases already exist;
many companies standardise around it.

AI may actually extend ladder’s life.

If AI can generate, explain and maintain ladder effectively, engineers may feel less pressure to replace it purely for productivity reasons.

What may change is how much ladder engineers manually type.

Will Structured Text Become More Important?

Likely yes.

Structured languages are naturally compatible with software-generation tools.

AI models already handle text-based programming languages extremely well.

SCL and Structured Text are therefore particularly suitable for AI-assisted generation.

However, generated ST must still remain readable.

There is little value in producing 5,000 lines of technically correct logic that no commissioning engineer wants to maintain.

Good AI engineering should generate better maintainable code, not merely more code.

What I Would Do If I Were Starting as a PLC Engineer Today

I would still learn PLC programming properly.

I would learn ladder.

I would learn Structured Text.

I would learn industrial hardware.

I would learn electrical drawings.

I would spend as much time commissioning machines as possible.

But I would add another layer.

I would learn:

AI tools

Python or C#

engineering APIs

simulation

digital twins

industrial networking

cybersecurity

That combination could become extremely powerful.

What Experienced Engineers Should Do

Experienced controls engineers have a major advantage.

They already possess the most difficult knowledge:

industrial context.

You know what bad commissioning looks like.

You know what operators actually do.

You know how machines fail.

You know which alarm will wake somebody at 03:00.

You know what code becomes impossible to maintain.

Do not compete with AI at generating boilerplate.

Use it to remove the boilerplate.

Then spend more time applying the knowledge that took years to develop.

AI Will Not Remove Engineering Responsibility

This may be the most important point.

If an AI system generates unsafe PLC logic, somebody still owns the machine.

If the sequence damages equipment, somebody must explain why it was approved.

If the robot moves when it should not, saying:

“The AI generated it.”

will not be an acceptable engineering justification.

The future automation engineer therefore needs two apparently contradictory skills:

Use AI aggressively.

and

Trust AI cautiously.

That balance will define good engineering.

Final Answer: Will AI Replace PLC Programmers?

AI will replace some PLC programming tasks.

It may replace large amounts of repetitive engineering work.

It will generate increasing amounts of code.

It will create HMI elements.

It will configure hardware.

It will explain projects.

It will write documentation.

It will generate tests.

And eventually it may perform substantial sections of an automation project with relatively little manual interaction.

But that is not the same as replacing the automation engineer.

Industrial automation exists in the physical world.

Someone still needs to understand:

what the machine should do;
what happens when it fails;
how people interact with it;
whether it is safe;
whether the architecture is maintainable;
whether the generated software actually works.

The PLC programmer of 2030 may write less code manually.

But the best automation engineers may accomplish far more.

The winning strategy is therefore not to compete with AI.

Will AI Replace PLC Programmers? What Automation Engineers Need to Learn Before 2030