The Movie Terminator 2:Judgment Day came out in 1991. It was 35 years ago.

T2 Plot: Skynet wakes up. It decides humans are a threat. It launches the nukes. That is the part everyone remembers. It is also the part that has not happened, and probably will not happen the way the movie shows it.

Sure time-travel is purely fictional, but the film has another reading angle. Cyberdyne/Skynet: Who is allowed to build the dangerous machine? Who controls the parts inside it? Can the military use it to attack people without a human saying yes first? Watch T2 again with these questions in mind. In 2026, real life matches this part of the movie surprisingly well. Not only because of killer robots , but because the argument in the film is now a getting close to a real life possibility.

Recently, Anthropic restricted broad access (based on state export rules) to its most capable model, citing safety concerns too serious for general release.

The Cyberdyne Problem

In the movie, one company, Cyberdyne Systems, sits at the center of dangerous military AI. The whole story depends on who controls what that company builds. Swap “Cyberdyne” for a real AI company, and you get something close to what is happening with some defence departments.

In early 2026, Anthropic signed a +200 million USD contract with the US Department of Defense. It became the first AI company allowed onto the Pentagon’s classified network. But the contract came with rules, it could not be used in fully autonomous weapons, meaning weapons that pick and attack targets with no human involved. These are the kind of limits you would expect from a company that took the T2 warning seriously.

The Pentagon was not happy with these limits. It wanted looser wording instead, something like “any lawful use.” Anthropic refused to change its rules. The talks broke down so badly that, according to Axios, the Pentagon considered calling Anthropic a “supply chain risk to national security.” That label had only ever been used for companies like Huawei. The Pentagon reportedly considered using a special law, the Defense Production Act, to force the issue if Anthropic did not drop its restrictions. Soon after, OpenAI signed its own deal with the Department of Defense. OpenAI said that deal also bans domestic mass surveillance and requires a human to be responsible for any use of force, including from autonomous weapons. The exact details of the deal were not made public. source

This is almost exactly the Cyberdyne story. A private company holds the keys to systems the military wants to use in weapons. The fight is over the exact same line the movie cares about: should a human stay in control, or should the machine decide when to use lethal force? The strange part is not that this feels like the movie. The strange part is that it is happening in real news articles, not a script.

The Chip story

In the movie, everything depends on one physical chip, recovered from the wreckage of the first film. The whole Cyberdyne company is built around it. Real life does not have one single chip. But the basic idea is the same: whoever controls the chips controls how fast the AI race moves. Today, that control comes from government export rules instead of one company’s lab. Whoever controls factory access and export licenses controls how fast anyone in the world can build AI. That is Cyberdyne’s chip, just spread out and run by government policy instead of one company.

The Public Reaction

In T2, people only say “we should not have built this” after Judgment Day, a nuclear disaster. In 2026, we got a small preview of that same reaction, but it did not take a disaster to trigger it. A contract dispute was enough.

Claude was reportedly used, through Palantir’s “Maven Smart System,” to help with targeting in a military strike on Iran. Soon after OpenAI’s Pentagon deal became public, people started deleting ChatGPT from their phones, uninstalls nearly tripled, while Anthropic became more popular. This was a small, real-time version of the public drawing a line on what they are comfortable with AI being used for.

What is left to happend

None of this means Skynet is coming. But just for the sake of going trough James Cameron’s vision…

There is no single company in control. Skynet exists because Cyberdyne is the only company left standing. In real life, power is split between OpenAI, Anthropic, Google, xAI, Meta, and Chinese AI labs, all racing around each other and around export rules.

Control of nuclear weapons has not changed. T2’s biggest fear is an AI in charge of nuclear weapons. Nothing like that exists today. US policy keeps humans in charge of any decision to launch nuclear weapons. And the real fights happening right now, Anthropic’s rules, OpenAI’s human-in-the-loop requirement, are the AI companies trying to keep that same kind of human control over regular weapons too. In some ways, the AI companies are the ones defending the lesson of T2, not ignoring it.

There is no self-improving AI. In the movie, Skynet “becomes self-aware” and starts improving itself extremely fast, within hours. In real life, better AI still comes from separate, expensive training runs that humans plan and run by hand. Progress is fast compared to history, but it is not automatic yet, and it will not happening overnight.

The part of T2 that still matters is not the robot uprising. It is the argument underneath it: a defense department pushing an AI company to loosen its safety rules, while the company tries to keep humans in control of lethal force. In 1991, that idea was just a setup for an action movie.

There is a battle going on right now, and this one is not being fought with code. For years, the big tech fights were about software: who had the best search engine, the best app, the best cloud service, the best algorithm.

Today everyone is fighting over chips: who can build them, buy them, and run the biggest AI models on them without going broke. NVIDIA and Apple are both in this, but from completely different angles, and looking at why explains a lot about where AI is actually going to be run.

Chips Are the New Gold

Every AI company hits the same wall: you need GPUs, and there are not enough of them. Training a big model can cost hundreds of millions of dollars in compute alone, and running one for millions of users is not a cheap task either. Who controls the chip supply controls how fast everyone else can move, especially when a single top-end server costs more than a house and takes months to actually get. That’s basically why NVIDIA became one of the most valuable companies almost overnight, and why Apple is quietly playing its own version of the same game.

NVIDIA: originally for gaming and visual computing

NVIDIA did not just build fast chips, it built a trap that’s hard to leave. Its software platform, CUDA, has been around since 2007, and nearly every AI tool out there, PyTorch, TensorFlow, is built to run on it. This represent almost twenty years of tooling and habits that competitors like AMD are still trying to catch up to. You could design a chip that beats NVIDIA on paper, but getting the whole industry to switch is a much bigger problem.

Chips like the GB10 and the newer Blackwell series have made NVIDIA the default choice for anyone training or running large models, which means it also gets to set the price. Its own CEO has said the quiet part out loud: they’re not just selling chips anymore, they are selling entire “AI factories”, chips, networking, and software bundled together so leaving becomes painful. And even NVIDIA does not fully control its own supply chain: almost every advanced AI chip in the world gets made by TSMC in Taiwan, a single dependency that is probably one of the biggest risks nobody talks about enough.

It is worth remembering who is actually running NVIDIA, because it explains a lot. Jensen Huang isn’t a finance guy who inherited a chip company, he is a chip guy from the start. He studied electrical engineering at Oregon State and Stanford, then spent years designing microprocessors at AMD and LSI Logic before co-founding NVIDIA in 1993. Thirty years later he’s still CEO, and the company still moves like an engineering shop that happens to be worth trillions, not the other way around.

Apple: distributed AI on device

Apple isn’t trying to beat NVIDIA at building data centers. Instead it leans on something surprisingly good for AI: unified memory. On a Mac with Apple Silicon, the processor, graphics, and AI parts all share one pool of memory, up to 512GB on the biggest Mac Studio. That matters because the real bottleneck in running AI models usually isn’t raw power, it’s having enough memory to hold the model. A consumer NVIDIA card tops out around 24GB; a Mac Studio can be configured with far more, and use all of it directly. Combined with Apple’s own MLX framework and the growing pile of models built for regular computers, a Mac has quietly become one of the best machines for running AI yourself, no cloud, no bill, nothing sent to someone else’s servers.

Apple is not chasing NVIDIA’s training-scale compute. It is following a different strategy: being the place where AI runs, on your own device, for the billions of people who will never touch a data center. It can make that bet because it controls everything, the chip, the OS, and increasingly the models themselves.

That focus on silicon and hardware is not an accident. Tim Cook stepped down in September 2026 after 15 years as CEO, and Apple handed the job to John Ternus, who ran Hardware Engineering. Ternus is a mechanical engineer who’s spent 25 years at Apple building the actual devices, not managing spreadsheets. Putting a hardware guy in charge right as the industry fights over chips and on-device AI is a pretty clear signal of where Apple thinks the next decade gets won.

Two Different Bets, Same Battle

NVIDIA is betting on going big: massive data centers, huge models, compute rented by the hour. Apple is betting on going local: smaller models running on hardware you already own, selling privacy and speed instead of raw power. Neither bet is wrong, they’re just built for different futures, and the likely outcome is both keep growing side by side, heavy training staying in NVIDIA’s data centers while everyday AI, coding assistants, summaries, increasingly runs locally on Apple Silicon or whatever competitors ship in response.

Software Is Dead?

While everyone fights over who runs these models, something strange is happening to the value of the code they produce. Tools like OpenAI’s Codex and Anthropic’s Claude Code can now write, fix, and ship working software from a plain instruction, often faster and with fewer mistakes than a human.

So is software dead? Not really, but what makes someone good at it has changed fast. Typing code was never really the hard part, it just felt that way. These tools are great at producing code that works, but still bad at knowing what to build, why it matters, and what to do when it breaks in the middle of the night, and that judgment has not gotten any cheaper. If anything, checking the work becomes the new bottleneck: when code is nearly free to write, the value shifts to reading it, testing it, and deciding whether to trust it.

The advantage shifts to a higher level. Getting started is also getting much easier, and that’s mostly a good thing: one person can now do what used to take a whole team. But this also means just knowing how to code is not a special career advantage anymore, the same way knowing how to use a spreadsheet stopped being one decades ago. The easy, repetitive parts of coding are getting automated. What is left are the truly hard parts: sofware architecutre, technological knowledge, and understanding what people actually need. Software is not going away only the “just writing the code” part is going away or delegated.

Conclusion

The fight between NVIDIA and Apple is really about two ideas of where AI should live, in giant data centers or on the devices already in our hands, and both will probably keep winning in their own lane for a long while. Meanwhile the tools running on all that hardware are quietly taking over the easy parts of writing software, pushing what makes someone valuable different. Whichever side you are leaning on, the chip in front of you matters more than it used to, and the code running on it is about to matter very differently.

The make or buy question is old. Do you build the tool yourself, or do you buy something that already exists? For most of my career, “buy” won almost every time. Building software in-house meant months of engineer time just to reach what an off-the-shelf product already did on day one. AI coding assistants just changed that math, and not by a small margin.

How it was before

Buying was never really about the price tag on the invoice. The real cost was the process around it: writing an RFP, shortlisting vendors, running a proof of concept, checking how it fits your existing landscape, security review, negotiating the contract. Weeks, sometimes months, before a single user touches the thing.

Building it yourself meant weeks or months too, just spent differently: specs, architecture, writing the code, testing it, fixing it. Either way, the timeline was long. So “buy” usually won, because someone else had already paid that cost and you were just renting the result.

What changed

With Claude Code, the “make” side of that equation collapsed. Describing what you need, getting a working first version, and iterating on it now takes days, sometimes hours, not months. Testing is faster too, since the AI writes a lot of the test coverage alongside the code.

The “buy” side did not get any faster. You still need the RFP, the calls, demos, building a PoC, the the negiciation, the integration work, the contract review. All of that overhead is now bigger than just building the thing yourself. The balance flipped: writing your own tool can be quicker than the process of evaluating someone else’s.

Customization

Off-the-shelf tools are built for the average customer, not for you. If you have a specific use case or need a specific feature, the “buy” route means opening a feature request, explaining your case to the supplier, and waiting. Best case it lands on their roadmap for a release months out. Worst case it never happens, because your use case is not common enough for them to bother with. Either way, once it finally ships, you still have to fit it into your system landscape, on their schedule, not yours.

Building it yourself skips all of that. You know exactly what you need, you build exactly that, and you control your own integration and your own timeline. No discussions to convince a supplier your feature request matters, no waiting months for a roadmap slot, no settling for a compromise because it did not fit someone else’s product plan.

Vendors are getting greedy

On top of that, software and SaaS pricing has gotten out of hand. Per-seat pricing keeps climbing, basic features get pulled behind a pricier tier, usage-based pricing punishes you for growing. A lot of vendors are optimizing for extracting more, not for being worth more. That pushes the decision toward “make” even further: why pay a growing bill for a fraction of what you actually need, when building the exact fraction you need is now fast and cheap?

How the “make” approach could work

AI-assisted development is not a free pass. It changes the cost of building, not the need for judgement. A few things are non-negotiable if you want “make” to actually succeed:

People who understand the tech stack, not just the prompt. Someone on the team has to actually read the generated code, understand what it does, and catch it when it’s wrong. AI writes confident code even when the code is bad. Without someone able to tell the difference, you are not building software, you are gambling with it.

Stick to a stack you know personally. Let the AI move fast on technology your team already understands well, not on something brand new to everyone involved. Familiar tech means you can spot when the AI goes off track, debug it when it breaks, and know its limits. Using AI to learn an unfamiliar stack from scratch, on something that matters, is a different and much riskier bet.

Accept the risk, and plan for when it goes wrong. Faster and self-developped does not mean risk free. Keep a fallback: a rollback plan, a time-boxed checkpoint to decide if it’s working. A “we buy the tool instead” option still on the table if the in-house build stalls. Taking the risk is fine, but refusing to build a plan B: manual fallback, do it like before or buying a tool is not ok.

Conclusion

The make or buy calculus has quietly flipped for a lot of software decisions. Building your own is often faster than shopping for and rolling out someone else’s product, and vendor pricing is only making that gap wider. But that only holds if you have people who genuinely understand what’s being built, a tech stack the team already trusts, and a real plan for the moments it does not go as expected. AI made “make” cheap. It did not make it safe by default, that part is still on you.