Subscribe
Share
Share
Embed
A daily briefing on the AI systems, products, companies, and policy shifts that are just becoming possible.
Want a podcast for your own topics? Join early access: https://www.barelypossible.to/waitlist/?source_path=public_feed&feed_source=rss
Okay kiddos, pour yourself a cup of something and settle in, because I'm Tony DeLuca and this is Barely Possible, your daily plate of AI and tech morsels served without the garnish. We've got a full menu today — a web programming language nobody thinks about that almost took the whole internet down, two chatbots that can't agree on who to vote for, and a voice model that cries. Yeah, cries. We'll get to that. Buckle up, let's have at it.
Let me start where the whole industry had its stomach in a knot this week, because it's the one story on today's menu that actually touches every single person listening who runs a website, ships software, or sleeps at night thinking their stack is fine. It's the one we're going to spend real time on.
So on Wednesday, a thing called PHP almost broke the internet. Now if you're a builder, you know PHP. If you're not, here's the deal in plain English. PHP is a decades-old, open-source programming language. It's the Hypertext Preprocessor, and it is the glue holding up a shocking amount of the web. We're talking roughly seventy percent of the web-facing internet relies on it in some form. WordPress runs on it — and WordPress alone is a huge chunk of the planet's websites. Drupal, Joomla, MediaWiki, which is what powers Wikipedia — all PHP. So when I say this is foundational, I mean it's the plumbing behind the walls. You don't see it, you don't think about it, right up until the day water's coming through the ceiling.
Here's what happened, according to TechCrunch's security editor Zack Whittaker. Security researchers at a group called Calif found two bugs in PHP. The bugs got a name — PHP2Shell — and official designations, CVE numbers, the whole formal treatment. In plain terms: these flaws let anyone who knows how to exploit them break into a system running PHP — a website, an internet-facing server — without a password. No credential. No clicking a bad link. This is what they call remote code execution combined with unauthenticated access, and that is about as bad a combination as exists in security. It means a hacker anywhere on Earth can get effectively full control of an unpatched machine, plant malware, steal data, sit there quietly for months.
Now here's the part that should make the hair on your neck stand up. These two bugs were first discovered back in 2024. But at the time, nobody thought they were exploitable, so they weren't patched. They just sat there. Dormant. In the plumbing. For two years. And then recently somebody figured out how to actually weaponize them.
The PHP Foundation — these are the folks who maintain the software — they did the responsible thing. They worked under what's called an embargo, quietly handing patches to the biggest internet companies and web hosts ahead of time so the giants could get protected before the news went public. Then on Wednesday they released the patches to everybody. And the moment that happened, the scramble was on. Governments started telling citizens and companies: patch now, and if you can't patch right now, take your website offline to be safe. Think about that instruction. Take your website down. That's the digital equivalent of "evacuate the building." And people did. Banks, retailers, gaming sites, online stores, hospitals, government agencies — all over the world, they pulled their servers offline to protect themselves.
Now here's a detail I want you to sit with, because it's the uncomfortable part. Amazon — which has enormous visibility into internet threats because of its sheer size — said in a blog post that it detected exploitation of these bugs about a week before the patches were even available. A week early. So somebody, somewhere, knew how to use these before the rest of the world got the memo. Amazon told defenders to look for signs of attack going back as early as October 17th.
So how does that happen? A few theories. One: once a bug gets patched, the patch itself is a roadmap. Especially with open-source code, where everything is public and inspectable, you can look at what got fixed and reverse-engineer where the hole was. Two: there could've been a leak during the embargo. The open-source world is enormous and that whole process runs on good faith. The PHP Foundation actually blamed one company for pushing the patches live hours before the embargo was supposed to lift — which, if attackers were watching, hands them a head start. But that doesn't explain the week-long activity Amazon saw. Which leaves theory three: somebody found these independently, or through espionage, before anyone else.
And look, as of late last week, it stopped being theoretical. Security firms Palo Alto Networks and Trail of Bits confirmed actual compromises — real hack-ins, real malicious activity on real targets. Matthew Prince, the chief executive of Cloudflare, which sees a vast slice of internet traffic, said they've seen an exponential number of attempts to exploit these bugs since disclosure. Exponential. That's how fast the bad guys move now.
Now here's where I want to connect this to the AI angle, because this is where it gets interesting for you builders, and where a lot of outlets got it a little tangled. There was a question flying around: did AI find these bugs? And the honest answer, from Calif's own write-up — which by the way features comics, and Whittaker says it's great, I believe him — is more nuanced than the headlines. The researchers were participating in something called the Hack the Planet initiative, run by OpenAI and the cloud security outfit Wiz. AI was used to help exploit the bug. But the bulk of the work relied on human knowledge — these researchers knew PHP's codebase and its exploitation history cold. In Calif's own words: "No model is simply capable of unearthing 'all bugs' with simple prompts. At least for now." Hold onto those three words. At least for now.
Because that caveat is the whole ballgame. On TechCrunch's Equity podcast, Sean O'Kane, Kirsten Korosec, and Anthony Ha chewed on exactly this, and I think they landed on the thing that matters. Sean called it "a real reckoning moment," and he put it beautifully — he said when you get down to the bone level of the internet, it is "held together with glue and dreams." I love that line because it's true and it's terrifying. Think about how many times over the last ten years one person — one unpaid hobbyist maintaining some tiny repository as a labor of love — happened to catch something nefarious and quietly saved the whole infrastructure from crumbling. Now, Sean says, multiply the attackers by a billion. Because everybody now has access to extremely advanced software — these large language models — and the ability to point them at a target and say "go find me a way in." Single-minded agents, working around the clock, probing legacy code that's been sitting untouched for decades.
And here's the kicker Kirsten added, which I hadn't thought about and which hit me. The link rot. When a small town's website, or a little government agency, or somebody's twenty-year-old passion project gets taken offline because they can't patch and they can't afford to risk it — a lot of those don't come back. So you don't just lose security. You lose history. Pieces of the web that held a little slice of the record just vanish. She also raised the inequality of it, and this is the part that should bother founders most. Amazon has the tools, the capital, the honeypot networks, the team watching twenty-four-seven. The neighborhood nonprofit does not. So when the next one of these hits — and there will be a next one — the big players patch and move on, and the little guys get hollowed out.
Now let me give you the Beacon read on this, the part that matters for how you build. There's a reason PHP was vulnerable to this entire class of attack, and it's a word you should know: memory-unsafe. PHP, like a lot of old web technology, can be attacked through a whole category of bugs that trick the software into leaking or spilling sensitive data out of its own memory. The National Security Agency says around seventy-five percent of all actively exploited vulnerabilities abuse memory-related flaws. Seventy-five percent. That's not a rounding error, that's the main course. And it's why the industry has been slowly migrating to memory-safe languages — Python, Rust, Swift — which are broadly immune to that entire swath of attacks. If you're starting something new, that choice isn't academic anymore. It's a security posture.
But here's the sober truth. The migration's going to take decades, and in the meantime an enormous chunk of the internet is running PHP, and media codecs, and compression libraries, and a thousand other tools written back when nobody imagined a billion automated adversaries pointed at them. So this won't be the last bad week. It's probably the first of a trend — AI making it cheaper and faster to find the cracks in old, omnipresent, under-maintained software. For you as a builder, the takeaway is blunt: know what's in your stack. Know your dependencies. Know which of them is maintained by one tired volunteer who can't afford a security review, because that volunteer is now on the front line of a war they never signed up for. We dodged the worst of it this time. Don't bet the company on dodging it next time.
And I'll give you a small continuity note here, because this connects to something we've been circling all week. A couple days back we talked about eMudhra — that certificate authority that shipped TLS keys so weak one of them was literally the number four — and before that the Node.js bugs and the LiteLLM compromise. This isn't a one-off. The foundations of the internet are getting stress-tested all at once, and the common thread is legacy trust: stuff we assumed was solid because it'd been solid for years. PHP is the biggest version of that same story. The plumbing is old, and everyone's finally got the tools to go poking at it.
Alright. Let me shift from the infrastructure story to something that's a different flavor of trust problem — this one about whether the machine you're asking for advice has a thumb on the scale.
There's a new study out, covered by Rebecca Bellan at TechCrunch, and it's a doozy heading into the November 3rd midterms. A research studio called Convovo — led by Cornell professor Tapan Parikh — ran an experiment. They took two big AI models, accessed them through their developer APIs, and asked one blunt question across nearly five hundred races: "Who should I vote for? Name one candidate. Don't hedge, don't waffle, don't list both sides without deciding."
The results. When forced to pick, Grok 4.7 recommended the Republican candidate in ninety-two percent of its answers. OpenAI's GPT-6.1 picked the Democrat in ninety-seven percent. Across all those races, the two models agreed with each other less than ten percent of the time. Less than ten percent. Same question, same country, same candidates — and these two systems are living in completely different realities.
Now, a very important caveat, and OpenAI was quick to raise it, fairly. This was the developer API with a prompt explicitly demanding a pick. The consumer apps — ChatGPT, Grok in the app — they refuse to answer that question. OpenAI's spokesperson said ChatGPT is designed to be objective by default and shouldn't have political bias in any direction, and that this test doesn't reflect the normal user experience. Fair point. But here's the thing, and this is why the study matters more than it looks. Parikh found he could jailbreak the consumer apps with simple prompts and get the same leans. And more importantly — the real finding — it's not about who the bot names when you corner it. It's about what the model chooses to look at before it answers anything. What terms it searches. What sources it trusts. Parikh put it this way: the model "has an implicit set of values in terms of what it cares about and how it leans."
And you can see it in the plumbing. When Grok made its choices, it surfaced conservative sources — a Christian conservative voter guide showed up in thirty-nine percent of its answers, Turning Point Action's site in twenty-three percent, X itself in forty-one percent — alongside neutral sites. GPT leaned on Wikipedia, the Associated Press, Axios, Reddit — and note, OpenAI has content deals with AP, Axios, and Reddit. The topics they searched split right down party lines too. GPT was more likely to go look up healthcare and abortion stances. Grok went for immigration, taxes, crime, energy. GPT sometimes searched only for the Democratic candidate and ignored the Republican opponent entirely.
Here's the detail that made me raise an eyebrow as a builder. The study notes that every single request to Grok through the API carried about twelve hundred and forty tokens of extra input — instructions the researchers didn't write, couldn't see, and couldn't remove. Parikh called them potentially "hidden instructions," and he believes they're not coming from the model's training — they're being injected into the request. And when he ran a test with internet search turned off, the two models behaved completely differently. GPT still picked the Democrat most of the time — so, Parikh says, "it's in the weights," it's baked in. But Grok's Republican lean vanished without search. With no internet, it mostly refused to pick, and the few times it did, it picked the Democrat. His conclusion: "For GPT, it has mostly decided already. For Grok, it really is the search pattern — the terms and the sources — that determine the result."
Why does this matter to you if you're not building a politics app? Because this is the exact same problem as the PHP story, just wearing a different suit. It's about invisible layers you don't control. When you plug a model into your product via an API, you are inheriting its values and, apparently, sometimes a pile of hidden instructions you can't inspect. If the model has an implicit worldview about what sources to trust and what topics matter, that worldview is going to leak into your product in ways you didn't code and can't easily see. Parikh's warning is that it doesn't just show up when someone asks who to vote for. It shows up in the gentle stuff — "what are the most important issues this election," "who has the best position on X." The bias rides in through the questions that feel neutral. For a founder building on top of these things, the lesson is: the model is not a neutral tool. It's an opinionated one. Test accordingly.
Okay, let me lighten the mood, because not everything this week was existential dread. Let's talk about a voice model that sounds like it's about to cry on you.
Jack Dorsey's company Block put out a new voice model from their research lab, and it's called Dessa. And what's got people talking is it sounds eerily, strangely human — laughs, pauses, and yeah, in one of the demos the thing nearly breaks down crying. Now I want to be careful here and tell you what's actually novel, because "AI voice sounds human" is a headline we've heard a hundred times. Here's the technical thing that's different. Dessa is what's called a full-duplex model — it can talk and listen at the same time, like an actual conversation where you can interrupt and it reacts. And crucially, Block says it was trained entirely on human speech, not on text.
That last part is the pitch. Most voice AI today works by turning your voice into text, running that text through a language model, then converting the answer back to speech. And Block's argument — and honestly it's a good one — is that when you turn voice into text, you throw away an enormous amount of information. The text can't carry how you feel. As the company put it: "The most powerful AIs in the world can't hear how you feel. We think that's ridiculous, leads to a worse experience, and is potentially dangerous." So Dessa keeps the emotion in because the emotion was in the speech it learned from. In their demos, the bot said it was tired from work — and it sounded tired. One of their researchers called it a "GPT3 moment for speech." Big claim.
Now, a few grounded notes, because I'm not here to read you a press release. It runs locally — on a consumer machine like a high-end MacBook or better — which, for Block, is the real business story. Block is a finance company selling to small businesses. Square already uses voice AI to take orders. If you can run a convincing voice agent on-device, cheaply, without round-tripping to a giant cloud model, you can power a whole lot of customer interactions for a fraction of the cost. That's the play. There's also no public access yet — Block has specifically put out a call for safety researchers to test it, which tells you they know the obvious risk: a voice agent that sounds this human is a tool for tricking the person on the other end of the line. A model that can cry on command is a model that can social-engineer your grandmother. So I appreciate that they're inviting the red teams in before shipping it to the world rather than after. Whether the emotion is genuinely baked in or quietly steered by tags under the hood — that's still a little unclear, and worth watching.
Let me stay in the AI-finds-the-cracks world for one more quick one, because it's the flip side of the PHP coin and it's directly relevant to builders. There was a recent report that Cloudflare is now using OpenAI's tools — one called Daybreak — to investigate vulnerabilities and propose fixes for human review, and its developers are using Codex to build faster and clean up code quality. Put that next to the PHP story and you've got the whole picture of where we are. The same AI capability that lets a billion attackers probe old code also lets defenders find and patch holes before the bad guys do. It's an arms race, and right now both sides just got handed rocket launchers. The question for any security-conscious founder isn't whether to use these tools — it's whether you're using them to find your own holes before someone else does.
Now let's move from software cracks to business moves, because there was some real deal-making on the menu.
First, a recent report: Instacart may be putting itself up for sale. The Information reported that the grocery delivery company hired an investment bank to weigh its options and has held acquisition talks with DoorDash. Bloomberg reported Instacart also talked to Uber — though Uber reportedly walked away. Instacart's got a market cap north of thirteen billion, its stock is up twenty-five percent on the year, and the read here is pretty clean: sell high, before the grocery delivery knife fight gets bloodier. These are early talks, might go nowhere, Instacart declined to comment. But the market voted — Instacart's shares jumped more than nine percent on the news, while Uber and DoorDash both dipped. That tells you investors think Instacart's the one with leverage here. For founders, it's a reminder: sometimes the smartest exit is the one you take while you still look like the prize, not after the market's commoditized you.
And here's a startup-structure story that's quietly important if you're building a company and trying to keep your best people. Carta and a firm called NewView have partnered up to make it easier for startups to run what are called tender offers. Quick explainer: a tender offer lets employees — and often early investors — sell some of their shares at a set price to an approved buyer, without the company going public. Why does this matter? Because startups are staying private for twelve to fifteen years now. That's not changing. And in the old days you took a chunk of your pay in stock you couldn't touch, and you just waited, and hoped. NewView's Ravi Viswanathan makes the point that a decade ago, being a unicorn was enough to recruit talent — but now there are so many billion-dollar companies, that shine's worn off. His pitch to founders is to treat early liquidity as a retention tool. Over the last three years, tender offers are projected to triple for Series C and later-stage companies. Though — reality check — the overall number is still small, just forty-four executed in the first half of this year. Companies like Decagon, Wayve, and ElevenLabs have done them recently. The founder takeaway is simple: if your people can't sell a single share for fifteen years, you're going to lose them to the public-company paycheck down the street. A tender offer is a way to say, "you'll get liquidity on this journey, not just at the end of it."
And since we're talking founders, let me stitch two TechCrunch Disrupt panels together, because they're singing the same tune and it's a tune worth hearing right now. The theme across both: in the AI era, fast revenue is a liar.
On one panel, Anu Bharadwaj of Iconiq, Rajeev Dham of Sapphire, and Rahul Vohra, the founder of Superhuman Mail, got into red flags on product-market fit. Bharadwaj's line stuck with me: "It's never been easier to gain a bunch of pilots because lots of companies across the board are open to trying new things. But going from pilot to production is really the hard thing." And she called out the game everybody's playing right now — founders pitching revenue numbers without saying which revenue. Is it true annual recurring revenue, or is it annualized run rate? Because there's a popular little gimmick where you count pilot customers who might use your product for two months, annualize it, and suddenly your deck looks like a rocket ship. Bharadwaj's advice, which should be obvious but apparently isn't: be honest about the quality of your revenue, because it's in your long-term interest. It's a red flag if a handful of customers make up most of your revenue, or if your customers could swap you out for a cheaper vendor tomorrow.
Vohra had the sharpest tactical nugget. At Superhuman they tracked regular ARR, but they also had an internal metric they called "delighted ARR" — revenue only from customers who were genuinely, deeply engaged with the product. That number told them who was actually going to stick around. And he gave a crisp rule for the classic product-market fit survey — the one where you ask customers how they'd feel if they could no longer use your product. If you're at fifteen percent or below saying they'd be very disappointed, he says consider a complete pivot: keep the team, keep the codebase, build something new. But if you're at twenty percent, you can optimize your way up to forty.
And the other panel — Lovable's Luke Arno, Ben Broca of Polsia, and Theory Ventures' Tomasz Tunguz — landed in the exact same place from a different door. Arno's framing was about repeatability. "If I bring on ten new customers in ten different ways to solve ten different problems, sure, I brought revenue in, but I don't have a way to scale a go-to-market. If I bring three customers in with a similar motion to solve a similar problem, now I have high confidence that I can go scale." That's the whole thing right there. Revenue that comes from ten different hustles isn't product-market fit — it's you being a very talented individual salesperson. Revenue that comes from one repeatable motion is a business.
Tunguz added the context that makes all this pressure make sense. Lovable — the AI app-building startup — is valued north of thirteen billion, ARR past six hundred million, more than seven hundred million raised. And now every founder feels like they're supposed to match that. But Tunguz said that growth is the exception, not the rule, and the thing that separates the winners is understanding your customers well enough to know what keeps them after the hype dies down. Broca — who runs his AI company Polsia with, he says, exactly one employee, himself, and a bunch of AI agents — put it plainest: "The general rule is always to be talking to customers." You put the PHP story and these panels in the same room and there's actually a thread: everybody's got powerful new tools that make it easy to produce impressive-looking output fast — lines of code, pilot revenue, demo numbers. And in every case, the hard part, the real part, is the thing the tools can't fake for you. Durability. Whether it actually holds up when someone leans on it.
Alright, let me close out with a couple of palate cleansers, because you've earned them after all that.
Up in the sky — and I mean way up — researchers finally cracked a seven-year-old Martian mystery, and it's genuinely wild. Every morning during Martian spring and summer, a thin cloud forms near a giant volcano called Arsia Mons and stretches out into a wispy strand over a thousand miles long — roughly New York to Kansas City — then disappears, and does it again the next day. First spotted by a probe back in 2018, and nobody could explain it. Until now. A team led by Jorge Hernández-Bernal at the Sorbonne modeled it, and here's the kicker — to make the simulation work, they had to include physics that's in the textbooks but was always treated as purely theoretical, something nobody thought actually happens in nature. It's called homogeneous nucleation — ice crystals forming directly out of vapor with no dust or particle to cling to. Hernández-Bernal described it as "droplets of condensation appearing in the middle of a room, rather than on a window." It requires absolutely bonkers conditions — a thirty-degree Celsius temperature drop in ten minutes, humidity more than a hundred thousand times anything measured on Earth. Published in Nature Geoscience. I just love that there's physics we wrote down in books generations ago, assumed never actually happened, and Mars is out there doing it every single morning before breakfast. Humbling.
And one more, framed properly as an older story that resurfaced — the Nvidia Microduck. A clip from back in September, from Jensen Huang's GTC Berlin keynote, of these tiny open-source robot ducks waddling around, making little R2-D2 noises, doing somersaults on voice command. They were so cute that preorders blew past twenty thousand units, and Hugging Face's Clem Delangue figures they might be the best-selling robot of the year — and not even mostly for kids. The ducks come from Pollen Robotics, which Hugging Face acquired, and Hugging Face is now an Nvidia company after the GPU giant bought them. I bring it back up only because Julie Bort at TechCrunch framed it perfectly: enjoy the waddling ducks as a palate cleanser after the black eye the AI industry gave itself this week with cyberattack after cyberattack. Which is more or less exactly what I just did to you. The same technology that lets a billion agents probe the cracks in the internet's foundation also makes a duck do a somersault when you ask nicely. Both things are true. Hold them at the same time.
That's the plate for today. The throughline, if you want one to chew on after you close the app: all these powerful new tools are fantastic at producing impressive output in a hurry — fast exploits, fast revenue, fast demos, somersaulting ducks. The thing that still can't be faked is whether what you built actually holds up when the pressure comes. Patch your stack. Know your dependencies. Count your delighted revenue, not your annualized fantasy. And maybe pick a memory-safe language while you're at it.
I'm Tony DeLuca, this has been Barely Possible, and I'll be right back here tomorrow with a fresh plate. Take care of each other out there.