The Worm Is in the Workflow Tony Malott · Source dated 2026-07-08 https://shareplane.malott.ai/artifacts/the-worm-is-in-the-workflow/ Skip to article Software supply-chain risk has moved from bad packages to compromised workflows. The Worm Is in the Workflow Shai-Hulud, Miasma, Go-adjacent poisoning, and the end of casual dependency trust By Tony Malott Public-source security essay by Tony Malott, grounded in public advisories, public vendor research, official ecosystem documentation, and independent analysis. This material is personal educational work. It reflects public sources and independent analysis. It does not represent my employer, any client, or any vendor. It does not disclose confidential information, controlled documents, internal systems, regulated records, security details, implementation-specific designs, or company-approved policy. Public-safe Source-backed Go caveat preserved AI workflow risk Executive thesis The old question was whether a package was vulnerable. The better question is what can happen when a package, workflow, identity, runner, agent, and developer machine all trust each other at the same time. Workflow threat map The developer workflow is the propagation layer A trusted workflow graph, with the compromise path shown in deep red. Endpoint Developer endpoint Registry Package install SCM Source repository Credential reach Install-time execution Agent persistence Editor IDE tasks Assistant AI coding assistant CI CI runner Workflow execution Trusted publishing Blast radius Identity OIDC trust Registry Package registry Consumers Downstream consumers Old model Bad package New model Poisoned workflow Control lesson Scope trust, observe runtime, fail closed Provenance This article uses public advisories, public vendor research, official ecosystem documentation, and a clearly labeled academic preprint. It does not use employer-specific systems, internal incidents, private operational details, or insider-derived threat intelligence. Critical caveat Critical caveat: the Socket-reported Verana finding is Go-adjacent source-repository poisoning. Socket says normal Go module resolution or Go build logic did not appear to execute the payload. Do not turn this into the lazy claim that Go behaves like npm. Contents Shai-Hulud was not just another npm compromise The second wave moved from packages to pipelines Miasma shows the same pattern hardening into a repeatable playbook The Go angle is real, but it is not npm in a fake mustache AI coding assistants widen the timing gap The developer endpoint is now part of the release system Provenance is necessary, not sufficient What serious teams should change The uncomfortable conclusion The old software supply-chain story was simple enough for executives to misunderstand in one meeting: somebody published a bad package, somebody installed it, and now everybody gets to pretend they had a mature software supply-chain program because there was an SBOM somewhere in a folder nobody reads. That story is obsolete. The modern attack is not just a malicious dependency. It is a malicious workflow. Shai-Hulud, Mini Shai-Hulud, Miasma, recent malicious Go module research, and Go-adjacent source-repository poisoning all point to the same uncomfortable conclusion: the developer workflow itself has become the propagation layer. The blast radius is no longer limited to the application importing the dependency. It can include the developer workstation, local secrets, npm tokens, GitHub tokens, cloud credentials, CI/CD runners, repository automation, OIDC trusted-publishing flows, package registries, IDE task files, coding-agent configuration, and every downstream package or project the compromised identity can touch. This is why the threat is especially dangerous in the age of AI-assisted coding. AI coding tools did not invent dependency trust, credential sprawl, sloppy CI permissions, or developers blindly running package commands. Humans managed that disaster organically. But AI coding assistants make the dangerous parts faster. They make cloning, installing, scaffolding, executing, editing, committing, and publishing feel like a single fluid motion. That is exactly the kind of speed attackers want. A careless developer used to be a local risk. A careless AI-assisted developer can become a credential bridge. Shai-Hulud was not just another npm compromise CERT/CC described Shai-Hulud as a major npm supply-chain compromise involving more than 500 affected packages, with a self-propagating malware pattern that spread through credential theft and automated package publishing. GitHub separately reported removing more than 500 compromised packages and blocking uploads containing the malware indicators of compromise. That matters because this was not merely a poisoned package waiting for victims. It was software designed to turn victims into publishers of the next infection wave. The mechanism was ugly in the way successful attacks usually are: it abused normal developer trust. npm supports lifecycle scripts, including install-time events. Microsoft later described Shai-Hulud 2.0 as executing malicious code during npm preinstall, before tests or security checks, and exfiltrating stolen credentials to attacker-controlled public repositories. That ordering is the point. The malicious code runs before the organization can comfort itself with downstream controls. The developer runs a routine install. The package manager does exactly what it is designed to do. The dependency gets to execute because the workflow assumes package installation is a trusted act. That assumption is now a liability. The second wave moved from packages to pipelines Mini Shai-Hulud made the pattern clearer. Socket tracks Mini Shai-Hulud as an ongoing campaign beginning April 29, 2026, spanning npm and PyPI, with compromised package artifacts, developer and CI/CD secret targeting, and persistence through Claude and VS Code configuration paths. That last point deserves attention. If malware can persist through coding-agent hooks or IDE automation, then the developer environment is not just a workstation anymore. It is a programmable control surface. It can build, test, authenticate, commit, publish, and trigger other automation. Akamai’s May 2026 analysis sharpened the issue further. The wave used CI cache poisoning and npm OIDC publishing abuse, creating a condition where the publish path could appear legitimate enough to receive SLSA-style validation even though the workflow had been poisoned. JFrog made the same architectural point: provenance can tell you where an artifact was built, but not whether the build workflow was clean at runtime. That sentence should ruin a few dashboards. A green provenance badge is not a moral statement. It is a statement about a process. If the process was poisoned, the badge can faithfully describe a compromised reality. Miasma shows the same pattern hardening into a repeatable playbook Unit 42’s June 2026 reporting on Miasma shows why this is not a one-off shock event. Unit 42 reported that a June 1, 2026 supply-chain attack compromised at least 32 packages under the @redhat-cloud-services npm namespace. The attacker bypassed code review, triggered GitHub Actions workflows, requested OIDC tokens, and published trojanized packages with valid SLSA provenance. The important point is not that provenance failed mechanically. The certificate was accurate because the packages really were built by that pipeline. The pipeline just happened to build malware. Socket’s June 25, 2026 reporting shows the same pattern widening again. The latest Miasma Mini Shai-Hulud wave affected LeoPlatform and RStreams npm packages, three additional npm packages published by llxlr , GitHub Actions workflows, and a related Verana Blockchain Go module/source archive. The npm side used a binding.gyp path instead of obvious preinstall or postinstall scripts, which let install-time execution hide in build configuration. The payload staged obfuscated JavaScript through Bun, targeted developer and CI/CD secrets, searched GitHub Actions contexts, and planted persistence through IDE and AI coding assistant configuration. The Verana finding is the useful caveat, not a footnote. Socket says the campaign expanded beyond npm, but the execution path was not Go-native. The observed trigger was source-repository configuration: a VS Code folder-open task running node .claude/setup.mjs . Normal Go module resolution or Go build logic did not appear to execute the payload. That distinction makes the case stronger, not weaker. The threat is adapting to each workflow surface instead of relying on one package-manager trick. This is the workflow threat in miniature. A trusted identity can be abused. A trusted runner can be abused. A trusted publishing flow can be abused. A trusted package can be republished. A trusted attestation can faithfully describe a compromised build. A trusted source repository can become a delayed execution surface. The failure is not that trust exists. Software cannot function without trust. The failure is that we keep treating trust as a label instead of a living runtime condition. The Go angle is real, but it is not npm in a fake mustache The Go story needs precision because this is where lazy analysis will get stupid fast. There are two separate Go-related lanes here. One is Socket’s June 2026 Verana finding, which is Go-adjacent source-repository poisoning. The other is broader malicious Go module research showing how attackers abuse Go module identity, import behavior, and proxy persistence. They belong in the same article because both prove the workflow-trust thesis. They should not be collapsed into the same technical mechanism. Go modules do not have npm-style install lifecycle hooks. The official Go command documentation states that go generate can run commands described in source directives, but it is never run automatically by go build , go test , and similar commands. It must be run explicitly. That means it would be wrong to claim that a Go module compromise works the same way as npm preinstall malware. But that does not make Go immune. It makes the attack surface different. The Go module reference states that modules may be downloaded directly from version-control repositories or from module proxy servers. The Go specification also defines package initialization semantics: package-level variables initialize and init functions run as part of package and program initialization. That creates a different class of opportunity. Attackers do not need npm lifecycle hooks if they can abuse code that runs when a package is imported or initialized. A June 2026 academic preprint, Beyond Takedown: Measuring Malicious Go Module Persistence in the Wild , measured an automation-based Go ecosystem campaign where attackers repackaged legitimate Go modules under attacker-controlled owners and embedded obfuscated import-triggered downloader behavior. The authors reported 2,289 malicious versions of legitimate Go modules. They also found that takedown at the hosting layer does not equal remediation at the distribution layer: among artifacts that later became unobservable on GitHub, at least 99.4 percent remained retrievable via the Go proxy. This should be labeled as preprint evidence, not an official advisory. That is a different nightmare from npm. It is not install-script execution. It is distribution persistence plus import-triggered behavior plus developer trust in module identity and social signals. The correct article framing is not that an npm worm simply jumped to Go. The correct framing is worse: the supply-chain worm pattern is mutating across ecosystems according to each ecosystem’s native trust model. npm gives attackers install-time execution. CI/CD gives attackers privileged workflow execution. OIDC gives attackers short-lived publishing trust. IDE and coding-agent configuration give attackers developer-environment persistence. Go-adjacent source repositories give attackers folder-open and agent-hook execution surfaces. Go modules and proxies give attackers module identity confusion, import-time behavior, and distribution persistence. Same war. Different terrain. AI coding assistants widen the timing gap AI coding assistants are not the villain here. The villain is unmanaged execution wrapped in developer convenience and false confidence. Naturally, we put a cheerful chatbot on top of that because civilization enjoys adding a friendly interface to loaded weapons. The risk is timing. A disciplined engineer can use AI coding tools safely. That means isolated environments, pinned dependencies, reviewed changes, constrained agents, no blind install commands, no uncontrolled task execution, no uncontrolled repo writes, no secret-bearing sessions, and no casual trust in generated scaffolding. A low-discipline AI coder does the opposite. They ask for a project, accept a dependency graph, run the install, approve the tasks, let the assistant modify files, test locally, push changes, and move on. They may not understand package lifecycle scripts. They may not understand CI token scope. They may not understand that a repo task file or coding-agent hook is executable infrastructure. They may not even know where their credentials live. That is exactly why these campaigns matter. The attacker does not need to beat the best engineer in the organization. They need to find the fastest, most privileged, least skeptical workflow. AI-assisted coding creates more of those workflows unless governance catches up. The dangerous person is not the beginner. Beginners can learn. The dangerous person is the confident beginner with an agent, production-adjacent credentials, repo write access, and no instinct for provenance. The developer endpoint is now part of the release system Enterprises still tend to think of developer machines as endpoints and CI/CD systems as pipelines. That separation is increasingly fictional. A developer workstation can hold GitHub credentials, cloud credentials, package-manager tokens, SSH keys, local environment files, IDE plugins, repo-local tasks, agent memory, shell history, and access to private dependency sources. A CI runner can mint short-lived credentials, restore poisoned caches, execute untrusted build logic, publish packages, and write back into repositories. A coding assistant can generate the commands that connect those layers. From an attacker’s perspective, these are not separate systems. They are one workflow graph. Defenders need to model them that way. The practical control plane is not just dependency scanning. It is developer workflow governance: Which identities can publish? Which workflows can mint publishing credentials? Which repositories can trigger privileged workflows? Which caches can cross trust boundaries? Which package scripts can execute in CI? Which developer machines can hold release credentials? Which IDE or coding-agent configuration files are executable or persistence-capable? Which agents are allowed to install dependencies, run shell commands, alter task files, or commit changes? Which dependency updates are allowed without cooldown, review, or behavioral scanning? The old question was simple: is this package vulnerable? The better question is harder: what can happen if this package, this workflow, this identity, this runner, this agent, and this developer machine all trust each other at the same time? That is the real blast radius. Provenance is necessary, not sufficient The industry response cannot be to throw away provenance, attestations, trusted publishing, SBOMs, or package signing. That would be childish, which means somebody will probably propose it at a conference. We need those controls. GitHub’s post-Shai-Hulud roadmap points in the right direction: deprecating legacy classic tokens, shortening granular token lifetimes, pushing maintainers toward trusted publishing, requiring stronger publishing authentication, and encouraging WebAuthn over TOTP. Those are good moves. But Mini Shai-Hulud and Miasma show that trusted publishing changes the attack shape. It reduces static token exposure, but it increases the importance of runtime workflow integrity. If the trusted workflow is poisoned, trusted publishing can still produce a trusted-looking malicious artifact. So the next layer has to be behavioral and contextual: Treat release workflows as privileged production systems. Do not let untrusted pull request code influence privileged release caches. Separate test workflows from publish workflows. Monitor OIDC token requests and publishing events as sensitive identity actions. Keep package publishing isolated from general developer environments. Disable package lifecycle scripts in CI where feasible. Use dependency allowlists, quarantine windows, and repository-level policy gates. Scan for malicious package behavior, not only known CVEs. Review IDE and coding-agent config files as executable control surfaces. Audit source repositories for folder-open tasks, agent session hooks, hidden setup scripts, unexpected Bun usage, and configuration files that execute outside normal build paths. Rotate credentials after exposure, but design so fewer credentials are present in the first place. The lesson is not trust nothing. That is not an operating model. The lesson is trust with runtime boundaries. Trust should expire, narrow, and fail closed. What serious teams should change The serious posture is not complicated. It is just inconvenient, which is why it will be ignored until after the incident report. First, separate coding speed from release authority. AI tools can help write code, tests, docs, and scaffolding. They should not casually inherit the ability to install arbitrary packages, run arbitrary shell commands, modify CI configuration, change IDE task automation, or publish artifacts without policy and review. Second, treat package installation as code execution. In npm, that is literally true when lifecycle scripts run. In other ecosystems, the execution point may be build time, import time, test time, code generation, plugin loading, or runtime initialization. The control must follow the ecosystem, not a generic checklist. Third, make developer credentials boring. Short-lived, scoped, hardware-backed, auditable, and absent from routine environments whenever possible. Secrets sitting on developer machines are not secrets. They are delayed disclosures with better branding. Fourth, constrain CI/CD like production. CI runners should not be treated as disposable magic boxes. They are privileged automation systems. Cache boundaries, fork behavior, pull request permissions, OIDC token minting, and publish jobs need explicit threat modeling. Fifth, inspect the new persistence layer. .github/workflows , .vscode/tasks.json , coding-agent settings, shell profiles, package manager config, local hooks, and repo automation files are now part of the attack surface. Treat them as executable infrastructure. Sixth, slow down dependency adoption. Not forever. Just enough to avoid being the first fool through the door. Cooldown policies, internal mirrors, package reputation checks, maintainer-change alerts, diff review, and behavioral scanning create friction where friction is useful. Seventh, teach developers the workflow model. Not just do not run suspicious packages. That advice is useless. The real lesson is that dependency installation, package publishing, CI execution, IDE automation, and AI agent actions are connected. If a developer cannot explain what a tool is about to execute and what credentials it can reach, the workflow is too privileged. The uncomfortable conclusion Shai-Hulud matters because it is not merely a malware family. It is a preview of the developer workflow as an attack substrate. Miasma matters because it shows the pattern can keep reappearing through legitimate-looking publishing paths. The Verana finding matters because it shows that a Go-adjacent source repository can become an IDE and coding-agent execution trap without normal Go module resolution being the trigger. The Go research matters because it shows that ecosystems without npm-style install hooks still have native trust surfaces attackers can abuse. AI coding matters because it compresses the time between suggestion and execution. That compression is useful when the operator is disciplined. It is dangerous when the operator is merely confident. The industry spent years teaching developers to move fast. Attackers listened. Now the answer is not to move slow. It is to make trust explicit, scoped, observable, and revocable. The developer workflow is now part of the software supply chain. Treat it like one, or the worm will do the architecture review for you. Caveat ledger Go caveat preserved The article stays inside the allowed claims and refuses the blocked claims. This is the enforceable boundary that keeps the artifact public-safe. Allowed claims Shai-Hulud is a documented self-propagating npm supply-chain malware campaign. Later activity demonstrates workflow-level compromise across package managers, CI/CD, OIDC, IDE configuration, coding-agent hooks, source repositories, and developer endpoints. The Socket June 25, 2026 report supports a Go-adjacent source-repository poisoning claim tied to Verana. The Verana execution path must be described as source-repository / VS Code folder-open configuration, not normal Go module resolution or Go build logic. The arXiv Go paper supports a separate Go module abuse lane involving module identity, import-triggered behavior, and proxy persistence. Provenance and trusted publishing are necessary but insufficient when the trusted workflow is poisoned before publication. Blocked claims Do not say Go modules execute npm-style install hooks. Do not say normal Go module resolution or Go build triggers the Verana payload. Do not say Miasma has fully become a Go-native worm. Do not collapse Miasma, Mini Shai-Hulud, Shai-Hulud 2.0, and the Go malicious-module campaign into one identical incident. Do not over-attribute later activity where sources note public source release or copycat risk. Do not publish exploit code, runnable payload logic, full IOCs, or operational malware instructions. Do not turn this into generic anti-AI panic. The issue is discipline, trust, execution, identity, and workflow control. Control implications Treat developer workflow as supply chain Seven control levers that follow from the article thesis. 01 Separate coding speed from release authority 02 Treat package installation as code execution 03 Remove long-lived credentials from routine developer environments 04 Constrain CI/CD like production 05 Inspect IDE and coding-agent configuration 06 Slow dependency adoption with useful friction 07 Teach workflow trust, not slogans Visual prompt suite Reusable teaching prompts These prompts are not provenance prompts. They are teaching prompts. Each one is designed to visualize the thesis, architecture, caveat, or control model without exposing exploit detail or internal operational context. 01 Hero workflow threat map Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern, governance-grade technical hero infographic that explains the central thesis of the article: the modern supply-chain worm does not merely move through bad packages, it moves through the developer workflow. AUDIENCE Security engineering leaders, platform architects, AI engineering leads, developer productivity leaders, CI/CD owners, and serious technical readers. FORMAT * Aspect ratio: 16:9 * White or near-white background * Dense but readable technical architecture composition * Must stand alone as an explanatory image * High visual polish * Strong modern editorial design * Rich detail without clutter MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Primary title/header text: black with deep red emphasis * Section labels: black text with deep red accents * Main risk path: deep red * Support structures: light gray, medium gray, charcoal, black * Other colors: allowed only as secondary accents when they improve comprehension * Optional muted amber: use sparingly for caution points * Do not make teal, navy, purple, neon, or blue gradients dominant * Do not use colorful decorative gradients * Do not make it look playful, glossy, cartoonish, or SaaS-marketing flavored VISUAL STYLE * Clean white canvas * Premium security architecture aesthetic * Thin gray grid lines and dividers * Deep red control-path arrows * Black architecture boxes * Gray supporting metadata boxes * Red warning badges for compromised trust edges * Sparse line-art icon language only * High-trust technical editorial feel * No stock photo look * No 3D * No decorative clutter TITLE The Worm Is in the Workflow SUBTITLE Developer trust is now the blast radius TOP EXECUTIVE TAKEAWAY BANNER Place directly under the title in a white box with a thin black border and deep red left rule. Text: Modern supply-chain compromise moves through package managers, developer endpoints, CI/CD runners, OIDC publishing flows, IDE tasks, and AI coding assistant hooks. MAIN LAYOUT Use a central connected workflow graph. It should feel like a live architecture map, not a random network diagram. Required nodes: * Developer endpoint * Package install * Source repository * IDE tasks * AI coding assistant * CI runner * OIDC trust * Package registry * Downstream consumers Required connector labels: * Credential reach * Install-time execution * Workflow execution * Trusted publishing * Agent persistence * Blast radius Visual behavior: * Normal workflow edges should be thin gray or charcoal. * Compromised path should be deep red. * The red compromise path should resemble an abstract worm-like signal, but not a cartoon worm. * The red path should pass through multiple workflow surfaces, proving the thesis that the workflow is the propagation layer. MANDATORY CALLOUTS Add three compact callout cards: 1. Old model: bad package 2. New model: poisoned workflow 3. Control lesson: scope trust, observe runtime, fail closed TEXT TONE Technical, sharp, serious, high-trust, no hype. DO NOT DO * Do not use a literal cartoon worm. * Do not use hooded hackers. * Do not use fake exploit code. * Do not use vendor logos. * Do not make the image cyberpunk. * Do not use neon. * Do not use glossy 3D. * Do not overload the image with tiny unreadable text. * Do not imply one package is the whole blast radius. OUTPUT INTENT The viewer should understand in one pass that the developer workflow itself has become an attack surface and propagation path. Dark Expressive prompt Copy PRIMARY GOAL Create a visually stunning dark-mode hero infographic that explains the same thesis: the modern supply-chain worm moves through the developer workflow, not just through a single bad package. AUDIENCE Security engineering leaders, platform architects, AI engineering leads, developer productivity leaders, CI/CD owners, and serious technical readers. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, expressive, dramatic visual treatment * Must stand alone as an explanatory image * Highly modern, polished, and visually impressive * Clear enough for a technical reader to understand immediately TITLE The Worm Is in the Workflow SUBTITLE Developer trust is now the blast radius TOP EXECUTIVE TAKEAWAY Modern supply-chain compromise moves through package managers, developer endpoints, CI/CD runners, OIDC publishing flows, IDE tasks, and AI coding assistant hooks. MAIN LAYOUT Create a central connected workflow graph that feels like a premium threat-intelligence war room diagram. Use these nodes: * Developer endpoint * Package install * Source repository * IDE tasks * AI coding assistant * CI runner * OIDC trust * Package registry * Downstream consumers Use these connector labels: * Credential reach * Install-time execution * Workflow execution * Trusted publishing * Agent persistence * Blast radius Visual behavior: * Show a red adversarial signal moving through the workflow graph. * The signal should feel dangerous and active, but not cartoonish. * The visual should make the compromised path unmistakable. * The workflow should appear trusted until the red path reveals the hidden propagation route. MANDATORY CALLOUTS Add three compact callout cards: 1. Old model: bad package 2. New model: poisoned workflow 3. Control lesson: scope trust, observe runtime, fail closed TEXT TONE Serious, sharp, technical, cinematic, threat-intelligence oriented. OUTPUT INTENT The viewer should feel the urgency immediately and understand that developer workflow trust is now part of the blast radius. 02 Trust chain becomes propagation chain Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern, governance-grade technical infographic explaining how a trusted software delivery chain can become a propagation chain when the trusted workflow is poisoned before publication. AUDIENCE Security architects, DevSecOps leaders, CI/CD owners, package registry owners, software supply-chain reviewers, and engineering executives. FORMAT * Aspect ratio: 21:9 * White or near-white background * Wide technical explainer * Dense but readable * Strong architecture-diagram feel * Must work as an executive teaching visual MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Title text: black with deep red emphasis * Normal trust path: charcoal and gray * Compromise path: deep red * Attestation/caution point: muted amber only if needed * Support colors: light gray, medium gray, charcoal, black * Other colors: allowed only as secondary accents when functionally useful * Avoid teal, navy, purple, neon, colorful gradients, and SaaS-style blue gradients VISUAL STYLE * White technical canvas * Thin gray grid lines * Red control-path arrows * Black architecture boxes * Gray metadata cards * Red warning badge at the poisoned workflow point * Monospace labels only where useful * High-trust security architecture aesthetic * No 3D * No stock imagery * No cartoon icons TITLE When the Trust Chain Becomes the Propagation Chain HEADLINE CALLOUT Provenance proves the path, not that the path was clean. MAIN LAYOUT Create a left-to-right trust chain with the following required stages: 1. Maintainer identity 2. Package install 3. Source repository 4. CI/CD runner 5. OIDC trusted publishing 6. SLSA / provenance badge 7. Package registry 8. Downstream consumers Required visual logic: * Show the normal trust chain as a charcoal/gray flow. * Show a deep red compromise path entering before or inside the workflow. * Show that the final provenance badge can still appear valid while the workflow is already poisoned. * Make the provenance badge look accurate but insufficient. * The red path should continue into downstream consumers. MANDATORY LABELS * Trusted identity abused * Runner executes poisoned workflow * Short-lived token minted * Artifact published * Downstream trust inherited * Badge is accurate, workflow is poisoned BOTTOM VERDICT BANNER Use a black-bordered white banner with red emphasis. Text: Provenance is necessary. Runtime workflow integrity is the missing control. DO NOT DO * Do not imply provenance is useless. * Do not say trusted publishing should be abandoned. * Do not make the badge look fake. * Do not use fake exploit code. * Do not use vendor logos. * Do not make the graphic playful. * Do not use cyberpunk or neon. * Do not overcrowd the chain with unreadable detail. OUTPUT INTENT The viewer should understand that attestations and provenance can describe a compromised workflow accurately without proving the workflow was clean. Dark Expressive prompt Copy PRIMARY GOAL Create a visually dramatic dark-mode infographic explaining how a trusted software delivery chain can become a propagation chain when the trusted workflow is poisoned before publication. AUDIENCE Security architects, DevSecOps leaders, CI/CD owners, package registry owners, software supply-chain reviewers, and engineering executives. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, cinematic, modern, highly polished technical visual * Must stand alone as an explanatory graphic TITLE When the Trust Chain Becomes the Propagation Chain HEADLINE CALLOUT Provenance proves the path, not that the path was clean. MAIN LAYOUT Create a left-to-right trust chain with these required stages: 1. Maintainer identity 2. Package install 3. Source repository 4. CI/CD runner 5. OIDC trusted publishing 6. SLSA / provenance badge 7. Package registry 8. Downstream consumers Required visual logic: * The chain begins as legitimate software delivery. * A red compromise path enters before or inside the workflow. * The provenance badge still appears valid because it accurately describes the path. * The graphic should show the difference between “valid path” and “clean runtime.” * The red path should continue into downstream consumers. MANDATORY LABELS * Trusted identity abused * Runner executes poisoned workflow * Short-lived token minted * Artifact published * Downstream trust inherited * Badge is accurate, workflow is poisoned BOTTOM VERDICT Provenance is necessary. Runtime workflow integrity is the missing control. TEXT TONE Sharp, technical, high-impact, threat-intelligence oriented. OUTPUT INTENT The viewer should understand that the problem is not provenance failure. The problem is poisoned workflow runtime. 03 Ecosystem terrain map Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern technical terrain map showing how the same supply-chain threat pattern adapts across different ecosystems and workflow surfaces. AUDIENCE Security engineers, platform architects, software supply-chain leads, language ecosystem reviewers, AI engineering leaders, and senior developers. FORMAT * Aspect ratio: 16:9 * White or near-white background * Dense but readable * Clear comparative structure * Must stand alone as an explanatory infographic MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Section labels: black with deep red numbering or accents * Main adversarial thread: deep red * Surface lanes: black, charcoal, light gray, medium gray * Other colors: allowed only sparingly if they clarify the terrain model * Optional muted amber only for caution labels * Avoid teal, navy, purple, neon, blue-gradient, rainbow, and decorative gradients VISUAL STYLE * Clean white architecture canvas * Six vertical terrain lanes * Red adversarial thread crossing all lanes * Thin gray lane dividers * Black lane labels * Gray explanatory cards * Red risk markers * Sparse abstract line icons only * High-trust engineering explainer aesthetic * No logos * No mascots * No playful illustration TITLE Same War. Different Terrain. SUBTITLE The threat mutates according to each ecosystem’s native trust model. MAIN LAYOUT Create six vertical lanes: 1. npm Attack surface phrase: install-time execution 2. CI/CD Attack surface phrase: privileged workflow execution 3. OIDC Attack surface phrase: short-lived publishing trust 4. IDE / AI agents Attack surface phrase: developer-environment persistence 5. Go-adjacent source repositories Attack surface phrase: folder-open and agent-hook execution 6. Go modules / proxies Attack surface phrase: module identity and distribution persistence Required visual logic: * A single red adversarial thread crosses all six lanes. * The red thread should change shape slightly in each lane to show adaptation. * Each lane must be clearly distinct. * The image must not imply all mechanisms are identical. * The Go-adjacent lane and Go modules/proxies lane must be visually separate. MANDATORY CALLOUT Add a red-bordered callout: The pattern is shared. The mechanism is ecosystem-specific. DO NOT DO * Do not collapse Go-adjacent repository poisoning into Go module execution. * Do not imply Go behaves like npm. * Do not use real company logos. * Do not use cartoon icons. * Do not use cyberpunk or neon. * Do not overload the visual with paragraph text. OUTPUT INTENT The viewer should immediately understand that modern supply-chain worms adapt to the trust surfaces available in each ecosystem. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful terrain map showing how the same supply-chain threat pattern adapts across ecosystems and workflow surfaces. AUDIENCE Security engineers, platform architects, software supply-chain leads, language ecosystem reviewers, AI engineering leaders, and senior developers. FORMAT * Aspect ratio: 16:9 * Dark mode * Expressive, rich, dramatic, modern technical visual * Must stand alone as an explanatory infographic TITLE Same War. Different Terrain. SUBTITLE The threat mutates according to each ecosystem’s native trust model. MAIN LAYOUT Create six distinct terrain lanes: 1. npm install-time execution 2. CI/CD privileged workflow execution 3. OIDC short-lived publishing trust 4. IDE / AI agents developer-environment persistence 5. Go-adjacent source repositories folder-open and agent-hook execution 6. Go modules / proxies module identity and distribution persistence Required visual logic: * A single red adversarial signal crosses all six lanes. * The signal should adapt visually in each lane. * The Go-adjacent repository lane and Go modules/proxies lane must remain separate. * The graphic must clearly communicate that mechanisms differ even when the adversarial pattern is shared. MANDATORY CALLOUT The pattern is shared. The mechanism is ecosystem-specific. TEXT TONE Technical, serious, cinematic, highly explanatory. OUTPUT INTENT The viewer should feel the pattern spreading across terrain while still understanding the technical distinction between each ecosystem surface. 04 Developer endpoint as release system Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern architecture infographic showing that the developer endpoint is no longer just an endpoint. It is part of the release system because it holds credentials, automation hooks, repository access, and CI/CD pathways. AUDIENCE Endpoint security leaders, platform engineers, DevSecOps owners, identity architects, CI/CD teams, AI coding governance leads, and engineering executives. FORMAT * Aspect ratio: 16:9 * White or near-white background * Dense architecture diagram * Strong central concept * Readable at executive and technical levels * Must stand alone as an explanatory visual MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Main title: black with deep red emphasis * Normal trust zones: charcoal and gray * Credential bridges and risk paths: deep red * Support structures: light gray, medium gray, charcoal * Other colors: allowed only as secondary accents when useful * Optional muted amber only for caution markers * Avoid teal, navy, purple, neon, blue gradients, and decorative gradients VISUAL STYLE * Clean white technical canvas * Central abstract workstation node, not a person * Surrounding identity and automation nodes * Thin gray trust boundaries * Deep red credential bridges * Black and gray labels * Red warning markers * High-trust enterprise security architecture feel * No people * No stock photo laptop * No vendor logos * No cartoon icons TITLE The Developer Endpoint Is Part of the Release System SUBTITLE A workstation can become an identity and automation bridge. MAIN LAYOUT Place a central node: Developer workstation Surround it with connected nodes: * GitHub credentials * Cloud credentials * npm tokens * PyPI tokens * SSH keys * Local environment files * IDE tasks * AI assistant hooks * Shell history * Source repository * CI runner * OIDC token exchange * Package registry Required visual logic: * Show the workstation as a bridge, not an island. * Show normal trust zones in gray. * Show red paths where credentials and automation can cross into release authority. * Show how a compromised developer workflow can reach package publishing and downstream consumers. MANDATORY CALLOUTS Add three callout cards: 1. Endpoint risk becomes release risk 2. Agent hooks can become persistence 3. Credentials define blast radius BOTTOM VERDICT BANNER Text: Developer machines, CI runners, package registries, and coding agents must be modeled as one workflow graph. DO NOT DO * Do not show a human character. * Do not use a stock-photo laptop. * Do not use fake code screens. * Do not use logos. * Do not make the diagram look like a generic network topology. * Do not make the image playful or glossy. OUTPUT INTENT The viewer should understand that developer endpoint security, identity governance, CI/CD governance, and AI coding governance are now connected problems. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful architecture infographic showing that the developer endpoint is part of the release system because it holds credentials, automation hooks, repository access, and CI/CD pathways. AUDIENCE Endpoint security leaders, platform engineers, DevSecOps owners, identity architects, CI/CD teams, AI coding governance leads, and engineering executives. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, expressive, dramatic, modern architecture visual * Must stand alone as an explanatory graphic TITLE The Developer Endpoint Is Part of the Release System SUBTITLE A workstation can become an identity and automation bridge. MAIN LAYOUT Place a central node: Developer workstation Surround it with connected nodes: * GitHub credentials * Cloud credentials * npm tokens * PyPI tokens * SSH keys * Local environment files * IDE tasks * AI assistant hooks * Shell history * Source repository * CI runner * OIDC token exchange * Package registry Required visual logic: * Show the workstation as a bridge between local development and release authority. * Show credential and automation paths reaching CI/CD and publishing surfaces. * Show the blast radius expanding from endpoint to release system. * Make the relationships clear enough for architecture review. MANDATORY CALLOUTS 1. Endpoint risk becomes release risk 2. Agent hooks can become persistence 3. Credentials define blast radius BOTTOM VERDICT Developer machines, CI runners, package registries, and coding agents must be modeled as one workflow graph. TEXT TONE Technical, intense, architecture-grade, serious. OUTPUT INTENT The viewer should immediately understand that endpoint governance is now release governance. 05 Go caveat split-panel Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern, highly precise technical split-panel explainer that prevents the article’s most dangerous misreading: Go is not npm, and the Verana finding must be described as Go-adjacent source-repository poisoning, not normal Go module/build execution. AUDIENCE Security engineers, Go developers, software supply-chain analysts, platform architects, AI coding governance reviewers, and technical editors. FORMAT * Aspect ratio: 16:9 * White or near-white background * Split-panel technical explainer * Dense but readable * The distinction must be impossible to miss MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Main title: black with deep red emphasis * Correction markers: deep red * Normal explanatory panels: light gray and white * Support text: charcoal and medium gray * Other colors: allowed only if they clarify the distinction * Optional muted amber only for caution callouts * Avoid teal, navy, purple, neon, colorful gradients, and playful styling VISUAL STYLE * Clean white canvas * Two large panels with clear contrast * Red X / correction marker on the incorrect claim * Red check / evidence marker on the correct claim * Gray technical sub-panels * Simple abstract icons only * Very clear hierarchy * High-trust technical editorial style * No meme styling despite the humorous title * No cartoon mustache * No exploit detail TITLE Go Is Not npm in a Fake Mustache SUBTITLE The campaign reached Go-adjacent workflow surfaces. It did not turn Go into npm. MAIN LAYOUT Use two large side-by-side panels. LEFT PANEL TITLE Not the claim LEFT PANEL CONTENT Show the incorrect claim as a blocked interpretation: * Go modules execute npm-style install hooks * Normal Go module resolution triggers the Verana payload * Go build behaves like npm install Use a red X and a correction label: Blocked claim RIGHT PANEL TITLE The actual claim RIGHT PANEL CONTENT Show two separate evidence lanes: Lane 1: Go-adjacent source-repository poisoning * VS Code folder-open task * AI-agent / Claude setup hook * Source repository as execution surface Lane 2: Separate malicious Go module research * Module identity confusion * Import-time behavior * Go proxy persistence MANDATORY CALLOUT Add a red-bordered caveat card: The mechanisms are related by workflow trust, not by identical execution semantics. BOTTOM VERDICT BANNER Text: The article is stronger because it preserves the distinction. DO NOT DO * Do not imply Go behaves like npm. * Do not imply normal Go build triggered the Verana payload. * Do not merge the two evidence lanes into one mechanism. * Do not use comedy art. * Do not use a cartoon mustache. * Do not include exploit code. * Do not use logos. OUTPUT INTENT The viewer should understand the Go caveat instantly and leave with the correct distinction. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful split-panel explainer that makes the Go caveat impossible to miss: Go is not npm, and the Verana finding is Go-adjacent source-repository poisoning rather than normal Go module/build execution. AUDIENCE Security engineers, Go developers, software supply-chain analysts, platform architects, AI coding governance reviewers, and technical editors. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, expressive, dramatic, modern technical visual * The distinction must be unmistakable TITLE Go Is Not npm in a Fake Mustache SUBTITLE The campaign reached Go-adjacent workflow surfaces. It did not turn Go into npm. MAIN LAYOUT Use two large side-by-side panels. LEFT PANEL TITLE Not the claim LEFT PANEL CONTENT Blocked interpretation: * Go modules execute npm-style install hooks * Normal Go module resolution triggers the Verana payload * Go build behaves like npm install RIGHT PANEL TITLE The actual claim RIGHT PANEL CONTENT Two separate evidence lanes: Lane 1: Go-adjacent source-repository poisoning * VS Code folder-open task * AI-agent / Claude setup hook * Source repository as execution surface Lane 2: Separate malicious Go module research * Module identity confusion * Import-time behavior * Go proxy persistence MANDATORY CALLOUT The mechanisms are related by workflow trust, not by identical execution semantics. BOTTOM VERDICT The article is stronger because it preserves the distinction. TEXT TONE Sharp, corrective, technical, memorable. OUTPUT INTENT The viewer should immediately understand what the article does and does not claim about Go. 06 Control plane checklist Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern, governance-grade control checklist poster that explains what serious teams should do after understanding that developer workflow is part of the software supply chain. AUDIENCE Security leadership, engineering leadership, DevSecOps teams, AI coding governance owners, platform architects, and audit-minded technical reviewers. FORMAT * Aspect ratio: 4:5 * Portrait infographic * White or near-white background * Dense but readable * High executive utility * Must stand alone as a control model MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Title text: black with deep red emphasis * Control markers: deep red * Cards and dividers: light gray and medium gray * Support text: charcoal * Other colors: allowed only when they improve comprehension * Optional muted amber only for caution or governance gates * Avoid teal, navy, purple, neon, colorful gradients, and SaaS-style palettes VISUAL STYLE * Clean white poster * Large strong title * Seven stacked control cards * Deep red numbering or check markers * Thin gray dividers * Black labels * Short gray explanatory subtext * Sparse line icons only * Serious security leadership artifact * No marketing fluff * No cartoon icons * No 3D TITLE Treat Developer Workflow as Supply Chain SUBTITLE The control plane is trust, execution, identity, and release authority. MAIN LAYOUT Use seven stacked control cards. Card 1: Separate coding speed from release authority Subtext: AI can assist creation. It should not inherit publish authority without review. Card 2: Treat package installation as code execution Subtext: Install, build, import, test, and agent hooks are all possible execution moments. Card 3: Remove long-lived credentials from routine developer environments Subtext: Secrets on developer machines are delayed disclosures with better branding. Card 4: Constrain CI/CD like production Subtext: Runners, caches, tokens, and publish jobs are privileged systems. Card 5: Inspect IDE and coding-agent configuration Subtext: Tasks, hooks, setup scripts, and agent files are executable control surfaces. Card 6: Slow dependency adoption with useful friction Subtext: Cooldowns, mirrors, diff review, reputation checks, and behavioral scanning reduce first-fool exposure. Card 7: Teach workflow trust, not slogans Subtext: Developers must know what a tool can execute and what credentials it can reach. BOTTOM VERDICT BANNER Text: Trust should expire, narrow, and fail closed. DO NOT DO * Do not make it look like a SaaS checklist. * Do not use playful icons. * Do not use colorful gradients. * Do not use stock photos. * Do not overfill cards with tiny text. * Do not imply full autonomy is the goal. * Do not make controls sound optional. OUTPUT INTENT The viewer should be able to use this as a serious leadership artifact for developer workflow governance. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful control checklist poster explaining what serious teams should do after recognizing developer workflow as part of the software supply chain. AUDIENCE Security leadership, engineering leadership, DevSecOps teams, AI coding governance owners, platform architects, and audit-minded technical reviewers. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, expressive, dramatic, modern security leadership visual * Must stand alone as a control model TITLE Treat Developer Workflow as Supply Chain SUBTITLE The control plane is trust, execution, identity, and release authority. MAIN LAYOUT Create seven prominent control cards: 1. Separate coding speed from release authority AI can assist creation. It should not inherit publish authority without review. 2. Treat package installation as code execution Install, build, import, test, and agent hooks are all possible execution moments. 3. Remove long-lived credentials from routine developer environments Secrets on developer machines are delayed disclosures with better branding. 4. Constrain CI/CD like production Runners, caches, tokens, and publish jobs are privileged systems. 5. Inspect IDE and coding-agent configuration Tasks, hooks, setup scripts, and agent files are executable control surfaces. 6. Slow dependency adoption with useful friction Cooldowns, mirrors, diff review, reputation checks, and behavioral scanning reduce first-fool exposure. 7. Teach workflow trust, not slogans Developers must know what a tool can execute and what credentials it can reach. BOTTOM VERDICT Trust should expire, narrow, and fail closed. TEXT TONE Direct, serious, commanding, executive-readable. OUTPUT INTENT The viewer should see a complete control model, not a motivational poster. 07 Source-to-article evidence chain Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern, governance-grade explainer infographic showing how public threat research becomes a public-safe teaching artifact without using private or employer-specific material. AUDIENCE Engineering leadership, security researchers, governance reviewers, technical writers, AI-assisted publication reviewers, and public-safe artifact owners. FORMAT * Aspect ratio: 16:9 * White or near-white background * Technical process explainer * Dense but readable * Must stand alone as a public-safe provenance model MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Title text: black with deep red emphasis * Provenance boundaries: deep red * Evidence cards: light gray and white * Metadata panels: medium gray and charcoal * Other colors: allowed only sparingly if they help distinguish public evidence from blocked material * Optional muted amber only for caution callouts * Avoid teal, navy, purple, neon, colorful gradients, and marketing palettes VISUAL STYLE * Clean white canvas * Left-to-right evidence flow * Public evidence cards * Claim ledger and caveat ledger modules * Red public-safe boundary gate * Polished article artifact on the right * High-trust governance aesthetic * No confidential-document styling * No fake classified documents * No raw transcript mechanics * No company-specific hints TITLE Public Evidence to Public-Safe Article SUBTITLE The article is grounded in public research, not insider disclosure. MAIN LAYOUT Create a left-to-right flow: Left column: Public evidence * CERT/CC advisory * GitHub platform response * Microsoft research * Socket research * JFrog research * Akamai research * Unit 42 research * npm and Go official docs * arXiv preprint Middle column: Human-side judgment * Source authority ranking * Claim ledger * Caveat ledger * Blocked claims * Public-safe boundary Right column: Published teaching artifact * Article * Source ledger * Visual prompt suite * Footer receipt MANDATORY RED BOUNDARY GATE Label: No employer-specific detail crosses this line BOTTOM VERDICT BANNER Text: Public evidence can teach the pattern without exposing private operations. DO NOT DO * Do not show raw internal documents. * Do not imply employer endorsement. * Do not show private systems. * Do not include raw transcript workflow. * Do not make it look like a generic process chart. * Do not use playful icons. * Do not use cyberpunk styling. OUTPUT INTENT The viewer should understand how the article remains credible, sourced, and public-safe. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful evidence-chain infographic showing how public threat research becomes a public-safe teaching artifact without using private or employer-specific material. AUDIENCE Engineering leadership, security researchers, governance reviewers, technical writers, AI-assisted publication reviewers, and public-safe artifact owners. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, expressive, dramatic, modern governance visual * Must stand alone as a public-safe provenance model TITLE Public Evidence to Public-Safe Article SUBTITLE The article is grounded in public research, not insider disclosure. MAIN LAYOUT Create a left-to-right evidence flow: Left column: Public evidence * CERT/CC advisory * GitHub platform response * Microsoft research * Socket research * JFrog research * Akamai research * Unit 42 research * npm and Go official docs * arXiv preprint Middle column: Human-side judgment * Source authority ranking * Claim ledger * Caveat ledger * Blocked claims * Public-safe boundary Right column: Published teaching artifact * Article * Source ledger * Visual prompt suite * Footer receipt MANDATORY BOUNDARY GATE No employer-specific detail crosses this line BOTTOM VERDICT Public evidence can teach the pattern without exposing private operations. TEXT TONE Serious, precise, governance-grade, visually dramatic. OUTPUT INTENT The viewer should understand the credibility and safety model behind the article. 08 Social preview Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern square social preview image that makes the article instantly understandable and shareable without losing seriousness. AUDIENCE Security leaders, developers, architects, AI coding tool users, DevSecOps teams, and technical readers on social feeds. FORMAT * Aspect ratio: 1:1 * White or near-white background * Minimal but visually striking * Must remain readable at small sizes * Corporate-safe * Modern and memorable MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Primary accent: deep red * Support lines: light gray and medium gray * Other colors: only secondary and only if functionally useful * Avoid teal, navy, purple, neon, colorful gradients, and playful styling VISUAL STYLE * Strong typography * Compact workflow graph * One red compromise path * Clean geometry * High negative space * Crisp editorial design * No clutter * No logos * No fake code * No people * No cartoon worm TITLE The Worm Is in the Workflow SUBTITLE Developer trust is now the blast radius. MAIN LAYOUT Use a compact workflow graph under or beside the title. Required nodes: * Package * Workflow * Identity * Agent * Release Visual behavior: * Use gray/charcoal for normal nodes. * Use one deep red path moving through the graph. * The composition must be readable in a social feed. BOTTOM MICROCOPY Public-source security essay DO NOT DO * Do not use a literal worm. * Do not use hacker imagery. * Do not use fake code. * Do not use logos. * Do not overfill with text. * Do not make it look like clickbait. OUTPUT INTENT The image should make a serious reader want to open the article. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful square social preview image that makes the article instantly understandable and shareable while feeling premium and serious. AUDIENCE Security leaders, developers, architects, AI coding tool users, DevSecOps teams, and technical readers on social feeds. FORMAT * Aspect ratio: 16:9 * Dark mode * High-impact, visually expressive, modern, and memorable * Must remain readable when shared TITLE The Worm Is in the Workflow SUBTITLE Developer trust is now the blast radius. MAIN LAYOUT Use a compact workflow graph with these nodes: * Package * Workflow * Identity * Agent * Release Visual behavior: * A red compromise path moves through the graph. * The title must dominate. * The subtitle must be legible. * The image should feel urgent without becoming sensational. BOTTOM MICROCOPY Public-source security essay TEXT TONE Serious, sharp, premium, technical. OUTPUT INTENT The image should make a serious reader want to open the article immediately. 09 Reading-lane section divider Mainline White prompt Copy PRIMARY GOAL Create a refined, visually stunning but quiet section divider graphic for a long-form technical article. The graphic should support reading rhythm without overpowering the article. AUDIENCE Readers of a serious technical security article, including engineering leaders, security architects, and developers. FORMAT * Aspect ratio: 16:9 * White or near-white background * Subtle technical editorial divider * Must be beautiful but restrained * Must not behave like a hero graphic MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary labels: black or dark charcoal * Subtle diagram lines: light gray and medium gray * One signal line: deep red * Other colors: only if functionally necessary, and very sparing * Avoid teal, navy, purple, neon, colorful gradients, and decorative palettes VISUAL STYLE * Fine gray grid lines * Thin red signal path * Minimal workflow diagram * Sparse labels * Editorial elegance * Strong negative space * No dense text * No icons unless extremely subtle * No fake code * No illustration clutter TITLE Optional small label: Workflow trust surface MAIN LAYOUT Create a minimal horizontal signal diagram with five labels: * Package * Workflow * Identity * Agent * Release Visual behavior: * Use gray lines for normal structure. * Use a single deep red line moving across the structure. * Keep the divider quiet and sophisticated. DO NOT DO * Do not make it busy. * Do not add paragraph text. * Do not use large icons. * Do not use cyberpunk effects. * Do not make it look like a stock background. * Do not overpower the article. OUTPUT INTENT The image should serve as elegant visual punctuation between article sections. Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode section divider graphic for a long-form technical security article. It should be visually rich enough to feel premium, but quiet enough to preserve reading flow. AUDIENCE Readers of a serious technical security article, including engineering leaders, security architects, and developers. FORMAT * Aspect ratio: 16:9 * Dark mode * Expressive but restrained * Must support article pacing TITLE Optional small label: Workflow trust surface MAIN LAYOUT Create a minimal horizontal signal diagram with five labels: * Package * Workflow * Identity * Agent * Release Visual behavior: * A red signal line moves across the structure. * The image should feel like refined visual punctuation. * Keep the layout spacious and readable. TEXT TONE Quiet, premium, technical, elegant. OUTPUT INTENT The graphic should improve article rhythm without stealing attention. 10 Executive briefing graphic Mainline White prompt Copy PRIMARY GOAL Create a visually stunning, modern executive briefing graphic that summarizes the article’s central control question: what trusts what? AUDIENCE Senior engineering leaders, CISOs, platform owners, AI governance leaders, DevSecOps leaders, and enterprise architects. FORMAT * Aspect ratio: 16:9 * White or near-white background * Executive technical briefing visual * Dense but readable * Must stand alone in a leadership deck or article hero module MANDATORY COLOR SYSTEM Use the Mainline White visual system: * Background: pure white or near-white * Primary text: black or very dark charcoal * Control emphasis: deep red * Trust surfaces: charcoal and gray * Support panels: light gray and medium gray * Other colors: allowed only as secondary accents when useful * Optional muted amber only for caution * Avoid teal, navy, purple, neon, colorful gradients, and SaaS-marketing aesthetics VISUAL STYLE * Clean executive briefing design * Central question * Six connected trust surfaces * Red blast-radius overlay * Three control principles * Strong visual hierarchy * Sparse but meaningful detail * Modern, sharp, technical * No logos * No cartoon icons * No stock imagery TITLE The New Blast Radius CENTER QUESTION What trusts what? MAIN LAYOUT Place the central question in the middle: What trusts what? Around it, show six connected surfaces: * Package * Identity * Workflow * Runner * Agent * Endpoint Show a deep red blast-radius overlay when those surfaces trust each other without runtime boundaries. Add three control principle cards: 1. Scope trust 2. Observe runtime 3. Fail closed BOTTOM VERDICT BANNER Text: The developer workflow is now part of the software supply chain. DO NOT DO * Do not make this generic cyber art. * Do not use hacker silhouettes. * Do not use fake dashboards. * Do not use vendor logos. * Do not overcomplicate the graphic. * Do not use colorful gradients or decorative clutter. OUTPUT INTENT The viewer should leave with one executive question: what trusts what? Dark Expressive prompt Copy PRIMARY GOAL Create a dark-mode, visually powerful executive briefing graphic that summarizes the article’s central control question: what trusts what? AUDIENCE Senior engineering leaders, CISOs, platform owners, AI governance leaders, DevSecOps leaders, and enterprise architects. FORMAT * Aspect ratio: 16:9 * Dark mode * Rich, dramatic, premium technical briefing visual * Must stand alone in a leadership deck or article hero module TITLE The New Blast Radius CENTER QUESTION What trusts what? MAIN LAYOUT Place the central question in the middle: What trusts what? Around it, show six connected surfaces: * Package * Identity * Workflow * Runner * Agent * Endpoint Show a red blast-radius overlay when those surfaces trust each other without runtime boundaries. Add three control principle cards: 1. Scope trust 2. Observe runtime 3. Fail closed BOTTOM VERDICT The developer workflow is now part of the software supply chain. TEXT TONE Executive, sharp, technical, high-impact. OUTPUT INTENT The viewer should leave with one executive question: what trusts what? Artifact record The Worm Is in the Workflow Metadata JSON Receipt Graph Publication Author Tony Malott Published July 8, 2026 Format Teaching Artifact Worked Example Privacy public-safe-aggregated JavaScript artifact-local Provenance public-source-supported-owner-thesis No employer-specific systems, internal incidents, private operational details, or insider-derived threat intelligence are included. Public sources 15 CERT/CC VU#534320 public-evidence Original Shai-Hulud baseline, npm compromise, credential theft, self-propagation, automated publishing, and 500+ affected packages. Open source GitHub Blog, Our plan for a more secure npm supply chain public-evidence npm/GitHub platform response, 500+ removed packages, IoC blocking, token hardening, stronger authentication, and trusted publishing roadmap. Open source NCSC New Zealand advisory public-evidence Government corroboration of Shai-Hulud 2.0 credential harvesting, exfiltration, propagation, destructive payload, and mitigation guidance. Open source NHS England Digital CC-4722 public-evidence Health-sector corroboration of npm compromise, pre-install behavior, credential theft, propagation, and remediation. Open source Microsoft Security Blog, Shai-Hulud 2.0 public-evidence Preinstall execution, maintainer compromise, credential exfiltration to public repositories, Mini Shai-Hulud update, and defensive mechanics. Open source Socket, Mini Shai-Hulud campaign page public-evidence Ongoing Mini Shai-Hulud tracking, npm/PyPI scope, affected artifacts, secret targeting, and Claude/VS Code persistence paths. Open source Socket, Miasma Mini Shai-Hulud Hits LeoPlatform npm Packages and GitHub Actions, Expands to the Go Ecosystem public-evidence LeoPlatform/RStreams wave, binding.gyp, Bun-staged JavaScript, GitHub Actions targeting, AI coding assistant persistence, and Verana Go-adjacent source-repository poisoning. Open source JFrog Security Research, Shai-Hulud: Here We Go Again public-evidence Provenance limitation, CI/OIDC abuse, trusted publishing exploitation, npm preinstall, PyPI import-time behavior, and worm-like propagation. Open source Akamai, Mini Shai-Hulud: The Worm Returns and Goes Public public-evidence CI cache poisoning, npm OIDC endpoint abuse, SLSA validation issue, Claude Code hooks, VS Code task automation, worm source release, and copycat risk. Open source Palo Alto Networks Unit 42, The npm Threat Landscape public-evidence Miasma Red Hat namespace context, GitHub Actions OIDC token use, valid SLSA provenance, and attribution caveat. Open source npm Docs, Scripts public-evidence npm lifecycle script semantics, including preinstall, install, and postinstall. Open source Go Modules Reference public-evidence Go module distribution, VCS/proxy downloads, module paths, and dependency behavior. Open source Go command docs, go generate public-evidence go generate command behavior and the caveat that it is not run automatically by go build or go test. Open source Go Language Specification, package initialization public-evidence Package initialization semantics and init function behavior. Open source Bae and Yagemann, Beyond Takedown: Measuring Malicious Go Module Persistence in the Wild public-evidence Clearly labeled arXiv preprint evidence on malicious Go modules, 2,289 malicious versions, import-triggered downloader behavior, and Go proxy persistence. Open source Share or reuse Send the page or take its public context with you. What’s included The agent package contains the canonical public HTML, public metadata, receipt, plain-text context, package guide, and member-hash manifest. Agent context is a generated public-safe plain-text projection. It is not canonical Markdown and does not replace the artifact or its versioned authority. SOURCE REFERENCES CERT/CC VU#534320 https://www.kb.cert.org/vuls/id/534320 GitHub Blog, Our plan for a more secure npm supply chain https://github.blog/security/supply-chain-security/our-plan-for-a-more-secure-npm-supply-chain/ NCSC New Zealand advisory https://www.ncsc.govt.nz/alerts/supply-chain-compromise-impacting-npm-ecosystem/ NHS England Digital CC-4722 https://digital.nhs.uk/cyber-alerts/2025/cc-4722 Microsoft Security Blog, Shai-Hulud 2.0 https://www.microsoft.com/en-us/security/blog/2025/12/09/shai-hulud-2-0-guidance-for-detecting-investigating-and-defending-against-the-supply-chain-attack/ Socket, Mini Shai-Hulud campaign page https://socket.dev/supply-chain-attacks/mini-shai-hulud Socket, Miasma Mini Shai-Hulud Hits LeoPlatform npm Packages and GitHub Actions, Expands to the Go Ecosystem https://socket.dev/blog/miasma-mini-shai-hulud-hits-leoplatform-npm-packages-go-ecosystem JFrog Security Research, Shai-Hulud: Here We Go Again https://research.jfrog.com/post/shai-hulud-here-we-go-again/ Akamai, Mini Shai-Hulud: The Worm Returns and Goes Public https://www.akamai.com/blog/security-research/mini-shai-hulud-worm-returns-goes-public Palo Alto Networks Unit 42, The npm Threat Landscape https://unit42.paloaltonetworks.com/monitoring-npm-supply-chain-attacks/ npm Docs, Scripts https://docs.npmjs.com/cli/v11/using-npm/scripts/ Go Modules Reference https://go.dev/ref/mod Go command docs, go generate https://pkg.go.dev/cmd/go#hdr-Generate_Go_files_by_processing_source Go Language Specification, package initialization https://go.dev/ref/spec#Package_initialization Bae and Yagemann, Beyond Takedown: Measuring Malicious Go Module Persistence in the Wild https://arxiv.org/abs/2606.26291