❌

Vue lecture

What are we not talking about anymore?

What are we not talking about anymore?

I used to enjoy talking about the web, in many ways. I love the fact that it is for everyone, by design. And I used to love talking about the consequences of this design decision: that everyone is allowed to do whatever they want on the web, and that everyone is allowed to use the web any way they want to, and that everyone must be able to use the web, and that it is hard, but fun, to make stuff that everybody can use. And I used to love talking about, what I consider to be the wonderful material of the web: HTML and CSS, two beautiful, and extremely powerful languages, if you take your time to understand them.

I am forced to talk about other stuff

Since a year or two it gets harder and harder to talk about these things, things that I care about. Every time I mention such a thing, someone will say “but AI can do that”. And now, immediately, instead of continuing discussing this wonderful thing, I have to think, and talk about the question if an AI can really do that. So instead of talking about the beauty of taking your time to write well considered HTML, I am now talking about the idea that a robot could do this wonderful work instead. Instead of talking about working out a complicated layout with CSS, and trying and trying until it works, I have to answer the question why I don’t just use an LLM to fix this for me. And instead of talking about the life changing experience I give to my students when I invite real people into our classrooms, people, with their very particular ways of using the web, people with screenreaders, or people who cannot use a mouse, instead of talking about these incredible experiences, that really change the perspective on design of some of my students I have to talk about synthetic users, the most cynical concept of all.

I do not want to talk about this stuff

I think this tactic is called something like “fill them with bullshit.” The idea is that they fill us with so much bullshit, in such enormous quantities, that there is nothing else left anymore. It is a weapon used by certain politicians, and silicon valley is using it as well, in an incredibly aggressive way.

Naiveté?

I’m not sure what to do about this. I’ve noticed that being naive helps. People tell me that a senior developer with an AI can do the job of 10 junior frontend developers. Instead of becoming desperate about these kinds of things, I have decided to ignore them. I try to keep on doing what I do in order to stay sane. I keep on teaching about the wonderful web to my students, even if nobody will ever hire a talented, creative, junior developer again. I keep on teaching about the consequences of the open web, even if it’s harder and harder to find anything open in this monopolised web anymore. And I do that because I still care. Because I still think HTML and CSS are wonderful creative materials, and I still think we should use these languages to make nice things that really work for everybody.

So, next time you ask me if an AI can’t do that job I’ll ignore your question and keep on talking about what I believe we should be talking about.

  •  

De l’illusion des connaissances ou des compétences apportées par l’IA

L’IA générative donne aujourd’hui accès à des connaissances et à des capacités qui étaient autrefois réservées à des spécialistes. Le risque est de confondre cette puissance de production avec nos propres connaissances ou compétences : produire ne signifie pas nécessairement comprendre, juger ou savoir reprendre la main. Je vous propose dans cet article d’examiner cette […]

L’article De l’illusion des connaissances ou des compétences apportées par l’IA est apparu en premier sur FredCavazza.net.

  •  

Quand t'as pas compris les emoji

Oui, parce que si les emoji existent comme ça, c'est qu'il y a plein de raisons.

Cela fait trop longtemps que je n'ai pas écrit sur ce blog. Le manque de temps, le fait que pour parler technique, je privilégie mon émission radio CPU, le manque parfois d'envie.

Alors réveillons-le comme une sorte de brouillons pour mes futurs sujets, pour des à-côtés, ou simplement comme ça, dire que je suis toujours là.

Certains le savent, je manipule les emoji depuis 1999. Oui, depuis aussi longtemps, et les traces sont sur ce site web. Cela a été l'objet d'une de mes premières conférences techniques en 2012, adaptation d'une série de billets persos Des emoji dans l'Unicode. D'une manière assez amusante, on m'a cité une fois en entretien d'embauche mon propre sujet en ignorant que j'en étais le rédacteur. J'ai eu aussi des informations précieuses de première main, parfois très drôles, et j'ai toujours envie de raconter cette épopée des emoji dans l'Unicode et les implications techniques.

Mais ça ferait peut-être hautain.

Donc je me baladais sur LinkedIn en quête de ma prochaine quête quand je tombe sur ce post d'une ESN française

The emojis we got vs. the emojis we deserve 💭
The world is evolving faster than ever. New technologies, smarter engineering, cleaner energy and more connected industries are just some of the advances impacting our everyday lives.
However, most of the emojis available don’t represent these innovations… So we decided to take the matter into our own hands and create the versions that would best fit the ALTEN approach!
Take a look at our refreshed emojis. 👇🏻

Suivi d'une collection d'images opposant des emoji de la fonte Google Noto (donc Android ?) à leur réinterprétation par IA générative. Par exemple, une personne derrière un laptop revu dans un environnement holographique, ou une paire de lunettes revue en dispositif de Réalité Augmentée

© Alten

Pour une boite spécialisée dans l'ingénierie informatique, ne pas avoir compris pourquoi et comment les emoji existent, les contraintes optiques, les usages directs, le besoin d'abstraction, tout cela pour s'exprimer graphiquement par des images générées par IA,…

Qu'en 3 petits prompts pour générer ton post sur LinkedIn pour faire plus joli plus rapide sans en comprendre contraintes et complexité, cela laisse rêveur.

C'est encore plus drôle quand ce post arrive une semaine après que, dans un spectaculaire retour en arrière, LinkedIn supprime ses outils d'amélioration par Copilot des contenus et propose maintenant de filtrer et modérer fortement tout contenu post généré par IA, constatant que c'était devenu infernal.

Allez, à la prochaine bafouille

  •  

When It Makes Sense To “Block” The Main Thread

We’ve all heard of the sacred rule in modern web development, the rule never to be broken. The rule of “Never block the main thread.”

You almost can’t miss it as a web developer; it’s in almost every performance guide, and to be fair, it is good advice. We all know the browser’s main thread is single-threaded, meaning it can only do one thing at a time.

Plus, as we know, the main thread isn’t ours alone; we share it with the browser’s rendering engine, input handlers, and other critical tasks. As a result, the less time we hold onto the main thread, the more responsive an app feels. That leads us to share tasks with background workers as we’ve convinced ourselves there should be a hard line between the UI and any computation, and that line shouldn’t be crossed.

And that is what a “recommended” architecture looks like.

But I dare say that sometimes**, moving the data to a worker is slower than just letting the main thread do the work.

I found this out a few months ago while building a Chrome extension with screenshotting features called Fastary. I kept finding a latency of about 2 to 3 seconds in all my testing, even after using an Offscreen Document (a background process in Chrome extensions) to handle the canvas operations. A screenshot task should feel instant without lag, after all.

It is quite ironic that by reflex, we move work away from the main thread to avoid freezing the UI, but sometimes the act of moving that work (e.g., serializing, copying, and deserializing) can also freeze the UI. And sometimes the recommended approach of letting the background do the work can be slower than just doing the work on the main thread.

Let’s talk about that.

The Architecture Of Browser Context Isolation

To put things in perspective, let’s understand why we isolate browser contexts and how they communicate with each other, with emphasis on the communication part.

A browser is more than a single environment. Different environments are running at the same time, each having its own memory space, what it can access, and rules:

  • The main thread is what we are most familiar with; this is where JavaScript logic runs, where the DOM lives, where styles get rendered, and where users interact.
  • The Web Workers are separate threads that can also execute JavaScript without DOM access. We mostly use this for heavy data tasks.
  • The Service Workers are network-related proxies in charge of intercepting network requests and can even run when the page is closed.
  • And then there are Chrome extension contexts, where we have background service workers, content scripts, and Offscreen Documents (the relevant ones for this article).

Each one of these is isolated from the others. A web worker or background script lives in a different memory space from the main thread. They cannot just reach and read each other’s variables or logic, and this is known as the “shared-nothing” architecture.

How do these isolated environments communicate? They explicitly message each other back and forth using APIs, like postMessage().

The Structured Clone Algorithm

postMessage() tells the browser to take a piece of data and deliver it to the context that requested it. But to do this, the browser relies on the Structured Clone Algorithm (SCA).

You’re probably familiar with JSON.stringify(). SCA is similar, but much stronger and smarter. In its simplest form, SCA is a deep, recursive copy operation, i.e., cloning. It walks through the entire data structure it is given, clones every single value, serializes it into a transportable format, ships those bytes to the target contexts, and then reconstructs the original object on the receiving side.

SCA is fast, or maybe fast-ish... For a small regular config object like {theme: "dark"}, it is imperceptible; you don’t even notice it. The story changes, however, when dealing with heavy data because the SCA is a synchronous blocking O(n) operation, i.e., the cost increases linearly with the size of your data.

Let’s put that into perspective. A user clicks a button, and internally, an 8MB image payload is sent to a background worker for processing. When you call postMessage(), the main thread must immediately stop what it is doing to run this serialization and copying process.

So, if the time it takes to pack, ship, unpack the data, and go back to the start is longer than the time to just process the data on the main thread, why not do that instead?
What About Transferable Objects?

I’m sure some of you are already thinking, “Why not just use Transferable objects?” And that is a valid point. Let’s talk about that.

Developers who really pursue ultra-high-performance web apps usually use Transferable objects (e.g., ArrayBuffer, ImageBitmap, or MessagePort) to bypass the Structured Clone Algorithm. This is because when you transfer an object, you’re not making a copy (like SCM). Instead, the browser switches ownership of the data from one context to another.

The browser performs a hand-off whereby the sending context loses access to the data instantly, and the receiving context takes full control. It is actually insanely fast. According to Chrome Developers’ benchmark, transferring a massive 32MB ArrayBuffer can take under 7ms, compared to about 300ms when cloning with SCM. That’s a 43x speed boost.

But like all good things, there are downsides. To name a few:

  • You lose it once you send it.
    If the UI still needs that data (like to show an image preview), you can’t access it anymore.
  • Not all data is transferable.
    A plain JS object is not. A Blob is not. Even a Base64 string is not.
  • API limitations.
    In the context of browser extensions, Chrome’s internal messaging (chrome.runtime.sendMessage) traditionally forces everything through JSON serialization.

So, as far as my screenshot extension went, Transferable objects were not an option.

Why We Isolate Contexts Anyway

Why do we even bother isolating contexts at all? Why not just leave it all to the main thread?

Offloading long-running CPU tasks to a background thread is absolutely the right thing to do. The browser needs to paint a new frame every 16.6ms to keep things fluid; that means any task that takes >50ms is generally considered “long”. Offloading to the background is absolutely the right thing to do.

The issue, however, is that we’ve turned this “never block the main thread” into an absolute rule, without asking is this task expensive to process or expensive to move?

I have come to realize now that the rule is less “never block the main thread” than “never block the main thread for too long.”

When The Right Architecture Is The Wrong Architecture

My goal with the Fastary extension was to make it feel like a native app, running as smoothly and instantly as you would expect a native app to.

As you already know, I took the recommended approach to use the Offscreen Document to handle DOM work in the background. But to my surprise, that took a different turn.

The Offscreen Document API is a clear winner. You create a hidden, undisplayed document that runs entirely in the background. It has a DOM and supports Canvas. For example, if I want to crop a screenshot, stitch multiple screenshots together, perform heavy image manipulation, or add a watermark, Offscreen Document was made for that.

Turns out that was not the best approach. This was my architecture:

  1. The background Service Worker captures a screenshot with chrome.tabs.captureVisibleTab(), which returns a Base64-encoded data URL string.
  2. The background Service Worker uses chrome.runtime.sendMessage() to ship this image payload to the Offscreen Document.
  3. The Offscreen Document receives the image, loads it into an <img> element, then draws it onto a canvas before it applies the user’s crop coordinates, encodes the result, and sends the processed image back to the background worker.

But when I tested it, the screenshot didn’t feel instant. As I said earlier, there was a consistent 2–3 second lag.

I figured out that when captureVisibleTab() takes a screenshot, it returns a Base64 URL string, and on a standard 1080p screen, that string could be approximately 1MB or more, depending on how detailed the image is. It gets even more interesting on modern Retina displays (e.g., MacBooks) as they tend to automatically double the image’s size by default.

Keep in mind that since the image payload could be doubled and extension messaging relies on JSON serialization (as of this writing), we potentially deal with massive synchronous communication that costs an entire round trip.

The image string data is JSON-serialized at least twice: once when going into the Offscreen Document and once coming back out with the processed results to the background worker. The actual image processing (cropping) done inside the Offscreen Document was fast, no doubt, but I can’t say the same about the transfer overhead.

The Retina High-DPI Problem

As if the latency itself wasn’t enough, I noticed a rather subtle bug — which, now that I think of it, was more of my ignorance. After a screenshot was taken, the crop result was completely off in a way that either weirdly scaled the image or resulted in incorrect coordinates.

It turns out that when a user selects a region to crop, the content script gets the box coordinates using getBoundingClientRect(), which is measured in CSS pixels; this is what the DOM uses. But when the screenshot is captured natively in Chrome, the browser doesn’t crop it automatically; it instead uses the physical hardware pixels to get the full screen capture. And the browser uses devicePixelRatio (DPR) to know how many physical pixels should represent one CSS pixel. Basically, if a user on a Retinal display (DPR = 2) highlights an area of 400x300 CSS pixels, the actual captured image area is 800x600 physical pixels.

Note: One CSS pixel is equal to 1 physical pixel (DPR of 1) on a standard monitor. On a Mac Retina display or a modern 4K monitor, however, the DPR is usually 2 or 3.

For an accurate crop, I needed to apply these two different measurement systems with the right DPR, i.e., scale the crop coordinates by the DPR. But remember, Offscreen Documents have no physical display. Processing any image would have a default DPR equal to 1. To fix this, I would have to capture the exact devicePixelRatio from the active tab, serialize it, pass it alongside the image payload, and manually do the scaling math inside the Offscreen Document. The complexity starts to compound.

What if I broke the golden rule and did the work on the main thread instead?

Working On The Main Thread

Some developers will argue that UI tasks are the only things that should run on the main thread, but I don’t fully agree with that. Personally, I believe that user explicitly-invoked actions that need immediate results can sometimes get a solid pass to run on the main thread, provided the work is incredibly fast (e.g., 1s).

That’s what I did: scrap out the Offscreen Document and reengineer the logic. Instead of:

Background → [serialize] → Offscreen Document → [serialize] → Background → Content Script

…I decided to run the whole image processing in the active tab:

  1. The background Service Worker captures the screen and gets the Base64 string (same as before).
  2. The background sends the payload directly to the content script in the active tab using chrome.scripting.executeScript().
  3. The content script (running on the main thread) receives the payload, draws it to a canvas, performs the crop using the correct DPR value, and copies the result to the clipboard.
// Background Script
const screenshotUrl = await chrome.tabs.captureVisibleTab(undefined, { format: "png" });

// Inject the processing function into the active tab as a content script
await chrome.scripting.executeScript({
  target: { tabId: activeTab.id },
  func: processAndCopyImage,
  args: [{ base64Image: screenshotUrl, cropData: userSelection }]
});

This approach completely clears out multiple context hops and round trips that JSON serialization requires. The only cross-context transfer involves sending the data URL from the background to the content script.

The Retina DPI issue essentially solved itself, as the content script runs directly inside the real, active browser tab because it knows the monitor’s real devicePixelRatio.

But there’s an elephant in the room that you may have noticed.

Sure, the image is now processed on the main thread, and the background manipulates the canvas in the active tab. I could technically be blocking the main thread. That’s where I amended the “no blocking the main thread” rule to “no blocking the main thread for too long.” In this specific case, at least, blocking the main thread for a task the user requests for approximately one second is justifiable. It works conversely as well: maybe don’t isolate processes if the data transfer cost is greater than the processing cost.

Conclusion: When To Isolate And When Not To

I’ve boiled it down to a mental model that depends on whether the task is:

1. Compute-Heavy Tasks (CPU-Bound)

These are tasks where the primary cost is computation and not the size of the data itself. These are tasks where most of the time is spent on doing calculations or heavy transformations, e.g., image compression, audio profiling, physics simulation, etc.

The transfer cost for these tasks is minuscule compared to the actual work.

2. Data-Heavy Tasks (Data-Bound)

These tasks are the exact opposite. These tasks are only expensive because of the size. The processing time is almost insignificant, but the data is expensive to transport, e.g., image cropping, filtering an array, shallow copy, etc.

In my specific case, offloading the task to the background falls mostly into negative-sum efficiency. If we are talking about moving megabytes of data to perform a 50ms operation, there is no benefit to offloading it to the background.

Perhaps we can think of it like this:

Total Time = Serialization Cost
  + Transit
  + Background Processing Time
  + Deserialization Cost

Looking at this, if the “background processing time” is the most dominant task in your operation, then isolation is the clear winner. But if serialization, plus deserialization, plus transit exceeds that cost, then there’s no need to isolate things.

And if you can’t figure out if the task is CPU-heavy or data-heavy, it certainly doesn’t hurt to measure it, for example, using performance.mark() and performance.measure() around postMessage calls to profile the transfer cost.

  •  

What’s !important #15: Boundary-aware CSS, Time-based CSS, Full-bleed CSS, and More

Read all about boundary-aware CSS, accessible grid lanes, time-based web designs, full-bleed, the customizable select, and new web platform features.


What’s !important #15: Boundary-aware CSS, Time-based CSS, Full-bleed CSS, and More originally handwritten and published with love on CSS-Tricks. You should really get the newsletter as well.

💾

  •  

AI and greener choices

The earth is heating up and AI isn't helping. It drives major increases in electricity use, water use and CO2 emissions. Yet, industry and governments alike seem keen to leverage the latest tech. Can we make greener choices?

Yesterday, I spoke at a conference on AI in government about sustainable choices. The presentation and slides were in Dutch, this post is a high level summary of what I covered.

As the presentation took place during a record-breaking heatwave, which meteorologists attribute to climate change, and there were some airconditioning-related issues, very little irony was lost on us.

Words matter

I started out talking about if AI is good or bad for sustainability and called it the wrong question. It's the wrong question, because both AI and sustainability are concepts that have many meanings.

AI can be understood in different ways:

  • as a technology, there are many kinds; Microsoft alone has 78 products named Copilot, but also, there are many types of AI, like computer vision, natural language processing, generative AI and agentic architectures. Traditional vs generative can be a useful distinction in sustainability, because of the difference in energy impact.
  • as an economic phenomenon (it isn't profitable yet, so it may get more expensive or introduce ads, and there are lots of financial stakes that explain why it's sometimes forced on consumers)
  • as an infrastructure (behind the cloud metaphore, there are very real data centres that warrant closer inspection)

Sustainability is multi-faceted too. In the Web Sustainability Guidelines, we center our definition around three pillars that ultimately need balance between them: Planet, People, and Profit:

  • Planet: its surface temperature rises due to emission of greenhouse gases that trap heat, and it has a finite amount of water of which only a small portion is suitable to drink.
  • People: think of people, including children as young as 11 years old, who are working in cobalt mines in Congo for the batteries that power our devices, or of people (and hospitals) who had no electricity during last year's Spain heatwave, while data centres continued uninterruptedly.
  • Profit: within our capitalist system, the needs of planet and people need to be balanced with profit, in order for anyone to successfully make the case for change.

So, there's some nuance about what the words mean, but despite that, it's worthwhile to try and reduce climate impact of our services. The pope said so, and in government, it's an increasingly a priority (like in the UK, where the Digital Service expanded their design guidance last year with principle 11: Minimise environmental impact) .

It's ok not to use AI

I shared five tips to make greener choices around AI, but couldn't help myself to add a bonus tip as tip zero: in many cases, not using AI for your project makes the most sense. Which is fine.

Many of us will have sat in meetings around a new idea or project, where someone put up their finger and said ”oh, maybe we can use AI for this”. The AI vendors primed us for this with hype.

Often, using AI, and especially generative AI, is like going to your local corner shop using a helicopter. What if you could solve the same problem with a couple of lines of Python, and Excel-sheet, people, or manually summarising?

I wanted to mention this specifically, because nobody wants to be the downer in the group and suggest not doing the thing that everyone is hyped about. But to be sustainable, we need to pick out just the cases where AI is absolutely necessary, and go without it for anything else.

Five tips to make greener choices

When using a specific type of AI actually solves your problem best, here's five tips to make greener choices.

Smaller models

When using generative AI, model size differs wildly. An example of a large model is DeepSeek v4 Pro, which has 1.6 trillion parameters (12 zeroes), while there are small models like Hugging Face's SmollLM that has 135 million parameters (6 zeroes).

A smaller model could save 30⨉ emissions of CO2 (and equivalent greenhouse gases), explain Luccioni, Jernite, & Strubell in their paper “Power Hungry Processing: Watts Driving the Cost of AI Deployment?”.

More specific models

A lot of generative AI uses so-called general purpose models, which are systems that know pretty much everything about the world. When hiring humans, we usually list a specific area of expertise. That's partially because there are no humans that know it all (just ones that think they do).

We should try to do the same with language models. If we're building a system that answers questions about taxes, we don't need to tell it what the capital of France is.

In “Power Hungry Processing”, Luccioni, Jernite, & Strubell explains this: “multi-purpose generative architectures are orders of magnitude more expensive than task-specific systems for a variety of tasks, even when controlling for the number of model parameters” (emphasis mine).

Be smart about data centre usage

In many applications of AI, the relevant software needs lots of computing: GPUs, CPUs, memory, and storage. This computing is often done in the “cloud”, or: data centres. The climate impact of data centres is widely seen as three components: electricity, CO2 emissions (and equivalent greenhouse gases), and water usage.

The International Energy Agency predicts the amount of data centres to double or triple over the next few years. The electricity used for this will be green, partially. But it won't all be green : gas and coal will continue to be a share of what powers data centres.

On an operational level, we could reduce the load on data centres by reducing how many tokens we use, via smarter prompting (shorter, more specific, more explicit, less repetition through variables). The paper Smarter, smaller, stronger by Perez Ortiz and Drobnjak details tests that show reducing a response from 400 to 200 words reduced energy consumption by 54%.

On a policy level, one tip I learned at the AI reporting event I attended, is to question how many 9's you really need. Data centres are convenient because they offer compute for rent and make it easy to scale. And they offer uptime, guaranteeing sometimes up to 99,99999 availability: five nines. More nines could mean less sustainability: some data centres will use diesel power or other unsustainable sources when they have a power cut. So to get to a higher uptime guarantee, they need to make such choices. What if we required less nines? What if we decided it's ok to have the AI thing not work for a couple of days a year?

Recognise greenwashing

Greenwashing is everywhere, and to make sustainable choices, we'll need to develop our skills to recognise it from afar. Sometimes it's easy to recognise, like an airline that said with them, you can “fly responsibly” (a Dutch court said this is misleading). EU Directive 2024/825 effectively forbids greenwashing, but companies still tend to do it.

Examples from The AI Climate Hoax include:

  • “bait and switch”: often “traditional” AI has a much smaller footprint than generative AI; when companies point at how clean their traditional AI is while ignoring the effect of their generative AI, this is misleading
  • use of (own) research with little evidence
  • hidden emissions through clever bookkeeping (often leaving out Scope 3 or ‘embodied’ emissions)
  • empty promises, like pointing at technologies that don't exist yet
  • downplaying via selective shopping in data or data without context
  • fatalism: “we'll reach those sustainability goals anyway, why bother trying”

Measuring matters

My last tip is around data collection. It's tricky to know how much energy data centres use, not the least because Big Tech successfully lobbied the EU to treat energy usage data as company secrets.

When you do get data, it often does not include Scope 3 emissions, which are estimated to be a very large part (I've seen percentages from 30 to 89%, and I am not sure what's right, other than that it is large).

There can also be a major difference in reporting: some companies do location-based reporting, others market-based reporting. Location-based means that you get information about how much a specific data centre is actually using, whereas with market-based, factors outside are taken into account, including certificates for carbon.

Location-based data is the most helpful if your team is trying to make optimisations, because it allows them to see the numbers go down (or up),where they would appear constant with market-based reports.

Lastly, I mentioned grid intensity: because there are many different power sources, and they deliver different amounts of energy depending on the time and location, grid intensity vary. For instance, if it's sunny and windy today at noon, the grid intensity will be low because there is lots of green energy available. At other times there's less.

Your application can use this difference, that constantly changes, by moving your computing to the right place at the right time. This is also called “carbon aware computing” and companies like Google already do it, to save emissions and costs at the same time.

Summing up

AI-related electricity usage, water use, and carbon emissions can be huge. That's a problem, but it's also an opportunity (cheesy but it's true). There is lots of low-hanging fruit that we can start addressing. As there's still so much to reduce, our efforts really can make a dent.

I really enjoyed giving this talk and hearing the audience comments afterwards. The main worry seems to be: how do I sell this within my organisation, and an answer emerged in the group: cost-savings and carbon-savings often go hand in hand.


Originally posted as AI and greener choices on Hidde's blog.

Reply via email

  •  

Responsive Separator for Horizontal List

Separating a horizontal list of items with a divider is a common design pattern. The tricky part is making sure we have separators only between adjacent items, never at the beginning or the end of the row/line.

CSS-only responsive list separator

There are many hacky ways to solve this, but the new Gap Decoration feature offers a simple, modern solution. No more hacks and only a few lines of code to get the shape of the divider you want.

Read more

  •  

De l'importance de la souveraineté logicielle

Un énième signal.

Le 13 juin dernier, la société Anthropic, connue pour sa domination du marché de l’intelligence artificielle générative avec les grands modèles de langage (LLM) de la série « Claude », s’est vue contrainte, sur ordre du gouvernement américain dont elle dépend, de couper l’accès à certains de ses services aux ressortissants étrangers.

Le pourquoi importe moins que le geste. Il est ici question de décider arbitrairement de qui a le droit d’utiliser quoi, et selon quels critères. De faire fi de la justice et de la morale.

  •  

∪ of Target Audiences (Accessibility, SEO, AEO/GEO)

Using SEO (search engine optimization) to justify accessibility was only ever a technique for bosses or clients or stakeholders who see accessibility as a cost center and are typically driven more by dashboards or money. Ideally, you want to get past that ASAP to drive better outcomes for humans, not SERPs (search engine results pages). I get it as a foot-in-the-door tactic — hopefully it goes no further.

But SEO also drove bad accessibility practices, such as alt text keyword stuffing, low-contrast text, verbose headings, link text built around keywords, gratuitous landing pages, and more. Karl does a good job of demonstrating how little SEO and accessibility are connected. As such, I’ve always been wary of companies pitching accessibility and SEO in their marketing.

Now I see companies pitching accessible & “AI-ready” or “agent friendly” work, often still including SEO. I’m calling foul.

Venn diagram with three circles. 1, Accessibility: The work needed to make things accessible to humans in assorted contexts. 2, SEO: The work needed to get your sites into search engines and maybe even ranked well. 3, AEO/GEO: The work to get your IP stolen by LLMs as they DDoS your site, so it can be later incorrectly regurgitated. Overlap with Accessibility and SEO: With bonus per­for­ma­tive use of the term “a11y.” Overlap of SEO and AEO/GEO: This is someone tricking you into speed-running having your IP stolen. There is no overlap of Accessibility and AEO/GEO nor all three.

We’ve already seen anti-user guidance from LLM companies asking for their notion of accessible sites. Never mind that these PhD-level genius LLM tools can’t handle a general site most kids navigate with ease. Let’s ignore the failure of that technology and instead start slapping misunderstood ARIA attributes on all our pages instead.

Sure, there’s overlap between SEO and LLM-thieving. SEO and accessibility even have slight overlap. But accessibility is about people. Twisting a human affordance to feed these corporate efforts to make humans redundant (among all the other harms) is a signal. Different people will read that signal in different ways. If it sells work and you still focus on humans first, cool.

But to me that signal says you aren’t serious about the work. That your TESCREAL patch is just waiting to get sewn on. I’m trying to be less absolutist, less black-and-white. But boy is it hard given what I see every time I peel back the veneer.

I made a thing (based on an old experiment) to better illustrate where I see the overlaps.

See the Pen Accessibility + SEO + AEO by Adrian Roselli (@aardrian) on CodePen.

  •  

Fermeture de dialog avec l'attribut closedby

Pour rappel <dialog> permet de créer des boîtes de dialogue (modales, popups, popins, elles ont tant de noms) en HTML sans plus avoir à tout gérer en CSS+JavaScript pour positionner un élément <div> en absolu.

Et on a aussi connu cela : une popin qui se ferme quand on appuie sur echap alors qu'on voulait forcer l'utilisateur à valider un formulaire, ou à l'inverse une modale qu'on ne peut fermer qu'avec un bouton alors qu'un clic en dehors serait tellement plus naturel. Jusqu'ici, la solution consistait à empiler du JavaScript pour gérer ça à la main.

Désormais, un simple attribut HTML suffit.

Mentionné par Una Kravets et Bramus Van Damme à la Google I/O 2026.

Comment ça marche ?

L'attribut closedby s'ajoute directement sur l'élément <dialog> et accepte trois valeurs :

  • any — le dialogue se ferme via la touche Échap, un geste natif (retour arrière sur mobile), ou un clic en dehors (correspond à ce qu'on appelle un light dismiss).
  • closerequest — fermeture via la touche Echap ou geste natif uniquement, pas de clic en dehors. C'est le comportement par défaut d'une modale ouverte avec showModal().
  • none — fermeture uniquement via code (bouton, soumission de formulaire…), aucune alternative native.

Exemples rapides :

<!-- On peut cliquer à côté pour fermer -->
<dialog closedby="any">
  <p>Aperçu rapide, fermable au moindre clic extérieur.</p>
  <button onclick="this.closest('dialog').close()">Fermer</button>
</dialog>
<!-- Aucune fermeture "accidentelle" possible -->
<dialog closedby="none">
  <p>Formulaire critique. On ne vous laisse pas esquiver comme ça.</p>
  <button onclick="this.closest('dialog').close()">Valider et fermer</button>
</dialog>

Et sans closedby ?

Si l'attribut est absent ou invalide, le navigateur applique un comportement automatique : - showModal() → se comporte comme closedby="closerequest" (Echap fonctionne). - show() ou attribut open → se comporte comme closedby="none" (rien ne ferme sans code).

Autrement dit, rien ne change pour vos éléments existants. Ouf la rétrocompatibilité.

Compatibilité navigateurs

À ce jour, le support atteint environ 70 % de couverture globale d'après Caniuse ce qui est encourageant mais insuffisant pour un usage en production sans y réfléchir.

Navigateur Support
Chrome / Edge ✅ depuis la version 134
Firefox ✅ depuis la version 141
Opera ✅ depuis la version 119
Safari (macOS & iOS) ❌ pas encore supporté

🐌 Safari reste en retrait... et tant que ce n'est pas supporté un fallback JavaScript pour le light dismiss peut faire l'affaire :

// Fallback pour les navigateurs sans closedby="any"
document.querySelectorAll('dialog[closedby="any"]').forEach((dialog) => {
  document.addEventListener('click', (e) => {
    if (dialog.open && !e.composedPath().includes(dialog)) {
      dialog.close();
    }
  });
});

Accessibilité

L'attribut closedby agit uniquement sur la fermeture, il ne modifie pas la sémantique de l'élément. Les bonnes pratiques habituelles restent donc :

  • closedby="any" : le clic en dehors ferme la boîte de dialogue, vérifiez que ce comportement est prévisible pour les utilisateurs de lecteurs d'écran. Un clic accidentel à côté d'un formulaire partiellement rempli peut surprendre. Réservez cette valeur aux interactions légères et non critiques (petites popups d'information ou de prévisualiation).
  • closedby="none" : si l'utilisateur ne peut pas fermer via la touche Échap ni en cliquant en dehors, il doit impérativement y avoir un bouton de fermeture, accessible au clavier et aux technologies d'assistance.
  • Gestion du focus : à l'ouverture, le focus doit aller dans la modale ; à la fermeture, il doit revenir sur l'élément déclencheur (qui a ouvert la modale, par exemple un bouton).
  • Libellé/titre : pensez à aria-labelledby (pointant vers le titre) et éventuellement aria-describedby pour les descriptions. L'élément <dialog> expose déjà le bon rôle ARIA, mais sans nom accessible les lecteurs d'écran annoncent une boîte de dialogue anonyme.

Publié par Alsacreations.com

  •  

headingoffset is Not the Document Outline Algorithm

Hi, just me heading off some bad advice I’m starting to see in developer venues.

Background

The JAWS heading list dialog with a yellow three-in-one surface level resting on top and a board nailed over it with hand-scrawled ‘offset=2’.

The proposed Document Outline Algorithm, where headings would automatically reset themselves to the appropriate level based on their position in the DOM structure, was never part of a final HTML specification. It was quickly proven to be unworkable; brief support in JAWS demonstrated that. You can read the tortured history (and a JAWS support demo) in my 2016 post There Is No Document Outline Algorithm.

In 2019 WHATWG worked to resurrect <hgroup>, partly in a novel effort to try to resurrect the Document Outline Algorithm. In the end, even that effort was futile. <hgroup> came back, but it came back as a grouping element only. The only impact it has on heading structures is that browser could, if they really wanted, ignore other headings in the same <hgroup>.

In 2020, Steve Faulkner wrote about the doc-subtitle role, from the Digital Publishing WAI-ARIA Module 1.0, as a way to handle subtitles until <hgroup> found its new footing. Sadly, a cadre of authors thought that role could be the basis for the Document Outline Algorithm.

Authors very much want to make the browser decide heading levels for them. Authors also very much continue to write content and HTML structures that make that impossible.

So I wasn’t surprised when Firefox’s recent announcement of headingoffset support coming to Firefox behind a flag resulted in many cheering the “return” (irony quotes) of the Document Outline Algorithm.

But it isn’t.

headingoffset

The headingoffset attribute lets authors offset heading levels for descendants of a given node.

So if you have, say a dialog that starts at <h2>, you could add headingoffset="2" and then let it pull in (server-side or via your preferred user-slowing front-end tooling) another page that uses <h1> as its first heading, you can be comfortable knowing that <h1> will be treated as <h3> in the accessibility tree.

This can be handy for content re-use without authors needing to make every heading a variable or burning down the DOM each time to forcibly re-write them.

But it’s still the author’s job to make an intentional and good decision. The browser will know nothing more about your content or structure than it did before. And it certainly doesn’t reduce WCAG risk.

Other useful nuggets:

  • headingoffset values must be valid non-negative integers.
  • headingoffset values must be between 0 and 8.
  • headingoffset values greater than 8 are specified to max at level 9, but existing bugs may impact that.
  • Other invalid headingoffset values should fall back to level 2, but again, bugs and implementation decisions wil impact that.
  • headingreset is a boolean attribute that tells browsers to ignore headingoffset for that node and its descendants.
  • Do not use headingoffset until you can confirm support for the computed heading level in your target audience browser.

Recap

  1. headingoffset is not the (nor any) Document Outline Algorithm, nor does it replicate it.
  2. headingoffset requires the author to make decisions based on content.
  3. Until JAWS and TalkBack fix existing bugs, probably don’t do / allow any heading levels higher than 6.
  4. Don’t do / allow any heading levels higher than 9.
  5. If you are hoping headingoffset will resolve your heading level problems in a hands-off way with imported or user-generated content, you may end up creating confusion and WCAG risk.
  6. Do not try to use headingoffset to try to recreate the Document Outline Algorithm.

Related

Not a ton of detail in this post, but at 500 words if you want more then here are some resources beyond what I linked:

  •  

Lancement du site a11yfrance.org

Suite au lancement de l’association a11y France en avril 2025, nous avons désormais un site web dédié : https://a11yfrance.org.

Qui sommes-nous ?

A11Y France, association de loi 1901, fédère les personnes professionnelles de l’accessibilité numérique et les personnes concernées pour un numérique véritablement accessible à toutes et tous.

L’association a été cofondée par Ideance, Temesis, Tanaguru, l’Association Valentin Haüy et la Fédération des Aveugles et Amblyopes de France. Elle compte actuellement plus de 40 membres actifs (liste à venir prochainement).

  •  

Centrer verticalement en CSS : épisode final

Le centrage vertical en CSS… C’est historiquement l’une des difficultés les plus célèbres du développement web, un sujet de plaisanterie classique qui fait sourire les développeurs back-end et désespérer les intégrateurs depuis l’époque de CSS2.

Pendant près de quinze ans, nous avons multiplié les détours techniques. Nous avons buté sur des vertical-align: middle capricieux réservés aux tableaux, ou des position: absolute combinés à des top: 50% et des transform: translateY(-50%) aussi magiques que fragiles.

Cette époque de savants calculs et de lignes de code superflues est désormais révolue depuis l'arrivée des modèles de positionnement Flexbox et Grid Layout.

Ceci dit, une petite révolution est passée quasi inaperçue, et pourtant elle simplifie tout : la propriété align-content fonctionne désormais dans le flux normal (Block layout). Plus besoin de déclarer un display: flex ou display: grid simplement pour aligner du contenu verticalement.

Le grand déblocage : align-content partout, pour tous

Jusqu’à récemment, align-content était une propriété exclusivement réservée aux modules Flexbox et Grid Layout. Elle permettait de distribuer l’espace entre les lignes ou d’aligner le contenu sur l’axe secondaire. Si vous tentiez de l’appliquer sur un simple bloc de texte (display: block), le navigateur l’ignorait superbement.

Grâce à une mise à jour majeure des spécifications CSS (CSS Box Alignment Module Level 3), align-content est désormais fonctionnel dans tous les modes d’affichage.

Un support universel et moderne

C’est une excellente nouvelle : ce comportement n’est pas une simple piste de réflexion, il est déjà pleinement supporté par tous les navigateurs modernes (Chrome, Firefox, Safari et Edge). Vous pouvez dès aujourd’hui l’utiliser en production pour simplifier considérablement vos intégrations.

Alors comment ça marche ?

Le principal avantage de cette évolution est l’économie de code et de structure HTML. Voyons cela à travers deux cas d’usage concrets.

1. Le centrage vertical parfait

Pour centrer un contenu verticalement dans un conteneur de hauteur fixe ou minimale, il suffit désormais de deux lignes de CSS sur le parent. Pas de Flexbox, pas de Grid, juste du bloc natif.

.hero-banner {
  display: block; /* Optionnel, c'est le comportement par défaut d'un div */
  min-height: 400px;

  /* La magie opère ici */
  align-content: center;
}

Ce qui change par rapport à Flexbox

Avec Flexbox, écrire align-items: center (ou align-content) nécessite impérativement un display: flex. Le problème, c’est que le passage en mode Flexbox modifie le comportement de tous les enfants directs (ils deviennent des flex items, se mettent en ligne par défaut, etc.). Avec align-content sur un bloc, les enfants restent des blocs normaux, conservent leurs marges et leur comportement natif dans le flux.

2. Aligner en bas de page

Vous souhaitez positionner un pied de carte ou un texte tout en bas d’un bloc sans avoir recours au positionnement absolu ? L’opération est tout aussi directe :

.card {
  min-height: 300px;
  align-content: end;
}

Vous pouvez bien sûr utiliser toutes les valeurs classiques de la propriété : start, end, center, space-between, space-around, space-evenly.

Tableau récapitulatif des valeurs courantes

Valeur Effet sur un bloc (display: block)
start / flex-start Aligne le contenu au début (haut) du conteneur.
center Centre le contenu verticalement.
end / flex-end Aligne le contenu à la fin (bas) du conteneur.
space-between Distribue l’espace résiduel entre les blocs enfants.

Et pour l'axe horizontal ? Le cas de justify-self

Si align-content règle magistralement la question de l'alignement vertical sur le parent, une autre propriété complémentaire pointe le bout de son nez pour l'axe horizontal : justify-self.

Appliquée cette fois directement sur un élément enfant au sein d'un bloc, elle a pour but de lui permettre de se positionner de manière autonome à gauche, à droite ou au centre de son parent (par exemple avec justify-self: center ou justify-self: end).

Pour le moment, le support actuel par les navigateurs reste encore trop partiel pour envisager une utilisation en production. Pour l'alignement horizontal d'un bloc individuel dans le flux normal, les bonnes vieilles marges automatiques (margin-inline: auto, etc.) ont donc encore de beaux jours devant elles.

Pourquoi ça change la vie ?

Au-delà du gain de temps, cette évolution CSS apporte une vraie rigueur sémantique et technique :

  • Lisibilité du code : Moins de conteneurs (div) superflus créés uniquement pour corriger des défauts d’alignement.
  • Performance cognitive : Le code est plus lisible. Quand on lit align-content: center, on comprend immédiatement l’intention, sans avoir à analyser si le display: flex associé ne risque pas de perturber le reste de la mise en page.
  • Respect du flux : On conserve la puissance et la prévisibilité du modèle de bloc traditionnel là où Flexbox ou Grid n’étaient finalement que des détours techniques pour un besoin simple.

Dix-quinze ans après les premiers débats enflammés sur les forums d’Alsacreations pour savoir s’il fallait utiliser les display: table-cell ou des hacks à base de lignes fantômes, le CSS moderne nous offre enfin l’outil ultime. Une seule propriété pour les gouverner toutes. Elle n’est pas belle, la vie d’intégrateur en 2026 ?

Publié par Alsacreations.com

  •  

Maybe Don’t Rely on Google’s “Modern Web Guidance”

Just in time for Google I/O, the Chrome for Developers site announced Modern Web Guidance (MWG):

Orange star between two curly braces, topped with a circle-line and a flat line at the bottom, appearing almost as an ASCII art lantern.

Modern Web Guidance is a set of evergreen and expert-vetted skills that guide your AI coding agents across many common use cases to build modern web experiences that are accessible, performant, and secure.

I appreciate this set of LLM skills lists accessibility first, something I feel strongly every MVP (or early preview as Google calls this) must:

Simply, if your MVP does not have accessibility factored in, it is not viable. If you claim accessibility is a core principle but your version 0 does not include it, then it is not a core principle.

Last year I made a straightforward and simple request to Google (that also respects the law in most jurisdictions where Google does business):

Please, if your team cannot explain how the thing satisfies all WCAG Success Criteria at Level AA, then don’t release the thing.

Unfortunately, MWG accessibility doesn’t satisfy. Partly because not every pattern has tailored guidance. For example, you may remember when Google ran at a toast pattern before abandoning it:

Again, the people designing the feature neither understood accessibility nor had consulted anyone who did while they designed it, instead relegating accessibility to the later stages of their design and assuming it could simply be remediated with a modest effort and without any serious redesign or rethink.

I hoped Google also remembered and applied that experience here, making a skill tailored to toasts to avoid another debacle. Nope.

Reopening because this guide needs accessibility guidance in some form as there’s no general toast guidance.

22 May comment reopening issue #393 “Create guide and evals for the persistent-toast-notifications use case,” originally marked complete 4 April 2026

But this is an early preview of what developers can do with MWG. It’s not going to cover every pattern. That would be absurd. So let’s look to a pattern Google decided to showcase at launch via this first example prompt on the page:

Create an accordion-style stats component that smoothly animates on open and close.

First prompt on MWG home page, under Build new user experiences heading.

I expected a pile of <details name> elements, maybe CSS block-size with a JavaScript fallback, probably a couple placeholder images for generic stats, possibly a well-formed table to accompany them, and of course all of it passing WCAG. This is what Antigravity produced with MWG:

See the Pen Google Modern Web Accordion by Adrian Roselli (@aardrian) on CodePen.

Antigravity with MWG went well beyond the prompt, providing a theme switcher, configuration settings, and plenty of calls to Google fonts. But it failed to do what I asked. The animation doesn’t work in Firefox. This despite the promise of baseline / Baseline support and fallbacks:

  • Progressive Enhancement & Nuanced Fallbacks: We distinguish between purely additive enhancements (like speculative preloading) which are safe to let older browsers silently ignore, and critical behaviors (like dialog controls or network beacons) where we write highly considered, low-overhead fallbacks.
  • […]
  • Baseline-Aware Integration: We leverage real-time compatibility data from the Baseline project so agents can dynamically adapt to current browser support and any browser support preferences.

This is already worrisome given we know that three years on, Baseline still doesn’t really address baseline support:

The relatively new Web Platform Baseline offering does not track browser support for accessibility features built into the web platform. If you need to understand whether browsers support accessibility features as your own base level set of requirements, for legal or other compliance reasons, then Web Platform Baseline does not represent a baseline.

Let’s ignore the non-DRY code, like duplicated HTML text in the script and stringing out the transition instead of using transition-property. Antigravity with MWG didn’t even create a WCAG-conformant example from its own prompt. I found errors within moments. MWG failed its core promises of creating accessible and performant code. Despite its own explicit guidance.

For the first two of these MWG already had guidance, and the a11y skill just wasn’t picked up. Overall activation aside, this highlights the importance of including contextual a11y information.

[…] [W]e should try to have one guide for each common interactive element summarizing and linking/embedding relevant bits of guidance (e.g. tabs, accordions, drawers, etc). The more scattered the use case guidance is, the less likely it is that agents will actually pick up all the pieces.

And there’s the rub. There’s no way to guarantee you’ll get what you ask for, that you won’t get something else, and that these guides — the entire promise of MWG — will be honored. MWG asks authors to trust MWG when using an LLM to code interfaces. But MWG knows its guidance may be ignored:

LLMs are non-deterministic. Even if we do everything right, there is no guarantee any guideline will be used for any given prompt. Even if the relevant guide is picked up, it may not be read fully. Case in point: As you say, MWG already had guidelines for many of these things!

Mastodon post from a domain expert consultant to Google for MWG, 21 May 2026

The underlying code generation technology can’t be trusted to follow the rules and the rules aren’t robust enough to blunt that reality.

Crude orange Vonnegut-style asterisk between two curly braces angled out a bit, topped with a rounded rectangle and a curved line at the bottom, appearing almost as an ASCII art toilet.

If your job requires you to burn tokens to satisfy some manager’s dashboard, then yes, grab the MWD skills files and integrate them into your LLM work. You’ll almost definitely get better output than if you do nothing at all. There are smart people working on this and many of the accessibility rules I saw were on-point.

But that output will be wrong in subtler and more nuanced ways across potentially fatter piles of code with more unrelated output and unwanted dependencies. It will require a more specialized set of skills to identify errors. And those errors will be different every time the code is generated.

So on the side, keep supporting any existing pattern library. If it’s built well, it’s copy-ready code that you can stuff into a project just as quickly as a chatbot could generate it. It’s deterministic, so you get the same code every time. Ideally it’s been vetted, so you don’t need to look for errors. It’s tailored to your context, meaning you don’t need to yank out random style switchers and typefaces (hoping you got all the dependencies).

If your job doesn’t require you to burn tokens, then probably ignore MWG and, by extensions, LLM for code. In case the environmental damage, intellectual property theft, wealth redistribution to the rich, encoded biases, and built-in support of fascism weren’t enough.

Update: 24 June 2026

The Silktide blog has this banger of a quote:

Across the board, [Google Antigravity using Modern Web Guidance] was a deprioritization of accessibility requirements in favor of visual presentation.

I don’t agree Antigravity nor MWG should use APG, which a regular visitor here may know, but the author is correct the APG disclosure pattern is mostly harmless.

But Silktide is right that the, once again, Google built the wrong thing for the wrong people and then proudly shoved it out into the world with no hint of self-awareness.

  •  

Google publie son guide officiel pour l'optimisation IA

Google a mis en ligne un guide officiel, assez compact, que beaucoup attendaient pour expliquer comment "optimiser son site" pour ses fonctionnalités d'IA (obtention de résumés automatiques, mode "IA" dans les résultats, etc.).

Bonne nouvelle pour le web : il n'y a rien de révolutionnaire, et cela ne devrait - pour le moment - aboutir à aucune technique fourbe qui impacterait les humains ou l'accessibilité numérique.

Le message principal est que les bonnes pratiques classiques restent valables.

Le but de cette actualité n'est pas de faire la promotion de l'usage de IA par Google mais bien de souligner l'espérance d'une absence d'impact supplémentaire sur la qualité du web actuel.

Les réponses générées par l'IA de Google s'appuient sur le même index de recherche qu'avant : si vous n'êtes pas indexé, vous n'existez pas pour l'IA non plus.

On attend toujours un contenu de qualité, une structure technique propre, une bonne expérience utilisateur. À ce sujet Google a également confirmé il y a quelques jours qu'il pénaliserait les sites modifiant le comportement du bouton retour du navigateur, notamment pour "faire rester" les humains sur un site dans un piège infini grâce aux méthodes history.pushState et history.replaceState.

Ce qui est intéressant, c'est la section mythbusting où Google démonte quelques idées qui circulent en ce moment... Les rumeurs et fausses astuces circulent encore plus vite qu'avant.

  • Les fichiers llms.txt : inutiles pour Google. Le fichier n'a aucun effet particulier sur le traitement de votre site.
  • Découper le contenu en petits morceaux : pas nécessaire, les systèmes comprennent des pages avec plusieurs sujets.
  • Réécrire ses textes pour l'IA : inutile également. Les systèmes comprennent le sens général, pas besoin de cibler chaque variante de requête imaginable.
  • Les données structurées : toujours utiles pour les résultats enrichis classiques, mais pas requises pour apparaître dans les réponses IA.

La seule vraie nuance apportée concerne le contenu "non générique" : avoir un vrai point de vue, une expérience personnelle, une analyse qui va au-delà du consensus. Dans un monde où produire du contenu banal est à la portée de n'importe quel outil ou LLM quelconque, ce qui a de la valeur c'est ce que vous seul pouvez apporter.

Publié par Alsacreations.com

  •  

Finally, the Handoff is Dead

The designer/developer handoff has been with us for years. And even though today's AI tools are dramatically increasing everyone's output, the walls between disciplines haven't changed. So now we're throwing more stuff over the wall, faster. We've been iterating on a different workflow, which Amelia Wattenberger and I demoed at Design Futures Assembly.

Most companies have years of cemented process. Changing how designers and developers work together means unwinding habits, tools, and politics that have been building for a long time. We're in a different situation because we're spinning up new companies regularly. Which means we can recreate the design/dev process each time. And as the technology evolves and we learn what works, we adapt and carry those lessons into the next one. Today we'll share our current approach.

With AI, I Don't Even Need Developers

Where a lot of the discourse on AI is these days, and where a lot of AI tools are at, is individual empowerment. Designers saying: "I can finally ship code, I don't even need developers anymore." Developers saying the reverse.

With AI, I Don't Even Need Designers

But very few people are actually asking the question: how do we use AI to work better together?

How Can We Use AI to Work Together?

Because pretty much everybody, in this room and beyond, is working with other people. And that's where the magic lies. Being able to pull multiple folks, their skills, and their experience together to create something better than you could do yourself.

Throwing Things Over The Wall

Why doesn't this kind of collaboration happen already? As user experience, front-end development, and product management have matured as disciplines, we've fallen into a throw-it-over-the-wall modality. Partially because as these roles have matured, specific tools have been made for designers, like Figma. Likewise specific tools for developers, tools for PMs, et.c

And now we're adding a lot more tools, thanks to AI. So we're all able to produce more at a higher rate. Which means we're more throwing stuff over the wall faster. That's why you hear stories of developers just being overwhelmed with PRs as everyone starts "shipping" their ideas.

Even a Blog Post Requires Collaboration

That applies to big complex projects but also nearly everything we do. Like publishing a blog post on your Web site. Maybe these days, the PM writes the content in ChatGPT, the designer makes the assets in Nano Banana, the developer writes the code in Codex. Everyone's productive, but are they aligned?

The Workspace Primitive in the Intent App

To help solve this, we've been building an app called Intent. The goal: make it easier to build software together. For any task, you spin up a workspace, which is a bundle of everything you need. Files (an isolated copy of the codebase, so you can change without messing up what others are doing), context (specs, scratchpad, data from external systems via MCP, etc), and agents (with tools and the ability to delegate and orchestrate work). Because these are all in one bundle, it becomes easier to put things down, pick them up, and hand them off.

The Workspace Primitive in the Intent App

Here's why that matters in practice. A designer keeps working where they already work (like Figma or paper) and brings their expertise into the workspace: grid, typography. That all gets encoded. A developer gets to work in their tools: CSS frameworks, deployment, structure. Same surface, different expertise.

Encoding Design and Development outcomes into a Workspace in Intent

The same surface that makes it easy to collaborate with people on your team is the same one that makes it easy to collaborate with agents. And true collaboration means respecting everyone's taste. So any workspace that gets spun up will align with how the designer encoded the styles to work and how the developer encoded the code to work.

Figma File with layouts and styles for Aria Website

To illustrate as a designer, I've got a Figma file with a grid and layouts. I go into a workspace in Intent and say: "Agent, look at the Figma file. Create the grid. Here's what the breakpoints are." Now that's encoded in the workspace and anybody that creates a new page or drops in a new asset, it works within that system.

Encoding Design  grid and breakpoints into a Workspace in Intent

I can also set up how animations should work to give everything made in the workspace silky smooth transitions.

Encoding Design  grid layouts and responsive behaviors

Same idea on the developer side. The dev can say: here's the agent's MD file, here's how we're testing the code, here's the tailwind config. The agent encodes all of that.

Encoding Development configurations into a Workspace in Intent

Taste gets baked into code files and markdown files in the repo. And because things are built on top of the same version control that developers use, it gets automatically included into every new workspace.

Assets from an illustrator and text from a write for an Aria blog post

The great thing is that this same pattern works for anybody on the team. An illustrator can use their own tools to make assets. A content writer can write their copy in Word.

Turn this into an  Aria blog post command in Intent app

Then anybody on the team can spin up a workspace and say: we're making a blog post, here are the assets, here's the Word doc. Because that workspace already includes the designer and developer's tastes, what pops out the other end is a blog post that's fully aligned with the rest of the site.

An Intent workspace turns assets into a unified design and development result

You can also run these workspaces in parallel so many people can be working on different parts of the experience simultaneously. And because every workspace is encoded in the same way, everything that gets added ends up unified by default.

Running many workspace in parallel in Intent

This gives us massive parallelism and the ability to accommodate all kinds of last-minute requests. Which, even in an age of AI, still happen. Here's me busting out 10 last-minute 8pm asks in minutes using multiple workspaces without messing up the design or code integrity of the site.

AI tools are making individuals faster, but speed isn't the problem. Cohesion is. When taste is encoded into a shared workspace in Intent, designers keep designing, developers keep developing, and everything that comes out the other end holds together. No handoffs necessary.

  •  
❌