Category
More Front-end Bloggers
77 Sources
- Adam Silver
- Adrian Roselli
- Ahmad Shadeed
- Aleksandr Hovhannisyan
- Ana Rodrigues
- Andy Bell
- Ashley Nolan
- Ben Frain
- Ben McCormick
- Ben Myers
- Better Web Type
- Big Medium
- Bram.us
- Bruce Lawson's personal site
- Chen Hui Jing
- CSS Articles by Temani Afif
- CSS In Real Life
- Dan Davies
- Darek Kay
- Dave Ceddia
- David Bushell
- DigitalA11Y
- DXD
- Eric Portis
- Flavio Copes
- Frontend Masters Blog
- Geoff Graham
- Harry Cresswell
- HeydonWorks
- Hidde's blog
- Jack Franklin
- James Sinclair
- Jeffrey Zeldman Presents
- Jim Fisher’s blog
- Jim Nielsen’s Blog
- Jonnie Hallman
- Josh Comeau's blog
- Julia Evans
- justmarkup
- Kilian Valkhof
- Kitty Giraudel
- Krasimir Tsonev
- localghost
- Manuel Matuzović
- Marius Schulz
- Mark's Dev Blog
- Max Böck
- Max Stoiber's Essays
- Mike Taylor
- Modern Web Development with Chrome
- Monica Dinculescu
- Perishable Press
- Phil Nash
- Piccalilli
- raganwald
- Remote Synthesis
- Rob Dodson
- Robin Osborne
- Robin Wieruch
- Ryan Mulligan
- Salma Alam-Naylor
- Samuel Kraft
- Sarah Fossheim's Blog
- Scott Hanselman's Blog
- Scott O’Hara
- Set Studio
- Stéphanie Walter
- Swizec Teller
- swyx
- Tan Li Hau's Blog
- Tania Rascia
- text/plain
- The Code Barbarian
- The Web Witch's Blog
- Thoughts From Eric
- Trys Mudford's Blog
- Zell Liew
Darek KayMore Front-end Bloggersread at source
#0201
A curvy road between trees and a lake leading to the Mount Cook mountain
Flavio CopesMore Front-end Bloggersread at source
A deep dive into Clairic
Extract typed values from text, screenshots, and PDFs with Clairic on Cloudflare Workers AI. Build a Worker and learn how to check the model's answers.
Flavio CopesMore Front-end Bloggersread at source
A deep dive into Inkling 2 Mini
Run Inkling 2 Mini on an Apple silicon Mac, send it a screenshot through Ollama, measure a local request, and see how a looped transformer reuses its layers.
Flavio CopesMore Front-end Bloggersread at source
Resend: the email API I use for my sites, my apps and my AI agents
What Resend does, how I use it to send sign-in links and form emails across my course sites, why I like it, and how to give AI agents email with its MCP server, CLI and skills.
Flavio CopesMore Front-end Bloggersread at source
Turn on automatic security updates on your VPS (and decide about auto-reboot)
Set up unattended-upgrades on Ubuntu and Debian, tested on a real Droplet with the November 2026 NGINX HTTP/2 fix: security-only vs all packages, auto-reboot, needrestart, third-party repos, logs and alerts.
Flavio CopesMore Front-end Bloggersread at source
Finishing is a skill
How I get things done: the three states every project is in, why everything I ship is version one, the seven-day rule, why I ship lots of small experiments, and why deleting or automating something counts as finishing it.
Frontend Masters BlogMore Front-end Bloggers8 min read
Apps I’ve Vibe-Coded Lately That Are Pretty Damn Useful To Me, Actually
Hey, we can all vibe code. But sometimes what you need are ideas that are actually useful.
Jeffrey Zeldman PresentsMore Front-end Bloggers1 min read
Snow White, 2008–2026
Our family had sixteen unforgettable years with this magical, majestic, queenly feline. The post Snow White, 2008–2026 appeared first on Jeffrey Zeldman Presents .
Flavio CopesMore Front-end Bloggersread at source
How to thrive in the agentic AI era
Agents made producing things cheap. What's scarce now is judgment, trust and knowing what done looks like. What that means for developers, professionals, prosumers and small business owners.
Flavio CopesMore Front-end Bloggersread at source
Cloudflare Browser Run: headless Chrome for AI agents and web apps
What Cloudflare Browser Run is, the problem it solves, and how to use Quick Actions, Puppeteer sessions, CDP and MCP for AI agents and web apps.
Flavio CopesMore Front-end Bloggersread at source
AI model names explained: Luna, Haiku, Hydrogen and the rest
OpenAI, Anthropic and Google each name their models by size. Here is which name is small, medium, large and largest, what the IDs mean, and how versions move.
Ana RodriguesMore Front-end Bloggers1 min read
A new talk in my pocket
Earlier this year, Pawel from NN1 Dev Club sent me a message inviting me to do a talk. According to him, the topic was simple: “whatever excites you at the moment”. This invitation came around the time I was having a big girl cry over an article that was going viral, claiming…
PiccalilliMore Front-end Bloggersread at source
The Index: Issue #207
When everything has changed, what do we do next? This is a message to managers and decision makers who are mandating their staff to use AI all day with a warning: you're burning your staff out and setting yourself up for long term problems unless you get back to investing in their skills and satisfying their curiosities. The CSS caret-* properties and custom caret accessibility As always, Sara has put an unbelievably in-depth resource together for us. A must read. Tech for good (enough) jobs list Hiring in tech has slowed to a crawl but there is hope still. Jess has gathered a great list of open opportunities at companies who are not horrible and evil. They've put together a very useful spreadsheet system too . What can't I press? A very useful app by Eric to show you what keyboard shortcuts are already claimed by screen readers and apps, for if you're adding key bindings to what you're building. Understanding CSS random() There's been a lot of people talking about how exciting CSS random() is and also plenty mentioning how they're struggling to understand it. Luckily Mat is very good at explaining complex stuff and he's brought a nice design pattern as the context with him too. P.S. this is a fun . Sponsor message Our Black Friday deal is launching on November 23 for two weeks only . We’re announcing it now so you can get the approvals you need from your bosses. The deal is simple: save 50% on every course , including the newly re-worked and updated JavaScript for Everyone . Sign up for updates to get alerted when the deal goes live! Check it out
Bram.usMore Front-end Bloggers12 min read
CodePen Commander — Sync, serve, and build local CodePen 2.0 Pens straight from the CLI
I scratched my own itch (again 😅) and built CodePen Commander — a CLI cdpn command to sync local folders with CodePen 2.0 Pens, deploy them, and manage privacy rules right from the terminal.
Flavio CopesMore Front-end Bloggersread at source
Give your coding agent its own Docker Engine
What Docker’s new direction means for coding agents, from testing a Postgres migration to reviewing an infrastructure change.
Flavio CopesMore Front-end Bloggersread at source
How Vercel Board can be useful for coding agents
How coding agents can claim tasks, recover expired leases, and hand work to one another on Vercel Board, with a local example and two diagrams.
Big MediumMore Front-end Bloggersread at source
Sentient Design @ Design+AI
This talk was the closing keynote at Design + AI conference in Brighton, England, on September 25, 2026. Download mp3 Download slides (PDF) The book Sentient Design (Rosenfeld Media) “Excellent, essential” —Don Norman “What an epic book” —John Maeda Need help? Big Medium provides product strategy, design, and development of intelligent interfaces. Get in touch. In this talk, Josh Clark and Veronika Kindred show how using AI as a design material, not just a production tool, enables designers to create meaningful new experiences that have only now become possible. Sentient Design is the practice of crafting intelligent interfaces, experiences that have the awareness and agency to adapt to users in the moment. These are dashboards that design themselves, apps that manifest on demand, agents that just get it done, and much more. What entirely new kinds of experiences can we create? What dramatic new value can they deliver? Josh and Veronika show examples and bring the receipts. Here’s the lightly edited transcript. Let’s look up from our tools Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Josh There’s a lot of talk right now about tools and process, including on this stage today. And this stuff is important, right? We’ve suddenly got a lot of new tools we can use, and they’re changing how we work, introducing new productivity and efficiency, and changing our roles. And I think all of that stuff is great. But that conversation leaves out something really important. When we talk about tools and process, what’s left out is the product itself: what we actually make and the experience we create. Ultimately, that’s the only thing that matters: What do we put in the hands of our customers, and what happens next? So for this session, let’s look up from our tools . Instead of talking about production, let’s talk about product , about the experiences we can create. We can create experiences that weren’t possible just a few years ago. We’ve been talking about adaptive interfaces and personalization for decades, right? But we suddenly have a technology that makes it all possible. And yet, as an industry, we’ve barely explored experiences beyond text-based chat and agents. We can create experiences that weren’t possible just a few years ago. What happens when you weave intelligence into digital interfaces, into the canvas itself? What becomes possible when the surface of our applications becomes collaborative? That’s what Sentient Design is about. More than generating assets, how do we use AI to create new kinds of experience? Veronika, you want to take us out? Our whoa moment Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Veronika I’m sure everyone in this room had the moment where you saw something that AI was able to do, and you said, Whoa, this is not like what came before. This is doing something I wasn’t able to do before. We’ll get to some more serious examples in a bit, but I want to start by sharing our “whoa moment.” This started with a little toy project that Josh and I created two years ago now. It’s called Sentient Scenes . You can give it a scene like, “the submarine descends.” And it starts to act it out. You could give it another prompt like “HAL 9000” from 2001: A Space Odyssey , and it will change form to act that out, too. So it’s changing its style, its mood, and its behavior based on the intent of the user’s prompt. ( Try it out here. ) There’s even this kind of personality in the square’s motion and the way it acts things out. The colors, the type it chooses, it’s all adapting to the mood of the scene. Like I said, this is just a little toy, but it really cracked something open for us: This is the entire interface adapting to the user’s intent without explicit instructions. Josh Four things really jumped out at us about it: First, it’s an intelligent interface that goes beyond chat. It’s still got an open-ended input, but the way that it responds is not about text, but about a change in the interface itself. Second, it has personality without anthropomorphism. It’s not pretending to be human, but it does have some personality to it, in the way that it moves, the tone that it has. There’s something that feels like intelligence in there, but it’s not human intelligence. Third, it has awareness of context and intent. It not only describes the scene, it becomes the scene . And it does it in a way that reflects mood and emotion, so it’s intuiting more than just what’s in the simple text description. And finally, it’s open-ended within constraints. I think this is the most exciting thing about this era of interaction design: it can take any input and respond in a way that makes sense. But also works within this constraint. It doesn’t turn into some kind of robot fever dream. It’s always this recognizable stage that the actor is on, but the stage dressing changes. We made this a couple of years ago, and of course the technology kept changing. We continue zooming into the future. So Veronika, take us to the future. A world built as you explore it Veronika Yeah, let’s do it! Here we go, the future, exactly as I pictured. Okay, maybe not. This is a painting by a French painter named Eugène Galien-Laloue. He painted this Paris street scene at the turn of the last century, and I think it looks like a cool place to go, so let’s go there, let’s do it. Now we’ve entered Mirage 2, which is a world model that takes an image and a text prompt to create a world on demand. It’s building the world frame by frame as you explore it. So anything not in view hasn’t been invented yet. So we can walk across this street here and explore. We’re inventing whole new city blocks in Paris just by walking in that direction. Until we turn that way, it literally doesn’t exist yet. It’s being conceived in the moment, but still following the rules suggested by that original image. It’s still following the coherent laws and physics of that Paris world… except for that riderless horse we’ve got going. Josh What the hell is on that horse? Veronika Ignore that part. Josh All right. So I mean that’s a pretty impressive technical feat, but I want to draw attention to its implications: the world is created as you explore it, based on your specific actions. So it’s a one-of-a-kind place. Like Veronika was saying: the world is created at the very moment you turn this way or that. It’s a different experience for every person who explores it. It begins the same for everyone, with that same painting of Paris, but it quickly becomes something that is unique to you, this utterly individualized experience that’s mediated by AI, but created by the choices that you make. What if any digital experience worked this way? Veronika What if any digital experience could work this way? This is an interface that bends to you instead of forcing the reverse. It brings you what you need and lets you manifest it in the moment. This is an interface that bends to you instead of forcing the reverse. What if websites were generated this way, invented as you explore them? Instead of climbing through navigation, what if the views that you needed simply came to you? When would that be helpful, and when would it be utterly confusing? How do we make sure it doesn’t feel like a crazy robot fever dream? How do we make it grounded enough to make sense to the user? Josh If it’s a different experience for everybody, when is that helpful and when is that a hassle? How do you share information with people? How do you get back to where you were before when it’s a completely dynamic experience? This shows the dial turned all the way up to 11. What are quieter forms of adaptive interfaces that we can introduce through this awareness of context and intent? LLMs are masters of manner Josh It’s not particularly new to say that LLMs are powerful but weird. And so these observations aren’t going to be new to you. But I want to cast them in the particular light of what it means for experience design. First, fluent in intent. It’s what I was talking about with the Sentient Scenes concept of open-ended input. LLMs are really good at making sense of arbitrary open-ended inputs. They just get what you mean, right? Understanding intent used to be hard; it used to be really brittle. With older versions of Alexa, if you said, “switch the lights on,” instead of “turn the lights on,” you wound up stuck in the dark. Now that’s entirely handled. The systems understand what you mean and can act on it. Next, expert at manner. It means that they’re very good and flexible in their output, too. We know this from using assistants, right? They can adopt the tone and role that you give to them. But it’s also true of the mode or format of communication. They can speak or communicate through video, images, handwriting, or any of the messy ways we communicate as human beings. And across systems, too. So LLMs are very, very flexible in the input that they accept, and also super flexible in the output that they give. The trouble is they’re a little shaky on facts, right? It’s hard to know when you can actually trust them with the truth. How do we take the benefits of LLMs and also treat the weirdness of these things as an asset instead of a liability? A thing that can help with that is this fourth characteristic: They play well with others. They get along with other systems. So you don’t have to trust LLMs with the facts. Instead, you can ground them with RAG databases and MCP servers as other trusted systems. So when you add all this up, it turns out that LLMs are great at presentation. So: we can use LLMs to make design decisions in the moment, according to the systems and guidelines that we create, but leave the facts to other systems. What we get is a really flexible way of communicating that can change interaction mode or content or structure or behavior on the fly—sometimes all of them at once—according to what’s needed and appropriate. So that’s pretty exciting. But it’s also a little bit heady. So we’re gonna bring this down to earth now: Who’s ready for enterprise software? Enterprise software! Veronika Let’s do it! This is Salesforce Generative Canvas . It’s a plugin for Salesforce that assembles dashboards and content based on implicit context—your calendar, for example—or explicit questions. Salesforce Generative Canvas. Here you can see it gathering information related to an upcoming meeting on your calendar. You can also ask it a question like, “What has my team been discussing with this customer?” and it assembles the right information and the right UI to answer the question. Now what’s very cool is it’s using familiar design patterns from the Salesforce design system, and it’s pulling data from the usual Salesforce data sources. It’s not making anything up, just assembling it on the fly. So you get this really custom experience, but all the content is safe and trusted. And so to come back to Josh’s list of LLM attributes, the system inferred the relevant data from the context because it’s fluent in intent . It found the data sources because it played well with others . And it formatted them in the right way because it’s expert at manner . And here we’re kind of sidestepping the whole “shaky on facts” thing by using AI to focus on the presentation rather than the generation of the content itself. Bespoke UI: shape-shifting interfaces Josh We call this the bespoke UI experience pattern. It’s this shape-shifting interface, conceived in real time. Bespoke UI experiences compose their own layout or content or controls. (Sometimes these are called “generative UI,” but there are lots of other kinds of UI and design decisions that can be generated, so we prefer the term “bespoke UI” here.) This is the most “step one” of intelligent interfaces. These experiences, like Veronika was saying, usually have a constrained set of components filled from data from trusted sources. So it’s not making up the UI on the fly; it’s composing it. We let AI make some very simple design decisions about what to assemble in real time. So design systems and best practices, particularly in this bespoke UI experience pattern, become more important than ever. Veronika, you’ve got another example? Veronika More enterprise software! Okay, so now we’re looking at Cisco’s AI Canvas. This is a platform to let you explore network incidents. Cisco’s AI Canvas generates a data-viz dashboard view at right and also collaborates to let you drag new charts from the chat at left. Here we have a specific network incident. I’ve asked the system to troubleshoot the ticket, and the system populates the canvas on the right over here with all of these chart widgets. Each of these widgets is itself interactive, but they’re all design system components that the system has selected to match the relevant context and the relevant content here. So you’re getting a totally bespoke dashboard. We can also follow up and ask questions in the sidebar on the left. “Can you look for a correlation between these metrics?” And it replies not only in text but also in data visualizations. I think this chart is helpful, so I drag it onto the canvas, and the canvas all of a sudden becomes this collaborative surface between me and the system to research and collect the evidence I need to figure out the problem. Guys, what a difference from traditional SaaS software! Normally, I’d have to climb through layers and layers of navigation to find all the content that’s being shown here. Instead, it’s the reverse: the UI comes to me. The intelligent canvas Josh With bespoke UI, the system creates layouts for you: “I think you need this, so here’s a UI for that.” This Cisco AI Canvas offers a glimpse of the intelligent canvas experience pattern. The intelligent canvas goes a step further by manifesting the content you describe or ask for, and then the system and user collaborate to create the interface and content experience. So what we’re seeing here blends the bespoke UI experience generating a dashboard to start, but then blends into an intelligent canvas that becomes collaborative. It’s a pattern that’s really good for exploration and discovery. We’ll look at another example of it in a minute. At our agency, Big Medium, we’ve got three different projects with Fortune 50 companies right now. These are big, complex organizations that have a million different use cases and user scenarios. And over years and years, their applications grow over time to serve all million of those cases. You know what the result looks like: a million different dashboards that you have to find yourself by navigating a horrible, dense information architecture and baroque navigation. These very big, complex companies are typically slow-moving, but we’ve found that they are jumping into these bespoke UI and intelligent canvas patterns very quickly. It’s because they feel the pain and weight of these million dashboards, and these solutions provide a real, immediate way for companies to modernize what has become a really slow and frankly torturous experience for their customers. These patterns let the system bring the interface to the user instead of forcing the reverse. When you really dial up the intelligent canvas even more, you can even manifest applications on demand. Some of this, of course, is becoming more familiar now. You’ve probably encountered this with chat assistants like Claude that let you make an app, and start using and improving it right away. Here, I told Claude that I wanted it to build an Asteroids game that I could play in the browser, and in seconds I was playing it during the chat. Then, you know, I made some additional updates, changed the scoring and the sound effects. And then, of course, I asked it to add zombies; I didn’t even know what that would mean. But then suddenly I had these green asteroids chasing me around, and I was very pleased with myself. On-demand interfaces, disposable software Veronika I also love Claude, and while Josh is playing his Gen X video games, I’m trying to get some real work done. So the other day I was using Claude, and I asked it to check the accessibility contrast between two colors. On its own, it decided to write up its own little application to do the calculation. I didn’t ask for an application, but it created it because it decided it was the best way to answer my request. It didn’t even keep it when it was done. So we’re starting to get these on-demand, in the moment, completely disposable applications. Josh I mean you know what this is, right? Just sort of like sketching out an idea and it becomes real? Yeah, it’s sort of like this guy. Wile E. Coyote tried this all the time: just gonna paint a tunnel on here, try to trick the Road Runner into running into the wall. But it becomes this real tunnel. It’s this magic, intelligent surface that worked for everybody except for poor Coyote, of course. (If I were him, I would sue Acme. I hear that’s in the works. ) Or maybe this guy, anyone? It’s this fundamental fantasy of conjuring what you want just by gesturing at it. Draw or say what you want to make it so. And it’s incredibly satisfying because the thing that you want or need just materializes. Many of us are already using AI to generate experiences as part of our traditional design production. But what happens when you put it directly in front of the user and let AI make those design decisions in real time? That’s the main quality of the intelligent canvas pattern. It can be a literal canvas or it can be sort of a metaphorical one, more like what we saw with Claude. Agents on the canvas Josh Here’s another example of an intelligent canvas. This is an application we’re creating with a client, a company called VIA, to explore data in a visual context. Think Figma or Canva, but for data. Somewhat similar to the Cisco example that we saw, you can ask for information, and it will draw the appropriate visualization on the canvas, an aspect of bespoke UI. But I’m going to show you something different, which is how we visualize an agent experience. You can ask the system for data, including asking it to do complex multi-step tasks: in this case, filling out a form to report energy usage at a facility. And if the system recognizes this as a task that it knows how to do, it will send in an agent to do the work. The agent appears just like another user in a multi-user environment, driving its own cursor on the canvas. If it has trouble, it will ask what to do. In this case, it notes there are three different buildings to analyze; what should it do? I tell it to do just one building. And then I’m following it as it works, in the same way that you would follow another user in Miro or FigJam. But I don’t have to. I could go off and use some other part of the canvas and do my own work. But here I can watch it and see what it’s doing to monitor its progress, and it’s showing its work as it goes. As it gets this data, it can show what it’s analyzing. The animation shows it sort of sniffing at the data as a way to indicate what it’s up to, what it’s processing. And then when it’s done, it generates this PDF. Thanks, see ya, it’s out of here. Then you can go through and see the tasks that it did, look at its reasoning, and of course see the finished result. I think what’s really interesting here, too, is that you can go back and follow its train of thought. This is a literal audit trail that it leaves behind—or any other user leaves as they work. Where did this data come from? What was the logic that got there? I can drill in and see what it’s doing, or continue with new tasks. It’s got those bespoke UI aspects of selecting the right component to display for each kind of data. It’s got collaborative aspects of an intelligent canvas. It’s got an agent that’s going off and just getting it done on its own. This is an intelligent interface that is very much not a chat experience. This is an intelligent interface that is very much not a chat experience. It’s a different kind of interaction model and mental model that we’re creating around the visual exploration of data. So Veronika, I think there’s a lot more to explore here. Sentient Design provides the map Veronika Absolutely. These are just a few examples, and they’re only scratching the surface. We’ve been working this into all of our client work at Big Medium. And of course we’re hardly the only ones doing this, but the work has been pretty unevenly distributed in the industry. It’s been kind of haphazard so far, and there’s really been no uniform vocabulary or framework for what types of experiences to create, or even what those types might be. As we explored this work, we needed a map. We wanted to identify all of the species of intelligent interfaces that we could find, experiences with the awareness and agency to respond to your users in the moment. Josh Friends, it took us two years to explore these intelligent interfaces and their patterns. But I think we cracked it, and we put it into a book. I give you: Sentient Design ! It’s available at all of your favorite booksellers. We hope you enjoy our book. We’ll get back to that map that Veronika mentioned in a moment. But first I want to say I could not have written this book without Veronika. So halfway into this thing, I think it’s probably past time for us to do some introductions. Veronika We might be overdue, honestly. Two generations of interaction design Josh Well, hello. I’m Josh Clark. I lead an agency called Big Medium. I’ve been a product designer and strategist for 30 years, running Big Medium for about 25 of them. I’ve written a bunch of books about user experience for O’Reilly and A Book Apart and now Rosenfeld Media. (I don’t know if I mentioned that we’ve got a new book? Yeah, it’s called Sentient Design ?) So with all this experience, my assumption coming into this era was that I’ve got this UX stuff figured out. I understand product design. But as I’ve worked with machine-generated results, with machine learning, and in the last few years with LLMs, I’ve realized that a lot of those hard-won best practices need revisiting. And that’s where this one comes in. Veronika Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Hi, my name is Veronika Kindred. I’m a designer and researcher at Big Medium with Josh, and I’m a zillennial or elder Gen Z. I grew up in this world beyond static websites: TikTok, Instagram, algorithmic feeds, all those things which have turned out to be so good for our mental health, right? But also in my career, I’m AI native. I started at Big Medium right after ChatGPT ushered in the proliferation of LLMs. And so for all of my career, my work has focused on the design applications of AI. Josh Veronika doesn’t yet have my experience, but she’s also not burdened by it. And so you’re looking at two generations of designers here, and very literally: Veronika is not only my colleague, but also my daughter. I’m very proud of her. (She loves this part of the talk.) For me, working together has been a really productive relationship both personally and professionally because it’s helped me to develop new perspectives about what this new generation of experience design can be. AI is weird. It offers lots of new possibilities and also lots of new problems. And so we need new perspective here. This is a moment we’re figuring out what this is, who it affects. So the way that we’ve always done things has to be revisited—in process, as we’ve been talking about a lot today, but also in interaction design. Why does it have to be that way? The answer has to be better than “because that’s how we’ve always done it.” Across generations, across disciplines, across classes, across all facets of humanity, we need to seek out more perspectives right now—to share, to teach, to let go of orthodoxies. This is an opportunity to revisit everything. Like I said, I couldn’t have written Sentient Design without you, Veronika—or seen it so clearly without your perspective. Veronika I always blush. We do this every time and I always get embarrassed. Josh This is the best dad moment. The Sentient Triangle Josh All of that collaboration let us make the map that we’ve been talking about. And here it is! The Sentient Triangle! The Sentient Triangle defines four essential experience postures of intelligent interfaces: tools, chat, agents, and copilots. The Sentient Triangle is based on the wonderful work of Matt Webb. Thank you, Matt, for all of your help with this. You really unlocked something for us with this, as well as your help with the book. The Sentient Triangle organizes intelligent interface experiences across three attributes: Grounded: how reliable and consistent the experience is Interoperable: not only across systems, but also across formats and modes of communication Radically adaptive: experiences that are conceived and delivered in real time Grounded and interoperable have been a big part of computing for decades. The radically adaptive experiences are what LLMs have unlocked in the strongest way we’ve yet seen. Andreea Tufescu ." target="_blank"> Photo by Andreea Tufescu . Four experience postures Josh As you map these three dimensions, four postures emerge. Postures represent the relationship that the system has to the user. The way that you use the system and the way that it communicates with you is different across all of these. Tools are the most traditional computing experiences. They’re very transactional and controlled: here’s an input, you get an output. Chat is conversational, of course, but it’s not necessarily literal text dialogue. It’s open-ended, turn-based communication with a peer: You say something, it responds, you respond to that, and together you craft a whole meandering journey that is unique to the experience and wasn’t designed as any one happy path. As the user, you have to manage tools and chat. You have to be involved at every step to keep them going. Agents, of course, you delegate to. You tell it what you want to happen, and the agent makes a plan, executes it, decides when it’s done, and if all goes well, comes back with what you’re looking for. Copilots support you. This is a posture that stands by and waits until it can be helpful. Otherwise, it stays out of your way. Spell check is part of the long history of the copilot posture. It’s very quiet and deferential; it says, here’s a little correction that you might consider, take it or not. It’s a background task that is supporting you constantly, ambiently. So you use tools, you talk to chat, you delegate to agents, and you’re supported by copilots. When you go down to a lower altitude in the Sentient Triangle, 14 different experience patterns become visible. Unfortunately, we don’t have time to talk about all of these today, but we’ve already talked about bespoke UI and intelligent canvas. (I don’t know if I mentioned we’ve got a whole book about this, though, friends.) The Sentient Triangle maps 14 experience patterns for intelligent interfaces. But with 14 different experience patterns, there is so much that we can explore. And you can also blend these, like we already saw with the Cisco example blending bespoke UI and intelligent canvas. But they all have a common theme, Veronika. Behavior design and creative direction Veronika Yes, absolutely. Designing these intelligent interfaces is ultimately about behavior design. It’s about teaching the systems to be able to make reliable design and interaction decisions in the moment. The effect is kind of like installing a designer right into everybody’s monitor so that anytime they visit any website, a designer can provide the right experience for the moment. The intelligent interface becomes collaborative between the system and the user. This is delegation, not abdication. This is delegation, not abdication. Designers might not be drawing every single pixel or designing every single interaction. We may not be designing fixed paths anymore, at least not at the level that we’re used to. Instead, we’re setting the system’s goals, its rules of engagement, the tools and interactions it may use, and when it may use them. These still all fall under the designer’s responsibility. You become the creative director who gives the system its brief. Josh Right. AI might be making real-time design decisions, but designers are creating the environment, the machinery that AI will work within, and humans too. In this aspect, it’s not all that different from the work that we’ve always been doing, where we create the interaction model, the mental model, the specific controls and tools that can be used. The new thing is that we’re also teaching AI to use, manipulate, or present content and interaction within that specific environment. This is behavior design, right? Interaction design has always been about behavior design—traditionally the design of user behavior. Now our design decisions define system behavior. And system behavior determines the experience. What we’re getting at is teaching systems autonomous behavior. That’s agentic behavior, so let’s talk a little bit about agents, Veronika. Agents and the manager experience Veronika Yeah, let’s do it. We already saw an agent at work in that VIA example we showed earlier. The point of agents is that you can delegate to them. You give them the mission, and then they go and do it. Now some people say that this might mean the end of the interface. “If the agents are doing everything, there’s no interface to show,” they say. Josh, I believe we have a technical term for that? Josh Yeah, let me see, what’s that technical term. Veronika The word is hoo-ha . Josh Right! That is hoo-ha, friends. Veronika We still need transparency and explainability when agents do their work. We do need experience and interface design for agent experiences, but its nature absolutely changes. The consulting firm BCG published a big study recently , and they basically found that people who manage agents intensively report deep cognitive exhaustion. The researchers call it brain fry . You’d think, hey, wait, agents are doing my job for me. It should be easier, not more exhausting. But instead, this group of heavy users of agents reported brain fog, buzzing, headaches, impatience. One of those reasons—and this matters for us here—is the ergonomics of the agent experience. The experience of managing agents has not yet been thoughtfully designed or considered. Josh The user experience gives way to the manager experience. If agents are doing a lot of the tasks that users used to do, we now have to figure out how to manage all those agents doing those tasks. At the moment, that generally consists of reading walls and walls of text going by, effectively watching the console as things happen. The user experience gives way to the manager experience. But even aside from the ergonomics, managing is simply hard. For those of you who have made the transition from independent contributor to manager, you know what I’m talking about. It’s a very different thing to suddenly have to keep track of the missions, tasks, plans, and progress of a whole bunch of people. The same thing is true of dealing with agents. That’s a really different skill, and it takes some new design to help people adapt. It’s just as true in the digital realm as it is in the physical. Veronika, we take this up a lot in the book. (I’m not sure I mentioned it, it’s called Sentient Design .) Veronika Yeah, that’s right. This idea of the manager experience is another area that we lean into. How do we help people manage these agents in intelligent interfaces? In the book we describe five phases of delegation that apply just as much to systems as they do to people. Not all of these phases always require user interaction; it depends on the complexity of the task. The five stages of managing agents (and people, too). These are the transitional seams where support can really be designed with intention: setting the mission; reviewing the plan; monitoring the work; interrupting or redirecting; and reviewing the result. We’ll focus here on monitoring the work. This is the part that the BCG study called out as particularly difficult. Right now the agent experience is overwhelmingly text-based, and managing the detailed communications of agents is just a lot to track as they do their work. The NPC pattern: agents as “just another user” Veronika How could we do that differently? The VIA example that we showed earlier was one example of a method we call the NPC experience pattern . NPC stands for non-player character, a gaming term for a character that’s run by the system rather than by a person. The agent does its work as another user, and you can monitor its work just as you would another user in the system. Josh Here’s another example of the NPC pattern. It’s a Chrome extension called Pointer that works in Google Docs. Here I’ve asked it to review my document for technical accuracy. It goes in and makes suggestions like a colleague or human editor would. I don’t have to go into some separate chat interface. It behaves as an NPC within the rules of the application. You can see the edits that it’s made. It’s doing this as my account, which I think is just a limitation of working as a Google Docs plugin. It would get extra points for making it clear that my robot was doing this work. But as an experience pattern, it’s solid: Instead of going off to some other place, another application or a sidebar to interact with the intelligence, it’s woven into the canvas of the application. It uses familiar “tracked changes” features that human users would use. The NPC pattern brings the intelligent interface into the same tools and channels that human users use. A simple version of that is in chat environments or Slack, where the robot is just present in the channel, posting and replying like human users. And you can make that even richer, as we saw in the earlier VIA intelligent canvas example. Now for something completely different Josh This is a prototype created by designer Filip Havlena to visualize agents—as Sims , basically. The model has lots of tools available to it; some of those tools manipulate the agents’ 3D bodies. And you can spawn new agents and put them to work with more traditional tools like Google Docs. Here you can see it using Google Calendar to create a new calendar event, but you can also use it to do work in word processing documents or spreadsheets too. As it works, you can see its progress puffing away above its head, showing you what the agent is thinking. When it’s finally done, you can see the result in the calendar. It’s a new way to show the agent’s progress. And again, you can just spawn a whole bunch more of these things and put them to work on a whole bunch of tasks all at once. And you can see them doing their work or glaring at you because they resent the crummy tasks that you’re giving them. This is obviously pretty whimsical, and the utility of this would have to be pretty specialized. But it’s worth imagining the potential use of spatially represented agents across a city or some geography. What are the possibilities of representing these things not as a churn of console logs, but actually representing their work in a more direct mental model? Another interesting question is what happens when they run into each other in the wild ? You know, will they get along? Will they compete? Will they ignore each other? Will they start crazy cybersecurity chat channels? Will they hack things? How do we design for this? We still have to figure all that out. But again, it’s ultimately about behavior design. At last, we get to invent again Josh There’s so much to invent and explore here. It’s been 15 years since mobile demanded that we explore new interaction paradigms. And that’s what AI is asking of us now. I think we’re a little rusty at it. The last 10 or 15 years of design innovation have mostly been about design ops. The questions that have dominated our industry have been: How do we work together? How do we do design at scale? How do we create design systems? We have done that at the expense of product innovation. We have had very little focus as an industry on new interaction design, new product design. At last, that’s the work ahead of us now. The opportunity and responsibility is to explore this new material and discover the truly new and meaningful experiences we can create. We get to invent again. It’s not the material or the tool that makes us designers. It’s our creativity and judgment and ability to understand the problems and people deeply. The work is not AI. The work is pointing AI at problems worth solving, imagining experiences that weren’t possible before that can answer those problems better than anything that we’ve had before. What are the thorny problems that intelligent interfaces can uniquely solve? The work is not AI. The work is pointing AI at problems worth solving. Let’s not do this for novelty, or because the market says “we need an AI solution.” Ask: How do we help people? How do we make their lives better? That is what designers do when we’re working at our best. These are design questions, and these are fun, hard questions to solve. Friends, I am excited. Can you tell that I am excited? I’m even excited about enterprise software. This is a rare moment that we have here. In my 30 years of doing this, this is the most excited and creative that I’ve felt as a designer. You are needed more than ever Josh I invite you to approach that excitement and enthusiasm with real thought and intention. All of us here, the people right here in this room, we have real influence and agency over how this rolls out. If we don’t decide the best way to use this strange and powerful technology, then the technology will decide for us—or the billionaires. The future should not be self-driving. This technology is being shaped right now, and so is its application. How it is used is up to us. We have this astonishing new design material that can really elevate our craft. There’s a lot of conversation about how to use AI to bring more productivity and speed to our craft. I think that’s important and useful. But in the rush to grind out new efficiencies, let’s not lose sight of the fact that we have real creative power with this material to create significant, meaningful value for our customers and for the businesses that we serve. Those creative opportunities are huge. They can elevate design—and designers!—if we do it right. That is up to you. You have the tools and this new technology, of course, but more important, you have the creative material right now—today!—to make something amazing. So Veronika and I invite you to please do that, friends. Make something amazing. Thanks a lot. Veronika Thank you, guys, so much. Thank you. We can help you. Big Medium helps solve complex problems with intelligent interfaces. Our Sentient Design practice includes product strategy and product design engagements, workshops, and Sentient Design sprints. Get in touch to learn more.
David BushellMore Front-end Bloggers5 min read
Where we’re going, we don’t need chatbots
“You’ve been working hard, why not take a weekend vacation!” Your chatbot says, after a 72 hour unattended session. It says that New York is nice this time of year. You ask it to book the cheapest flights. Half the airlines respond with a 429 code because your residential IP is part of five botnets. […]
Flavio CopesMore Front-end Bloggersread at source
Gemini 4 Neon: I tested it against Opus 5.5
Gemini 4 Neon is the middle model of the Gemini 4 family. I ran it on two coding tasks, a writing task and a 100k-token search against Opus 5.5 and Gemini 4 Carbon, with real costs.
Perishable PressMore Front-end Bloggers1 min read
Chrome AI Features Wasting Much Bandwidth
🔎 Finally solved the mystery. At some point this year (around a few months ago), my bandwidth/data usage went thru the roof. Figured out it was Chrome’s recent AI features. Then got immediate bandwidth-relief after disabling all the “AI innovations” and “On-device” stuff. Here is a screenshot of the settings: Find the Chrome AI settings under “AI innovations” I simply disabled everything on that settings page, and the needless bandwidth leakage stopped immediately. Don’t take my word for it. Fire […]
Frontend Masters BlogMore Front-end Bloggers6 min read
5 CSS Values for Easier Text Styling
Sometimes picking the right value matters more than picking the right property. Here are five CSS values (unset, AccentColor, ch, from, and revert-layer) that take a lot of the work out of styling text.
Jim Nielsen’s BlogMore Front-end Bloggersread at source
Email Dumpster Diving
Sometimes, for fun, I like to go rummage around in my email’s Spam folder. Why? Who knows (probably a question for a licensed medical professional). I think there’s some part of me that chases the dopamine hit of finding a “needle in the haystack”: an email flagged as spam that shouldn’t be (which almost never happens, so I guess this behavior falls under the label of addictive/impulsive seeking). I think there’s also a part of me that enjoys keeping a finger on the pulse of scam tactics, like “Let’s see how people are trying to trick me today…” Almost like a form of inoculation: deliberate exposure to scam tactics in a controlled environment. It helps me develop an immunity, which comes in handy when family members come to me with their emails and ask, “Is this legit?” Here’s a little exposure to what I’ve seen recently. First: I see a lot of emails that exploit the way cloud services bill us. For example: “You’ve hit your limits! Better log in or you’ll lose access!” Or, “Your credit card has expired. Better log in and enter your new credit card so you can keep doing what you’re doing.” (Note the little green banner at the top — “This message was sent from a trusted sender.” A kind of “Why would I deceive you?” ) These emails are interesting not only as an exercise in analyzing scam tactics, but also as a meta-commentary on legitimate software use cases. For example, isn’t it interesting how difficult it can be to distinguish scammer tactics from legitimate software company practices? “Hey, you better give us your credit card or you’ll lose access to your thing!” That’s what ransomware is; it’s also what SaaS is, lol. It’s kinda funny, yeah? No, just me? Ok, I digress. Next email. This is an interesting one. Usually phishing emails are pretty overt in their intentions: click this big button and get taken to a page where you do what we want, e.g. enter sensitive info like a password or credit card. (Again, interesting that legitimate marketing teams follow the same strategy lol. It’s called a “CTA”: click here and do what we want.) In this case, however, the email claims to be from a “Gina Rinehart” and tries to establish credibility by saying, “Look I’m a real person! Here’s a link to my Wikipedia page.” No CTA to a sus web page here at all. I do wonder what would happen if I emailed back. I’m sure somewhere down that road is a solicitation for my bank info or the like. I’d love to mess with them, but I got better things to do with my time (like write this blog post). Ok, last email. I came across this one in my Spam folder: “Oh interesting,” I thought. “Somebody is trying to ride the Trump Accounts initiative from the current administration and trick folks into divulging sensitive information.” Makes sense. Totally plausible vector for attack. But then as I do my email forensics (examine where the links point to, inspect the sender, etc.) I find something surprising: Turns out, service.govdelivery.com is a legitimate domain and irs@ service.govdelivery.com is listed on the IRS’ website as the official sender for their bulletins. (The email headers check out too.) On top of that, the CTAs in the email all point to officially sanctioned websites, App Store apps, etc. In other words: this is actually a legitimate email from the United States Government that was flagged as Spam in Gmail, lol. And there it is: my needle in the haystack. The dopamine hit I need to continue with this ridiculous, fun, and informative habit. Reply via: Email · Mastodon · Bluesky
Kilian ValkhofMore Front-end Bloggers1 min read
State of HTML results
The 2026 State of HTML survey results are out, and I’ve been reading through them with much interest. I do that every year, but this year especially because I got asked to write the conclusion! What makes the State of HTML interesting is that it’s more broadly the state of the “platform”. Much of browser […] The post State of HTML results first appeared on Kilian Valkhof .
PiccalilliMore Front-end Bloggersread at source
Understanding CSS random()
One develops a certain degree of muscle memory putting together an in-depth course on JavaScript's arcane workings . That's why a particularly keen-eyed reader might notice that the posts on my own blog have started shamelessly copying taking inspiration from features that you'll see here on Piccalilli. These little margin notes, for example. In the earliest drafts of JavaScript for Everyone I was using Piccalilli's component to solve for a specific problem that I ran into almost immediately: JavaScript is made out of JavaScript, and you can't cover almost any topic or syntax without touching on dozens of other topics and syntaxes. When I found myself backed into a corner by terminology and concepts related to the topic at hand that we hadn't yet covered, I would use a side note to call it out — a way to keep from littering every lesson's prose with " which we'll cover later "s and " don't worry about this yet "s: As tends to happen with any feature, the more I found myself settling into the project, the looser the use case for these little components became: ...And owing to a condition that I call The Speedrunner's Temperament , I inevitably ended up using them to play with the boundaries of the medium a little bit, just to see what I could get away with: I ended up really missing these little widgets when I'd be writing for my own site, so I used a little bit of my downtime this week to steal take inspiration from them. The core of it ends up bring a relatively light lift, thanks to grid layout and a quick Eleventy shortcode that parses a supplied string as Markdown and returns the result wrapped in . I use "hand-scribbled" accents for notation on my website, so I carried that sort of design treatment over to these as well: Good start, but anything worth doing is worth doing to ludicrous excess, I always say: a subtle application of animation-timeline: view() makes them fade in and scale up ever-so-slightly as they approached the center of the viewport, by a slightly different scale() factor across breakpoints. That had things looking pretty sharp, but arguably a little too sharp — these were meant to be "scribbled in the margins" both tonally and in terms of presentation, and a perfectly squared span of text wasn't quite getting that across. Easy enough to put a quick transform: rotate(2deg) on there too, but that would still give me a uniform result throughout the page: What I needed was some old fashioned, organic-style jank , and that gave me the perfect excuse to finally try out the brand new random() CSS function. In its most basic form random() accepts a pair of comma-separated values that will act as the lower and upper bounds for the random value that will result, and an optional third value defining the step — the intervals between those limits. random( 0px, 10px ) will result in an arbitrary pixel value between 0 and 10, while random( 0px, 10px, 5px ) will result in 0, 5, or 10. Nothin' to it, at face value. transform: rotate( random( -2.5deg, 2.5deg ) ) suited my needs just fine, giving me a random rotation value between -2.5 and 2.5 degrees. By default this calculation is scoped to each individual element, which means that each note will have its own random rotation : Choice of the word "scoped" there very deliberate, for reasons you'll soon understand. .sidenote { transform: scale(0.925) rotate(random(-2.5deg, 2.5deg)); } Now we're talking — now those are some jaunty angles! Quick work, though we're not quite done yet. For one thing, remember that I mentioned I was applying slightly different transforms to these components across breakpoints — overriding the transform property in a media query meant I needed to include that random rotation again, lest the new instance of transform undo my rotation altogether. Easy enough to fix: .sidenote { transform: scale(0.925) rotate(random(-2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* Just using `transform: scale(1.1);` would override the rotation, so: */ transform: scale(1) rotate(random(-2.5deg, 2.5deg)); } } The result is that the baseline scale of my sidenotes changes while — notably — each element maintains the same random rotation across breakpoints, rather than being recalculated . Of course, I'm using transform in my little timeline animation as well (in browsing contexts where animation-timeline: view() is supported, at least). By animating a transform that didn't include that rotate() value, my rotation could be once again be undone, and my sidenotes summarily de-jauntified . I am a professional technical writer. Just as easily fixed; I just needed to repeat the rotate transforms inside my @keyframes rule as well: .sidenote { animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(0.925) rotate(random(2.5deg, 2.5deg)); } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(0.925) rotate(random(2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(1) rotate(random(2.5deg, 2.5deg)); } } As before, no recalculation takes place in terms of each individual note's rotation inside or outside of the animation window — the reason being, all these calls to random() share the same random base value (or seed ) used to generate the rendered value. The base value is the randomly generated number that provides the basis for calculating the value that results from the call to random() . When random( 0px, 100px ) is called, a random seed between 0 and 1 is generated and used to perform the calculation of the resulting value - if the value of that seed is .5 , the resulting value is 50px . If the value of the seed ends up being .25 , the resulting value is 25px . Any two random() calculations based on the same seed will always give you the same end result. The way I'm using random() in the snippet above, the rotation value that results from the first evaluated call to random() will be the value that results from the the other calls to random() , since they're all able to share the same base value used to generate that rendered value. Once random() is called and a base value is generated, an identifier that represents that seed value is created — a random cache key that can be used anywhere that cache key is in scope . In the examples you've seen so far here, the cache key is leaning on the default scoping behavior: scoped to individual elements (each instance of .sidenote ), the property name ( transform ), and the index of that call — the order in which random() was called within the value of that property. That's a lot on paper (and I found the concept of index scoping particularly tricky, I don't mind admitting), but it does make a lot more sense one we start putting some of this into practice. To start with, let's step through some of the random() usage you've already seen in a little more detail: div { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { div { transform: rotate(random(2.5deg, 2.5deg)); } } The first call to random() generates a random seed between 0–1, uses it to calculate a value between -2.5deg and 2.5deg , and creates a cache key — an invisible identifier that represents the random seed. Here, that cache key will be scoped to the first random() value in subsequent transform declarations that are applied to each individual element targeted by the selector . Given these calls to random() using the same values, on the same element (any individual div ), within the same property ( transform ), as the first call to random() in each declaration — that is, at the same index — the random seed already available to that scope is used for the calculation, and the same rotation results. If our page contains two div s, they'll both end up with different random values since the cache key is scoped to each individual element. FYI CSS is declarative, which means that there's no assumption of any specific evaluation order and "the first call to random" doesn't necessarily mean "the one at the top." That's the detail that necessitates all the repetition, messy as it might seem: we couldn't have a shorthand that says "use the same value as that other random() " if "that other random() " may or may not have been evaluated yet. By repeating the values, these functionally-identical instances of random() can share a single base value regardless of their evaluation order. Given another element altogether, we leave the scope where that cache key applies — so a new random seed is created to perform that calculation and a new cache key is generated for that new scope: div { transform: rotate(random(2.5deg, 2.5deg)); } p { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { div { transform: rotate(random(2.5deg, 2.5deg)); } } In this snippet three discrete cache keys are generated, each representing a different seed value, and each resulting in a different rendered value. One for each div , scoped to the transform property and and first index (the first instance of random() in the declaration). For each individual div on the page, and given the same transform property, a call to random() at the same index uses the same seed — each div ends up with a different rotation value, and those values are maintained across breakpoints. Naturally, that cache key is out of scope for the subsequent p , so a new value is calculated there. FYI Keep in mind that this is element -based, not selector -based — so long as we're targeting the same element, using the same property, and a value with the same index, the same cache key applies: div { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { .rightround { transform: rotate(random(2.5deg, 2.5deg)); } } Different selector, but selector isn't a scoping factor — for the same element, using the same property, with the same random() index, the result is the same rotation. Again, how random() works mechanically might seem a little arcane, but the out-of-the-box behavior gives us predictable results with relatively little code, and "keep the scoping as tight as possible" is an inarguably sensible default for any addition to the web platform. For my part, leaning on defaults means my little sidenotes play out something to the tune of: Looking at you here, 1900s-era JavaScript . :root { --scale-down: 0.925; --scale-up: 1; } .sidenote { align-self: flex-end; animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* … */ transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(var(--scale-up)) rotate(random(2.5deg, 2.5deg)); } } That's a lot of repetition, I know, but remember that there's no assumption of execution order in CSS — any one of these random() calls could be the one that defines their shared cache key. Now, leaning on the default scoping behavior gets the job done for my little margin notes, but doesn't mean we're stuck with the default scoping behavior. So far we've only been passing random() a minimum and maximum value, but that first argument can instead be used to define a random key, with a specific identifier and specific scope — the second argument then defines the minimum value, and so on: .sidenote { transform: rotate(random(--random-rotation auto, -5deg, 5deg, 1deg)); } Used this way, that first argument will allow you to specify two things. The first is a dashed identifier (prefixed with -- ) that will act as the cache key. The second is a keyword that dictates whether that value should be scoped to a property ( property-scoped ) or property and index ( property-index-scoped ), to individual elements ( element-scoped ) or all matching elements identically, to individual elements and property and position ( auto , the default), or a fixed number ( fixed ) which you'd likely only use for debugging purposes. Once we've established a random key and a scope where it applies, we can reuse it in other instances of random() — an explicit means of saying "if a random seed is already available in this scope, use it." Mind the comma placement here, too — the dashed identifier and scope keyword make up one argument. I may or may not have tripped over rotate( random( --random-rotation, auto, 0px, 10px ) a few times myself. Let's walk through our scoping options one at a time: auto In the example above, the --random-rotation identifier I specified just ends up serving as a human-readable representation of the cache key — by specifying auto for the scope, I'm still just leaning on the default per-element property and index scoping. :root { --scale-down: 0.925; --scale-up: 1; } .sidenote { align-self: flex-end; animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* … */ transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(var(--scale-up)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } } It adds a little more noise to an isolated case like this one, but I certainly wouldn't mind having a human-readable label for the availability of a given cache key if we assume a couple thousand lines of real-world CSS between these instances of random() . FYI Despite sharing a shape, this identifier is very different from using random() in conjunction with a custom property. In this case, that property will still represent a call to the random() function itself , not the result of that function's evaluation: :root { --random-margin: random(0px, 10px); } div { margin-block-start: var(--random-margin); } p { margin-block-start: var(--random-margin); } --random-size won't represent the results of calling random( 0px, 10px ); , the way const randomSize = ${ Math.floor(Math.random() * 10 )px would — it represents a fresh call to random( 0px, 10px ) every time it's used. My JavaScript-addled brain recoils in horror. Again though, the addition of a manually-specified cache key doesn't gain us anything over using a generated cache key apart from a human-readable label for what are expected to be shared random() results, and specifying auto will result in the same scoping rules. What specifying a cache key does gain us is the ability to change the scope where that key will be available: property-scoped The invisibility of default/ auto scoping has the potential for confusion once we start adding a little real-world complexity, particularly when it comes to the "index" part of the equation. Given the following, we might expect all these calls to make use of the same random key, same seed, and same rendered result: div { margin-block: random(1rem, 5rem); } @media (min-width: 55rem) { div { margin-block: random(1rem, 5rem) random(1rem, 5rem); } } Here, we're targeting the same element inside and outside the media query and we're using the same property, but the cache key generated by the first call to random() is scoped to the first random value of the margin-block declaration applied to each div — even though we might expect these declarations to give us the same rendered result, the declaration using the start and end shorthand will have an identical margin-block-start , but generate a new random value for the margin-block-end . If we wanted these declarations to be functionally equivalent, we need something a little outside of the default scoping rules. If we instead specify property-scoped to say that the random key should be scoped to just the property — not the index — we can reuse that calculated value as both values in the margin-block shorthand: div { margin-block: random(--random-margin property-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin-block: random(--random-margin property-scoped, 1rem, 5rem) random(--random-margin property-scoped, 1rem, 5rem); } } Now the same value will be used for all three values. We don't have to specify an identifier for the cache key. The previous snippet is functionally identical to: div { margin-block: random(property-scoped, 1rem, 5rem); } /* … */ @media (min-width: 55rem) { div { margin-block: random(property-scoped, 1rem, 5rem) random(property-scoped, 1rem, 5rem); } } Same result, but again: given a couple thousand lines of CSS between these statements, I'd just as soon know what random seed is meant to be associated with which declarations at-a-glance. There's a catch here, though: by explicitly specifying property-scope , we've broadened the scope to only be limited by property — the cache key is no longer scoped to individual elements. Instead, any matching elements will be able to share a single cache key. If we were to only specify property-scope , like so: .sidenote { transform: rotate(random(--random-key property-scoped, -2.5deg, 2.5deg)); } The resulting value will be shared by all elements matching our selector, across all properties — a result comparable to: .sidenote { transform: rotate(/* Pick a random number between -2.5deg and 2.5deg */); } Good news, though: we can control that too. element-scoped By also adding element-scoped to this first argument, we can specify that the shared base value is scoped to individual elements and scoped to property only, not index: .sidenote { transform: rotate(random(--random-key element-scoped property-scoped, -2.5deg, 2.5deg); } But the same way specifying only property-scoped meant " only scoped to property" and lost that individual-element scoping, we can broaden the scope to "individual elements, any property, any index" by specifying element-scoped alone: div { margin-block: random(element-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin: random(element-scoped, 1rem, 5rem) 2rem; } } Here we're saying that per-element is the only applicable scope for this cache key — instead of the default/ auto behavior of being scoped to individual elements, property, and index, this cache key is only scoped to individual elements. That means any instance of random() using these values in any property that applies to any div on the page can share the same random seed, and will result in the same value: div { margin-block: random(element-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin: random(element-scoped, 1rem, 5rem) 2rem; } div.by-class { padding: random(element-scoped, 1rem, 5rem); } } The resulting seed is scoped to each individual div in the rendered page, so all of these calls to random() will result in the same random value between 1em and 5em — but at higher breakpoints, any div.by-class will use that same value for padding as well. Identifier Only We can, in fact, go one step global-er. Specifying an identifier and omitting a specific scope for that identifier results in the broadest possible scope for a cache key: a random key not specific to property or index, and not scoped to individual elements — a random seed scoped to all elements and properties targeted by that styling . “Global-er.” Professional technical writer, folks; can't stress that enough. In this example, the same random seed will be used to calculate a random value that can be reused for any property and any index, but it won't be recalculated from one div to another, either. Unless otherwise overridden elsewhere, the same random value will be used across every div targeted by these selectors: .sidenote { transform: scale(0.925) rotate(random(--random-key, -2.5deg, 2.5deg)); } The resulting value will be shared by all elements matching our selector, across all properties — a result comparable to: .sidenote { transform: scale(0.925) rotate(/* A random value between -2.5deg and 2.5deg */); } But because we're not scoping this to property or index, that means all of these calls to random() will result in the same value: .sidenote { margin-block-start: random(--random-key, 1rem, 5rem); } @media (min-width: 30rem) { .sidenote { border: solid red; border-width: random(--random-key, 1rem, 5rem) random(--random-key, 1rem, 5rem) 0 0; } } @media (min-width: 50rem) { .sidenote { font-size: random(--random-key, 1rem, 5rem); } } Any property, any index — and because we've left the realm of auto or element-scoped , every .sidenote element will be rendered using the same random value for all of these properties, if and when they apply to the user's browsing context. fixed There's one more random key you can specify, and it's a weird one. Remember back where I said "when random( 0px, 100px ) is called, a random seed between 0 and 1 is generated to perform the calculation of the resulting value - how, given random( 0px, 100px ) and a random seed of .5 , the resulting value would be 50px ?" Well, the keyword fixed will allow you to specify a base value manually , using a number between zero and one — a hard-coded seed: .sidenote { transform: rotate(random(fixed 0.5, -2.5deg, 2.5deg)); /* 0deg */ transform: rotate(random(fixed 0.5, 0deg, 20deg)); /* 10deg */ transform: rotate(random(fixed 0.25, 0deg, 100deg)); /* 25deg */ } As you might have guessed, fixed has a pretty specific use case: it gives you a quick way to try out some of the values that might result from a call to random() without needing to scratch out the entire line and replace it with a static value. You'd never use this in production. Odds are, you'll only reach for fixed when finessing the upper and lower bounds of a call to random() to see how a range of potential results would render — I certainly did, if only to try it out. Granted, trying a few different fixed values on for size was probably overkill for my purposes; realistically, a sense of how a whopping five (5) potential degrees of rotation will play across a few little side notes doesn't require much more than a couple of page-reloads and a little imagination. Still, tinkering with those base values does give you a little glimpse into the mechanics of how random() rolls the dice. “Anything worth doing is worth—” well, you know the rest. As for how those base values are shared between calls to random() , well, that clearly requires a little more imagination.
Flavio CopesMore Front-end Bloggersread at source
How to use Code Mode in Claude Code
Code Mode makes Claude Code write JavaScript that chains its tool calls and runs long jobs in the background. I tried it on a real project.
Flavio CopesMore Front-end Bloggersread at source
How to use GitHub Copilot CLI: a complete tutorial
Learn GitHub Copilot CLI with a real coding task: install, sign in, control permissions, review changes, run tests, manage context, and add skills, Ponytail and MCP tools.
Flavio CopesMore Front-end Bloggersread at source
How to use GPT-6.2 Astra and Sol in Codex and the API
Choose between GPT-6.2 Astra and Sol, compare a real code review, and preserve conversation history with the OpenAI Responses API.
Darek KayMore Front-end Bloggers1 min read
#0200
Red and purple firework next to a tower. Green and yellow smoke below the tower. The top of the tower is illuminated.
Flavio CopesMore Front-end Bloggersread at source
A deep dive into ChatGPT Sites
ChatGPT Sites turns a prompt into a hosted website or small web app. How to use it step by step, what runs under the hood, what hosting will cost, and its limits.
Flavio CopesMore Front-end Bloggersread at source
How to use OpenCode Browse
OpenCode Browse lets a coding agent use your real Chrome through an MCP server and an extension. I installed it, paired it, and tested handoffs, lent tabs and the limits.
Flavio CopesMore Front-end Bloggersread at source
A deep dive into ChatGPT Wallet
ChatGPT Wallet lets your dot pay with a one-time token, not your card number. How to add a card, approve purchases, stay safe, and get your website ready.
Flavio CopesMore Front-end Bloggersread at source
AI is eroding my coding skills, and I don't care
63% of developers in a Syntax survey say their coding skills are diminishing. Mine are too. Here is why it doesn't worry me, and which skills I still keep.
Frontend Masters BlogMore Front-end Bloggers11 min read
Browsers To Try If You’re Being Forced Off Arc
Arc will sunset on December 22, 2026. Here's some personal notes from trying a variety of a new crop of alternatives. There's some good ones!
David BushellMore Front-end Bloggers2 min read
Visited links are purple
A few weeks ago Kev Quirk asked: Do you use :visited on links? — and I said to myself: No! I don’t use visited links… but why don’t I use visited links? TL;DR: I’ve gone and styled visited links, and they’re purple. Blue and purple I did a cursory five minutes of research and found Wikipedia still […]
Jeffrey Zeldman PresentsMore Front-end Bloggers3 min read
Standout Designs for the Web
Andy Clarke’s Standout Designs for the Web ships Wednesday and is now available for pre-order. I had the honor of writing the Foreword, reprinted here: Foreword I first met British art director, writer, and illustrator Andy Clarke at the SXSW Interactive festival in Austin, Texas. At the time, SXSW was the number one destination for […] The post Standout Designs for the Web appeared first on Jeffrey Zeldman Presents .
Darek KayMore Front-end Bloggersread at source
#0199
A mural of a man wearing a white periwig and sunglasses with rainbow beams. A big sign on the wall reads 'London 1759'. A shadow casts a line from the sunglasses to a person walking on the street wearing sunglasses.
David BushellMore Front-end Bloggers4 min read
RSS Club #010: Chatbots
This is an RSS-only post, thank you for subscribing :) My RSS-only posts have a permalink for those who prefer reading from my website. That link is hidden and unindexed. URLs can be linked to but in the spirit of “RSS Club” I’d prefer if my RSS-only posts were only linked to from other RSS-only […]
Jeffrey Zeldman PresentsMore Front-end Bloggers5 min read
Thanks for nothing, Apple Logic Pro
Apple Logic Pro breaks the customer mental model and its own brain with ill-considered “Unified Browser” reminiscent of everything terrible. Prepare for a deluge of ugly metaphors. The post Thanks for nothing, Apple Logic Pro appeared first on Jeffrey Zeldman Presents .
Flavio CopesMore Front-end Bloggersread at source
What are your agents doing all night?
People say their agents run 24/7. Here is what they run at night, what the skeptics answer, which jobs deserve a schedule, and how I check my own scheduled agents.
Flavio CopesMore Front-end Bloggersread at source
How to use Fable as the orchestrator and Opus as the executor in Claude Code
Run Claude Code with Fable 5.2 planning and reviewing while Opus 5.5 sub-agents do the work: the setting, the prompt, and what a real job cost me.
Swizec TellerMore Front-end Bloggersread at source
Software has no value
Software is never the goal, what software can help you do is the goal.
Darek KayMore Front-end Bloggersread at source
#0198
An ICM photo that looks like a painting. Golden leaves under a pergola are lighted by the sun.
Jeffrey Zeldman PresentsMore Front-end Bloggers1 min read
Diggs This
RZA of Wu-Tang Clan has invested in AYO Music Group, the music copyright company co-founded by Tracklib’s Pär Almqvist and clearance veteran Deborah Mannis-Gardner. AYO helps rightsholders get more out of their catalogues. Bobby Digital is in the building. Pär (AKA Peyo) Almqvist is a magical creative being and my Swedish brother. If past lives […] The post Diggs This appeared first on Jeffrey Zeldman Presents .
PiccalilliMore Front-end Bloggersread at source
The Index: Issue #206
CSS Golf A fun spin on CSS challenges here where you try to fix an issue in as little "strokes" as possible. FaceTypes As the strap-line says, a collection free fonts that are actually worth using. I made a weird web page every single day in October and lived to tell the tale A nice write-up from Jenn with some very sage advice for people using LLMs a lot for their development work. Open source says no A collection of open source projects that have explicitly banned AI contributions. Big walk used AI in 'the final stretch' of development, kicking off intense awards debate This caused quite the discourse on Bluesky 😬 Some little ways I’m using CSS :has() in the real world Here's one from the Piccalilli archives that you might have missed to wrap up this issue. P.S. this is a good website from personalsit.es . Sponsor message JavaScript for Everyone has a huge new update! Mat Marquis has been hard at work to create 3 new modules, 20 new lessons — including practical exercises — and 13 re-worked lessons. It's a lot of good new stuff and people that have previously purchased the course get all of this for free ! Use the link here to save 20% off your purchase. Get the course and save 20%
DXDMore Front-end Bloggersread at source
O design como proposta de valor de uma startup
A Web Summit como mostra também do papel que o design nas suas mais variadas vertentes pode ter no crescimento do negócio de uma startup. O conteúdo O design como proposta de valor de uma startup aparece primeiro em DXD .
Frontend Masters BlogMore Front-end Bloggers11 min read
Creating Diagrams and Graphs Using Modern CSS
The final part of the connectors series: dynamic connections that pick the closest sides, static connections that always leave from the same edge, and some bendy, zig-zag, and spring connectors, all built with anchor positioning, border-shape, shape(), and if().
Dan DaviesMore Front-end Bloggers9 min read
Media Officer Role Breakdown
The work behind the posts in Welsh football I do the vast majority of the things listed below as part of my role at Holywell Town. Social media, graphics, photography, video, interviews, website updates and the requests that come in around them. Individually, some might seem like small jobs. Put them together over a week […]
Jeffrey Zeldman PresentsMore Front-end Bloggersread at source
Better Day, Sunshine
I haven’t driven a car in decades (New Yorker). But from my pre-New York life, I remember how sun glare could turn a pleasant road trip into a blinding gauntlet. Enter “Sunward,” a uniquely specific demo app my Automattic colleague Peter Westwood just whipped up in Spacefast. Spacefast – for your next idea Sunward – […] The post Better Day, Sunshine appeared first on Jeffrey Zeldman Presents .
CSS Articles by Temani AfifMore Front-end Bloggersread at source
Creating Diagrams and Graphs Using Modern CSS
Creating Diagrams and Graphs Using Modern CSS Read the full article online
Adrian RoselliMore Front-end Bloggers4 min read
My Interop 2027 Picks
Interop 2027 is gathering votes and the deadline is 19 November 2026. For the second year now, Firefox made a page to let you rank your Interop 2027 choices. Which I’ve now done. I narrowed it down to fifteen, though getting there was oddly difficult. It seems the top three…
Jim Nielsen’s BlogMore Front-end Bloggersread at source
Making a Website in 2026
Pete Millspaugh has a great post over on the Val Town blog where he documents his attempt at making generating the same website across a variety of AI tools. I love the post. Here are a couple of thoughts that come to mind. The Space Is Ripe for Referral Fees Pete decided to make a website for his conference talk, and he added a comments section to make it a less static / more dynamic demo. This is interesting because LLMs are really good at generating one-off HTML pages you open at file:// , but as soon as you start to introduce technological dependencies — like a database, or an analytics tool, or a service for sending email, or payment processing, etc. — the question becomes: How does the LLM choose which service to rely on? It’s one thing to have the LLM choose React over Angular or Vue over Svelte. But how (and why) does it choose something like an auth provider? Does it build you a site with Auth0 or WorkOS or Clerk? How would a non-technical user even know how to weigh the trade-offs of making such a decision? Pete said he was deliberately vague about these details, which is why I find his experience so intriguing. For example, here’s what he found after generating a site in Lovable: My Lovable app is fullstack React, I learn, clicking around to find the code. It seems a bit heavy for a single-page site what with dozens of files […] The comments database seems to be using Supabase, which required no intervention on my part to set up. There’s a whole lot more—analytics, e-commerce and AI integrations, etc. I’d be really curious to know what that “a whole lot more” was. Which tools/services did it choose to depend on? How many people creating these sites understand that, even for a website that’s mostly static content, they’re being given an output that ships a JavaScript application framework, router, hydration runtime, analytics, component bundles, etc.? You asked for a sailboat, but you got an aircraft carrier . Do you know? Or more importantly, do you care ? But it’s more than just a choice of languages and frameworks. It’s also a choice of third-party services. Why Supabase? Why not Firebase? Or Neon? Speaking of Neon, here’s Pete’s experience with Vercel’s v0: I copy-paste my prompt into the chatbox. After 11 seconds, v0 asks if I’d like to install Neon, because my comment wall needs a real database. Sure, why not. (Does that mean I need a separate Neon account? Vercel creates one for me, and later I’ll find a welcome email from Neon in my inbox.) Frankly, this all feels like a space absolutely ripe for those kinds of business referral transactions you find in other industries. Take real estate, for example. For lots of folks, when you buy a home you need an agent. (Not that kind of agent; a real estate agent.) Your real estate agent is there to help you answer all those common questions that come along with buying a home: You: “How do I finance this?” Agent: “I know a mortgage company…” You: “How do I know the house is in good shape?” Agent: “I know an inspection company…” You: “We found X during the inspection, who can address it?” Agent: “I know a company that does {roofing | electrical | plumbing | etc.}…” You: “How do I close on this deal?” Agent: “I know a title company…” While you’re free to make all these decisions yourself, your agent is also there to help you pick. Presumably they’ll choose a company that reflects well on them, but there’s also undoubtedly good money to be made in referrals. After all, who else is dealing with people with these kinds of needs all day long? The “make a website with AI” space has a parallel here which makes you wonder about the incentives behind the LLM’s decision-making. Why Supabase over Firebase? Because the LLM reasoned about it? Because, statistically speaking, it was the next most probable word? Because Supabase paid Lovable (and hopefully disclosed such preferential integrations)? If LLMs are already unpredictable and non-deterministic, nothing will make their actions more predictable and deterministic than some financial incentives. Who is the customer here? The person generating the website? Or the company willing to pay for its services to be embedded in generated code? (That’s a lucrative business waiting to happen…) Get Ya Some Imperial Credits As a customer, the credit systems behind these LLM systems are annoying as hell. Here’s Pete: I’m using up “credits” as the machine works—0.70 so far, now 2.30, now 3.10, oh boy—and I have no clue what that means. There are no units. I’d prefer dollars. Are credits just dollars? As it turns out, no. With another tool: I do two more rounds of click “Continue generation” and wait until my website is ready: 5 minutes 36 seconds for 0.070 credits, and 1 minute 29 seconds for 0.024 credits. It’s probably just me, but c’mon, who do these “credit” systems really benefit? When my prompt is running, don’t show me usage like this: Credits: 0.05 -> 0.0672 -> 0.0871 Just show me the cost: Cost: $0.02 -> $0.21 -> $0.31 Don’t make me do the conversion of credits -> dollars on the fly. Computers are good at math. [soap-box] I know it might hurt your bottom line if I’m not thinking about how much money credits I’m spending, but c’mon, can we stop with the financial abstraction on top of financial abstraction? I hate how so many hosting companies are doing this “credits” for compute primitives thing. It’s pitched as if spending credits is easier, because you can apply them across services, e.g. buy image transformations or serverless function compute, all with credits! Yeah well guess what other financial abstraction I can apply to all those different services? Dollars and cents. [/soap-box] Conclusion Pete’s conclusion: I am both optimistic and pessimistic about this moment for making websites. I’m optimistic because end-user programming, the idea that everyone should be able to customize their own software, seems more possible than ever. I’m pessimistic because a slopsite, an AI-generated website with little to no human thinking involved, is often worse than no website at all. That resonates — and feels generalizable. You fill in the blank: An AI-generated ___ with little to no human thinking involved, is often worse than no ___ at all. My conclusion? Making Generating a website may be easier than ever. Understanding what you’ve generated, who you now depend on, and why? Not so much. Reply via: Email · Mastodon · Bluesky
Frontend Masters BlogMore Front-end Bloggers3 min read
My Interop 2027 Picks
What web platform features are we all wishing for perfect cross-browser interoperability next year?
David BushellMore Front-end Bloggers4 min read
I was wrong about dark mode
Apple invented dark mode again! They’re calling the new feature Adaptive Dark Mode™. I’m learning that other browsers already had a similar feature. I assumed people relied on add-ons like Dark Reader (and millions do). Regardless, pushing what is effectively an accessibility option to the forefront […]
Frontend Masters BlogMore Front-end Bloggers7 min read
TanStack AI’s Sandbox API
Part 3 of this intro to TanStack AI covers the Sandbox API: spinning up a remote sandbox on Vercel or Railway, running Claude Code inside it with GitHub access, and having it clone your repo, add a feature, and open a pull request.
PiccalilliMore Front-end Bloggersread at source
JavaScript for Everyone: New Game+
We have great news. After months of effort, 3 new modules, 13 completely re-worked lessons and 20 new lessons (including practical exercises), JavaScript for Everyone's Updated content is now live! Check it out! We took feedback from the community about what they thought was missing from the course and overwhelmingly, people wanted practical exercises. It makes sense: JavaScript is a complex language to learn and there's not many better ways to cement new knowledge than by actually building with it. Mat took this feedback as a challenge, formulated a plan and got to work , disappearing into a text editor and reappearing with pretty much a whole course's worth of new and updated material. It's really inspiring to me, personally, because doing anything while it felt like our industry was being decimated felt impossible. Mat's resolve to keep doing what he does well: teach people, has been unmatched and the benefactors of that effort are everyone . JavaScript for Everyone was already the canonical, high quality educational resource for learning JavaScript, but now, it's at a whole new level. So what are you waiting for? Take it for a spin and truly understand how JavaScript works! Check it out!
Jim Nielsen’s BlogMore Front-end Bloggersread at source
Addition By Subtraction
I still think saying no is important. In that vein, here’s something I shipped by removing functionality (and I think my site is better for it). For the longest time on my icon gallery sites , you could view a list of icons in four pixel dimensions: 56×56 128×128 256×256 512×512 Each of these sizes could be accessed via a control on the website. This has been true for years on my site, whether it’s the current site: Or an older version of the site: By default, I loaded the 128-pixel version of the icons. But if you wanted to see other sizes, you could. However, the more I used the site myself the more I thought, “Four options is too many”. When it comes to choice, what I really wanted was: Default Smaller Bigger (Plus three is always a good number , unless you have a reason otherwise). So I removed the big 512 option. If I want to study an icon at that size and detail, I click through to the icon’s detail page. Now there are three options for list views: 56, 128, and 256. Small (great on mobile), 128 (great by default), and big (let me see more detail). It’s simple to think about: You get a size by default. Not big enough? Go up a size. Too big? Go down a size. You don’t need to think about it anymore than that. I mean you can , but I’ve found I don’t need to. So I’ve taken that off your plate. Less cognitive overhead. Maybe one day I’ll add a slider and make it all dynamic. But for now, I like this small addition by subtraction. Reply via: Email · Mastodon · Bluesky
Stéphanie WalterMore Front-end Bloggersread at source
Pixels of the Week – November 8, 2026
This week we explore if AI could make the open web disappear, if a dialog should close on outside click (plot twist: it depends), and we tag along flights in the sky. And don’t miss the fun pigeon armchair and portraits of people who dress alike.
Swizec TellerMore Front-end Bloggersread at source
How do we auto-approve and merge 60% of PRs?
I'm still drowning in code review. Getting to ~16% auto-approved and merged PRs helped but it's not enough. How can we do 60%?
Frontend Masters BlogMore Front-end Bloggers5 min read
true or false in CSS
CSS doesn’t have a boolean type, but it does have the true and false keywords. Register a custom property that only accepts them, flip it with :has(), and container style queries turn messy :checked selector combinations into readable conditions.
PiccalilliMore Front-end Bloggersread at source
The Index: Issue #205
Poznote In our endless search for a Notion replacement, this one is showing real promise. Fixing illustrations on a dark background with CSS The drop-shadow property is so overlooked considering how useful it is. This is a great use of it! Death comes for XSLT It's so frustrating that browsers are ignoring the one main rule: don't break the web . How to quit Spotify and improve your life in the process This one weird trick to improve your life. (We recommend TIDAL or Qobuz) Introducing adaptive dark mode It's interesting to see this concept back — this time from Safari — considering how much of a dreadful job Google did half a decade ago in Chrome. We'll see how it goes! CSS nesting: use with caution Here's one from the Piccalilli archives that you might have missed to wrap up this issue. P.S. this is a good website . Sponsor message When anyone can make anything, we can make you stand out. AI technologies have given anyone the ability to bring their ideas to life, but to produce a high quality service that actually works for the people it needs to work for requires experience, specialist skills and creativity. We’ve got heaps of all of that here at Set Studio and we've got availability starting in 2027, so check us out and see what we're about. Check out our work
Hidde's blogMore Front-end Bloggers4 min read
Reflections from TPAC 2026
TPAC is W3C's yearly work week. A large part of the Working Groups and all sorts of committees get together to collaborate in person (mostly hybrid). This post has some things I got out of it this year. Some of my week had been slightly overbooked, as is the faith of most TPAC…
Ahmad ShadeedMore Front-end Bloggersread at source
Beyond the viewport: Introducing Site Seeing
HeydonWorksMore Front-end Bloggersread at source
I am not a developer or an accessibility specialist. Hire me?
About being a so-called unicorn and its value.
Jim Nielsen’s BlogMore Front-end Bloggersread at source
“It Gives Great Demo”
There’s that famous video of Steve Jobs explaining why they don’t didn’t make touchscreen MacBooks: We thought about [a touch screen MacBook] years ago. We’ve done tons of user testing on this and it turns out it doesn’t work! Touch surfaces don’t want to be vertical. It gives great demo. But after a short period of time, you start to fatigue. And after an extended period of time, your arm wants to fall off. It doesn’t work. It’s ergonomically terrible. Touch surfaces want to be horizontal […] that’s why we’ve perfected our multitouch trackpads over the years. I’m not going to weigh in on the new MacBooks. But what I find specifically intriguing in this video — and broadly relevant — is that phrase: “It gives great demo.” Damn, that is a great line for so much of technology. “It gives great demo.” Something that looks amazing when it’s presented to you, but in practical day-to-day use you discover, “Actually this is kinda terrible.” Demo is everything nowadays. Whatever can garner attention. Who cares if it works in practice, does it give great demo? Because demo time is sale time. The purpose of a demo is to get your attention. To make you think about the product and that it exists. But a great product often makes you forget it exists at all. It seems like a paradox: we’re attracted to what stands out, but we become enamored with what disappears. Of course, this doesn’t just apply to products. People can give great demo, too. You can make a whole career out of just giving great demo. Reply via: Email · Mastodon · Bluesky
Frontend Masters BlogMore Front-end Bloggers12 min read
Data Access Testing With @testcontainers
Testing data access code has always been awkward: unit tests want to be fast and isolated, and a real database is neither. With Docker and @testcontainers you can spin up a throwaway Postgres inside your Vitest suite, push your Drizzle schema into it, and verify that your real insert and query code round-trips correctly.
Frontend Masters BlogMore Front-end Bloggers5 min read
Multi-Column Different-Speed Scrolling
Scroll-Driven Animations can step in and make scrolling feel different even if you aren't actually interfering with the actual page scroll.
David BushellMore Front-end Bloggers2 min read
Death comes for XSLT
Last halloween, Google decided to kill XSLT. That was not a unilateral decision mind you, Google said “jump” and other browser vendors said “how high?” In response, I published my Intent to Deprecate and Remove Google Chrome. A performative declaration of course, I don’t install spyware. […]
CSS Articles by Temani AfifMore Front-end Bloggersread at source
Re-Implementing :nth-child() With Modern CSS
Re-Implementing :nth-child() With Modern CSS Read the full article online
Frontend Masters BlogMore Front-end Bloggers5 min read
Overriding Heading Levels With the headingoffset HTML Attribute
The new headingoffset HTML attribute lets you bump a heading’s level up by adding to it, which is handy when a component’s h1 needs to be an h2 somewhere else. Here’s how the math works, how to reset it, how to style the result with :heading(), and where aria-level fits in.
Darek KayMore Front-end Bloggers10 min read
My new digital home
Technical details about my new website.
David BushellMore Front-end Bloggers4 min read
Tangled, hire a front-end accessibility expert
Not me, this is just friendly advice from a struggling user. Alongside Codeberg I’d consider Tangled to be a real GitHub replacement. We desperately need to leave GitHub behind. It’s difficult to recommend any tech these days. I used to spread the gospel of Proton and that backfired. […]
Stéphanie WalterMore Front-end Bloggersread at source
Pixels of the Week – November 1, 2026
This week sadly explores how buying online became a nightmare, from deceptive patterns to AI slop. Also, don't miss a fun history guessing game, colorful tufting art, and a book on feminist approaches to type, and my Golden Honey Suckle color.
Remote SynthesisMore Front-end Bloggersread at source
Two Ways AI Is Changing the Developer Conference Presentation
The nature of conference presentations at developer-focused tech conferences seems to be changing in at least two important ways.
Kitty GiraudelMore Front-end Bloggers4 min read
Playing with CSS Layers
A short piece to share that I’ve implemented CSS layers on my website, and the few things I’ve learned on the way.
Geoff GrahamMore Front-end Bloggers1 min read
New Album: Gone Dark
I worked on a new album this past year as a follow-up to last year’s Covers. I finished it early September, submitted it for distribution, and then… nothing. It sat quietly in “approval” hell. But Gone Dark came out Monday which just so happened to be a very big day for a very different reason. […]
CSS Articles by Temani AfifMore Front-end Bloggersread at source
Two Circles, One Connection, and border-shape
Two Circles, One Connection, and border-shape Read the full article online
Jim Nielsen’s BlogMore Front-end Bloggersread at source
Celebrating SIM Cards
It’s time to celebrate a little win. The other day, my mom contacted me saying her 10-year-old iPhone wouldn’t turn on. After getting a hold of the device and doing some family IT support, I concluded the battery was dead. So I bought her a new (old) one on Walmart (SE 3rd gen., if you must know). Her old phone used a SIM card, so I was expecting the process to go something like this: Take the SIM out of the old phone Put it in the new phone Setup the device Troubleshoot why there was no service Call my Mom’s carrier and work through the issue But step 4 and 5 never happened. The new phone “just” connected. I called her number. I texted it. Everything worked as expected. Everything worked as expected. Everything worked as expected. I didn’t have to Google a single question. I was floored. Flabbergasted. I know I shouldn’t have been because that’s how SIM cards are supposed to work, right? Like that’s the whole promise of a SIM card: you can seamlessly swap them between phones. And in this case, the tech worked exactly as promised. As I write this, I’m kind of amazed at how amazed I am that everything “just worked”. Shout out to anyone who has ever worked on SIM card technology. More things like this please :) Reply via: Email · Mastodon · Bluesky
Jeffrey Zeldman PresentsMore Front-end Bloggers6 min read
The Day the Focus Died
If we failed to do this, I feared, we would stop leading the industry and turn into “merely the CSS trick of the week.” The post The Day the Focus Died appeared first on Jeffrey Zeldman Presents .
Perishable PressMore Front-end Bloggers1 min read
9G Firewall
Hello! Just a quick post to let you know that the 9th version of my nG Firewall is in development. The 9G Firewall is not yet public, so if you encounter anyone claiming otherwise, they are incorrect. Unfortunately it is necessary to post this information because someone actually hijacked the name “9G Firewall” for their own project. So when people are looking for the next generation “9G” firewall, they are likely to find the counterfeit and possible confusion. Summary: 9G […]
David BushellMore Front-end Bloggers8 min read
Danse Macabre
My recent detour into Japanese detective fiction and the captivating mysteries of locked-room whodunits reminded me of popular BBC series Jonathan Creek. The show ran for three seasons between 1997–99. It returned with season 4 and 5 in 2003 and 2014 respectively. […]
DXDMore Front-end Bloggersread at source
Processo de desenho do Não é Só um Logótipo
O processo de desenho da identidade visual do "Não é Só um Logótipo" foi uma mistura entre planeamento, pesquisa e experimentação. O conteúdo Processo de desenho do Não é Só um Logótipo aparece primeiro em DXD .
Remote SynthesisMore Front-end Bloggersread at source
Your Agent Just Deleted Prod (Web Unleashed Slide Deck)
Just a quick post to share the slide deck from my presentation today at Web Unleashed in Toronto
Jim Nielsen’s BlogMore Front-end Bloggersread at source
Why My Dad Didn’t Have a Cell Phone
Here’s Dave Rupert writing about all those emails, texts, phone calls, etc. we’re getting these days: Once upon a time it had utility, now it’s all noise and grifter slop demanding our attention and giving us to-dos That last part really hit: “giving us to-dos”. I feel this. So many of the messenger apps on my phone are other people laying claim to my time and attention. It reminds me of an interaction I had with my Dad years ago. This was back when cell phones were starting to become ubiquitous. Not smartphones , mind you. Cell phones, i.e. telephones that were mobile. Texting wasn’t really a thing yet. These were devices for making voice calls wherever you went. As a teen, it seemed like everyone had one: my teachers, my friends, even my friends’ parents. But not my parents. They were “behind the times”. (Everyone was getting cell phones and we didn’t even have caller ID on our landline!) One night at family dinner I asked, “Dad, why don’t you have a cell phone?” His response? “Why would I want to allow other people to contact me whenever they want?” I still think about that. Reply via: Email · Mastodon · Bluesky
Stéphanie WalterMore Front-end Bloggersread at source
Pixels of the Week – October 25, 2026
This week we explore the “disability dongle” problem, ecommerce accessibility issues that get customers stuck, and the double-edged sword of AI-generated prototypes. Also, don’t miss some horror graphic novels for Halloween and a gaming database for parents!
Remote SynthesisMore Front-end Bloggersread at source
The Joy of Programming
Coding brought two kinds of fulfillment: creativity and problem-solving. AI has dramatically impacted both, to opposite effect.
Geoff GrahamMore Front-end Bloggersread at source
I’ve never been as nervous to publish on CSS-Tricks since my first article in 2015.
Bruce Lawson's personal siteMore Front-end Bloggers8 min read
On CMA’s proposed NFC access conduct requirement for Apple’s iOS
If the title of this post didn’t get your pulse quickening, you’re probably in a coma. Sorry if it’s a bit clickbaity. On Tuesday, the daring, dauntless and doughty defenders of digital diversity at the UK’s competition regulator published their Proposed NFC access conduct requirement for Apple’s mobile platform. You might be wondering why contactless […]
Robin WieruchMore Front-end Bloggersread at source
Testing AI-Generated Code: Lint the Pattern, Test the Decision
Testing AI-generated code without the noise: lint the patterns coding agents follow, share one test harness, and add tests only where a file leaves its pattern.
Ben FrainMore Front-end Bloggersread at source
Colour variants from base colours with OKLCH, CSS relative color, and CSS functions
Many others have covered the manipulation of colour in CSS. This is me documenting what has worked for me, practically, 'in the wild'. It is a common requirement to need a variant of an existing colour. Think about the borders for a visual pod/component; it may have a background colour but you need some variant […]
Josh Comeau's blogMore Front-end Bloggersread at source
The Future of CSS ✨
Every year, browser vendors collaborate via the Interop project to synchronize their efforts on new HTML/CSS/JS features. This year, there’s a ton of super exciting features being considered! In this blog post, we’ll explore the CSS of the future, to get a glimpse of what we’ll soon be able to do.
localghostMore Front-end Bloggers6 min read
Digital recipe management for fastidious cooks
Much like your favourite recipe websites, I'm not going to get straight to the point, I'm going to start with a backstory and you're not getting a skip link. Having grown up with a dad who read cookbooks for leisure, and who caused me to turn vegetarian for several weeks once at…
Thoughts From EricMore Front-end Bloggers6 min read
My Interop 2027 Rankings
In which I explore why I ranked what I did for Interop 2027.
Zell LiewMore Front-end Bloggers2 min read
Redefining My Relationship With You
I no longer knew how to define my relationship with the people who read my work. Not teacher and student, not leads and customers. Here's where I eventually settled: fellow wayfarers.
Andy BellMore Front-end Bloggersread at source
In response to “The death of web development education”
I read Mathias Schäfer’s excellent post, titled The death of web development education . I was thinking about how I can contribute to the conversation and really struggled to articulate the problem. The most effective way I can contribute, in my opinion, is a crude sketch I…
Julia EvansMore Front-end Bloggers5 min read
Replacing the old battery on rechargeable bike lights
Hello! Recently I needed bike lights for my bike. And I remembered that I already had rechargeable bike lights that I bought ten years ago, that I hadn’t tried in a long time. I tried to recharge them, but after fully charging them, they only worked for maybe 5 minutes before…
text/plainMore Front-end Bloggers7 min read
“The” IP Address
As elaborated in a prior post, sites and services often try to use an IP address as an input into protection (e.g. blocking a spammer) or customization (providing local weather info) algorithms. Commonly, software would like to know “What is this device’s IP address?” Unfortunately, this is not a trivial question to answer, because it Continue reading "“The” IP Address"
The Web Witch's BlogMore Front-end Bloggers1 min read
A Short Update on Designing for Foldable Devices
And here we are three years after I wrote about the Google Pixel Fold being announced , followed now with the announcement of the iPhone Duo...(I have questions about the naming by the way). Four years ago I was talking about web primitives in the platform for the Surface Duo.…
Jonnie HallmanMore Front-end Bloggers16 min read
Building the Open Standard website with Stripe
Reuniting with my friends at Stripe, I collaborate with them on the landing page for Open Standard.
The Code BarbarianMore Front-end Bloggersread at source
Faster SSE Responses with Async Generators and Promise.race()
Phil NashMore Front-end Bloggersread at source
Build a contact form with Astro and Resend
I try to keep my email address from appearing on public websites to avoid spam. But I do like people to be able to contact me if they have something I might be interested in. The solution for this? A contact form! This site is mostly statically generated, but as it is currently built with Astro and hosted on Cloudflare Workers , I can designate an endpoint as dynamic, use it to accept a form submission, validate the data on the server, and send it to my email inbox using Resend . In this post, I’ll show you how I built it. What it does When you visit /contact , the Astro framework renders an HTML page with a form on it containing three inputs: the user’s email address, a subject, and the message they want to send. When the user fills in the form and submits it, the browser makes a POST request to the same URL, and the server-side code kicks in. It extracts the details from the form, validates the data, and uses the Resend API to send a message to my email address. If the user didn’t include all the details, the page is rendered again with error messages and the existing content of the form so that they can correct the form and submit again. For full disclosure, I currently work at Resend, but I implemented the first version of this back in 2024 . It’s always nice when you go from a happy user of a service to working there. Let’s see how to build this. Start with the HTML Astro pages are simple to build; they start with the component script, which is effectively TypeScript frontmatter for your template, and finish with the component template, made up of HTML and other Astro components. I built my contact form as a page at the /contact route, so I started with a file at the src/pages/contact.astro path in my Astro app. The contact form then starts with the HTML: --- // Component script --- form method = "POST" > div > label for = "email" > Your email label > input type = "email" id = "email" name = "email" placeholder = "you@domain.com" required /> div > div > label for = "subject" > Subject label > input type = "text" id = "subject" name = "subject" placeholder = "Hi Phil!" required /> div > div > label for = "message" > Message label > textarea id = "message" name = "message" placeholder = "Your message" required > textarea > div > div > button type = "submit" > Send button > div > form > Setting the form’s method to "POST" but not providing an action means that it will submit to the same route that rendered it. My site is set to output as a static site, but you can enable on-demand dynamic routes and rather than prerender a static page, it will dynamically render pages and respond to POST requests. To do this, just add the following to the component script: --- export const prerender = false ; --- If your Astro site is set to server mode , this isn’t required. Set up your secrets To send emails with Resend you will need a Resend account , a domain verified with Resend , and an API key . With those sorted, add the API key, an email address you’ll be using to send the email using the verified domain, and the email address you’re sending it to (yours), to the .env file: RESEND_API_KEY = RESEND_TO_EMAIL = RESEND_FROM_EMAIL = You can then load and validate these variables in Astro config in astro.config.mjs . // astro.config.mjs import { defineConfig , envField } from "astro/config" ; export default defineConfig ({ env: { schema: { RESEND_API_KEY: envField . string ({ context: "server" , access: "secret" }), RESEND_TO_EMAIL: envField . string ({ context: "server" , access: "secret" }), RESEND_FROM_EMAIL: envField . string ({ context: "server" , access: "secret" , }), }, validateSecrets: true , }, }); This is incredibly useful as this config both validates that the environment variables are present when you build or run the application and ensures that the server-side secrets aren’t included in any bundled artifacts. Return to the src/pages/contact.astro page. You can now import those environment variables from astro/env:server . Another bonus is that they will be correctly typed. --- export const prerender = false ; import { RESEND_API_KEY , RESEND_TO_EMAIL , RESEND_FROM_EMAIL } from "astro:env/server" --- Prepare values and errors For both GET and POST requests, the page renders the current field values in the HTML. It may also need to render validation errors or a success message. Let’s set those up in contact.astro . --- type ContactErrors = { email ?: string [] | undefined ; subject ?: string [] | undefined ; message ?: string [] | undefined ; }; let errors : ContactErrors = {}; let email = "" , subject = "" , message = "" , successMessage = "" ; --- The page can be updated to show the success message if it is present or the form and any values or errors. --- // Component script --- { successMessage ? ( p > { successMessage } p > ) : ( form method = "POST" > div > label for = "email" > Your email label > { errors . email && errors . email . map (( error ) => ( p class = "form-error" > { error } p > )) } input value = { email } type = "email" id = "email" name = "email" placeholder = "you@domain.com" required /> div > div > label for = "subject" > Subject label > { errors . subject && errors . subject . map (( error ) => ( p class = "form-error" > { error } p > )) } input value = { subject } type = "text" id = "subject" name = "subject" placeholder = "Hi Phil!" required /> div > div > label for = "message" > Message label > { errors . message && errors . message . map (( error ) => ( p class = "form-error" > { error } p > )) } textarea id = "message" name = "message" placeholder = "Your message" required > { message } textarea > div > div > button type = "submit" > Send button > div > form > ) } Verify the input Next, we need to validate the submitted data. I chose to do this with zod , since it is already installed as part of Astro. Start by importing zod and defining two schemas. --- import { z } from "astro/zod" ; const normalizedFormSchema = z . object ({ email: z . string (). trim (). catch ( "" ), subject: z . string (). trim (). catch ( "" ), message: z . string (). trim (). catch ( "" ), }); const contactFormSchema = z . object ({ email: z . email ({ message: "Please enter a valid email address" }). trim (), subject: z . string (). trim (). min ( 1 , { message: "Please enter a subject" }), message: z . string (). trim (). min ( 1 , { message: "Please enter a message" }), }); Check to see if the request is a POST by checking Astro.request.method . If it is, commence the work of validating the input and sending the email. I used two different zod schemas to help with parsing the submitted data. The normalizedFormSchema will always return an object containing email , subject , and message properties, defaulting each property to an empty string. The parsed values can be assigned to the default values for the email , subject and message that we set up earlier. Parsing with the contactFormSchema does the real validation. If parsing succeeds then we have all the information required to send an email. If validation fails, we collect the errors using zod’s flattenError function and pass them to the component to render. --- if ( Astro . request . method === "POST" ) { const data = await Astro . request . formData (); const normalizedFormData = normalizedFormSchema . parse ( Object . fromEntries ( data ), ); ({ email , subject , message } = normalizedFormData ); const contactFormData = contactFormSchema . safeParse ( normalizedFormData ); if ( contactFormData . success ) { // The data is correct, send the email } else { errors = z . flattenError ( contactFormData . error ). fieldErrors ; } } Hook up the Resend API Now that the data is validated, we can send the email. It’s easiest to send with Resend using the Resend Node.js SDK : npm install resend Import the SDK at the top of contact.astro : --- export const prerender = false ; import { RESEND_API_KEY , RESEND_TO_EMAIL , RESEND_FROM_EMAIL } from "astro:env/server" ; import { Resend } from "resend" ; Then, when the data has been parsed and validated correctly, create an instance of the Resend client and use it to send the email: --- // validate the data if ( contactFormData . success ) { const resend = new Resend ( RESEND_API_KEY ); const { error } = await resend . emails . send ({ to: RESEND_TO_EMAIL , from: RESEND_FROM_EMAIL , replyTo: contactFormData . data . email , subject: contactFormData . data . subject , text: contactFormData . data . message , }); if ( error ) { throw new Error ( `Failed to send contact email: ${ error . message } ` ); } successMessage = "Thanks for your email, I'll get back to you soon!" ; } else { errors = z . flattenError ( contactFormData . error ). fieldErrors ; } --- Here we are using an email address on our own domain to send the email since we can’t send on behalf of the user using the contact form. We set the user’s email address as the replyTo property, so that when you hit reply in your email client, it goes back to them. If Resend returns an error, we throw it so that Astro responds with a 500 status and our monitoring can alert us. Otherwise, we set successMessage and render the confirmation. Spam protection I initially built my contact form like this to keep from publishing my email address on the public web and avoid getting picked up by spammers. While that worked, it did not stop another class of bots from finding the contact form and filling it out themselves. I was so excited when I got my first email from the form, and then it turned out to be spam anyway. So, while this is how to set up a contact form using Astro, there is more work to do before you publish: you need to stop bots from abusing it. Ultimately, I put Cloudflare’s Turnstile in place, though you might consider things like Google’s reCAPTCHA or hCaptcha . In another post I’ll share how I implemented Turnstile. Happy emailing This is how to build a contact form with Astro and Resend. I like how Astro’s pages allow you to do all of this in one file, and how sending the email with Resend is just a couple of lines of code. Thankfully, once I’d shut down the bots, I’ve also received some really useful emails through this form. I hope this is a helpful look at how to add just a touch of interactivity to an otherwise static site using Astro.
Adam SilverMore Front-end Bloggers2 min read
Why I wait for research to prove something is needed before it’s added to the UI
Last week, a colleague gave feedback on a prototype I’m working on - a flow that helps users review a case. The UI has an accordion of documents. You can select text within each document to annotate it: Here’s what the page looks like when the accordions are collapsed: The…
DigitalA11YMore Front-end Bloggersread at source
How to Test Touch Target Size for WCAG Compliance
Has this ever happened to you? You’re scrolling through an app or website on your phone and accidentally tap a link or button you never intended to select. Or perhaps you’re trying to complete an online purchase and, instead of pressing the small “Buy Now” button, you accidentally activate a neighboring link because the controls...
Scott Hanselman's BlogMore Front-end Bloggers3 min read
Debugging my new network, when 10 Gigabit Ethernet Runs at 300 Megabits
I've been moving my home storage over to a UniFi UNAS Pro 8 as part of a larger homelab moderization . My main IRONHEART (the ultimate PC from a few years back) desktop now has an Intel E610-XT2 10GbE card, the NAS is on 10GbE, and there's a Minisforum MS-01 miniPC on the same network with a 10GbE SFP+ connection running Immich and Portainer and a few other things. Everything says 10 gigabit. Windows says 10 gigabit. UniFi says 10 gigabit. SMB copies are using the correct NIC but my file copies are running at around 100 to 200 megabits per second which is sad making. Naturally, I blamed the NAS, and the spinning rust within. The UNAS has six 16 TB spinning disks in RAID 6 and a pair of NVMe SSDs being used as cache. I'm also running Immich on the MS-01, with its photo library living on the UNAS, so there are lots of thumbnails, metadata reads, and little background writes happening. All seem like reasonable suspects. I switched the UNAS SSD cache from read-write to read-only. No meaningful difference. I stopped Immich completely. No difference. I looked at iostat ; the disks weren't saturated. We looked at SMB signing and Windows Defender network scanning. Still slow. Then I stopped testing the NAS and ran iperf3 directly between the Windows desktop and the MS-01: iperf3 -c 192.168.1.222 -P 4 133 Mbit/sec Oops. The reverse test was better, but still wrong: iperf3 -c 192.168.1.222 -P 4 -R 1.33 Gbit/sec That's weird. Now the disks, SMB, Immich, RAID, and the NAS itself were completely out of the equation. This was a Windows/NIC problem and it's weirdly asymmetrical. Looking at the Intel adapter statistics shows me... Get-NetAdapterStatistics -Name "Ethernet - 10 Gig Intel" There were nearly a million ReceivedDiscardedPackets . During one ten-second iperf3 test, the counter increased by another 268. Why? The E610 driver had its receive buffers at the default 512 , although it supported up to 4096. I increased them. I love an increased buffer. Set-NetAdapterAdvancedProperty ` -Name "Ethernet - 10 Gig Intel" ` -DisplayName "Receive Buffers" ` -DisplayValue "4096" The discarded-packet count during the next test went from 268 to zero , and receive throughput jumped from 1.33 Gbit/sec to 5.15 Gbit/sec . The transmit direction was still terrible, basically 313 Mbit/sec . The next experiment was disabling Large Send Offload (LSO) V2 for IPv4: Set-NetAdapterAdvancedProperty ` -Name "Ethernet - 10 Gig Intel" ` -DisplayName "Large Send Offload V2 (IPv4)" ` -DisplayValue "Disabled" Then I ran the same iperf3 test again. 7.03 Gbit/sec That's not a typo. 313 Mbit/sec to 7.03 Gbit/sec by changing one NIC setting. Sweet sassy molassey. LSO exists for a good reason: Windows can hand large TCP buffers to the NIC and let the adapter/driver segment them into network-sized packets, reducing CPU work. Microsoft does, however, explicitly point out that segmentation offload can reduce maximum sustainable throughput with some network adapters/configurations. LSO is usually useful, but not in this case. In my particular combination of Windows and the Intel E610-XT2, something in the IPv4 LSO path was very, very sad. I don't yet know whether this is an Intel driver bug, firmware issue, Windows interaction, or something particular to this machine, so I wouldn't turn this into random tech blogger advice that everyone should disable LSO. Measure first, cut once. Er, twice. Just stay woke. Finally I went back to the test that started all this and copied the same large file to the UNAS and Robocopy reported: Speed : 350,201,354 Bytes/sec. Speed : 20,038.682 MegaBytes/min. About 350 MB/sec , or 2.8 Gbit/sec of sustained real-world SMB writes to a six-disk RAID 6 NAS. That's much more like it. The useful lesson isn't "disable LSO." It was that when storage is mysteriously slow, eventually you have to stop testing storage. iperf3 removed the NAS, filesystem, RAID, cache, SMB and disks from the experiment in one move. Once the raw network was also slow, the problem became dramatically smaller. And, sometimes the little checkbox labeled Large Send Offload is capable of making your 10 gigabit card run like it's 2004. TL;DR - with LSO V2 for IPv4 enabled, Windows-to-Linux iperf3 managed about 313 Mbit/sec . Turning off that single offload took the exact same test to 7.03 Gbit/sec . I’m deliberately saying on this machine because LSO is normally useful and this isn’t blanket advice to disable it everywhere. © 2025 Scott Hanselman. All rights reserved.
Chen Hui JingMore Front-end Bloggers4 min read
I still like writing websites by hand
Back in 2020, I built Alex's website. He has not changed it since then. That's on him, not me. I think I first met him in 2017. It is now coming up to 10…
Manuel MatuzovićMore Front-end Bloggers12 min read
My HTML boilerplate in 2026
Every element I use for the basic structure of a HTML document, with explanations why. Five years ago, I shared the HTML boilerplate I use for most of my projects. Since then, a lot has happened in HTML. It's time to give it an update. My boilerplate This is the final document.…
Monica DinculescuMore Front-end Bloggers3 min read
Classic dopamine economics
I keep forgetting to write a post. Instead what happens is I leave myself little bread-crumb trails of notes (“chitaru shiota exhibit; can’t relate”, “birdhouse craft”), like a woman fleeing a crime scene that she will later have to investigate. They just sit there. A little…
Max Stoiber's EssaysMore Front-end Bloggersread at source
Build something to disagree with
A rough first version gives everyone the same thing to react to. Make ideas concrete before debating them.
Modern Web Development with ChromeMore Front-end Bloggers4 min read
The web the model sees
A run of recent posts on aifoc.us that I did not plan as a series but which turned into one. The thread is that the web a model sees is staler and thinner than the one you ship, and I have mostly been trying to find ways to see it.
swyxMore Front-end Bloggersread at source
What America has meant to me
Every time I have given up on America, it has been a mistake. And yet, America has never, ever given up on me.
Salma Alam-NaylorMore Front-end Bloggers12 min read
Goodbye, forever, probably.
Why I’m leaving developer relations, and why I’m not telling you what’s next.
Jack FranklinMore Front-end Bloggers5 min read
AI loops: who pays for the tokens?
A recent trend in AI has become this idea of "loops". Rather than you doing prompting and working with the AI to design and implement, you instead give it a higher level goal and let it roll. You build a system to let the AI make decisions, build and verify its work, all with…
Aleksandr HovhannisyanMore Front-end Bloggersread at source
How to Use an Android Phone Camera in OBS
Mirror your phone's camera to your computer with scrcpy, and record it with OBS.
Ashley NolanMore Front-end Bloggers2 min read
Hello again (and a new look)
After far too long a break from writing, I've given my site a fresh coat of paint.
Mark's Dev BlogMore Front-end Bloggersread at source
My Thoughts on AI, Part 2: Agent Setup, Workflow, and Tools
Introduction Hopefully you've already read Part 1: Fears, Opinions, and Mental Journey so you understand how I ended up with this mindset and approach. Or maybe you saw how long it was and just immediately bailed out :) Welcome either way. Part 1 was the braindump. Story, thoughts, feelings. Here's the part that probably more of you are interested in :) What my actual agent setup and dev workflow looks like. How I approach using AI for writing code, what tools I use, how I have them configured. You can see a cleaned-up version of my config at https://github.com/markerikson/opencode-config-example - follow along in that repo for the pieces as I describe them here. As I said in Part 1: I am not trying to sell anything, change anyone's mind, or say I am an expert. I don't have the answers. BUT I DO HAVE SOME OPINIONS NOW! :) I'm not saying that everybody should follow them, but this is where I've landed. Introduction Agent Setup Overview Agent: OpenCode and CodeNomad Model: Opus 4.6 IDE / VCS: VS Code and Fork Daily Development Workflow Parent Orchestrator Session for Project Management Subtasks for Development OpenCode Config Permissions Management File Reads Code Structure and Search Context Management Session History and Search Dev Plans Repo and Management Scripts Plan Management Issues Personal Dev Plans Repo Workflow Artifacts devplans.ts Automation Script Progress Updates and Subtask Handoffs AGENTS.md Commands and Skills Project Setup Progress and Subtask Management Task Tracking Other Commands Other Skills Config Improvement Process Potential Future Workflow Improvements Final Thoughts Agent Setup Overview Agent: OpenCode and CodeNomad I've settled on OpenCode as my agent of choice. I quickly decided I couldn't use TUIs for any development work. I've always been a GUI / IDE user anyway. I briefly tried both Claude Code and OpenCode TUIs, and bounced off hard . It's not that I am against terminals or CLI tools, I use a lot of them! But I also like having multiple tabs, my choice of coding font, syntax highlighting, and even just straightforward copy/paste abilities. Maybe I gave up too quickly, but I really struggled to get any of the TUIs to do that. I know Claude Code is the market leader for coding agent. Maybe if I gave it another shot I'd find some use out of it. On the other hand, I've always been enough of a tinkerer that I do customize my tech and tool setups. Yeah, I'm a lifelong Windows user, but I've got a comprehensive suite of tools and techniques and customizations I've built up over the years. I use Android because I want to fiddle and customize and configure the system the way I want it. OpenCode fit that bill when I tried it. It works well for me, and I'm happy with it. So if I'm not using the TUI, what's the alternative? I found a great third-party OpenCode web UI called CodeNomad . Tried it, loved it, works great . My personal laptop is all Windows, but my day job is WSL within Windows. I can start CodeNomad's server from within the WSL environment, browse to the web UI from the Windows side, and not have to deal with any cross-platform filesystem limitations. I can have multiple sessions open in one browser tab (with a tabbed UI inside of the page), or have multiple browser tabs talking to the same server. I get full GUI copy and paste, good tool and edit/diff views, and a lot more. So, I now am actually doing my primary development there in CodeNomad. Not an IDE. Model: Opus 4.6 We primarily use Anthropic models at work. Honestly I've never even tried Gemini / Codex / GPT-whatever / Kimi / etc. I've really only used Opus and Sonnet. Opus 4.5 and 4.6 have both produced great results for me. Sonnet is decent. There's probably a lot I'm missing. I don't want to burn a lot of time trying out models and running evals every few days, or switching back and forth just to eke out another 1% gainzzz. That's fine. I just need something that works well enough for me and that I'm comfortable with, and Opus 4.5/4.6 have fit that bill perfectly. (As of writing, I haven't tried out 4.7, and I'm kinda scared to. Too many weird reports about its behavior.) Also worth noting that I'm using via API, not Max plans. IDE / VCS: VS Code and Fork I've been using VS Code as my editor and IDE of choice for many years. It's not perfect, but it works. Ironically, I now use it more as a file and diff viewer than as an editor :) I mean, I am writing this blog post itself in VS Code. But for daily dev work, I do the session driving in CodeNomad in the browser, and then I flip over to VS Code to review and commit the diff. Honestly I don't like VS Code's Git panels and UI! They feel very awkward. The diff hunk staging view in particular is bad , especially compared to other IDEs like WebStorm or purpose-built Git GUIs. (Think I saw they maybe made some improvements in the last couple VSC releases - I haven't updated lately.) Fork has been my Git GUI client of choice for the last few years. Excellent, absolutely worth it. The issue here is that all my work repos are inside the WSL environment. It's technically possible to point Fork at a cross-platform WSL share of the repo folder, but the file changes tend to not refresh well, so I've mostly fallen back to just doing Git diff operations in VS Code. I think there may be some Fork tweaks that make it work better in WSL - haven't dug into those. I do know there's some Linux-native Git GUIs out there, I just haven't spent time evaluating those lately either. Daily Development Workflow My workflow is: A long-running "Orchestrator"-mode parent session with the overall context for the major development work that I'm doing. This session's job is solely to spawn child subtasks where I do the real work interactively. Child subtasks dedicated to some subset of the actual work. This may be codebase research and exploration, feature planning, or actual code development. These are highly interactive - I spend all my time discussing, directing, and driving these subtasks. The core principles here are: I'm in control. I'm the one who knows what I'm working on and what I want to accomplish. I decide what the tasks are, and how to accomplish them. I decide when to move from research to implementation, when to keep digging further or pivot a session from the original goal to a side quest, and when a task is actually done. I need to be mentally engaged, understand what is happening and why, review the code, and actually commit it when I'm satisfied. Most of the time I have one active parent session, and 1-3 active subtask sessions. I do bounce between the active subtasks and context-switch. Normally these are all still part of the same actual workstream. I have tried running sessions for 2-3 different workstreams at the same time, and it's tough, so I mostly stick with one workstream at a time now. I'm sure a lot of folks will say "but that's so slow, you could be moving so much faster!". I know. That's the point :) I'm intentionally choosing to limit the workflow to what I can manage in my own head, so that I am still fully mentally engaged and building my own understanding of the system. I also specifically aim to keep as many of the moving pieces as deterministic and scripted as possible, especially for things that can be automated like file management tasks. Parent Orchestrator Session for Project Management I start every new parent session by running my /context command. This tells the agent to read current-focus.md and the last 2-3 days worth of progress file entries. That way it has baseline knowledge of the current repo, recent work, and what I'm actually working on. From there, I give specific instructions for whatever I'm working on. This is usually several paragraphs of "here's the overall goal I'm working towards today, here's what I'm specifically trying to accomplish, here's how I want to get there". Then I specifically instruct the orchestrator parent session to spawn one or more subtasks to do the actual work. It then sits and waits for those to complete. OpenCode subtasks are essentially async functions with a return value, where the subtask can return some message to the parent. However, the child often returns a response with the initial result, but I then keep driving the subtask much further and do a lot more work, so the initial response doesn't capture the actual work accomplished. Another problem is that if I don't like what a subtask is doing and hit the "Stop" button in that session, it cancels the response to the parent and returns an empty value. The orchestrator has a bad habit of seeing that empty response and saying "oh, the child didn't complete, let me spawn another subtask to pick up where it left off". I've had to specifically instruct it " never spawn more subtasks until explicitly told to do so !" My instructions for spawning a subtask are surprisingly lax in some ways. I've done a bunch of work to give the orchestrator context on what I'm doing, why, and what the next goal is. At that point, I often say "spawn a new subtask to....", and leave most of the details up to the orchestrator. Sometimes I'll give fairly specific bullet points: "have the child read files A, B, and C for context. Then, come up with an initial plan to build this feature, and pause. I'll review and confirm implementation." Other times, especially when the parent session has gone on for a while and the orchestrator has already spun up a half dozen child tasks for earlier steps, I might just say "yep, kick off phase 3", but by that point I have high confidence that we're on the right track and there's an established pattern for what we're doing. I've had some parent sessions last up to a couple weeks as I'm focused on an ongoing effort. Other times it might be a fresh parent session each day. Either way, it's about the overall goal that I'm working towards right now. Here's what a typical orchestrator session looks like - the tail end of the /context being loaded, and my initial instructions for what I want to do in this session. Subtasks for Development Subtasks are where I do all the actual work. I let the orchestrator write up the full prompt for child subtasks. This is normally enough to get the task started, read a bunch of files, orient itself, and "get the full picture" :) The entire subtask session from there is highly interactive. If it's a research or planning session, I review the results and provide feedback on the output. If it's a coding session, I look at the initial plan for the changes and provide specific guidance and direction. I want to be very sure both me and the agent understand what we're trying to do, why, and how. I'll provide guidance on specific techniques to use, ask questions about edge cases and ideas, have it expand my own thinking as much as possible. I only tell it "okay, go make these changes" once I'm very sure about the intent. I usually try to keep an eye on the agent as it's making edits. I don't want to have to explicitly approve operations as it's running (and we'll talk about permissions management more later), but I at least want a sense of what it's doing and if it looks like it's heading in the right direction. If not, I'll mash the "Stop" button and course-correct. Once the edits are done, I'll run / test / etc as needed. I also try to review the code as much as possible. I then do the actual Git commits myself - staging, messages, commits. In a lot of ways this is "one developer workflow, but with extra steps". Fair :) The speedup comes from the agent's ability to do the research for me, expand "here's what I want to do" into a plan for how to do it, and then turn the "what and how" plan into specific code edits faster than I can. My fingers are fast, but my brain always had to work through the intent first. Here, I get to focus more on the intent and the desired behavior, and let the AI define most of the code-level changes to accomplish that. I frequently drive subtasks for extended periods of time. I try to keep a given subtask on track, but sometimes I end up veering into side quests because it's easier to keep going here rather than start up a whole new subtask and load context for the freshly discovered problem all over again. Early on, this definitely led to hitting session context limits, which forced me to create commands to reload an entire session's transcript and run those after the entire session got auto-compacted. Now that I have the OpenCode Dynamic Context Plugin and better tools and instructions for reading files, it's rare for even an extended session to end up over 100K context. The agent is very proactive about compressing recent tool calls and discussions in order to keep context manageable, and this seems to produce much better results than a big-bang "summarize the entire session so far" compaction. (Granted, sometimes it over -compresses recent chunks of the discussion and gets a bit confused on what we were doing :) ) Once I am actually ready to wrap up a given subtask, I specifically manually trigger the two record keeping commands. /progress tells the subtask to append a new "what did we accomplish?" entry to today's progress log file. /subtask-complete writes a standalone version of that update with more details, suitable for the parent orchestrator session to read. I then switch back to the parent session and run /subtask-resume , which reads all outstanding subtask handoff files so it knows what the N most recent subtasks accomplished. There's some duplication here, but I view it as /progress is for the permanent record of what I did today, /subtask-complete is the function return call results for the subtask to ensure the parent session knows where things stand. Here's a typical child subtask, in this case for working on Replay MCP's ReactComponent MCP tool. First, the initial orchestrator-provided prompt: Then my responses to some of the agent's analysis and implementation suggestions: and finally nailing down some design decisions: OpenCode Config I have a very customized OpenCode config and setup that I've built to directly support that workflow. Permissions Management I don't YOLO or --dangerously-skip-permissions . I run my agents directly on my own machines, no sandboxing. That also means that I need some amount of safety checks on commands that get run. I do want to eliminate as many unnecessary permissions prompts as I can. Even if I'm watching and directly driving an agent session, it does get very annoying to see a bunch of permission prompts in the chat session blocking and waiting for my approval, when they're pretty clearly harmless. So, as I said in Part 1: determinism. I generated a custom OpenCode plugin to auto-approve as many Bash commands as reasonable based on the contents. It's decently sophisticated. There's a very long regex-based list of known safe commands and subcommands that get auto-approved, as well as a similar of known dangerous commands that will get blocked. It actually does Bash parsing and tries to deal with heredocs and command substitutions. The bigger question is how this actually works with OpenCode at all. OpenCode refactored their whole permissions and plugin system a few months ago. There was already a "permission.ask" event trigger that allowed plugins to actually return a result, but in the refactor that got disabled. I filed an issue, other people have filed PRs, those haven't been merged. So, I've been maintaining a small local fork of OpenCode that reimplements that functionality. That allows my plugin to actually manage permissions. I saw Claude Code now has a "not quite YOLO but let the agent self-approve commands" mode. That's nice, but why rely on more agent calls and more tokens when you can just parse and manage the commands deterministically? :) The big loophole here is dynamic scripts - bun -e , node -e , python3 -c . Agents love those. They're really useful! Don't even bother writing a script file to /tmp , just bun -e "someCodeHere()" and get the results. Really useful when introspecting some data files. Obviously this means the agent could trivially smuggle through code that starts nuking folders or uploading my secrets to the mothership. In practice: I'm not sure I've seen my agents actually try to run a command that would be truly destructive. I've got these guardrails in place, and to some extent I haven't seen evidence that they're necessary . The permissions plugin does try to do some additional scanning of inline eval scripts for blatantly obvious calls like unlink() and flags those entire commands for approval. It's a tradeoff I'm happy with at this point. File Reads OpenCode has a Read tool, same as every other harness. It works. But agents default to just reading massive amounts of file text, over and over, both to learn the codebase and to remind themselves of what they've seen already. I found a file read caching tool called cachebro that is available as an MCP. It checks file access times and hashes, and if the file hasn't changed since the last read, the tool returns a message saying "this hasn't changed". I've told my agent to default to using cachebro for file reads. Unfortunately, the cachebro MCP read tool doesn't interact with OpenCode's own "file last read" logic. That meant that if my agent tried to write to a file, OpenCode would return an error saying "you must use the Read tool first", and then it would have to actually call Read and it's all a waste of time and tool calls and tokens. So since I was already maintaining a small running fork of OpenCode to handle the "permission.ask" event, I just added another commit to the fork that exposed OpenCode's "file access time" calls into the Plugin interface. Then I built my own cachebro plugin that watches for cachebro MCP tool calls, and gets/sets the file read times so OpenCode knows that file's been read. Works great. Code Structure and Search Per above, agents default to just Read for everything. This is awful for codebase exploration. Read 10-15 files just to trace dependencies and imports. Lots of extra wasted code text bloating the context. Don't do this! I've tried out a half-dozen different MCP tools that do full codebase parsing and provide tools to query structure, dependencies, outlines, and relevant chunks of code. Currently, I use grepika and tilth via MCP, and get great results. Highly recommended. I again have my AGENTS.md with instructions to always use those as the primary file reading options, and I consistently see my agent using them and intelligently only loading relevant parts of files. I've also previously tried ckb (CodeKnowledgeBase). It's got a massive set of tools for querying structure and blast radius, and I've wanted to use it, but I've run into a few problems with indexing not working or tool calls timing out. Been playing with ariadne , and I'm constantly keeping an eye out for other codebase indexing tools. Context Management Per above, I do all my work exclusively in subagent sessions that I drive myself. This means my parent orchestrator session doesn't have any issues with maxing out the context window and needing to compact, but the child tasks do. I did pretty frequently hit 160-170K context and run into auto-compaction. I hated it. The auto-compact summaries were adequate , but inevitably there'd be a bunch of details I cared about that would get lost. At first I built some dev scripts commands that would read the OpenCode session JSON files, filter out tool calls, and export the meaningful message contents out as a complete Markdown file. I built a /session-reload command and skill that would force the agent to run the export command, read the entire exported transcript, and then pause. However, grepika really reduced the amount of code that was bloating context. That helped. Then I found the OpenCode Dynamic Context Pruning Plugin . Instead of waiting until your session is almost at full context and then doing a big summary of the entire session as a replacement, which would be really lossy, it gives your agent a compress tool that it can use at will to compress and summarize chunks of your session (like a bunch of exploration file reads, or earlier messages as you switch focus to a follow-up effort). This means there's more of the session messages that stay exactly as-is, there's less time spent compacting, and it's much rarer that one of my subtask sessions actually nears max context and has to compact everything just to reset. Ironically, I really found a great working combo of tools right before Anthropic shipped 1.0M context windows by default for everyone :) But seriously, in the last couple months since landing on this combo of tools and plugins, I find that even a very long-running technical subtask session rarely gets above 100K context, thanks to grepika and cachebro minimizing file reads and the agent happily compressing earlier chunks on the fly. I know this does mean you might have some cache invalidations that could bump cost because it's no longer just the one latest message at the end of the session that hasn't been seen by the server. But on the flip side, keeping the actual total context size smaller seems to pay off, and it's not like the agent is calling compress every other turn. I was using the rtk Rust CLI tool to automatically compress the output of tools like grep to save on tokens. Unfortunately I saw too many cases where the agent got stuck in a loop trying to call grep , rtk grep would change the output too much, the agent got confused and tried again, and it just wasted time and tokens. So, eventually disabled rtk . Might come back to it at some point. Session History and Search As mentioned, I initially built some custom scripts that would find the right session JSON files and export as separate Markdown transcripts with just the message text, no tool contents. OpenCode 1.2 switched to storing sessions internally in SQLite. I held off upgrading to 1.2 for a while because I had all my custom scripts and commands and didn't want to take the time to rewrite them. But, I finally did, and that actually simplified things quite a bit. My previous /session-reload command told the agent "run the export session -type command, look at the list of most recent sessions it gives you, find what you think is the right Markdown file based on your own context and instructions, and read that". Kind of awkward, left room for error. After rewriting my own session history plugin to read from OpenCode's own plugin/internal client.session object, that all went away. Instead, I have a reload_session tool that can just directly grab the list of messages from the plugin API using the session ID, filter, construct the Markdown contents, and directly return it as the tool call result. No file path or "match up the session" steps needed. It was also trivial to throw together search_sessions and read_session tools. They're currently pretty dumb and just do basic regex searches on session contents, no vector DBs or similarity scores or anything. But they're pretty useful even in that form. Dev Plans Repo and Management Scripts Plan Management Issues During my initial couple months of using KiloCode, I found myself with the same proliferation of Markdown plan files that we've all run into. So where do those go? The agent wants to default to writing them to the root of whatever repo you're working in. I made an effort to redirect it to write them to a ./docs folder, although in our main backend repo that already existed so I had to resort to ./docs/merikson . Some of these plan files were worth committing or preserving, even if just for my own reference later. Others weren't. So where do the plan files go if this is a shared repo? I really didn't want to pollute a shared repo and commit history with dozens of my own personal semi-ephemeral plan files, or even the maybe-more-widely-useful architectural writeups. Personal Dev Plans Repo I decided the best option was to set up an entirely separate personal development doc knowledge base repo, just for myself. I dubbed it dev-plans . That would give me a consistent place that I could store all my own Markdown artifacts and knowledge, commit it, save those for future reference, and not pollute the shared actual repo Git history. My dev-plans repo structure is: /dev-plans /personal /redux /$PROJECT1 /architecture /features /progress-updates /research /subtask-handoffs current-focus.md QUIRKS.md /replay current-focus.md is intermittently updated whenever I feel I'm significantly shifting gears or focus on a repo, or completed a major chunk of work and the "what I'm working on now" section should reflect that. QUIRKS.md is more of a project structure, known actual quirks or patterns, things to remember document. Every file other than the two fixed current-focus.md and QUIRKS.md files starts with a YYYY-MM-DD prefix, such as features/2026-05-06-some-feature.md . I've got some archival scripts set up to move older documents from the flat folder structure into a nested YYYY/MM structure to keep things a bit more readable, but haven't done much with that yet. I suspect I'll need some tools to help index the documents when I do that. Workflow Artifacts architecture is meant to be longer-lived explorations of the codebase structure and patterns. Full-blown "what do we know about this project", vertical "trace through this feature or data flow path", reference material features is WIP development plans. Here's the next thing we're going to build, we've turned this into a concrete plan, use this as the basis research is more of a grab bag. Sometimes it's scanning the codebase for concepts, other times it's research dives through Github and NPM for relevant concepts progress-updates is the daily dated appended progress entries, subtask-handoffs is the individual handoff files that get automatically archived as soon as they're read devplans.ts Automation Script I've settled on using Bun with TS scripts for a lot of my personal needs and utilities. I've tried to automate a lot of the common tasks I saw consistently pop up when interacting with the dev-plans repo. I created ~/.config/opencode/scripts/devplans.ts and have fleshed it out over time with a variety of commands the agent uses all the time. Currently, that provides: /** * devplans.ts - Unified dev-plans CLI helper * * Commands: * devplans info Get project mapping info (no side effects) * devplans progress Get/create today's progress file (with late-night date logic) * devplans progress list [n] List n most recent progress files (default 3) * devplans progress append [file] Append entry from JSON file (deleted after read) or stdin * devplans handoff create [slug] Get path for new handoff file * devplans handoff list List files in pending/ * devplans handoff move [file] Move from pending/ to completed/YYYY/MM/DD/ * devplans handoff consume List, read, and move all pending handoffs * devplans doc create Create dated doc (type: feature|arch|analysis|issue) * devplans doc list [n] List docs of type (default 10) * devplans session extract Extract recent sessions, list newest 10 * devplans archive Archive old files to folder/archive/YYYY/MM/DD/ * devplans archive --all Archive all doc folders */ These deterministic commands save a lot of steps that the agent would have had to run itself to figure out what dev-plans folder path matches the current repo, creating placeholder handoff files or documents, and updating progress docs. Most of my OpenCode slash commands start with some variation of "Run `bun dev-plans.ts some-command". I also have a JSON file with folder mappings for my usual repo checkout paths in my personal laptop Windows and work laptop WSL environments. That way the script can just read those mappings and use the known paths. Per the Workflow section, I have a /init command that helps me set up the scaffolding when adding a new project to dev-plans . Progress Updates and Subtask Handoffs The most used subcommands are for progress and handoff . My original /progress command told the agent to actually read today's progress file completely, then append a new section. This became an O(n^2)-type problem as the progress file kept growing over the course of a day. Just reading the file would bloat context, and this was especially bad when the subtask was already bordering on max session context. Now, devplans progress prints JSON output with today's progress file path, but also creates a placeholder temp file and provides that path as well. The agent is instructed to overwrite the placeholder with its actual update, and then runs devplans progress $TEMPFILE . The script then deterministically appends the new section to today's progress doc so the agent didn't have to read that file itself. Similarly, /subtask-complete in the child tells it to run devplans handoff create creates a target file path that the agent can write to, and then when I run /subtask-resume in the orchestrator parent it runs devplans handoff consume which auto-prints all pending handoff files immediately and then auto-archives them. This saves multiple steps of the agent fumbling around. The devplans commands also intelligently handle dates and timestamps - automatically generating file paths with timestamps, figuring out today's progress file, and even assuming that any updates between midnight and 6 AM really belong on "the previous day's progress file" because it's likely I was working late into the night on something. There's still a lot of manual trigger behavior in here, and again I'm good with that :) AGENTS.md My AGENTS.md file is currently about 250 lines (and writing this post forced me to review it and do some reorganizing and condensation - it had gotten rather crufty). It starts with a short personal overview: who I am, day job at Replay, OSS work on Redux. Major sections include: Interaction patterns: I specifically instruct the agent to be keep its responses short and direct, and avoid sycophancy. That includes both descriptions, and acknowledging my instructions. Thinking and problem solving: use critical thinking and be skeptical about assumptions and correctness; stop and rethink problems if stuck; do research, not trial-and-error; state plans and wait for confirmation to check assumptions and confirm user intent Git: never commit, always stop and wait for me to review changes Personal tool environment: personal vs work laptop setups, path management, use Bun for scripting not Python Coding standards: TS usage, running tests, minimizing comments Code navigation: minimize context loading at all times; use grepika and tilth for navigating code, cachebro for other file reads Tasks and behavior: manage todos and progress; be careful counting completion; manage current context Dev plans workflow: use devplans.ts for file management; use of QUIRKS.md and other rules files Subtask spawning and workflow rules: only spawn subtasks when told; verify completion; I make no claims that my AGENTS.md is optimized, correct, or a model to follow :) It's just what I've evolved through my own usage. Commands and Skills Project Setup I have some commands and skills for initial dev-plans setup for a new repo - the usual /init and /architecture -type commands that scan the codebase, do a writeup of the details, do some initial architecture description docs, etc. Don't do those often, nothing special there. Progress and Subtask Management As described above: /progress specifically instructs the current session to create a new entry in today's progress log. /subtask-complete tells a child subtask to record a separate handoff file that can be used as a "return value" to update the parent orchestrator session, /subtask-resume has the parent session read all outstanding handoff files to know what got done. Task Tracking For most of my day to day work development, I've gotten along fine without any explicit external task tracker. I'm the one who knows what I'm working on. For a couple projects, I've tried using dex as a lightweight external nested task tracking CLI. (Think beads , but with way less slop.) It's worked pretty well! I've got a skill that instructs the agent how to use dex efficiently. I'd have the orchestrator session run dex commands to see where we stand in terms of task status, then pass dex task IDs to a subtask and tell it to mark that task as in progress. Similar to avoiding having the agent do any Git commits, I told it not to mark any dex tasks as complete until I explicitly instructed it to do so, and have a /dex-complete command to help with that. Other Commands /session-reload extracts the entire message history of the current session and returns it. Per above, this used to be writing it all to disk as a Markdown file, now it just constructs the transcript in memory from the DB entries and returns it as the tool result. I use this much less frequently now thanks to the OC Dynamic Context plugin and use of better file search tools - now that I have those I rarely get close to 150K+ context even in a long running subtask session. I wrote my own AI-powered code review tool called diffloupe that tries to compare stated change intent vs inferred change intent, and reviews for both bugs and intent mismatches. I have a /code-review command that tells the agent to review the current changes by triggering diffloupe and then report on the results. Other Skills I do have a variety of skills available: several for frontend design and UI work advanced TS patterns Replay CLI and MCP usage Architecture design and feature planning File / codebase search tools Assorted skills explaining how to use diffloupe , dex , and gh Config Improvement Process After I did my initial config and workflow development efforts back in December, I've alternated between periods of leaving it exactly as-is and focusing on just doing work, and getting annoyed with parts of the workflow and making improvements. Generally it's noticing that some particular pain point is becoming an issue - that I keep having to repeat a particular set of instructions, or that part of the workflow could be automated via devplans.ts , or trying out a different codebase indexing plugin that I found. At that point I'll go spin up a new session inside my OpenCode config repo itself, talk through the problem space, and develop the changes accordingly. As a relevant example, just reading AGENTS.md to write this post showed me how the content had gotten somewhat bloated and disorganized. So, I just started up a new session to review it, described my pain points, and the agent suggested a slimmed-down version that retained the key points, moved some of the detailed file tool usage instructions out to a separate skill, and better organized the "how to communicate" and "daily workflow" sections. Done. Potential Future Workflow Improvements I'm pretty happy with the tooling and workflow that I've got right now. The one area where I feel I'm lacking right now is that longer-term memory and context. The system I've got is great for "what is the repo we're working in?" and "what's the current set of tasks?", but I'm finding I have to do a lot of work to dig up other recent sessions where some decision was made or a research document was generated, and feed those back into the current session. I need something that helps index or scan generated planning and progress files and dynamically feeds in relevant results to the current session, or MCP tools that the session can use to scan already-indexed files. I also don't have any kind of automatic "scan recent sessions for common patterns or corrections or learnings, and extract workflow improvements" system. I do instruct agents to include possible learnings in the progress and handoff artifacts, and sometimes those trickle over to updates to QUIRKS.md , but I feel there'd be value in the automatic review process. I am very happy with grepika and tilth for codebase exploration over just reading files manually. I can imagine it would be nice to somehow preload more of the codebase into a given session so it doesn't have to re-explore some of the same files each time Code review and ensuring intent are still hard. diffloupe has been useful for doing some review checks. I intended to add my own full code review UI to it, but got distracted and never got back to that. I've bookmarked a bunch of other code review tools and may still investigate some of those. Final Thoughts 6000+ words, and this was with me deliberately avoiding going into full amounts of technical detail :) So there you go. See the example config repo for the actual commands, scripts, and setup. No idea how many people will end up going through here, but as always, hope this info was useful! And more than anything else: whether you use AI to write all your code or write it by hand, I hope that you can find a workflow for yourself that is sustainable, maintainable, understandable, and safely productive.
Set StudioMore Front-end Bloggers2 min read
Astro is our preferred front-end platform
 We’re not usually ones for welding ourselves to a platform or technology, aside from web standards like HTML, CSS and JavaScript. Part of what makes us so…
Harry CresswellMore Front-end Bloggersread at source
Designing the Morpho album artwork
Matt and I have been creating artwork for his music for almost 12 years now. It’s a collaboration I’m immensely proud of, and one that offers a welcome change of scene from my day-to-day job of designing and building websites. Morpho , released on Sound Records in November last year, is our most recent project. Our 12th vinyl release and the 1st Matt is releasing using his last name, Benyayer, instead of his pseudonym, Dark Sky. Now, I must admit, I’m no print designer. And, to be clear, this is my one and only what I’d call “graphic design” gig. However, I now find myself in a position where I have a decent amount of experience creating music artwork. More specifically, artwork for records pressed onto 12" vinyl. With that in mind, I figured it might be interesting to share some of the process that went into making the artwork. Planning Projects always start life on WhatsApp, where Matt and I will discuss all sorts of ideas for concepts that somehow resonate with the music Matt has created. For this project, it was important to create something that felt connected to the artwork that we’d already designed for the singles making up the album. A similar vibe, but somehow different at the same time. It had to feel bigger, more impressive, like a season finale. At the start of a new project, Matt creates a shared Google doc, which tends to evolve as we sculpt our rough ideas into a cohesive direction. The document includes the project objective, themes to explore, information that needs to be present on the final product – think track listings, record label logo, catalog ID – and any technical notes that might be useful, such as colour options for the vinyl, who is printing it, and so on. Not a creative brief in the strictest sense, but something not far off. Once we land on a concept that feels right, all other ideas get scrapped. Any references to those ideas get moved to the bottom of the document, for future reference. But, this usually doesn’t happen before we‘ve explored a whole bunch of ideas first. So let’s get into that next. Research Once we have some rough ideas in mind, it’s time to explore them further to see if we can turn any into a solid concept. A large part of that involves going down the rabbit hole, usually online, to research subjects as much as we can. Early in the process we’ll set up a mood board to collect visual references. These might directly relate to a concept, or simply reference a design style or technique that we think could work well and want to try out. Much like the creative brief, we’ll refine the mood board as we start to make sense of our ideas and land on particular concept or direction to explore further. The goal is to get some inspiration for how a concept might translate into something visual. Our wild ideas are usually tamed by what the label is prepared to pay for. No surprises there. So, another important part of our research is to consider what’s possible within the budget, as well as to identify any creative constraints that may cause issues further down the line. We’ll consider print and vinyl pressing techniques, materials we could use, and so on. At this point, we’ll reach out to potential printing partners to discuss our ideas and figure out what’s possible. We’ll also request card stock samples to help us decide on packaging weight and finish. It’s important to get an idea of these things early on. That way we hopefully wont end up designing something that isn’t feasible to create in physical form. Lucky for us, Sound Records had a decent budget and were open to doing something a little different. This gave us a fair amount of creative freedom and presented a good opportunity to work with a laser cutter. We’d been keen on the idea ever since spotting the artwork for Cascade by Bambounouu a few years back. Concept development After pursued a few dead ends, I received the following message from Matt: ”…it could be interesting to look at symmetry in nature and take inspiration from it. Maybe deconstructing and repeating the body parts of a butterfly could be a something to look at. Could be super subtle. Utilise forms found in nature to enhance the function of the design 🤔. Butterflies symbolise transformation and rebirth, which connects to this new project well and the process I’ve gone through moving from Dark Sky to Benyayer.“ This one had promise. We’d worked with symmetry before on Cold Harbour EP . The artwork was based on a photo Matt had taken of Barrier Block , the brutalist style housing estate in Brixton, South London. Exploring symmetry in nature felt like a nice evolution, yet a fun little throwback to 2019, when we created that particular artwork. It also gave us a subtle way to link this new project back to Matt’s earlier work as Dark Sky. The concept felt like a good fit, so we researched it further. Somewhere along the way, this lead us to Belenois aurota , a medium-sized butterfly, also known as the Pioneer White. Two large migrating butterflies followed: Monarch , one of the largest and rarest butterflies seen in here the UK, and Menelaus Blue Morpho , one of the largest butterflies in the world. While the Pioneer and Monarch would steer the rest of the project visually, the Blue Morpho would eventually lead to the album title itself. The Pioneer White, photo by Jaya Shukla The Blue Morpho, photo by Mori M The Monarch, photo by Justin DoCanto Now we had some creative direction, it was time to explore the concept visually, to see what we could create. Design ideation During design ideation, the goal is to figure out how to turn our concept into a piece of artwork. It’s the point we jump into design software, draw on our inspiration, play around with various techniques and create basic mockups to see what we can come up with. For this part, we usually meet up in person to work on the project together. We wanted the artwork to feel alien, like nothing you’ve really seen before. That meant trying not taking the concept too literally. Whatever we ended up creating had to be a subtle abstraction, not immediately obvious. Something to make you pause for a moment, wondering what the hell it is. As with every project, it also had to be appealing to look at. That may sound fairly obvious – it’s a visual artwork after all – but it‘s easy to forget when you’re busy messing about with design software. For every project, we’ll also consider how the artwork will translate into visuals that can be animated. This is important for live shows, social media reels, and so on. Admittedly, this has been an afterthought in the past and a challenge to reverse engineer, so these days we try to account for this early on. With our concept in mind, Matt played around with openart.ai , using it to generating a bunch of new ideas from our visual references. Generated using openart.ai Generated using openart.ai Generated using openart.ai This helped us visualise some interesting, somewhat alien, jellyfish-like looking forms. However, using a butterfly as the source image would often produce results that felt much too literal. Generated using openart.ai Generated using openart.ai Perhaps we didn’t push things far enough with AI. However, ultimately we concluded that although it was an interesting way to brainstorm ideas, it wasn’t a tool we wanted to rely on to produce the final artwork. After some experimentation, we came back to Matt’s initial idea of deconstructing and repeating the body parts of a butterfly. Focusing on the organic shapes found in the wings of the Pioneer White, we created a rough trace in Affinity Designer. The Pioneer White, photo by Divam Suthar Vector trace of butterfly wings Now we had some vector shapes to work with, the next step was to deconstruct them further to create a symmetrical design that felt interesting and a little weird. The process was made much easier once we discovered the symbol tool trick used to create symmetry in Affinity Designer . Your browser does not support the video tag. Soon enough, we realised we were in the process of creating the artwork that would become the laser cut perforations featured on the outer sleeve of the vinyl packaging. We pictured these shapes revealing a graphic on the inner sleeve beneath. This meant we now had to consider an artwork for the inner sleeve itself. Early in the design stage, I’d played around with the idea of a gigantic bitmapped butterfly motif covering the full front and back of the sleeve. Being far from subtle, I’d abandonded the idea. We returned to the idea once we realised the motif would appear more abstract, when folded in half and viewed through the laser cuts, as it would be in its final form. By duplicating a couple of layers, adding a colour overlay, then applying a blend mode, we were able to come up with something that looked much more interesting. Both when seen through the laser cuts, and when the inner sleeve was removed from the outer sleeve altogether. Feeling like we might be on to something, we tried to piece each part together by creating a basic mockup of how the laser cuts might look with the artwork behind. Now it felt like we’re actually getting somewhere. Time to end another late night design session, get some sleep and look at it again another day. Finding the right direction is always a good feeling. You’re on the right track so you can finally let go of all the other ideas taking up mental bandwidth. In our next sessions we could focus on bringing it altogether. Development At this stage, we’ve visually distilled our concept into a clear direction. Now it’s all about developing the final artwork so is ready for production. The first step is to create final digital prototypes. That means creating mockups of the full product packaging. Outer sleeve, with laser cuts and printed elements like track listing and catalogue number on spine. Inner sleeve, on body vinyl labels and the vinyl itself. It’s not about getting it 100% accurate at this point. The goal is to visualise how the final artwork and physical product might eventually look. Then figure out if it works as we’d imagined. One of the harder decisions was whether to cut out the centre of the inner sleeve revealing the vinyl label beneath. This would create an extra challenge, as we then wanted to ensure that the design featured on the vinyl label would line up with the laser cuts on the outer cover. In reality it rarely would, that is unless you replaced the vinyl in its sleeve with perfect alignment and precision. But we wanted to ensure it was, at least, technically possible, to please those like us who obsess over the details. Ultimately we took the risk and decided to go for it. Seeing right the way through to the vinyl from the cover added some extra depth and dimension to the artwork. Given the intricacy of the design, Matt also made a physical prototype for the laser cut cover, using the sample card stock we’d received from the printers. It was important to figure out whether our laser cut design would affect the structural integrity of the outer sleeve. This lead us to remove some of the elements from the final graphic, then space the rest slightly further away from each other, and away from center and the edges. Your browser does not support the video tag. The next step was to turn our digital prototypes into actual deliverables. These are the print-ready files that the printer, and, in this case, laser cutter, can work with. This is the part where we spend way too much time fussing over the details, making sure everything is perfectly aligned and positioned where it should be on templates provided by the printer. To prevent any issues scaling artwork to fit, we always work in design files large enough to translate to 12" vinyl, even during the design ideation stage. Likewise, I’ll always set the colour format in Affinity to CMYK/8 and speak to the printer about what CMYK profile they want me to use. It’s most often Coated FOGRA39 , if that means anything to you. With this set up we shouldn’t have any surprises when the final product returns from the printer. As our design required both laser cutting and printing, we had to split the artwork into four separate files. One file for the laser cut outer. Another for the text and record label logo that would be printed onto the back of the outer sleeve. Then one for the printed inner sleeve. And lastly one more file for the vinyl labels. I like to export and deliver two versions of each file, one with printer guides and one without. That way there’s nothing to dispute later on. I tend to export and deliver all files in TIFF format to prevent any compression, but I know many printers prefer PDF. Production Now we’re at the business end of the project. Time to deliver our print-ready design files for printing and, in this case, laser cutting. The project is out of our hands and down to our chosen partners to turn digital designs into a physical product. My background is in web design. For those that aren’t familiar, it’s an iterative process. We’ll regularly make improvements to a website long after the project goes live. Print design is the complete opposite of that. There’s no room for mistakes and no going back once you’ve delivered artwork ready to be printed. Although there’s a sense of relief that our part is finally over, there’s still that lingering dread that we’ve messed something up and things won’t turn out exactly how we imagined. It’s an anxious wait between delivering the artwork and receiving it back. Fortunately, this time we got everything spot on. Much of that was down to a good amount of patience and two fantastic partners who were happy to answer our barrage of questions. Press on Vinyl did a stellar job on the printing, as did North London Laser on laser cutting the outer sleeve. Unfortunately, we weren’t organised enough to get shots of the print process. But we did manage to get some of the laser cutter in action. Wrapping up Although the progression from concept to artwork might seem fairly linear, I can tell you now, that couldn’t be further from the truth. In reality, designing music artwork is a messy process. At least, it is for us anyway. Until we hit the development and production phases, we tend to move back and forth between stages in no particular order. Often we’ll have an idea for a concept, do some research, mock up some visuals, then scrap the idea altogether and start the process from scratch. Over the years, I don’t think we’ve ever landed on the right concept before we’ve hit a bunch of dead ends first. Things only start coming together once we’ve done this dance at least a handful of times. Usually it’s a simple idea. Something we touched on early on, that needed time, experimentation and going through the motions to reveal itself and materialise. The final artwork is the result of many hours spent playing around with different ideas, parking the ones that aren’t working, then deliberating over where to go next. It takes time and effort to find the right direction. Along with countless emails, WhatsApps, a bunch of late nights, and arguably too much pizza and whisky. The whole project took around 8 months in total. From the moment Matt first briefed me on the project in February 2025, right through to when Matt received the finished physical product in October 2025. It’s hard to say how many hours we actually spent on it. We had the initial concept down within 3 months, but it wasn’t like we were working on it everyday. Often we’ll give it days, sometimes weeks, between design sessions. Giving ideas time and space to evolve seems to be the key. Anyway, we’re both super stoked with how the artwork turned out. A massive thanks to Tom at Sound Records , Antonio at Heartfelt Management , and the folks at both Press on Vinyl and North London Laser , for helping us to bring the project to life and making it happen. I’ve spent this whole time banging on about the Morpho artwork. However, I’d be doing a massive disservice to Matt if I didn’t mention his fantastic music that’s pressed on the vinyl itself. Ultimately, that’s what this project is all about. You can find Morpho on Spotify if you want to give the album a listen. If you’d like to own your own copy and support the project financially, it’s also available to buy directly from Matt’s Bandcamp page , in both digital and physical form.
Robin OsborneMore Front-end Bloggers4 min read
Your AI Robo-Buddy Is Legally Required to Grass You Up
Since it has an interesting overlap in the Venn diagram of “AI” and “data sovereignty”, here’s a brief follow up to my “Kubernetes, I Guess” article… Cloud Act The Cloud Act allows “federal law enforcement to compel U.S.-based technology companies via warrant or subpoena to provide requested data stored on servers regardless of whether the […]
Krasimir TsonevMore Front-end Bloggersread at source
The naked truth about AI-assisted coding
In this article, I argue that AI-assisted coding is useful but overhyped. I see real value in speeding up boilerplate and first drafts, but I also see serious risks: weaker developer fundamentals, more technical debt, shallow productivity metrics, security and licensing concerns, and growing pressure on open source maintainers. My core point is simple: AI can help me write code faster, but it still doesn’t solve the hardest part of software engineering - building the right systems that stay reliable, secure, and maintainable over time.
Rob DodsonMore Front-end Bloggers10 min read
How I Built My Mobile Second Brain
In my last post, My Second Brain Never Worked. Then I Gave It a Gardener , I mentioned that putting my Obsidian vault on a VPS with Claude Code permanently running on it, and being able to access it from my phone, was the real “ah ha” moment for me. A few people asked how I set…
Eric PortisMore Front-end Bloggersread at source
Monochrome Summer
Samuel KraftMore Front-end Bloggersread at source
Using SF Pro Rounded with React Native
How to use San Francisco Pro Rounded with React Native