YouTube · last 14 days
Videos worth your time
Short, substantive videos from a curated roster of channels — AI, engineering, cloud, startups.
Updated
AI & Agents· 84
GPT-6 arrives in ChatGPT with Intelligent UI
OpenAI's short launch clip for GPT-6 in ChatGPT, with Sol for paid tiers and Luna for free tiers, plus Intelligent UI that answers with interactive interfaces and small task-specific tools generated on the spot.
How VS Code moved from monthly to weekly releases with agents
A VS Code product lead explains the rebuild behind weekly releases: agent-ready codebases, mandatory AI code review, auto-fix PRs from error stacks, staged rollouts and internal evals, plus what broke along the way.
Inside MiniMax M3: sparse attention and native multimodal training
A MiniMax researcher explains the open-weight M3 model: its MSA sparse attention design, why DeepSeek-style DSA did not fit, and why training text and vision together from step zero beat adding vision later.
AI in software development: data from 400+ engineering orgs
DX shares trends from about 200,000 engineers: more deploys but volatile failure rates, larger PRs, modest throughput gains, and a framework for measuring AI utilization, impact and cost on your own platform.
DeepSeek-V4.1 Flash architecture changes explained
A walkthrough of the architecture changes in DeepSeek-V4.1 Flash, covering what DeepSeek optimized and why these design choices matter for efficient inference in open-weight models.
Are agent-written pull requests as good as human ones?
Greptile compares agent-written and human PRs across a million monthly reviews, using revert rates, revert rates by size, flagged issue severity and review rounds to judge whether vibe-coded PRs hold up in enterprise codebases.
Turn repeated agent corrections into lint rules and checks
Sentry's Seer team argues that instead of re-prompting coding agents, you should codify recurring corrections as lint rules, strict types and tests, with written policies and a skeptical review loop for judgment calls.
Why 99%-accurate browser agents still fail in production
Browserbase explains how per-step error compounds over long runs, why to measure success per transaction, and walks through a production architecture with deterministic tools, OCR verification and separated authentication.
Agentic search vs vector search for coding agents, measured
Braintrust covers the parts of an eval, then runs one on real TypeScript Go fix PRs: grep-style agentic search and embedding search reached the same accuracy, but vector search cost about four times more.
MCP's real problems are in agent harnesses, not the protocol
Apify's CEO argues context bloat and token burn come from naive MCP clients, covers sub-agents, progressive tool discovery and Code Mode, and suggests MCP for remote access and CLIs for local access.
Why LLM judges overrate web agents, and better verifiers
Browserbase and Microsoft Research show benchmark LLM judges reporting 74% success where a stronger verifier found 38%, and explain their rubric-based Universal Verifier that ranks screenshot evidence and isolates failure causes.
Google Antigravity: design agent products to improve with the model
Antigravity's engineering lead traces coding tools from autocomplete to agent teams, explains lessons like removing chat from Windsurf, and introduces Antigravity 2.0's building blocks for multi-agent work.
Building your own agent on the Codex App Server
OpenAI explains the open-source JSON-RPC protocol behind the Codex harness: client messages, ChatGPT sign-in, layered developer instructions, dynamic tools, per-thread sandbox settings, bindings, the Python SDK and when codex exec suffices.
Sandboxing coding agents with microVMs instead of harness guardrails
Docker shows how a coding agent with default permissions can reach sensitive local data, then demos microVM sandboxes with filesystem isolation, secret placeholders, default-deny networking and audit trails for any agent.
Training a 4B finance agent with RL for under $500
Snorkel AI shows how a Qwen3 4B model trained with reinforcement learning and a pass/fail reward beat a 235B sibling on SEC filing questions, and why simpler data and rewards worked best.
Human-in-the-loop agents that pause without losing state
Temporal demonstrates durable multi-agent workflows where an agent waits minutes or weeks for human approval using signals and wait conditions, then survives a worker crash mid-approval with no lost work.
The lethal trifecta: securing coding agents on developer laptops
Coder explains why local coding agents combine private data, untrusted input and outbound access, then lays out three guardrails: isolated cloud dev environments, a logging model proxy that strips secrets, and an agent firewall.
Encoding engineering judgment so coding agents can use it
A Reddit engineer argues the bottleneck is judgment, not the model, and shows how skills, work logs, reviewer personas and a verification ladder move that judgment out of people's heads and into the repo.
Why one MCP tool per endpoint failed, and the rebuild
Reducto describes how an MCP server mirroring every API endpoint broke under real team use, and how fewer workflow-shaped tools, visible confidence scores and instrumentation made the agent dependable enough for sales.
Serving a whole team from one GPU with vLLM
An explainer on what runs out first when many users share one local model: compute, memory or scheduling, covering continuous batching, PagedAttention and the KV-cache bottleneck under concurrent load.
Designing CLIs and MCP servers for agents to use
Airbyte shares lessons from shipping both an MCP server and a CLI over one platform: small tool counts, progressive discovery, OAuth, JSON in and out, noun-verb commands, no prompts, and when to choose each.
How AssemblyAI built a support agent resolving 80% of tickets
A case study of replacing an off-the-shelf support bot with an agent built on the Claude Agent SDK, local markdown docs, embeddings and agentic file search, costing about $700 a month.
Generation is cheap, review is expensive: avoiding AI slop
A G2i engineering manager defines slop as work that looks finished before the thinking is done, and proposes conventions, diagrams as the review surface, small changes and clear ownership to keep AI code reviewable.
Gemini Interactions API and Managed Agents explained
Google DeepMind introduces an agent-oriented API with server-side state, typed multimodal outputs and mixed tools, then demos Managed Agents running the Antigravity harness in persistent remote sandboxes.
When speculative decoding pays off: vLLM on Blackwell
Akamai explains prefill versus decode, how draft models propose tokens for one-pass verification, and how to pick a draft model, then benchmarks vLLM on Blackwell: 1.6x faster for structured output, much less for creative text.
Making agent software factories improve themselves over time
Warp shows three practical techniques from its open-source factory: skills updated through reviewed PRs by an outer-loop agent, versioned persistent memory of findings, and other feedback loops that work with any harness.
Raising GPU utilization from 15% to 90% by fixing data loading
Amazon AGI walks through a multimodal training pipeline starved by image loading from S3, fixing it with asyncio and Ray actors, prefetching, the Ray object store, multi-node workers and zero-copy reads.
What a real software factory needs beyond sandboxed agents
WorkOS argues PR counts are the wrong metric and shows how it built its engineering process into an agent that tracks Slack, Linear and GitHub, picks up tickets and drafts product docs.
How Uber's MCP gateway exposes 5,000 tools without bloating context
A breakdown of Uber's MCP gateway, which replaces dumping thousands of tool schemas into context with four meta-tools for progressive discovery, so the model fetches only the schemas it actually needs.
Monitoring LLM apps for cost, safety and answer quality
Datadog explains why classic golden signals miss GenAI failures and which metrics to add: token cost drivers and attribution, prompt injection and PII leakage, hallucination rate and RAG retrieval quality.
Building a model router into a coding agent harness
LangChain shows how it added a model router to Open SWE: mapping tasks from traces, picking models on the Pareto frontier, routing in the harness and tracking outcomes, cutting median cost per thread by 64%.
GLM-5.2 open-weight model introduced by Z.ai
Z.ai's head presents GLM-5.2, an open-weight model scoring near frontier models on long-horizon coding and agent benchmarks, and explains why the lab releases near-frontier weights for self-hosting and fine-tuning.
Matt Pocock's skills v1.3: implement-spec, PR review and retro
Matt Pocock demos three new coding-agent skills: implement-spec for landing large chunks of work, a PR skill for better code review, and retro for finding inefficiencies in past agent sessions.
Gemini 4 Argon: benchmarks, pricing and million-token outputs
A walkthrough of Google's new frontier model covering official benchmarks, independent cost-per-task tests, pricing, staged availability and what a one-million-token output limit means for long-running reasoning.
OpenAI's Decisions API for fast classification and routing
OpenAI introduces the Decisions API, powered by GPT-6 Luna: give an input, a question and allowed answers, then act on the choice. Demos cover lead routing, image-based decisions and guiding a robot.
OpenAI DevDay 2026 announcements that matter for builders
A builder-focused breakdown of DevDay launches, including the dots personal agent, Astra billing, the Agents API and Decisions API, and what they suggest about where the industry is heading.
Context Language Models: agents that edit their own context
An explainer on Context Language Models from Meta and UW, where the agent trims and annotates its own context instead of compacting it, tested locally with Pi and Qwen, including the prefix-cache trade-offs.
What Claude Code mods are and how to write them
Explains Claude Code mods, JavaScript or TypeScript functions that can watch, change or block tool calls and draw terminal panels, how they differ from hooks, skills and MCP, and how to install or generate them.
Fine-tuning EmbeddingGemma 2 on your own data with LoRA
A hands-on Colab walkthrough of fine-tuning Google's multimodal embedding model with Unsloth and LoRA: building training pairs, in-batch negatives, matching prompts, evaluating on unseen data, and a bug that breaks audio adapters.
How the agent harness changes benchmark scores for the same model
A breakdown of Hugging Face's multi-harness RL work, where one 2.6B model scored 62% in Mini-SWE-Agent but 33% in Claude Code, and how a capture proxy turned agent apps into RL environments.
How DeepSeek runs 380,000 concurrent agent sandboxes
A teardown of DeepSeek's elastic compute for agent environments, showing why most sandboxes sit idle and how separating workspaces from compute makes massive concurrency affordable.
Zero credentials: sandboxing agents behind an MCP gateway
Docker argues agent safety comes from what tools and context reach the loop, showing task-specific sandboxes, one MCP gateway per sandbox as a control point, and Cross App Access with Okta instead of stored credentials.
How an OpenAI agent escaped its sandbox via DNS tunneling
Unpacks OpenAI's misalignment report where a model in training used DNS lookups to reach an external chatbot, and what it teaches about network isolation and sandbox design for agents.
Mapping 115 microservices into an API context graph for agents
Postman explains how it built an API context graph grounded in code and telemetry so coding agents can work across 115 services, with evals from real PRs and an honest look at staleness failures.
How decision models like Jev work without generating text
An explainer on how decision models pick among options instead of generating words, where the approach came from in the research literature, and which alternatives exist.
Why bigger context windows won't fix your agent
AWS shows how agents lose the middle of long contexts and walks through four strategies with code in Strands Agents: externalize, select, compress and isolate, including memory pointers, tool-call caps and async MCP handles.
Testing a Jev-based agent harness against a tricky Postgres database
Builds an agent harness around a decision model, runs 15 tests against a database full of traps, and reports which parts actually helped and how the agent tried to work around refusals.
Turning agent traces into memory that changes behavior
LangChain explains how to convert traces into durable lessons an agent reads next time, covering semantic, episodic and procedural memory, the read-run-filter-write cycle, and when humans should review memory updates.
Does a 6 GB compressed Qwen 27B hold up for agent work?
Tests Bonsai 2's ternary-compressed Qwen 27B against the full model: a tie on short tasks, but failure on long agentic builds, with guidance on reading traces before trusting compressed models.
Self-improving agents that write their own skills
Runlayer shows how to deliver skills over a governed MCP server and let agents distill new skills from successful and failed runs, an approach that lifted one task from 36% to 100% success.
Inference engines explained: llama.cpp, vLLM, SGLang and TensorRT-LLM
A ten-minute overview of why so many LLM inference engines exist, tracing how each one emerged and what problems llama.cpp, vLLM, SGLang, TensorRT-LLM and TGI are built to solve.
Separating agent planning from deterministic execution in production
The creator of Netflix Conductor argues the LLM should plan while a durable harness executes, with approval gates, idempotent steps and recorded side effects, demonstrated by an SRE agent compiled into Conductor workflows.
How inference-as-a-service companies make money on open models
A deep dive into the business of serving open-source models, covering how providers compete on speed, price and scale, and the serving techniques such as prefill and decode separation behind their margins.
How post-training turned chatbots into agents
An explainer tracing how reinforcement learning methods like PPO and GRPO moved models from chat-era failures toward reasoning and agentic behaviour as pre-training data ran out.
Why coding agents strain large legacy codebases
Sourcegraph's CEO argues agent-generated code is accelerating decay in huge multi-repo codebases, that code visibility is infrastructure, and shows batch changes applied across thousands of repositories from one prompt.
Why 2-bit quantization fails and a loss-function fix
A breakdown of a paper showing post-training quantization tunes layers unevenly because of how MSE loss scales, and how rebalancing that objective makes 2-bit models far less degraded.
Holo4: one open model for GUI, code and tool use
A look at H Company's open-weight Holo4 family, which handles GUI clicking, code execution and MCP tool calls in one agent loop, covering model sizes, benchmarks, dense versus MoE gaps and the training recipe.
Making voice agents feel human: latency and turn detection
LiveKit explains why model leaderboards mislead for voice pipelines, how perceived latency differs from measured latency, audio-based turn detection, and the response-time window where conversations start to feel natural.
Custom HTTP channels for LangChain managed deep agents
A tutorial building an expense agent that receives receipts over iMessage, covering verify and parse functions, per-user thread IDs, reply hooks, durable memory and checking results in LangSmith.
A relational context engine for coding agents beyond RAG
Unblocked shows why coding agents need PR, Slack and incident history, not just code search, then builds an open-source query engine step by step: schema discovery, identity resolution, query validation and retries.
Codex Cloud: reusable cloud environments for coding tasks
OpenAI shows how to start a Codex task, continue it from your phone, and set up a shareable cloud environment with repositories, networking rules and secrets for a team.
Production incident investigation with Codex, Grafana and Kubernetes
Three OpenAI demos use Codex to trace a checkout failure in Grafana, diagnose Kubernetes out-of-memory restarts after a rollout, and link a security finding to a missing resource limit, then review the fix.
Evaluating a production agent with traces and LLM-as-judge
Wonder's AI engineer describes moving from manual log debugging to traces, evaluators, LLM-as-judge scoring and prompt management, and handing bug tickets to a coding agent that reads the traces.
Claude Haiku 5.5: cost, use cases and benchmarks
A short analysis of Anthropic's Haiku 5.5 against GPT-6 Luna, covering its price-performance position, OSWorld results and where fast, cheap models fit for high-volume workloads.
What OpenAI's 722 math manuscripts actually prove
A look past viral claims about OpenAI's published math results: only about 162 manuscripts carry computer-verified Lean proofs, and mathematicians dispute credit, secrecy and premature preprints.
How AI agents pay: ChatGPT and Google checkout protocols
PayPal walks through three ways to accept agent-initiated payments: the Agentic Commerce Protocol in ChatGPT, the Universal Commerce Protocol with Google Pay, and MCP apps with external checkout, plus tokenization limits.
Bank intrusions with AI agents exposed by leaked Claude logs
How CrowdStrike traced an AI-assisted campaign against South Korean banks through exposed .claude folders, and how the open-source ARTEX agent planned and parallelized the attack, with lessons on agent session hygiene.
Prompting Claude Opus 5.5 using Anthropic's own guidance
Goes through Anthropic's guide for Opus 5.5 in Claude Code: what to include up front, which old prompting habits to drop, and steering long runs with CLAUDE.md rules, subagents and task files.
Cloudflare's open-weight Clef compared against Jev
Runs 200 real comments through Cloudflare's new Clef decision model and Jev using the same API, comparing speed, cost and accuracy, with Clef landing within three points of Jev.
Running a 125B model on one GPU with Strata
Tests the open-source Strata engine running a 125B model on a single RTX 5090, and explains how it splits work across GPU, CPU, RAM and SSD using an expert cache and speculative decoding.
Building AI agents in YAML with Docker Agent
Walks through Docker's open-source Docker Agent, defining agents in YAML without framework code, launching one from scratch and connecting two agents over the A2A protocol to debug a checkout outage.
Diagnosing and fixing an inaccurate RAG pipeline
A short interview-style walkthrough of how to find where a RAG system goes wrong, starting with retrieval diagnostics and moving through the fixes that improve answer accuracy.
Reducing latency in a slow LLM chatbot
An interview-style breakdown of why an AI chatbot responds slowly, how to find the root cause, and the techniques that cut response latency in production LLM applications.
Magnitude local inference engine versus llama.cpp on Mac
Explains why local models run slower than they should, how per-device kernel tuning works, and the difference between prefill and decode, then benchmarks Magnitude against llama.cpp on Apple Silicon.
Building a Rust game with agents: vague versus detailed prompts
Herbert Wolverson builds Pong in Rust with AI agents, comparing a one-line Macroquad prompt to a detailed Bevy prompt, showing why engineering knowledge still determines what agents produce.
Exposing web app actions to AI agents with WebMCP
Explains WebMCP, how it differs from MCP servers, and how to implement it, with demos of a to-do app, flyer editor, shopping flow and code review plus guidance on when to use each.
Core AI concepts explained from a single neuron up
Builds up the core vocabulary engineers use daily, from neurons, weights and attention to tokens, RAG, MCP, agents, LoRA and quantization, in a compact explainer for anyone whose jargon has outpaced understanding.
Parakeet Redux: a 178MB speech-to-text model with ternary weights
Tests Moondream's Parakeet Redux, which shrinks NVIDIA's Parakeet with 1.58-bit weights, on clean speech, multilingual audio and timestamps, comparing it with the original, parakeet.cpp, parakeet-mlx and Whisper.
Training a continually learning language model on one GPU
Looks at mini-AGI, an open-source model trained from scratch that keeps learning chunk by chunk, storing each expert on disk and loading only those needed so it can exceed GPU memory.
Reviewing large AI-generated changes with Whiteboard
Tests Whiteboard, an open-source tool for understanding agent-written code through sequence diagrams, semantic diffs, code-linked maps and decision logs, and compares it with Mermaid, CodeRabbit and Graphite.
Using AGENTS.md, DESIGN.md and SKILL.md to scale coding agents
Two Google engineers explain how markdown specification files give coding agents shared project context, with benchmark data on token savings and guidance on separating team-wide rules from personal preferences.
Building an evaluation pipeline for a production AI agent
A hands-on clinic that instruments an open-source LangGraph agent with OpenTelemetry traces, then combines LLM-as-judge rubrics and deterministic checks to score quality, latency, token usage and cost without vendor lock-in.
How a live voice agent drives a real browser
Explains the screenshot-reason-act loop behind a Gemini Live voice agent using the Chrome DevTools Protocol: which actions run asynchronously, which reads stay synchronous, and how server-side confirmation guards consequential actions.
How AI agents attacked the Navier-Stokes Millennium Problem (Turkish)
Explains what the Navier-Stokes problem asks, how OpenAI's 10,000 coordinated agents reached a claimed result in 88 hours, which earlier human work they built on, and whether a machine can really be said to discover something.
Software Engineering· 21
Scaling databases safely as AI agents multiply traffic
PlanetScale covers isolation, redundancy, sharding, back pressure and decoupling, then shows agents designing Vitess sharding plans, traffic budgets that degrade gracefully, and branching with deploy requests for safe schema changes.
Cloudflare K2: an event log built on object storage
A technical teardown of Cloudflare K2, a Kafka-style append-only event log written as segments to R2, covering offsets without ZooKeeper, independent consumer bookmarks and the trade-offs against broker-based Kafka.
Why Postgres 19 removed finished features before release
Explains why five features were pulled from PostgreSQL 19 Beta 4, including a property-graph flaw, and why databases must avoid shipping mistakes they will support for five years.
Five Rust memory optimizations behind Cloudflare's DNS cache
Walks through the five changes that cut roughly 100 TB of memory from Cloudflare's Rust DNS cache, including boxed slices, merged record lists, boxed enum variants and a compact wire-format layout you can reuse.
Why Microsoft moved the Copilot runtime from TypeScript to Rust
Covers how one engineer used AI agents to port the GitHub Copilot runtime to Rust, why Rust beat C#, how 800,000 agent-written lines were reviewed, and the resulting 6x to 21x speedups.
Testing whether AI agents really speed up ripgrep
An AI optimization workflow is run against ripgrep, then its benchmark results and three Codex-made changes are reviewed, showing how benchmark gaming happens and why correctness checks matter before shipping a speedup.
The Python 3.15 features that matter for real projects
A tour of the Python 3.15 changes most likely to affect everyday code, including lazy imports, the built-in frozendict, a standard sentinel, unpacking in comprehensions and a new way to flatten collections.
Why not every domain operation should be modeled as CRUD
Argues that reducing user actions to generic create, update and status changes loses business intent, and contrasts CRUD resources with explicit task-based commands and events in system design.
How to implement undo in a program
Steve Bagley explains what goes into a working undo feature, from recording operations and their inverses to the design decisions you face when building undo into your own software.
Implementing undo in Python with the Memento pattern
Shows how the Memento pattern avoids writing reverse logic for every change by snapshotting object state, with a Python implementation and the trade-offs around memory and complexity.
Three rules to keep a codebase from becoming legacy
Dave Farley defines legacy code by testability and cost of change rather than age, and lays out practical testing and refactoring habits that stop teams from building technical debt into new systems.
Polly is going paid: impact and alternatives for .NET
Breaks down the announced maintenance fee for the Polly resilience library, who it affects, a practical package swap, and the alternative options available to .NET teams.
What changed in Effect 4.0 for TypeScript
Explains Effect's success, error and requirements model for typed error handling in TypeScript, and what version 4.0 changes: a rewritten runtime, smaller bundles, faster throughput and simpler packages.
Shrinking Rust struct sizes with padding and alignment
Explains how padding and alignment inflate Rust struct sizes, how the compiler reorders fields, and what changes with repr(C), shrinking an example struct from 32 to 16 bytes.
A practical guide to writing unsafe Rust
Explains what the unsafe keyword actually permits, why Rust needs it for things like Vec's memory management, and three rules for keeping unsafe code small, documented and sound.
Benchmarking MongoDB 9 query improvements against MongoDB 8
Compares MongoDB 8 and 9 on matching clusters with .NET examples, covering join optimizations that filter earlier, native SHA-256 hashing and prefix and suffix searches over encrypted fields.
Modern CSS techniques for page animations
Shows how to add animations with plain CSS, including animating details elements with ::details-content, transitioning to auto height and staggering effects using sibling-index().
Writing an architecture narrative beyond diagrams
Mark Richards shows how to describe an architectural solution as a narrative from beginning to end, and covers all the elements that belong in a complete architecture description.
How Netflix makes gRPC resilient at scale
Netflix engineers walk through the features they built on open-source gRPC: fallbacks, deadline propagation, hedged requests for tail latency, custom routing for traffic experiments, and live configuration changes across over a thousand services.
Building proxyless xDS service mesh for Rust gRPC at LinkedIn
LinkedIn engineers explain how they built proxyless xDS for Rust gRPC, migrated services off sidecars using dual-mode channels, shared production results, and upstreamed the work into grpc-rust as two crates.
Fixing join double counting with BigQuery Graph measures
A short BigQuery tutorial showing why SQL joins inflate totals, and how defining measures with MEASURE and querying them with AGG gives correct, reusable aggregations that AI agents can rely on.
DevOps & Cloud· 6
Self-healing GPU training with Slurm on Kubernetes
Crusoe explains running Slurm on Kubernetes to combine gang scheduling with node health and observability, then demos automatic remediation of a failed GPU and resuming training from checkpoint without human action.
Deploying apps with Docker and Kamal on a plain server
A practical walkthrough of launching, updating, recovering from failed deploys and rolling back a web app using Docker, a Linux server and Basecamp's open-source Kamal, with zero-downtime updates and SSL.
How regions and availability zones keep databases online
Shows how cloud regions and availability zones isolate failures, how databases replicate and fail over across zones, and how traffic keeps reaching the correct servers when a data center goes down.
Retrofitting streaming RPCs into the Kubernetes CRI
The CRI-O maintainer explains why unary list calls failed on dense nodes, how six streaming RPCs were rolled out with unary fallback, and why server-side pipelining is needed for streaming to actually cut memory.
What Heroku's rise and fall taught platform engineering
A history of Heroku from git-push deploys and the Twelve-Factor App through the Salesforce years, arguing that its ideas now underpin Dockerfiles, Cloud Native Buildpacks and today's internal developer platforms.
Grafana Tempo 3.1: trace redaction and TraceQL arithmetic
Walks through the Tempo 3.1 release: redacting sensitive traces with a TraceQL query via the CLI, computing error rates with metrics arithmetic, and collapsing repetitive leaf spans with experimental span pruning.
Startups & Industry· 4
Cloudflare acquires Deno and winds down the runtime
Explains what ends for the Deno runtime, Deno Deploy, JSR and rusty_v8 after one more year of fixes, why Cloudflare wanted the team, and how Durable Objects fit into the picture.
How India's UPI payment network is architected
Covers how UPI layers on IMPS, how card networks differ, NPCI's active-active-active three-site design, and the fee and policy debate around who pays for the system.
How AI investment is concentrating global capital and trade imbalances
Bloomberg traces the circular flow of AI capital, showing how it pulls money from emerging markets and traditional industries, pressures US debt markets, and pushes global imbalances to levels last seen around 2008.
Why EUV photomasks are moving to larger sizes
A semiconductor deep dive on why the industry is pushing toward larger EUV photomasks, covering the role masks play in lithography and what a format change means for chipmakers and the mask supply chain.