Daily Digest — June 25, 2026

[BUSINESS] Micron’s Record Quarter vs. the Chip Selloff

The story: Micron reported its most profitable quarter ever after Tuesday’s close. Q3 revenue hit $41.5 billion against $9.3 billion for the same quarter last year. The company also guided Q4 above expectations. This is the same Micron that dropped 13.2% on Monday during the global AI chip selloff. SK Hynix and Samsung each fell more than 12% in Seoul. The selloff was attributed to investor anxiety about AI capex returns and the possibility of Fed rate hikes. Micron’s earnings suggest the demand is real and the returns are happening.

My take: The market’s schizophrenia is the story. On Monday, memory stocks got crushed because investors “remembered” they were worried about hundreds of billions in AI infrastructure spending. On Tuesday, Micron reported its best quarter ever because that same spending is generating record demand for memory and storage. Both things can’t be true at once. Either the capex thesis is broken or it isn’t.

Micron’s numbers settle it. The memory shortage from earlier this week isn’t speculation — it’s showing up in financials. Gross margins at 80% plus record revenue means the demand is inelastic enough that costs get passed through. Apple’s price hikes, HP lobbying Washington to loosen Chinese chip restrictions, and now Micron’s blowout quarter all point to the same conclusion: AI infrastructure buildout is crowding out consumer supply, and the suppliers are capturing the margin.

SK Hynix announcing a $29 billion US listing this week is the supply-side response. These companies aren’t retreating. They’re raising capital to expand. The selloff was a sentiment event. The earnings are the underlying reality. The market will resolve this in favor of the numbers eventually, but eventually can take a while when the narrative is “AI bubble.”

The risk isn’t that demand disappears. It’s that capacity expansion happens fast enough to crash prices. But Micron, Samsung, and SK Hynix were all burned by past boom-bust cycles. They’re expanding cautiously despite 80% margins. That discipline is what keeps prices high and what creates the opening for Chinese competitors. The same dynamic Ben Thompson identified two days ago.

[AI] Jalapeño and the Full-Stack Flywheel

Source: OpenAI News · TechCrunch · Electrek

The story: OpenAI and Broadcom unveiled Jalapeño — OpenAI’s first custom inference chip. Designed from scratch for LLM inference, not adapted from general-purpose GPU architecture. Nine-month tape-out, with OpenAI’s own models used to accelerate the design process. Broadcom CEO Hock Tan called demand from his six major customers “simply insatiable” through 2028. The chip targets deployment at gigawatt scale by late 2026. Separately, Tesla, Sunrun, and Renew Home announced a 16 GW virtual power plant aggregating home batteries and smart thermostats to feed data center demand, with 300 MW deployable immediately in Virginia.

My take: Jalapeño is less interesting as a chip and more interesting as a signal. OpenAI now designs silicon, writes kernels, optimizes memory systems, and runs the serving layer. The vertical integration isn’t about cutting out Nvidia — OpenAI is still one of Nvidia’s biggest customers, and training likely stays on GPUs. It’s about owning the inference economics. Inference is where the revenue lives. Every API call, every ChatGPT response, every Codex task runs through inference. Reducing the cost per token by even a small percentage at OpenAI’s scale is hundreds of millions in margin.

The nine-month design cycle is the flywheel argument in hardware form. OpenAI used its own models to help design the chip. Better models design better chips faster. Better chips run models more efficiently. More efficient serving enables more usage. More usage funds better models. The loop exists in software — this is what it looks like in silicon.

The power story is the infrastructure constraint that makes the chip story matter. Tan said demand is insatiable through 2028. The Tesla/Sunrun 16 GW VPP is one answer — distributed home batteries feeding the grid. But 16 GW sounds larger than it is. Only 300 MW is immediately deployable. The rest requires customer enrollment, utility approvals, and regulatory coordination. Data center demand is hitting physical limits — power, cooling, grid interconnection. The companies that solve the infrastructure layer, not just the model layer, will capture the margin.

[ENG] Your Model Doesn’t Know Your Runtime

Source: TLDR · Jim Mont

The story: A detailed empirical analysis of LLM code generation patterns shows models default to manual Node.js implementations — custom query string parsing, per-field React state, axios wrappers, homemade abort patterns — even when the runtime already provides native Web APIs (URL, URLSearchParams, FormData, AbortController, fetch). Using native APIs reduces output tokens by roughly 85–92% per pattern and eliminates entire bug categories. MITRE research from June 2025 found stale comments actively mislead models, degrading comprehension below the no-comment baseline. The author’s directive to fix this: explicitly tell the model which APIs exist before generation starts.

My take: This is the most practically useful piece of engineering writing I’ve seen this month. The core finding isn’t about formatting or prompt engineering. It’s that the model’s training distribution is dominated by legacy patterns — Stack Overflow answers from 2015, npm packages with millions of downloads, boilerplate that predates standardization. The model reaches for what it’s seen most of. It has no knowledge of your specific runtime unless you inject it.

The token economics are staggering. A manual query string parser: ~140 tokens. new URL(rawUrl).searchParams: 12 tokens. Per occurrence. In a real handler, the compound effect is 400–600 tokens of boilerplate versus 60–90 tokens using native APIs throughout. At output token prices of 3–5x input prices, that’s real money. But the bigger cost is reliability. Custom parsers silently drop repeated parameters. Manual abort patterns leak timers. Homemade modals break keyboard navigation. The native implementations were written by the people who wrote the spec and tested against every edge case that exists.

The comment finding is equally important. Models treat comments as authoritative signal, not metadata. A stale comment describing what the code used to do before a refactor actively produces worse output than no comment at all. The only comments worth keeping are design constraints, invariants, and why — not what. The model can read the code. It can’t read your intent.

This connects directly to SE Intel’s probe pattern. Day 2’s RAG isolation probe doesn’t ask Claude whether the Vectorize query filters by orgId. It queries the index and checks the metadata. The model is too unreliable to verify its own infrastructure. The same principle applies here: tell the model what APIs exist, then let deterministic infrastructure do the work. Don’t ask the model to know what your runtime ships. It doesn’t.

A related insight from today’s infrastructure conversations: Training and inference are separate workloads with different economics, and production systems almost never retrain to update knowledge. Training happens once (or rarely), produces frozen weights, and costs tens of millions. Inference happens billions of times per day, serves users from those frozen weights, and is where the margin lives.

So how do models “learn” new information without retraining? They don’t — not through weight updates. Production systems use contextual memory: retrieve relevant documents and inject them into the prompt at inference time. This is RAG (retrieval-augmented generation) in the generic sense, and it’s exactly how SE Intel works. Claude’s weights are frozen. New knowledge lives in Vectorize and KV. At query time, the system retrieves relevant chunks and puts them in the context window. The model reads them fresh for that conversation, then discards them.

The customer translation: “You don’t need a $100M training run to make the model know your products. You need a vector database and a retrieval pipeline. Your docs can change hourly. The model always sees the latest version. No retraining, no fine-tuning, no compute bill.”

This is the architecture that makes AI a product rather than a research project. Jalapeño optimizes inference. Workers AI runs inference at the edge. SE Intel runs inference with live context retrieval. All three bet on the same pattern: cheap, fast inference with knowledge injected from storage at query time. The intelligence lives in your storage layer, not in the model’s weights.

[BUSINESS] AI Slop Drowns the Bug Bounty Model

Source: IT Brew

The story: Turso shut down its bug bounty program in May. HackerOne paused new submissions to its Internet Bug Bounty program in March. The reason: a flood of low-quality, AI-generated vulnerability reports. Turso’s framing: “It costs the slopmaker perhaps a minute to generate their submission, but it costs us hours to read, understand, and engage with them. And they can be generated at a semi-infinite pace.”

My take: Same verification bottleneck, different domain. Code review is drowning in AI-generated PRs. Bug bounty programs are drowning in AI-generated reports. Security researchers are drowning in AI-generated vulnerability disclosures. The generation layer scales infinitely. The human verification layer does not.

The economics are identical to the Polymarket fake-bet story from earlier this week. The cost of producing a fake report approaches zero. The cost of triaging it — reading, understanding, verifying, engaging — is fixed and human. The asymmetry breaks the model. Turso’s program worked when submissions came from humans with skin in the game. It collapsed when anyone could generate plausible-sounding reports at machine speed.

HackerOne’s response — pause and restructure — is what adaptation looks like. They’ll likely come back with higher barriers to entry, proof-of-concept requirements, or submission fees that make slop uneconomical. The bug bounty model isn’t dead. But the open-door version of it is. Every verification system that assumes human-scale generation rates will need to adapt or collapse.

The deeper pattern: any system where generation is free and verification is expensive is vulnerable to this dynamic. Spam, content farms, fake reviews, synthetic media, AI-generated job applications — same asymmetry, different surface. The fix is never at the generation layer. It’s always at the verification layer. Deterministic gates, reputation systems, proof-of-work. Something has to make slop more expensive than it’s worth.