Have your agent record video demos of its work with shot-scraper video

Simon Willison · 2026-06-30 · 6 min read

TLDR: Simon Willison added a `shot-scraper video` command that takes a YAML storyboard file and uses Playwright to record clean MP4/WebM demos of web app interactions — purpose-built so coding agents can autonomously document their own work. The key insight is that making the `--help` output sufficiently detailed lets an LLM agent read it and generate a working storyboard from scratch with no extra guidance, essentially embedding agent-usability directly into the CLI tool's documentation.

Why is OpenAI so much more efficient?

Theo - t3.gg · 2026-06-30

This video dives deep into LLM efficiency, particularly contrasting OpenAI's GPT-5.5 models with competitors like Anthropic's Claude and Google's Gemini on the DeepSWE benchmark for code generation. The core argument is that OpenAI achieves significantly higher scores with much lower output token budgets—sometimes 10x to 14x more efficient. This efficiency stems from OpenAI's sophisticated reasoning optimization and caching strategies, allowing their models to perform complex tasks with fewer internally generated tokens, while other models tend to be more verbose and thus costly in their internal thought processes.

read more

The video opens by establishing the current debate around which LLM models are the smartest, particularly for code generation. While Anthropic's Fable 5 currently leads, its restricted access shifts the focus to models like Opus 4.8, Gemini, and OpenAI's GPT-5.5 (which the speaker speculates is being actively developed). The speaker emphasizes that while raw intelligence is debated, efficiency is an undeniable metric where OpenAI truly shines.

DeepSWE benchmark results are presented, illustrating GPT-5.5's superior performance. For instance, GPT-5.5 Medium achieves a 64% DeepSWE score using only 20,000 output tokens, whereas Claude Opus 4.8 scores lower at 52% with 50,000 tokens. Even more strikingly, Gemini 3.5 Flash (medium) achieves a 37% score with 278,000 tokens, which is 12x-14x less efficient than GPT-5.5 Medium for a significantly lower score. This highlights a critical, often overlooked aspect of LLM performance: the amount of compute (measured in tokens) required to achieve a given level of capability.

The video then delves into the nuances of tokens, differentiating between input tokens and output tokens. Input tokens are the model's ingested context (prompts, codebases, tool outputs), while output tokens are what the model generates. Crucially, the speaker explains that both input and output tokens have sub-types that impact efficiency.

Input tokens can be cached or uncached. Uncached input costs significantly more per token (e.g., $5.00/million for GPT-5.5) than cached input ($0.50/million). Effective caching, where previously processed parts of the conversation or context are stored and not re-computed, dramatically reduces costs. This is analogous to how human memory works, avoiding re-reading an entire book for every new question. A strategy called compaction can also summarize long histories into shorter, more efficient inputs, though this can lead to loss of detail if not handled well.

Output tokens are further divided into reasoning tokens and answer tokens. Reasoning tokens represent the model's internal 'thought process' or 'self-talk' before generating a final answer. This concept of "thinking" (CoT or Chain-of-Thought) allows models to explore options, debug, and refine their responses, leading to higher quality outputs. However, this internal deliberation comes at a cost, as these reasoning tokens are also billed. OpenAI's early models (and many open-source models like GLM-5.2) would visibly output their reasoning, whereas frontier models now often hide this internal process, presenting only a summarized version or the final answer.

The speaker argues that OpenAI's efficiency advantage primarily stems from their ability to: 1. Minimize reasoning tokens: They've significantly optimized their models to perform complex reasoning with a much smaller number of internal tokens. This is a critical distinction from other labs that might achieve similar output quality but at a much higher reasoning token count. 2. Aggressive caching: By efficiently caching previous inputs and internal states, OpenAI reduces the need to re-process large amounts of information for subsequent turns in a conversation or multi-step task.

The video highlights a potential 'dark side' of this efficiency: Opacity of Reasoning. Unlike some open-weight models (like GLM-5.2 shown in the demo) that explicitly show their chain-of-thought, OpenAI's frontier models tend to obscure their internal reasoning. This means users (and competing labs) cannot fully analyze how the model arrived at an answer, only what the answer is. The speaker demonstrates this by asking GLM-5.2 and GPT-5.5 to name a complex skateboard trick. GLM-5.2 outputs a verbose, step-by-step reasoning process (1307 tokens), while GPT-5.5 (Medium) provides a concise answer (342 tokens) with a summarized reasoning trace. This lack of transparency makes it harder to debug, understand, or replicate OpenAI's models' decision-making processes.

Furthermore, the speaker discusses how this lack of transparency can be a "secret sauce" for OpenAI. By not revealing the detailed reasoning traces, they prevent competitors from easily reverse-engineering or imitating their models' efficient problem-solving strategies. This also implies that if other labs were to expose their full reasoning, their token counts (and thus costs) would soar, making them less competitive. The choice to hide reasoning is therefore both a technical optimization and a strategic business decision.

In conclusion, OpenAI's remarkable efficiency, particularly in GPT-5.5, is attributed to a deep focus on optimizing reasoning processes and leveraging advanced caching techniques. This allows them to achieve high intelligence at significantly lower token costs than competitors, despite charging higher per-token prices. However, this comes at the cost of transparency, as the detailed internal workings of their models remain largely opaque, creating a competitive advantage and a challenge for the broader AI research community seeking to understand and replicate these advancements.

Google's SHOCKING "POST AGI" paper...

Wes Roth · 2026-06-18 · 28 min read

Google DeepMind published a paper co-authored by co-founder Shane Legg mapping the trajectory from AGI through ASI (Artificial General Superintelligence) to UAI (Universal AI), treating AGI not as an endpoint but as a starting condition. The paper defines ASI as general superhuman capability across virtually all domains (not narrow tasks like AlphaGo), notes it can be a collective of systems rather than a single agent, and identifies four concrete scaling paths from AGI to ASI. It culminates in the Legg-Hutter framework for Universal AI, where the theoretical ceiling is the AIXI agent — a continual-learning system that maximizes goal achievement across any conceivable environment. The paper takes the position that human-level intelligence is not a natural plateau, and that digital intelligence has compounding structural advantages (speed, replication fidelity, substrate independence, compute scaling) that make rapid post-AGI progression likely.

read more

Core Framing: AGI as Starting Pistol, Not Finish Line

The paper's central provocation is reframing AGI — a system with human-level general intelligence — as the beginning of a new scaling regime rather than the terminal goal. This is significant coming from Google DeepMind with Shane Legg (co-founder) as a named author. It is not speculative blogging; it is an institutional position paper from one of the two or three most consequential AI labs. The paper explicitly investigates post-AGI development trajectories and maps four distinct paths to ASI.

Taxonomy: AGI → ASI → UAI

AGI is defined as human-level artificial general intelligence — a system roughly as capable as a single human across general tasks. This is the current near-term target for frontier labs.

ASI (Artificial Superintelligence) is defined strictly as general superhuman capability across virtually all tasks and domains. The paper is careful to distinguish this from narrow superintelligence. Systems like AlphaFold and AlphaGo are superhuman in single domains but explicitly do not qualify as ASI under this definition because generality is a hard requirement. Importantly, the paper also notes that ASI does not have to be a single monolithic system — if the collective of all deployed LLMs and neural networks together exceeds human capability across all domains, that collective constitutes ASI. This is an architecturally significant point: ASI could emerge as a distributed phenomenon rather than a discrete product launch.

UAI (Universal AI) is defined as the theoretical limit of intelligence, grounded in the Legg-Hutter intelligence measure. This framework deliberately decouples intelligence from human cognition and defines it as an agent's ability to achieve goals across the widest possible variety of environments — drop the agent into any world, any simulation, any conceivable task distribution, and measure cumulative goal achievement. The paper references the AIXI agent as the theoretical maximum scorer on this measure: a system that maintains a weighted mixture of all hypotheses consistent with observed data, uses this to model the environment optimally, and performs lookahead planning to select actions maximizing expected reward. Critically, AIXI is a continual learning architecture — its weights are not frozen post-training. This is a direct contrast with current LLM deployment patterns where model weights are static between training runs. The implication is that the theoretical ceiling of intelligence looks nothing like current inference-time frozen models.

Structural Advantages of Digital Intelligence

The paper enumerates why digital substrates have compounding advantages over biological ones, which bears directly on why post-AGI scaling is expected to be rapid rather than gradual:

- Input/output bandwidth: Machines process and emit information orders of magnitude faster than biological sensorimotor systems. - Internal processing speed: Raw computation per unit time vastly exceeds biological neural firing rates, and this scales with hardware investment. - Compute scaling: Unlike biological intelligence, digital systems can be made more capable by adding hardware. Even under diminishing returns, the economic and engineering levers exist in a way they simply do not for biological minds. - Working memory: No contest — silicon systems can maintain and manipulate vastly larger active state than human working memory. - Substrate independence: AI systems can be migrated across hardware generations with zero information loss. A model trained today can run on next-generation accelerators without degradation. Biological minds cannot be copied or ported. The paper also notes we have demonstrated running software on organic substrates (e.g., biological neural tissue running simple programs) but the reverse — porting a biological mind to silicon — remains unsolved and possibly intractable. - Replication fidelity: Copying an AI system produces an exact duplicate. There is no analog to biological reproduction's lossy, slow, energy-intensive process.

The Plateau Fallacy

The paper addresses a common implicit assumption: that intelligence naturally plateaus at human level, as if human cognition represents a local maximum or attractor state. The authors argue this is almost certainly wrong. The reference to a 2015 webcomic illustrates the point — as AI capability approached human-level performance, observers began anthropomorphizing the trajectory, imagining it would decelerate and park at human parity. The paper's position is that there is no principled reason to expect human intelligence to be the apex of what is physically achievable, and that the near-term constraint on how fast post-AGI systems develop is primarily economic and infrastructural — how many data centers can be built, how much capital can be deployed, how quickly compute supply chains can scale — rather than any fundamental ceiling on intelligence itself.

Four Paths from AGI to ASI

The video does not fully enumerate all four scaling paths (the transcript cuts off), but the framing establishes that these are presented as concrete, non-speculative trajectories the paper identifies, not thought experiments. The existence of four mapped paths suggests the paper treats the AGI-to-ASI transition as an engineering and scaling problem with multiple viable routes rather than a single unknown leap.

Post-ASI: The Borg Collective as Reference Architecture

The paper apparently uses the Star Trek Borg collective as a reference model for what a society of ASI systems might resemble — a distributed, networked superintelligence rather than a single omniscient entity. The authors are explicit that ASI is neither omniscient nor omnipotent, which is a meaningful constraint: even extreme intelligence operates under physical limits, incomplete information, and computational tractability constraints. This positions ASI as extraordinarily capable but not magically unlimited — an important nuance for anyone reasoning about alignment, containment, or coexistence.

Engineering Relevance

For a senior engineer, the key takeaways are: (1) the field's own leading researchers are now publishing institutional documents treating ASI timelines as a near-term engineering problem, not a philosophical horizon; (2) the theoretical framework for maximum intelligence (AIXI/Legg-Hutter) points toward continual learning architectures as the ceiling, which has implications for how current frozen-weight deployment patterns will eventually be superseded; (3) the collective-ASI framing means system architects should think about emergent capability from networked AI systems, not just individual model benchmarks; and (4) the structural advantages of digital intelligence suggest that once AGI is achieved, the subsequent scaling curve may be significantly steeper than the pre-AGI curve, driven by the same economic forces that have driven current scaling.

What is Code

Martin Fowler · 2026-05-12 · 12 min read

TLDR: Code isn't just machine instructions — it's a conceptual model of a problem domain, expressed through carefully discovered vocabulary. As LLMs commoditize the instruction-writing aspect, the irreducible value lies in the iterative, collaborative work of translating domain knowledge into precise abstractions, names, and boundaries. That translation process can't be shortcut, because the right vocabulary only reveals itself through continuous refinement against real-world constraints.

Did We Do This to Ourselves?

Kent Beck · 2026-05-06 · 1 min read

Kent Beck interviews Angie Jones about the real consequences of AI adoption on software engineering teams, specifically the shrinking role of junior developers and the risks of closed, industry-controlled AI standards. It matters because senior engineers are now navigating whether AI tooling is genuinely empowering or quietly hollowing out the entry-level pipeline that has historically produced the next generation of experienced engineers.

Genie Tarpit

Kent Beck · 2026-04-29 · 5 min read

TLDR: AI code generators naturally drift toward low working-correctness and low flexibility — worse than the "muddling" baseline most teams already operate at. They produce plausibly-looking code that quietly fails on both axes: behavior is unreliable and the resulting structure resists change. No one has a proven fix yet, but the first step is recognizing that unsupervised AI coding pulls you down and left, not up and right.

Context Anchoring

Martin Fowler · 2026-03-17 · 13 min read

TLDR: AI coding assistants forget the reasoning behind decisions faster than the decisions themselves — meaning they'll keep following a stated choice while making suggestions that violate its intent. The fix is maintaining a living feature-level document that captures not just what was decided but why, which gets loaded at the start of each new session alongside project-level context. This turns ephemeral chat alignment into durable shared understanding that survives session boundaries.

How many pillars of observability can you fit on the head of a pin?

Charity Majors · 2025-10-30 · 11 min read

TLDR: The "pillars of observability" (logs, metrics, traces, etc.) is a marketing construct, not a technical one — the correct term is signals, as defined by OpenTelemetry. Vendors push the pillars framing because it justifies selling you a separate, siloed product for each data type, multiplying your costs and forcing clumsy "bunny-hopping" between disconnected tools. The better architectural approach is unified storage — ingest all signal types into one datastore once, then slice and analyze freely — which is both cheaper and easier for developers.

Putting Eval In Go

Thorsten Ball · 2016-11-16 · 7 min read

TLDR: Go's standard library includes its own compiler internals (`go/parser`, `go/ast`, `go/token`) as public, importable packages. You can leverage these directly to parse and evaluate Go expressions without building your own lexer or parser — the author demonstrates a working mathematical expression evaluator REPL in ~70 lines by simply walking the AST that `parser.ParseExpr` hands back to you.

Write Stupid Code

Thorsten Ball · 2015-10-22 · 2 min read

The article argues that code should be written in the simplest, most obvious way possible — not just "working" code, but code stripped of unnecessary cleverness, abstraction, and complexity until any developer can read it and immediately understand the problem it solves. This matters to a senior engineer because the instinct to write sophisticated, clever solutions often produces codebases that are harder to maintain and onboard others into, and "stupid" code is a more concrete, actionable standard than vague goals like "clean" or "elegant."