I found the bit about using an agent to produce a minimal repro case interesting.

I'm very much on the side of "artisanally writing all code by hand" in terms of preference, but I have to admit that sometimes it puts me in a bind where there's stuff I wish I could do but don't because it's too time-consuming for the value provided. Isolating repro cases sometimes falls into that bucket.

This seems like a good use case for AI. Even if the resulting code isn't great, as long as it repros the issue and is fairly small, it's fine. It's eventually throwaway code anyway. At best, it will be harvested for a test case, but otherwise it's gone once the bug is fixed.

Maybe consider that other people are not as au fait with AI.

There are plenty of people learning to use AI and this article helps them.

A reasonable amount of repetition of "things you should know" is good.

The article is well written because you could skip the parts you knew, and learn from the parts you were unfamiliar with.

The part where Claude specifically tipped them off felt helpful to include. Stating that you used Claude to do a first pass just sounds like "I opened Vscode with highlighting to do a first pass" and that doesn't sound so relevant.

I might be too used to using coding agents in various parts of my workflow, and others are still getting acquainted, or others find it still much different than just another standard debugging tool.

And fwiw it's probably not Claude's fault that emoji fonts load this slow, though. Wtf Safari?

Not off topic at all!

While in this case we’d included the emoji font for displaying user content in another part of the app, the hazard of letting a “simple” approach expand and get out of hand is part of what I wanted to convey in writing this.

Not OT at all. Emojis everywere are ridiculous. And coding agents love them! They put emojis in Python log lines which inevitably break the console, and of course in web pages. Logs don't need emojis. Not sure if anything does.

I agree that the font and emoji hops aren’t great for complexity or performance, but the problem in the post was in the rendering of a tiny SVG; serving it directly would not have avoided the problem.

I would say just reusing widely-used emojis you have already downloaded would be less error prone

... assuming it all works ofc (though you could say that about serving svgs too)

I'd give people the benefit of the doubt. Personally, having built UI with Win32, WinForms, VisualBasic, Cocoa/Interface Builder, Qt, Tcl/Tk, XSLT, vanilla HTML/JS, jQuery, Backbone, Ember, Knockout, Bootstrap, MooTools, YUI, ExtJS, Svelte, Web Components, and React (including Preact, SolidJS…)… I'll happily choose the React approach. The only other one I would even describe as "good" was Qt.

I also don't get why "XML-like syntax in the JS code" is even a point worth complaining about. If anything, we should be encouraging people to experiment with more DSLs for building UIs. Make your tools suit the task. Who the fuck cares, if it's clear and productive?

    const div = document.createElement('div');
    div.className = 'foo';

Reactive UIs with unidirectional data binding (very important) seem to be the sweet spot. Spreadshees, which pioneered it in consumer software, still reign supreme.

React is quite fast, and is very compact (preact is half the sizef htmx). It seems to be the sweet spot for making rich web UIs.

In the end, this all was a red herring. The problem was in CoreSVG taking 1400ms to render an emoji, clearly a regression. A tweet would suffice to communicate this nugget, but for some reason the author wrote a long and winding piece.

I do this all the time in a dumb but effective way. Add logging statements to code paths that drop timing info. Another dumb but effective way, instead of using a step through debugger, is drop "here, value is {val}". Telling claude to do this is trivial, it's quick, and it can read its own output and self-solve the problem all with just the code itself.

IMHO git bisect is slower, especially depending on the reload/hot-reload/compile/whatever process your actual app is using.

When I read the first sentence, I expected the author to use `git bisect`.

However, what the author seems to have done is used a prompt with claude that probably looked something like this:

"Some piece of code is causing the page to load very slowly. To debug this, I'd like to use binary search, where we keep commenting/uncommenting 50% of the remaining code, and then I manually check if the page is still very slow. Let's start now; Comment out a component (or parts of a component) that you estimate is 50% of the page, and I will tell you if the page is still slow."

How well agents can do this is mostly proportional to how well they can understand and navigate your codebase broadly.

There are various contributing factors to this, but they include clear docs, notes and refactors that clear up parts the agent commonly gets confused by, choosing boring technology (your dependencies are well understood) and access to command-line tools that let it lint + typecheck + test the code. A lot of the scaffolding and wiring necessary are built into Cursor and Claude Code themselves now. Hope that helps!

Not sure what you mean, just have a coding agent (e.g. Claude Code) and talk to it.

"git bisect" usually does the trick.

This is a great technique!

In this case, I had made an overlarge squashed merge that included both the Intercom integration (a suspiciously likely cause of slowness) and the feedback button that added the heart – so I needed to go deeper to figure out the true cause. (Noto Emoji was in the app from before, but wasn't triggered in the dashboard until we added an emoji there.)

It's not solid red. It has shading.

As a bit more on this, until this piece I was oblivious to this COLRv1 thing, which is adding more of SVG-style functionality to already vector font standards.

https://nabla.typearture.com/

https://developer.chrome.com/blog/colrv1-fonts

My natural cynicism is to ask "should a font really do this?" But I guess it's pretty neat.

Still, I'm going to quote the living daylights out of "These coding agents are very much like a power saw. Profoundly useful, and proportionately dangerous."

Even though this particular case may not be fair, the comparison feels like a very fair one to me. The notion that these things can be very valuable in capable hands, but costly in others.

FTFY. I have created a font with a 1BP LLM inside which executes each time the glyph is rendered and figures out the appropriate representation. It will also recursively check the contents of the page and punch up the text.

The LLM contains copies of QEMU, so it can bootstrap itself throughout the enterprise. Naturally, if it finds another LLM, it replaces it. Running an OS and LLM is redundant, so eventually all the machines boot directly into the LLM. It can emulate all the popular desktops, so users won't notice the difference. ;-)