It's 7:40 on a Tuesday. Your lead developer opens her laptop to finish a change to the connector between the ERP and the scheduling screens on the floor.
Her code editor loads. In the corner, a few extensions update themselves.
She doesn't notice. Nobody would.
That laptop holds a lot:
One of those updates isn't what it claims to be. Within a minute of the editor opening, it has copied every key and token on the laptop and sent them out.
She finishes the connector change, pushes her code, and heads to a production meeting.
That night, the repository token gets used. A commit lands in the integration repository under the name "build-bot." It adds a small workflow that quietly copies the secrets the build pipeline depends on: the ERP database login, the cloud deployment keys, the service account for the scheduling integration.
Nothing breaks. The line runs. The schedule posts on time.
Nine days later, someone notices a workflow run nobody remembers creating. By then, everything that laptop and that pipeline could reach has been in someone else's hands for more than a week.
Now ask a simple question. Who approved that update?
IT assumes the developers manage their own tools. The developers assume IT secures the laptops.
Both answers are reasonable. Together, they mean nobody owns it.
That chain isn't made up. In May 2026, it played out in public, at companies with far deeper security teams than most manufacturers will ever have.
On May 11, a contributor to Nx, a widely used set of developer tools, installed packages for an unrelated project. One package had been poisoned that same day. It ran during the install and took the GitHub token stored on the laptop.
The project had a setting meant to block brand-new packages. The tool version it pinned was too old to read that setting, so the safeguard was skipped without a warning.
A week later, the attacker used that token to publish a poisoned version of Nx Console, a popular extension for the VS Code editor. It went out under a trusted contributor's name and passed the marketplace's automated checks.
Editors with auto-update pulled it in without a single click. Once running, it went looking for SSH keys, cloud credentials, and tokens.
CISA later reported that this extension reached a GitHub employee's device. From there, attackers copied thousands of GitHub's own internal repositories.
What caught the poisoned release? Not a security tool. A routine "your extension was updated" email that one Nx maintainer happened to read.
The attacker never had to break GitHub's defenses. They came in through a developer's editor.
1. The Assumption: Dev Tools Are a Productivity Choice
Most IT leaders treat editors, extensions, and code packages as the developers' business.
2. Why That Belief Made Sense
For years, it worked well enough.
3. Why It No Longer Holds
The tool isn't the risk because it's bad. It's the risk because of where it runs.
4. What It Costs in a Plant
A developer at a manufacturer usually isn't building a website. She's building the glue between the business and the floor.
In a plant, a stolen developer key rarely looks like a security event at first. It looks like nothing at all.
The cost shows up after. A week of rotating credentials, rebuilding laptops, and reviewing every recent change to code that feeds production.
A schedule nobody fully trusts until someone proves it clean. And one hard question: which machines had it, and what could they open?
5. A Better Way: Every Update Is a Deployment
Your plant already knows how to handle this. Nobody pushes a PLC program change to a running line without knowing the version, who approved it, and how to roll it back.
The developer toolchain deserves the same discipline. Not a lockdown. Change control, sized for a small team.
Every update is a deployment. Treat it like one.
6. How We Approach It
At InsITe, we work alongside internal dev teams, not over them. We start by mapping what a developer laptop can actually reach, across IT and the plant floor.
Then we build guardrails with the developers who will live with them, so the controls stick. The goal is one clear owner for the toolchain, not another gap between IT and everyone else.
The May attacks didn't break through anyone's firewall. They rode in on tools that updated themselves and ran with a developer's full trust.
Your plant would never accept that on the line. There's no reason to accept it on the laptop that writes the code the line runs on.
Every update is a deployment.
Two questions to sit with: