A huge weekend reading from Web Directions
This week we have almost certainly the biggest roundup of articles ever in a Weekend Reading–going all the way back to about 2006.
We also announced a significant number of speakers for AI Engineer across all tracks. This one is selling fast, so start planning now!
And while it’s still a bit further off, at the end of August, we’ve announced our first UX Australia keynote speaker too.
But for now, on with this week’s huge round up of reading.
The Software Development Lifecycle in Transition
The Software Development Lifecycle Is Dead
AI agents didn't make the SDLC faster. They killed it.
I imagine this piece will get quite a bit of pushback from a lot of software engineers who will argue that while this approach might be fine for greenfield projects, for small teams or individuals building something unencumbered by years or decades of existing coding systems, it's not true of larger, more complex systems, particularly long-standing ones.
Perhaps we'll see a bifurcation of existing systems — let's call them legacy systems — which will move toward maintenance mode, and greenfield systems built from day one with agentic programming at their heart.
Perhaps agentic programming will in time take over the maintenance and development of large existing systems. I think it's far too early to say. But I think perspectives like this are important whether you agree with them or not, because they can help shape your own reasoning about the work that you do and the systems you're responsible for.
A Sneak Preview Behind an Embedded Software Factory
Latent Patterns builds Latent patterns. I've taken some of the ideas behind "The Weaving Loom" and inverted them, put them into the product itself and have perhaps accidentally created a better Lovable. It's interesting because I see all these developer tooling companies building for the persona of developers, but to me, that persona no longer exists. You see, within latent patterns, the product (latent patterns) is now the IDE. If I want to make a change to something, I pop on designer mode, and this allows me to develop LP in LP. I can make changes to the copy or completely change the application's functionality using the designer substrate directly from within the product, then click the launch agent to ship.
Geoff Huntley, who is very much at the forefront of exploring the deeper impact of agentic coding systems on software engineering practice, thinks that
[he] might retire most developer practices, including CI/CD.
I think he's on to something. I think all the practices of software engineering that we have developed over the last nearly 60 years — let's say since the software engineering crisis of the late 60s — are now contingent. And it doesn't mean they're wrong, but we need to recognise that they emerged in a certain environment where certain things were scarce. There was a high coordination cost of having multiple people working on the same codebase, and as agentic systems become increasingly capable, those costs shift, and so the practices we developed to manage them need to be reconsidered.
I'll actually go a step further. I think Geoff isn't, perhaps, sufficiently ambitious here because he still imagines a world of software, of applications. And I have a growing inclination that where we're going we won't need applications.
Rapid Application Development Is Back
Every second counts; even sixty seconds for CI/CD is too long. The natural destination from here for @latentpatterns is live editing programming memory. Sure, I could move content from the file system to the database.
Back in the 90s, it was not at all uncommon to simply what we would now call deploy to production via FTP. We would update our HTML, our CSS, maybe a little bit of JavaScript or PHP, and then simply YOLO it (the acronym didn't then exist) to our FTP server, where it was live in production.
Over the last 30 years or so we've become a bit more circumspect about this, in no small part because what we build has become increasingly complex, and our local environments have become further and further distinct from our production environments.
Here, though, Geoff Huntley of Ralph Wiggum fame is arguing perhaps we are returning to an era of deploying to production as rapid development becomes a thing once more.
Write-Only Code
Six months ago, if you had asked me how much production code would eventually be written by AI, I would have claimed a large percentage. LLMs are clearly a massive productivity boost for software developers, and the value of humans manually translating intent into lines of code is rapidly depreciating. I also believed, and still do, that humans whose primary job is to build and operate enterprise software are not going anywhere, even as their day-to-day work is fundamentally redefined by this newest abstraction.
Source: Write-Only Code – Heavybit
This is a few weeks old now. It seems almost like ancient history. But it's one of the first things I've read which started to articulate the idea that increasingly software engineers may not even be reading the code that we are responsible for.
Agentic Engineering Practice
The 8 Levels of Agentic Engineering
AI's coding ability is outpacing our ability to wield it effectively. That's why all the SWE-bench score maxxing isn't syncing with the productivity metrics engineering leadership actually cares about. When Anthropic's team ships a product like Cowork in 10 days and another team can't move past a broken POC using the same models, the difference is that one team has closed the gap between capability and practice and the other hasn't.
Way back in the dark ages of October 2025, Guy Podjarny at TESSL used the model of autonomous driving and its five levels to articulate five levels of agentic coding.
Well, stand back because Bassim Eledath now identifies eight levels of agentic engineering.
I Built a Programming Language Using Claude Code
Over the course of four weeks in January and February, I built a new programming language using Claude Code. I named it Cutlet after my cat. It's completely legal to do that. You can find the source code on GitHub, along with build instructions and example programs.
Geoff Huntley, the discoverer of the Ralph Wiggum technique, used that approach — or indeed discovered that approach — while developing a programming language he called Cursed.
Over the last couple of months Ankur Sethi developed his own, probably somewhat less cursed programming language. And here he writes about his experience with that and broader experience working with large language models.
Design-First Collaboration
When I pair program with a colleague on something complex, we don't start at the keyboard. We go to the whiteboard. We sketch components, debate data flow, argue about boundaries. We align on what the system needs to do before discussing how to build it. Only after this alignment — sometimes quick, sometimes extended — do we sit down and write code. The whiteboarding is not overhead. It is where the real thinking happens, and it is what makes the subsequent code right. The principle is simple: whiteboard before keyboard.
Rahul Garg outlines an approach to working with LLMs that puts an emphasis on upfront collaboration to ensure the best possible design before handing responsibility to an agentic coding system to implement that design.
Humans and Agents in Software Engineering Loops
We need to adopt classic "shift left" thinking. Once upon a time we wrote all of our code, passed it to a QA team to test, and then tried to fix enough bugs to ship a release. Then we discovered that when developers write and run tests as we work we find and fix issues right away, which makes the whole process faster and more reliable.
Kief Morris advocates we adopt shift-left thinking when it comes to AI-assisted software engineering. The "why" loop is something for humans, while the "how" loop is something for agentic systems to focus on.
Start Where You Are: A Practical Guide to Building with AI
Here's the thing I want to emphasize, though: this is a really good time to get good at this. The best practices for building with AI haven't been written yet. Builders like you and me get to write them. This is an incredible time to jump in and be part of the story that figures this whole thing out.
Brittany Ellich, an experienced software engineer, talks about her approach to working with agentic coding systems. Always really good tips and lessons to pick up when people share their workflows like this.
3 Principles for Designing Agent Skills
Skills are an open standard supported by most major AI coding tools: Claude Code, Goose, Cursor, Amp, GitHub Copilot, Gemini CLI, VS Code, and many more.
Here's a good introduction to agent skills from the open-source team at Block.
Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?
Abstract: A widespread practice in software development is to tailor coding agents to repositories using context files, such as AGENTS.md, by either manually or automatically generating them. Although this practice is strongly encouraged by agent developers, there is currently no rigorous investigation into whether such context files are actually effective for real-world tasks. In this work, we study this question and evaluate coding agents' task completion performance in two complementary settings: established SWE-bench tasks from popular repositories, with LLM-generated context files following agent-developer recommendations, and a novel collection of issues from repositories containing developer-committed context files. Across multiple coding agents and LLMs, we find that context files tend to reduce task success rates compared to providing no repository context, while also increasing inference cost by over 20%. Behaviorally, both LLM-generated and developer-provided context files encourage broader exploration (e.g., more thorough testing and file traversal), and coding agents tend to respect their instructions. Ultimately, we conclude that unnecessary requirements from context files make tasks harder, and human-written context files should describe only minimal requirements.
Source: Evaluating AGENTS.md – arXiv
These recent counterintuitive results might give us reason to rethink a very common pattern with agentic coding, which is to provide — via skills and agents markdown files — a whole lot of context for any project. The findings here are that this may actually degrade performance.
The Human Experience of AI-Driven Change
My (Hypothetical) SRECon26 Keynote
Which means it was almost a year ago that Fred Hebert and I were up on stage, delivering the closing keynote at SRECon25.
Charity Majors is a genuine giant in the field of software engineering. One of the originators of modern observability, founder of Honeycomb, author, highly respected speaker.
Here she reflects on her transformation over the last 12 months when it comes to thinking about AI and software engineering. She captures a path that I think many software engineers have trod over the last year. And I think this should be required reading — whether a year ago you were very optimistic and positive about AI and software engineering, or like Charity, far more sceptical.
AI Is Creating an Identity Crisis for Software Engineers
The speed at which AI is reshaping software development — measured in months, not years — is stirring a mix of excitement and anxiety. Last week, the tech company Block laid off more than 40% of its workforce, saying the cuts reflected AI-driven efficiencies.
Annie Vela, who is quoted in this article, wrote "The Software Engineering Identity Crisis" a year ago.
A year ago we ran our first Unconference around the topic of AI and software engineering. At that time, I felt a lot of the participants — very experienced software engineers with years, if not decades, of professional experience — were still more sceptical about AI and software engineering than I expected.
Was that a kind of defence mechanism against this coming challenge to a very important part of our professional identity?
The Human-in-the-Loop Is Tired
I recently had a conversation with my colleague Douwe, who maintains the Pydantic AI framework and has been one of the most thoughtful people I know about integrating LLMs into open source workflows. He described waking up to thirty PRs every morning, each one pulled overnight by someone's AI, and needing to make snap judgment calls on every single one. The temptation to delegate the review itself to an AI was enormous. But, as he put it: "at that point, what am I still doing here?".
I think it's worth reading personal accounts like this and others that we have posted recently of how people are responding as software engineers to the way in which our profession is transforming at an incredibly rapid pace.
I think the anxiety folks are feeling is real and understandable. I think the fatigue, the exhaustion that many are feeling, including me, is real. Seeing other people's responses can perhaps normalise how we might be feeling ourselves.
AI Made Writing Code Easier. It Made Engineering Harder.
AI assistants autocomplete your functions. Agents scaffold entire features. You can describe what you want in plain English and watch working code appear in seconds. The barrier to producing code has never been lower.
If you're a software engineer and feel right now a lot of stress, a lot of anxiety, a lot of uncertainty, rest assured you're very far from alone. Here are some timely thoughts on why software engineering just got a whole lot more challenging.
We Might All Be AI Engineers Now
Everyone knows the models are good now. That's not news. But most people still miss the point. They see AI-generated code, call it slop, and move on. Sure, unguided, it is slop. But guided? The models can write better code than most developers. That's the part people don't want to sit with. When guided. When you know what you want. When you know what architecture to reach for. When you understand the tradeoffs and can articulate them clearly. The game goes on easy mode.
Source: We Might All Be AI Engineers Now
This aligns with my experience and thinking — though the question is, is this for say the next few months or couple of years? Or forever?
Software Engineering Perspectives
When AI Writes Almost All Code, What Happens to Software Engineering?
The bad: declining value of expertise. Prototyping, being a language polyglot or a specialist in a stack are likely to be a lot less valuable, looking ahead.
Source: When AI Writes Almost All Code, What Happens to Software Engineering? – The Pragmatic Engineer
The Pragmatic Engineer is a blog and podcast that many experienced software engineers pay close attention to. Gergely Orosz is a deeply experienced software engineer with a track record at companies like Skype and Uber, who brings that knowledge to bear on the state of software engineering today. Here, a few weeks ago, he reflects on what has been happening since late 2025 in terms of the capabilities of AI when it comes to software engineering.
Owning Code in the Age of AI
Software engineering is going through a shift that feels small on the surface but changes something fundamental: code is no longer scarce.
All software engineers are at some stage of grappling with this question — who owns the code, in essence who is responsible for the code written by agentic systems at our behest?
No answers, just a lot of questions — which is as it should be right now.
Yes, Learning to Code Is Still Valuable
Every few weeks, someone shares a bold opinion: "Don't bother learning to code, AI will do it all." I've seen this from VCs, influencers, and people who have never actually shipped a production system.
Matteo Collina, core contributor to Node.js and prolific open-source developer, argues that it's still valuable to learn how to code.
AI and the Ship of Theseus
Because code gets cheaper and cheaper to write, this includes re-implementations. I mentioned recently that I had an AI port one of my libraries to another language and it ended up choosing a different design for that implementation. In many ways, the functionality was the same, but the path it took to get there was different. The way that port worked was by going via the test suite.
The first-order effects of transformative technologies are the ones we think about first, and the ones that are easiest to make at least some sort of predictions about. It's the second-order effects — the impact on economics, the legal implications — that are much harder to reason about.
That's what Armin Ronacher is doing here when he ponders the implications of increasingly inexpensive code generation, particularly of existing systems based simply on their API, and what consequences that will have in terms of software licensing and intellectual property.
Recommended by LinkedIn
AI Economics & Adoption
Do AI-Enabled Companies Need Fewer People?
About a year ago I made some predictions about the effect of AI on programming jobs. Block laid off 40% of its staff claiming AI made them more efficient. Is that really true or did they just over-hire? Let's look at some data and see what's really happening.
Laurie Voss takes a bit of a deeper look into the impact of AI on employment levels, particularly in technology companies, in the wake of Block's recent layoff of 40% of its staff, claiming that was due to AI efficiencies.
Is that the case?
AI Adoption Has to Be Driven from the Top
While researching my AI strategy book, it became clear that the complexities of data integration and the expense of AI sprawl means AI policies and intentions must be set and communicated from the top. That doesn't mean an AI mandate, but ensuring everyone knows why any AI tool is important to the business.
It's not uncommon to see research suggest that at least enterprise adoption of AI technologies falls far short of the breathless promises we hear from CEOs at their keynotes.
over 80% of firms reporting no impact on either employment or productivity
And yet, at least anecdotally, developers individually report enormous increases in their productivity. So what is going on? And how can organisations adopt these technologies in ways that do deliver on the promises?
At LeadDev, Jennifer Riggins argues "AI adoption has to be driven from the top — not by mandate, but clear leadership and guidance over why AI is being adopted."
Is the AI Compute Crunch Here?
In January I wrote about the coming AI compute crunch. Two months later, I think "coming" was the wrong word.
For all the talk of an AI bubble, which seems to have receded in the last few weeks anyway, what doesn't seem to be factored in is just how much demand there really is for these tokens, this kind of "compute".
Martin Alderson has been tracking how much computational capability there is and the demand for it, and suggests that we've now hit a crunch that is being reflected in downtime for in particular Anthropic, who are clearly undergoing a meteoric increase in demand.
We Are Changing Our Developer Productivity Experiment Design
METR previously published a paper which found the use of AI tools caused a 20% slowdown in completing tasks among experienced open-source developers, using data from February to June 2025.
METR's research last year into open-source developer productivity using AI caused quite a stir because it suggested — or even demonstrated, in many people's opinion — that the uplift in developer productivity that many developers self-reported when using AI-based coding systems was perhaps illusory.
They are returning to this particular area of research, but as with many things, it is more complicated than it originally appeared.
If you're interested in diving more deeply into this, there is a fantastic in-depth conversation between METR's Joel Becker and Shawn Wang at Latent Space recently.
AI & the Broader Picture
Four Observations on AI and Capitalism
These four pieces form a single argument, read in sequence. Each observation builds on the last, moving from diagnosis to possibility.
This series of four short provocations should be recommended reading. So I'm recommending you read them. Each contains what could be several essays in their own right.
A Soft-Landing Manual for the Second Gilded Age
AI is arriving fast, the old economic arrangements are visibly failing, and the dominant narratives about what comes next have split into 2 equally unhelpful camps: utopian accelerationists who believe the market will sort everything out if we build fast enough, and existential doomers who've convinced themselves that the only possible outcome is either human extinction or permanent mass unemployment. Both camps share a singular trait: they've decided the future is already determined and that human agency is irrelevant to whatever happens next.
Joan Westenberg is one of the most thoughtful and knowledgeable people I have ever had the privilege to know. Everything she writes, and she writes voluminously, is worth reading. But this in particular is a standout piece.
I simply recommend when you have a few minutes, you take the chance to read it and sit with how it makes you feel. Perhaps relief from the anxiety you might feel about how AI is upending so much of what we have taken for granted for decades. Perhaps anger and opposition. Sit with that. Ask yourself what about this is challenging to you, what do you believe that it questions.
The world does change — not often, but when it does, that change isn't gradual.
There seems little doubt that we are in the midst of a transformation that hasn't been seen for generations, one which will upend many things we have taken to be foundational to our society and culture. Facing those challenges honestly, including those things we held to be immutable, is the challenge of our time.
Joan holds out hope for what that transformation might bring.
Billion-Parameter Theories
For most of human history, the things we couldn't explain, we called mystical. The movement of stars, the trajectories of projectiles, the behavior of gases. Then, over the course of a few centuries, we pulled these phenomena into the domain of human inquiry. We called it science.
I've long been very interested in complexity theory. It had its moment back in the late 1980s and early 1990s with chaos theory and a very popular science book from James Gleick.
Benoit Mandelbrot, he of the famed Mandelbrot set and one of the originators of the science, was something of a rock star.
In this long but very readable and I found engaging essay, Sean Linehan argues that large language models — attention-based models — are a new science. I highly recommend reading this, even if it's not something you'll apply in your everyday work.
AI Infrastructure & Models
AMI Labs: Real World. Real Intelligence.
Our main goal is to build intelligent systems that understand the real world.
Source: AMI Labs
Yann LeCun is a genuine giant in the field of machine learning and AI who developed techniques that are at the heart of modern machine learning.
Until recently the head of the AI efforts at Meta, he's long expressed scepticism that current large language model-based techniques are a pathway to AGI.
He, like a number of other researchers, believes that world models — models that have a genuine understanding of the world, rather than simply of human language — are that path. And today he announced a new company with a billion dollars in funding to further that work.
Is Harness Engineering Real?
A common debate in my finance days was about the value of the human vs the value of the seat: if a trader made $3m in profits, how much of it was because of her skills, and how much was because of the position/institution/brand she is in, and any generally competent human could have made the same results?
If you work with Anthropic's models or OpenAI's or Google's or other models, particularly as a software engineer, you're almost certainly doing it with an environment like Claude Code or OpenAI's Codex. And the release of Claude Cowork caused quite a stir a few weeks ago.
These harnesses or environments that enable us to work more effectively with models are considered by some to be the secret sauce in the explosion in capability of these kinds of tools in the last few months.
But do they matter that much? Is the work largely being done in the models, or is there something special that can be added by these kinds of harnesses? The folks over at Latent Space reflect on this today.
MCP Is Dead. Long Live the CLI.
I'm going to make a bold claim: MCP is already dying. We may not fully realize it yet, but the signs are there. OpenClaw doesn't support it. Pi doesn't support it. And for good reason.
Source: MCP Is Dead. Long Live the CLI.
For several months last year, MCP seemed to be all the rage when it came to AI engineering. But the last few months have definitely seen a cooling of the enthusiasm. Does that just mean they've become absorbed into people's everyday work? Or are new practices and patterns emerging that minimise their impact?
This piece echoes things I've heard from quite a lot of developers in recent weeks — that they are in effect overkill in many circumstances, and there are more lightweight and better solutions available.
The Illusion of "The Illusion of Thinking"
Very recently (early June 2025), Apple released a paper called The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity. This has been widely understood to demonstrate that reasoning models don't "actually" reason. I do not believe that AI language models are on the path to superintelligence. But I still don't like this paper very much. What does it really show? And what does that mean for how we should think about language models?
Sean Goedecke critiques a widely cited paper from Apple's research team from around a year ago, which questions whether reasoning models actually reason. This critique undermines the central argument of that piece.
A Dream of Spring for Open-Weight LLMs: 10 Architectures from Jan–Feb 2026
In this article, I will walk you through the ten main releases in chronological order, with a focus on the architecture similarities and differences:
Open-weights models, even when very large, offer the prospect of running our own inference locally, saving money, and addressing privacy issues. But are they up to scratch? Here is a detailed overview of 10 high-profile open-weights models in early 2026.
Demystifying Evals for AI Agents
Good evaluations help teams ship AI agents more confidently. Without them, it's easy to get stuck in reactive loops—catching issues only in production, where fixing one failure creates others. Evals make problems and behavioral changes visible before they affect users, and their value compounds over the lifecycle of an agent.
Evals are the key quality assurance technique of working with agentic systems.
Here Anthropic talk about how to work with evals for AI agents.
Becoming a Web AI Practitioner: A Map of the Emerging Stack
I quickly became fascinated with all the latest "Web AI" technologies, such as WebMCP, MCP Apps, MCP-UI, OpenAI's Apps SDK, Google's A2UI, and more. You'll notice that MCP — the Model Context Protocol — is part of the name for some of these new technologies. That's because MCP is a key connective protocol between AI agents and the Web. It allows agents to access web content, tools and services in a structured way.
When we think of AI and LLMs, we essentially think of very large systems running in the cloud that perhaps we access via APIs.
But there's a whole slew of AI technologies that run in the browser, that run on devices. Broadly speaking these have come to be known as Web AI. Here, Richard MacManus gives an overview of the landscape of Web AI.
Design & the Future of the Web
Do Websites Need Pages?
Until now, they'e been the most efficient way we've had to communicate information. But what actually are they?
So close and yet — people as users are still central to this way of seeing. I'll suggest that increasingly not people, but rather agents acting on their behalf, will be the primary audience for web "sites".
AI-First Design Is a Culture Shift, Not a Tooling Upgrade
What interests me is something far less theatrical and far more consequential: how AI fundamentally changes the way product organisations learn. Over the past 6 months, we have invested deeply in AI-first design workflows, not as a side experiment or a hackathon, but as a serious shift in how we build.
Just as the practice of software engineering is undergoing a transformation, so too is design. And just as right now we don't really have answers, just a lot of questions in software engineering, in design people are asking those questions as well. So here are some thoughts about how design practice is transforming now that ostensibly things are easier to make.
Filesystems Are Having a Moment
And here's the thing that makes all of this matter commercially: coding agents make up the majority of actual AI use cases right now. Anthropic is reportedly approaching profitability, and a huge chunk of that is driven by Claude Code, a CLI tool. Not a chatbot. A tool that reads and writes files on your filesystem.
Source: Filesystems Are Having a Moment
Well over a decade ago Scott Jenson opined "mobile apps must die".
Perhaps now they — and indeed all apps — will wither away, and the underlying data, good old-fashioned files, will become central. Apps just a way of interacting with your underlying data.
Accessibility
Can AI Agent Skills Help Developers Ship Accessible Code?
Clear accessibility acceptance criteria have always been one of the most practical ways to help developers ship accessible code. The difficulty has always been finding the right level of detail. What works for one team doesn't always work for the next. A general list sitting in a knowledge base like Confluence sounds good in theory, but in practice, developers often forget to look at it.
Intopia have been exploring how best to work with large language models to produce accessible websites and applications.
Here are some detailed and actionable findings from that research.
History
HyperCard Changed Everything
This video traces the history of Apple's HyperCard from Vannevar Bush's idea of the Memex to the Mother of All Demos to the Xerox PARC Alto to Bill Atkinson, the inventor of HyperCard, who said:
I, like many folks I know in technology, was profoundly influenced by HyperCard — so whether that was you, or you're "hyper what?", have a watch!
