Lighthouse is one of the most successful developer tools we’ve ever shipped, and I say that as someone who is genuinely proud of the work the team has done on it. But something has gnawed at me for a while. Our ability to help the developer ecosystem with it is ultimately capped by the number of tests we can physically create. Every audit is a hand-written piece of JavaScript. Someone has to sit down, understand a best practice, encode it as a deterministic check, ship it, and maintain it as the platform moves underneath it. A lot of rigor goes into that, and the rigor is a good thing, it is exactly what makes the scores trustworthy. But it is also a serious amount of time, which means you inevitably end up having to pick the highest-value tests to build, and whole categories of “is this any good” stay quietly out of reach because nobody could justify the cost of a check. The tool can only ever test what someone found the time to write a test for.
At first, this was a really easy post to write, but then I discovered some things. Built a lot of things. Spent a lot of tokens… And it became one of the hardest, longest, and most expensive posts I’ve done (the API costs were not small).
I’ve had this thing on my mind for ages and it started when I was thinking about how the mere presence of a technology name in a prompt seemed to bias the output to that technology.
I’m building software every day at a pace I’ve never managed before, even when I wasn’t a manager. The tools (Claude, Codex, Antigravity) have unlocked a huge amount of potential and given me the ability to experiment. However, I constantly run into issues. I live at the cutting edge of the web platform. A lot of what I build is literally just landing in the browser, so it kind of makes sense that the data is not in the models.
Just over a month ago I wrote that WebMCP is the new web intents … maybe, but now I really do think that WebMCP is the new web intents (in a good way, not the “the entire project crashed and burned” way). While the spec says that this is not the intended goal, I think we have a federated way for the web to declare its capabilities and for someone (ideally you) to keep an index of them, and then to have your tools recall and re-use those tools when they can match the user’s (or their) intent with the capability of the page.
What is described here in this project is dangerous, it can get pretty much full access to everything inside your browser and could enable control of your browser from outside it
I really do believe we are witnessing a transition in how we build and run software. This entire blog is dedicated to my explorations in this space, for example, I wrote about why the browser is the sandbox which explains how we can use the web platform’s battle-tested security boundaries to execute untrusted code. But sandboxing is only half the battle, when what remains is the utility of any of this technology.
If the majority of my app is just a prompt, then I have a very transportable program. The agent loop is the same everywhere (I have my own one but there are dozens). The memory is a few hundred kilobytes of files. The system prompt is a markdown document. I can take that bundle and run it on a server, in an email host, in a browser, on my laptop. The portability of the program isn’t really in question.
I keep hearing people say that there is a model “half-life” which keeps dropping from years between model releases down to a few months, with the implied assumptions that model releasing will drop to even further. I’ve heard the phrase “model half-life” so much recently that I wanted to actually look at the data.
I made a TSV of every headline model release from late 2022 through today across the US frontier labs (OpenAI, Anthropic, Google, xAI, Meta, Mistral) and the major Chinese labs (DeepSeek, Qwen, Zhipu, MiniMax, Moonshot, ByteDance). I split each vendor into the sub-series it actually ships in (Claude Opus is a different line from Claude Sonnet, GPT is a different line from the o-series, Gemini Pro is a different line from Flash). Then I plotted them.
I’m 45 years old and using cooked to mean something that it never meant. I don’t know when it happened, but it’s out there along with vibe.
Anyway… This post is all personal opinion.
Before we go too deep, I just want to ground some of this article in the definition of a PWA. MDN has a good overview.
“A progressive web app (PWA) is an app that’s built using web platform technologies, but that provides a user experience like that of a platform-specific app.”
Before Google, I worked at a small telecoms company in Liverpool called Qire. It was an interesting company and I’d just gone from working in a big slow corporate building Fraud Detection systems to a small company that had to be pretty nimble. It had maybe 15 people in total. We ended up building voice interaction systems, automated outbound calling, SMS campaigns, data processing and the like. I built reporting, call record management, web infrastructure, and helped wire some of these systems together. It was also one of my most productive periods as a developer, where I built a lot of side-projects that would ultimately be one of the reasons why I could get into Google.
There’s a confluence of things that have happened recently that have made me question how browsers might be developed:
- On January 8th 2026, Simon Willison predicted that someone will build a browser using mainly AI-assisted tools within 3 years
- On January 27th 2026, one human and one agent built a browser from scratch (great experiments)
- On the 19th February 2026, news came out that Taalas had a chip that can spit out nearly 17,000 tokens per second by baking a model onto the chip.
I would like to indulge in a little bit of projection and in my case, some science fiction of my own.
Knowing what is happening in the web development ecosystem is a critical part of my job in Chrome DevRel, so every Monday morning I get emails telling me what happened last week in Chinese web development; the state of Passkeys; WASM; HTML-in-Canvas; the Prompt API; AI Coding tools; OpenClaw, and many other topics I’m tracking. For a lot of what I’m tracking there are no newsletters or ecosystem-experts that publish this information, so pulling it together manually is a huge lift. I took the ideas and agent-loop in “The prompt is the program” and brought it into reality with a tool called emaila.gent. You create your own agent by emailing it and it will adapt to what you need. I mostly send it newsletters and ask it to track the concepts and topics mentioned in them, and that’s how I get my emails. It’s 99% the same as the Journal in “the prompt is the program”.
One day the web will have a federated way to link to functionality. I swear we will.
For those who know me, you can tell that I’ve been thinking about Web Intents again… a lot.
If you don’t know me, Web Intents was a 2012 attempt to give the web a vocabulary for “I want to do X, what site can help me?”. Share, edit, pick, save-for-later, buy. And a way for sites to ask for a link to a site that matched their intent. It was basically Android Intents for the web. It got pulled. I’ve written about what happened to Web Intents and again when I was reinventing Web Intents.
In early January 2026 I was listening to Transistor Radio, the Semi-Analysis podcast, where Doug O’Laughlin was talking about how good Claude Code had become. I follow a lot of analysis sites covering what’s happening in LLMs, Ben Thompson, Semi-Analysis, and others, and this one stuck with me. Then in February they published “Claude Code is the Inflection Point”, showing you could track AI coding tool usage through Co-Authored-By trailers in commit messages. I wanted to see the numbers for myself, so I built scripts to pull data from GitHub’s search API across every AI coding tool I could find: commits, PRs created, PR interactions, and issue comments.
Two conversations have been rattling around in my head this month, and they frame the same question from completely opposite directions.
The first is Steve Yegge on The Pragmatic Engineer podcast with Gergely Orosz. Steve’s argument is blunt. Every company has a dial, and he puts it like this: “Everybody has a dial that they get to turn from zero to 100. And you can keep your hand off the dial, but it just has a default setting of what percentage of your engineers you need to get rid of in order to pay for the rest of them to have AI. Because they’re all starting to spend their own salaries in tokens.” He thinks the dial is being set at about 50. Half the workforce gets cut to fund AI for the remaining half. And as he points out, “half your engineers don’t want to prompt anyway, and they’re ready to quit.”
When I was at Liverpool John Moores University studying software engineering, my best friend Jon pulled me aside and told me I had a verbal tick. Instead of saying “um” or “uh” between words, I was saying “f***ing.” Three or four times a sentence. I was doing it in normal conversation with friends, with people I’d just met, even with lecturers. I had absolutely no idea. Once he pointed it out, I started trying to listen to myself as I spoke. I’d slow down, really concentrate on not swearing, not dropping in filler words. It was hard, but I think it improved the way I communicated. Over the years since university, I always wanted to push myself a little more, and doing public presentations was a way that helped me improve how I communicated, which ultimately led me to finding my way into developer relations.
I built an application recently. It has a contact directory, a database, cross-referencing, topic tracking, meeting notes, project management, backup and restore, automated sync, conflict resolution, and a task queue. The entire program is a markdown file.
It’s just a CLAUDE.md file. It sits in a git repo with some bash scripts for plumbing, but the actual behaviour (what the system does, how it organises data, when it evolves) lives in natural language instructions. The prompt is the program.
NotebookLM is one of my favorite applications in decades. If you haven’t experienced it before, it’s an application that lets you pull in sources from all around - Google Drive, PDFs, public links - collate them into a notebook, and then query or transform that content. Want to turn five research papers into a podcast? Done. Need to extract key takeaways from a collection of articles? Easy. It’s a fundamentally different way of interacting with information that wasn’t possible before large language models.
I got hooked on Claude Code over the holiday break and used it to create a number of small projects in record time. The CLI works well, and claude.ai/code has a really nice way of just firing off tasks and then reviewing them when done. The model has enabled me to create and ship a lot of personal projects that I’ve always wanted to build (I will talk about my process in a later post, as I think software development is changing very quickly with CLIs like Gemini and Claude). For example, I created a Chrome Extension that works like NotebookLM but uses your active Tab as the source material, and another that transcribes and transforms my voice to insert directly into text boxes. This efficiency allowed me to rip through a backlog of ideas.
It’s been nearly 9 months since I started this blog and I feel that while I kept up a good pace of articles and I’ve dived deeper in to my thoughts on the intersection of web and AI (specifically LLMs), however a lot of what I’ve done is hidden away because they are the things that I’ve been building that help me test my ideas and hypothesis'.
To set some context, I’m the manager and lead of the Chrome Developer Relations team. My day job is to help my team be successful (they are successful when they help developers build amazing websites and help the web to thrive). Up until 2024 I’d been personally very pessimistic about the health and future of the Web. The platform is competing against mobile platforms (specifically Apps) and the platforms defined by those Apps (Facebook, Instagram, TikTok) and not really succeeding. These new platforms made it even easier to share ideas and content, and the general thought was that all use of computing by the billions of people on the planet will move to these new platforms and you could see and feel this slow decline of the web.
I fondly remember sitting with my friend Chris learning how to make HTTP requests so that we more quickly check if our web pages were rendering as we expected without the need to load the browser.
We would use:
c:\telnet.exe pcbware.com 80
Then blindly type:
GET /index.shtml HTTP/1.0
The keys I typed weren’t echoed back to me, but if we got it right it would return:
200 OK
Content-Type: text/html
<! .......
Huh. What’s Content-Type?
I remember my early days building for the web. We had no separation of concerns. We used <font> and <center> tags, transparent spacer.gifs, and complex table layouts to force our content into a shape. Presentation and content were a single, messy soup.
My first encounter with CSS in Netscape Navigator 4 was a mind-blowing moment. It was the first time I was confronted with the idea that you could (and should) separate the document’s structure (HTML) from its presentation (CSS).
These are my opinions and are ruminations on what might be happening as more and more developers use LLMs and Frameworks to build on the web.
In October last year I wrote “will developers care about frameworks in the future?” predicting that LLMs would abstract away framework choice. I was wrong—or at least, wrong about the timeline.
The reality is more interesting and more permanent: React isn’t competing with other frameworks anymore. React has become the platform. And if you’re building a new framework, library or browser feature today, you need to understand that you’re not just competing with React—you’re competing against a self-reinforcing feedback loop between LLM training data, system prompts, and developer output that makes displacing React functionally impossible.
This is a very quick post. I had an idea as I was walking the dog this evening, and I wanted to build a functioning demo and write about it within a couple of hours.
While the post and idea started this evening, the genesis of the idea has been brewing for a while and goes back over a year to August 2024, when I wrote about being sucked into a virtual internet. WebSim has been on my mind for a while, because I loved the idea of being able to simulate my own version of the web using the browser directly and not via another web page. And a couple of weeks ago, I managed to work out how to get Puppeteer to intercept requests and respond with content generated via an LLM.
The thing about the web is that you don’t know what is on the other end of a link. And yet, we happily click and tab on these blue, underlined pieces of text that could then run practically anything within the confines of that little tabbed rectangle. It’s an incredible thing to be able to deliver and run code that is unknown and unseen by the user. Imagine a world where instead of links, you had to visit a store, look at reviews and screenshots, and then install some software before it could be run. Pffft. What are we? Mobile platforms?
I was introduced to the concept of the Memex after my post about super-apps. It’s a fascinating view of the future from the late 1940s and early 1950s. Vannevar Bush presented a vision of an information system that he named the Memex. Ignoring the heavily gendered language and technology that were firmly set in their time (microfilm), “As We May Think,” the article that introduced the Memex, was a fabulous read that I encourage everyone to explore.
As much as I struggle with on-device processing and the quality of its output compared to server models, I am excited by some of the APIs that are being built into browsers that are backed by LLMs and other AI inference models.
For example, the prompt API, along with a multi-modal version that can take any arbitrary combination of text, image, and audio and run prompts against them. These APIs are neat but not yet web-exposed and many developers struggle to know what to do with a generic prompt. It’s not a solution that is natural to many people yet.
When I moved to North Wales I noticed how many of the local businesses were solely on Facebook and Instagram. I spoke to some of them to ask why they don’t have a site and it came down to four common issues 1) cost, 2) built in network, 3) skill, and 4) time. It’s hard to beat free, good enough, and access to a network of potential customers. At the same time nearly everyone that I spoke to knew it wasn’t a perfect situation and they wouldn’t say ’no’ to their own independent presence.
17 years ago I discovered Google App Engine. It was the first truly scalable “serverless” platform that I had ever seen. I could just write an HTTP handler and it would scale to meet the demand.
It was also the first time in computing where I experienced a direct relationship with the cost of my code running. Prior to this every service I built was compartmentalized to a physical server. I was used to building software and algorithms for this model. Database contention, process contention, C10k, etc, were all things that I had to plan for. Yes, we developed your algorithms to avoid those problems, but we tended to scale by estimating the total QPS per box and when you hit a limit you would just buy another box and stick it in the rack.
The web browser is such an amazing concept. From the very first moment I used one, right up until today. You type in a URL and you can have something run on the server and then displayed in the browser. It got me hooked in 95, and keeps me hooked today. Back in the day, Perl was my jam. I loved to create login systems, e-commerce sites, email hosting providers. You name it, I could get the server to mash out HTML like nobody’s business.
AI assisted programming is becoming more and more frequent amongst developers. Its usage ranges from asking AI tools like Gemini and pasting answers into the IDE, to using AI as a glorified auto complete, to full on vibe coding, delegating most of the code written to AI agents.
Models are getting more capable and, but still not perfect. Developers are still ultimately responsible for the code produced, and should review it before publishing to avoid nasty surprises like leaking API keys. But it’s amazing to see how models like Gemini 2.5 Pro are capable of building entire (even if reasonably simple) web applications from a one shot prompt, like this example where my prompt was Build a force directed graph demo.
No, not that one. The E in SLICE is for embedding content…. Oh wait, that E was for ephemeral. Hmm, never mind. I guess this is the other E which is actually the C in SLICE. “Composable”. After linking composability is one of the most critical features of the medium that is the web. It’s the only platform that I know of that enables expression by integrating live content from nearly any other site or service directly into the UI. Yes, we have APIs, but it’s the <iframe> and <embed> that have helped to make the web unique.
Paul Kinlan recently wrote about how latency of AI models to generate UIs with HTML, CSS and JavaScript is decreasing significantly, and how that can lead to user UIs that are ephemeral, dynamically generated, and specialized to the user need at hand.
To me, the direction of travel is clear. UI generation to service user-goals is going to happen.
Combining this with Model Context Protocol (MCP) has got me thinking about the good old site mashups, and how AI agents can unleash a new, modernized version of them. If you haven’t heard about mashups before, here’s what Gemini has to say about them:
I spent an evening in a fictitious web. The faux-browser window hosted at WebSim.ai gave me a view into a virtual world that didn’t exist, but one that felt like it did. Every page that I visited was created in the moment that I requested it, willed into existence by a generative AI model.
It was like the early days of the web. Every page felt fresh and unique. Some were high quality, some were low-fi. All were incredibly slow to load. I was on a dial-up connection in 2024. Even when my college’s shared connection in ‘98 was on a slow leased line, sites frequently took minutes to load, but at the time it didn’t matter, I had this new world to explore.
I’ll keep playing here while the rest of you flirt with apps. I’ll be here when you come back. I know it’s going to happen. Here’s why.
Linking.
Dave Winer - 2011
The web has a lot going for it. We coined the term SLICE (Secure, Linkable, Indexable, Composable, and Ephemeral) to describe its benefits, but at its purest essence the hyperlink is the thing that makes the web the web. It’s a thing of beauty. It’s why I fell in love with the Web. Click. Something new! It’s why I still love the web and it’s the thing that is unique to the medium because the web platform in a lot of cases has a thing at the end of it, yes there is link-rot, but you don’t have to install anything to get it running.
I’ve spent two weeks in April wandering around Japan with my wife, daughter and parents - it was incredible. I used a browser twice. Most of the time that I spent with my phone wasn’t on the web or in traditional apps, it was in a LLM.
I would give the LLM photos of packets of food and ask what it is and it would handily tell me the brand, and then I could follow up and with a photo of the back of the packet and ask if there was milk in it (my daughter can’t drink milk), and it would explain the ingredients and potential allergens…. Given my non-existent ability to read Japanese I had to trust the LLM.
I remember the exact moments when major transitions in my life happened. The first time I got a BASIC program working. The first time someone used one of my programs. My first email. The first time I visited a website. The first time I made a website. The first time I saw my future wife. The first time I held each of my children.
In each of these moments, I knew things changed and at the same time I had no comprehension of how they would change the direction of my life. It is like there was a fog in front of me, I could see vague outlines of things.