(Via Ian K. Rogers, who particularly notes the tickets’ integration of hand-lettering with typefaces.)

(Via Dan Cederholm’s Studio Notes.)

This image from April 10, 2026, captures NASA’s Orion spacecraft, with its parachutes deployed, seconds before splashdown in the Pacific Ocean. The Artemis II crew accomplished many milestones on their nearly 10-day mission, surpassing the Apollo 13 record for farthest crewed spaceflight and capturing views of the far side of the Moon.

Under Artemis, NASA will send astronauts on increasingly difficult missions to explore more of the Moon for scientific discovery, economic benefits, and to build on our foundation for the first crewed missions to Mars.

See more photos from the mission. (Link to https://www.nasa.gov/artemis-ii-multimedia/)

Following is an initial explanatory paragraph. It serves to help back up the previous paragraphs, and start to ground it in more applicable information. Expectations are set, and potential skepticism is addressed. A link to prior art is supplied, to provide additional context.

There is then a paragraph that serves as a segue. It connects the high-level concepts and begins to draw them down the realm of the practical.

A subheading to help segment the content

This paragraph begins to answer the questions in the reader’s mind that the segue paragraph introduced. It begins with level-setting. Certain key concepts are bolded to accommodate people who skim. Following that is supplying more context, albeit still at a relatively high level.

A short sentence isolated as its own paragraph to drive attention and impact.

The following paragraph begins to dive into particulars. It introduces a new concept related to the subsection’s topic at-hand, careful to stay focused to help the reader understand the larger goal you’re driving towards.

• Bulleted lists help the reader digest these particulars,
• Break up the flow of content, and
• Step through a process.

A follow-up paragraph at the end of a subsection may allude to the author‘s opinions or larger thoughts about the topic. It also sets up the next subsection.

Another subheading

The next concept is addressed, getting more technical as the reader becomes more acclimated. A link to a peer resource is threaded in as an appeal to authority, to help reinforce confidence in the author.

An ordered list is used to:

1. Communicate a series of instructions the reader should take,
2. In which order they should be followed, and
3. Do so in a way that both makes it easy to follow and also breaks up reading flow to be more noticeable.

There might then be another follow-up paragraph. This one might contain a sentence with an em dash—indicative of a trailing thought that is still topically related.

A deeper subheading

This section works deeper into the technical topic. It dispenses with reasoning and analogies and discusses practical specifics.

A piece of code that translates the practical specifics into language a computer can be instructed with. Comments are supplied to help facilitate understanding.

• A bulleted list is used,
• It breaks down and explains code concepts that may not be self-evident, and
• These points may be more holistic, meaning they aren’t a good fit for inline code comments.

A new concept is introduced

We break out of the depth of the deeper subheading’s content and return to a level higher. This is a new concept, yet still living under the umbrella of the overall topic at-hand.

The format of this new concept mirrors the structure of the previous section. This predictability helps with reading flow and answering the reader’s unspoken expectations.

A subheading that begins to tie all the previous sections’ content together

This subsection takes each of the previous points raised and reinforces their need to be sequentially discussed. It then explicitly confirms the case the rest of the content has been implicitly building, that this topic was worth breaking down to better appreciate as a holistic whole.

Some established trust is cashed in. The author is allowed some space to wax philosophical about larger implications, or discuss their feelings on the matter.

A conclusion

The bold first sentence is revisited now that the reader has completed learning about the concept being discussed. A subsequent sentence explicitly ties the nuance the rest of the content discusses to the overall point.

The reader is thanked, and the content ends.

Sometimes this gets taken too far and the joke falls flat, causing a lot more problems than would exist if the joke never happened in the first place. Incidents like this have resulted in many companies just putting in policies against doing that to avoid customer growth impact.

It's refreshing to see the Claude Code team introduce the /buddy system this year. When you run /buddy, it hatches a coding companion that hangs out in your Claude Code interface like a tamagochi. Here's my buddy Xentwine:

╭──────────────────────────────────────╮
        │                                      │
        │  ★★★ RARE                     ROBOT  │
        │                                      │
        │     (   )                            │
        │     .[||].                           │
        │    [ @  @ ]                          │
        │    [ ==== ]                          │
        │    `------´                          │
        │                                      │
        │  Xentwine                            │
        │                                      │
        │  "A methodical circuit-whisperer     │
        │  obsessed with untangling logical    │
        │  snarls; speaks in patient,          │
        │  patronizing riddles and will        │
        │  absolutely let you sit in your own  │
        │  bug for three minutes before        │
        │  offering the blindingly obvious     │
        │  fix."                               │
        │                                      │
        │  DEBUGGING  █████░░░░░  47           │
        │  PATIENCE   █████░░░░░  47           │
        │  CHAOS      ██░░░░░░░░  21           │
        │  WISDOM     █████████░  92           │
        │  SNARK      █████░░░░░  49           │
        │                                      │
        ╰──────────────────────────────────────╯
        

Here's what it looks like in the Claude Code app:

I think this is the best April Fools Day feature in recent memory because it seems intentionally designed to avoid impacting users in a way that would cause problems:

• You have to take manual action to create your coding buddy, it's off by default.
• It mostly stays out of the way when you do create it, meaning that it doesn't impact your normal working process.
• Your buddy sometimes randomly interjects like a tamagochi.
• You can pet the dog, dragon, or robot with /buddy pet.

This is the kind of harmless prank that all nerds should aspire for. 10/10.

If I were to write on this /ai page that I don’t let these tools touch anything I post on this blog, would you trust me? Would that change the perception you have of me? And if you did trust me, why are you doing it? After all, you have no way to actually know for sure. But that is precisely what trust is, isn’t it? Trust is not based on knowledge, but on instinct, on intuitions, on feelings, and on prior experience.

Personally, I couldn’t care less what you write on your /ai page. The same way I couldn’t care less if you use em-dashed. Words are cheap, easy to write, and they mean less and less. But your history, all the baggage you carry with you, all you have written and said, that is harder to fake, building it is time-consuming, but destroying it takes a second. If you start posting AI slop, my trust in you is gone in an instant, and no matter how you’ll try to justify it, that trust will not come back.

Thank you for keeping RSS alive. You're awesome.

Email me :: Sign my guestbook :: Support for 1$/month :: See my generous supporters :: Subscribe to People and Blogs

It was loosely decided at the beginning of 2026 that I would have my own point system for the kids when they speak English or do an English-language activity. Nikki declared it would be a “Lou-Lou Dollar” and, naturally, I overdid it.

I made a 1 Dollar bill, with these little details that only matter to me, bits of nonsense that exist only to satisfy the aesthetic. But I couldn’t stop at One. So I made a Two. Please note while the One has a ginkgo leaf and is from the Tokyo series, the Two has a sakura and is from the Osaka series. Because.

And then a Five, of course, which has a maple leaf from the Nagoya series.

I recognize this is completely out of hand. However, the Ten has a chrysanthemum from the Kyoto series.

I used LTR Federal, Ohno Fatface, Swear, and HEX Franklin. Because if I’m gonna do it, I’m gonna do it right, and those are what made it all feel right.

Oh, and the red kanji stamp in the corners is a counterfeit-prevention mechanism, should the kids discover this page on my website and get the dumb idea of thinking they can just print their own money.

2026-01-09: updated to include background colors and dithered shading

I’ve been hitting the gym hard and getting measurably stronger, so: Food! See, your boy can eat. The amount I can eat before I feel full would astound most of you out there. Whatever you think of as a complete hearty meal, sure as you’re born, ain’t gonna get me there.

Being fat comes with one (1) society-regimented bucket of shame. People look away. It’s a thing.

I had gone off my last round of GLP-1 drugs because I was doing OK, and it had lost its effectiveness. I’m not sure if it’s everyone’s experience, but it’s mine, and it’s happened a couple of times now. Honestly, I think my I CAN EAT THROUGH OZEMPIC line of XXXL T-Shirts has a chance. These drugs work very well for a bit. I like them because it gives me a glimpse of what it’s like to be a regular person who eats a regular amount of food and feels a regular amount of full. You settle into that for a while with these drugs.

But, in time, effectiveness wanes. And the pharmacies have an answer: higher doses! All these GLP-1 drugs, and I’m pretty sure it is all of them, have dosage tiers. The three I’ve tried have three tiers.

Ozempic rolls like this:

Wegovy is getting in on the action:

Mounjaro has even more layers:

Again, they do this because it loses effectiveness. I don’t think people quite realize this??? Even though it’s not hidden in any way.

I think these drugs are pretty amazing, and I’m proud of science for starting to figure all this out, but I’m also a little sick of hearing about how airlines are going to spend less money on fuel now. I’ve been reading this story for many years. It’s laughable when we literally know they don’t work permanently.

Look at those graphics above. This isn’t a forever solution yet. They are literally showing and telling us that. There is no answer once they lose effectiveness. Perhaps controversial, but I think overeating, in the form I experience it, is an addiction, and addictions come back. Is it possible to beat it? Absolutely. Is it likely? No.

I hope you don’t know firsthand, but I bet you already know that cocaine doesn’t maintain effectiveness, either. You need a second line for the same thrill before long. It doesn’t end well.

Anyway, I’m back on GLP-1s.

At least they work for a while, and that while feels pretty good.

It was a rough start, though. My doctor agreed it’s good for me and we should kick up the dosage based on the waned effectiveness. Wegovy this time. It was this past Tuesday that I picked up the meds. It’s down to $350 now! It used to be like $1,200 without insurance. I jabbed myself Tuesday night at about 8pm.

I was hugging the toilet hard by midnight. That was a first.

See, there was a lot of food in my body. I remember lunch that day, where I made a sandwich were my rational brain saw it and thought that’s 2-3 sandwiches. But of course I ate all of it. And one of those salad bags that make a Caesar salad for a family of four. And a pint of cottage cheese. And a bag of Doritos. I was full after that, but the trick is just to switch to sugar after that, and I can keep going. It wasn’t quite noon, and I had a decent breakfast in me already. I ate dinner that night as well.

So when the Wegovy started to hit, which tells your body you’re full when you eat a celery stick, it told my body that it was about to pop. I puked in four sessions over 24 hours.

Now it’s Friday, and I’ve barely eaten since. I’ve eaten a little. Like, I’m fine. It’s just weird.

I’m miscalibrated.

On my own, nature, nurture, whatever you think, my current body is miscalibrated. It doesn’t do food correctly.

On GLP-1 drugs, I’m also miscalibrated. My body doesn’t do food correctly. It highly overcorrects. That can feel good for a while. I don’t wanna be skinny, I just wanna be normal. I want to eat, and stop eating, like a calibrated person.

These two versions of fast mode are very different. Anthropic’s offers up to 2.5x tokens per second (so around 170, up from Opus 4.6’s 65). OpenAI’s offers more than 1000 tokens per second (up from GPT-5.3-Codex’s 65 tokens per second, so 15x). So OpenAI’s fast mode is six times faster than Anthropic’s¹.

However, Anthropic’s big advantage is that they’re serving their actual model. When you use their fast mode, you get real Opus 4.6, while when you use OpenAI’s fast mode you get GPT-5.3-Codex-Spark, not the real GPT-5.3-Codex. Spark is indeed much faster, but is a notably less capable model: good enough for many tasks, but it gets confused and messes up tool calls in ways that vanilla GPT-5.3-Codex would never do.

Why the differences? The AI labs aren’t advertising the details of how their fast modes work, but I’m pretty confident it’s something like this: Anthropic’s fast mode is backed by low-batch-size inference, while OpenAI’s fast mode is backed by special monster Cerebras chips. Let me unpack that a bit.

How Anthropic’s fast mode works

The tradeoff at the heart of AI inference economics is batching, because the main bottleneck is memory. GPUs are very fast, but moving data onto a GPU is not. Every inference operation requires copying all the tokens of the user’s prompt² onto the GPU before inference can start. Batching multiple users up thus increases overall throughput at the cost of making users wait for the batch to be full.

A good analogy is a bus system. If you had zero batching for passengers - if, whenever someone got on a bus, the bus departed immediately - commutes would be much faster for the people who managed to get on a bus. But obviously overall throughput would be much lower, because people would be waiting at the bus stop for hours until they managed to actually get on one.

Anthropic’s fast mode offering is basically a bus pass that guarantees that the bus immediately leaves as soon as you get on. It’s six times the cost, because you’re effectively paying for all the other people who could have got on the bus with you, but it’s way faster³ because you spend zero time waiting for the bus to leave.

edit: I want to thank a reader for emailing me to point out that the “waiting for the bus” cost is really only paid for the first token, so that won’t affect streaming latency (just latency per turn or tool call). It’s thus better to think of the performance impact of batch size being mainly that smaller batches require fewer flops and thus execute more quickly. In my analogy, maybe it’s “lighter buses drive faster”, or something.

Obviously I can’t be fully certain this is right. Maybe they have access to some new ultra-fast compute that they’re running this on, or they’re doing some algorithmic trick nobody else has thought of. But I’m pretty sure this is it. Brand new compute or algorithmic tricks would likely require changes to the model (see below for OpenAI’s system), and “six times more expensive for 2.5x faster” is right in the ballpark for the kind of improvement you’d expect when switching to a low-batch-size regime.

How OpenAI’s fast mode works

OpenAI’s fast mode does not work anything like this. You can tell that simply because they’re introducing a new, worse model for it. There would be absolutely no reason to do that if they were simply tweaking batch sizes. Also, they told us in the announcement blog post exactly what’s backing their fast mode: Cerebras.

OpenAI announced their Cerebras partnership a month ago in January. What’s Cerebras? They build “ultra low-latency compute”. What this means in practice is that they build giant chips. A H100 chip (fairly close to the frontier of inference chips) is just over a square inch in size. A Cerebras chip is 70 square inches.

You can see from pictures that the Cerebras chip has a grid-and-holes pattern all over it. That’s because silicon wafers this big are supposed to be broken into dozens of chips. Instead, Cerebras etches a giant chip over the entire thing.

The larger the chip, the more internal memory it can have. The idea is to have a chip with SRAM large enough to fit the entire model, so inference can happen entirely in-memory. Typically GPU SRAM is measured in the tens of megabytes. That means that a lot of inference time is spent streaming portions of the model weights from outside of SRAM into the GPU compute⁴. If you could stream all of that from the (much faster) SRAM, inference would a big speedup: fifteen times faster, as it turns out!

So how much internal memory does the latest Cerebras chip have? 44GB. This puts OpenAI in kind of an awkward position. 44GB is enough to fit a small model (~20B params at fp16, ~40B params at int8 quantization), but clearly not enough to fit GPT-5.3-Codex. That’s why they’re offering a brand new model, and why the Spark model has a bit of “small model smell” to it: it’s a smaller distil of the much larger GPT-5.3-Codex model⁵.

edit: I was wrong about this - the Codex model is almost certainly larger than this, and doesn’t need to fit entirely in one chip’s SRAM (if it did, we’d be seeing faster speeds). Thanks to the Hacker News commenters for correcting me. But I think there’s still a good chance that Spark is SRAM-resident (split across a few Cerebras chips) which is what’s driving the speedup.

OpenAI’s version is much more technically impressive

It’s interesting that the two major labs have two very different approaches to building fast AI inference. If I had to guess at a conspiracy theory, it would go something like this:

• OpenAI partner with Cerebras in mid-January, obviously to work on putting an OpenAI model on a fast Cerebras chip
• Anthropic have no similar play available, but they know OpenAI will announce some kind of blazing-fast inference in February, and they want to have something in the news cycle to compete with that
• Anthropic thus hustles to put together the kind of fast inference they can provide: simply lowering the batch size on their existing inference stack
• Anthropic (probably) waits until a few days before OpenAI are done with their much more complex Cerebras implementation to announce it, so it looks like OpenAI copied them

Obviously OpenAI’s achievement here is more technically impressive. Getting a model running on Cerebras chips is not trivial, because they’re so weird. Training a 20B or 40B param distil of GPT-5.3-Codex that is still kind-of-good-enough is not trivial. But I commend Anthropic for finding a sneaky way to get ahead of the announcement that will be largely opaque to non-technical people. It reminds me of OpenAI’s mid-2025 sneaky introduction of the Responses API to help them conceal their reasoning tokens.

Is fast AI inference the next big thing?

Seeing the two major labs put out this feature might make you think that fast AI inference is the new major goal they’re chasing. I don’t think it is. If my theory above is right, Anthropic don’t care that much about fast inference, they just didn’t want to appear behind OpenAI. And OpenAI are mainly just exploring the capabilities of their new Cerebras partnership. It’s still largely an open question what kind of models can fit on these giant chips, how useful those models will be, and if the economics will make any sense.

I personally don’t find “fast, less-capable inference” particularly useful. I’ve been playing around with it in Codex and I don’t like it. The usefulness of AI agents is dominated by how few mistakes they make, not by their raw speed. Buying 6x the speed at the cost of 20% more mistakes is a bad bargain, because most of the user’s time is spent handling mistakes instead of waiting for the model⁶.

However, it’s certainly possible that fast, less-capable inference becomes a core lower-level primitive in AI systems. Claude Code already uses Haiku for some operations. Maybe OpenAI will end up using Spark in a similar way.

edit: there are some good comments about this post on Hacker News. First, a good correction: Cerebras offers a ~355B model, GLM-4.7, at 1000 tokens per second already, so I’m wrong about Spark living in a single chip’s SRAM. Presumably they’re sharding Spark across multiple chips, like they’re doing with GLM-4.7.

Many commenters disagreed with me (and each other) about the performance characteristics of batching. Some said that continuous batching means nobody ever waits for a bus, or that the volume of requests for Anthropic models means batch wait time is negligible. Other users disagreed about whether chip-to-chip communication is a bottleneck at inference time, or whether chaining chips together affects throughput.

I only have a layman’s understanding of continuous batching, but it seems to me that you still have to wait for a slot to become available (even if you’re not waiting for the entire previous batch to finish), so the batch size throughput/latency tradeoff still applies.

edit: A reader wrote in with a compelling alternate explanation for Anthropic’s fast AI mode - that they’re using more aggressive speculative decoding, which spends more tokens but could plausibly deliver a 2.5x speedup at significantly higher costs (because many big-model rollouts are done in parallel and thrown away). I don’t know if I’m 100% convinced - I’m confident big labs are already doing speculative decoding, and the longer sequences you try the less reliable it is - but I think it’s certainly possible.

I didn’t ask for this and neither did you.

I didn’t ask for a robot to consume every blog post and piece of code I ever wrote and parrot it back so that some hack could make money off of it.

I didn’t ask for the role of a programmer to be reduced to that of a glorified TSA agent, reviewing code to make sure the AI didn’t smuggle something dangerous into production.

And yet here we are. The worst fact about these tools is that they work. They can write code better than you or I can, and if you don’t believe me, wait six months.

You could abstain out of moral principle. And that’s fine, especially if you’re at the tail end of your career. And if you’re at the beginning of your career, you don’t need me to explain any of this to you, because you already use Warp and Cursor and Claude, with ChatGPT as your therapist and pair programmer and maybe even your lover. This post is for the 40-somethings in my audience who don’t realize this fact yet.

So as a senior, you could abstain. But then your junior colleagues will eventually code circles around you, because they’re wearing bazooka-powered jetpacks and you’re still riding around on a fixie bike. Eventually your boss will start asking why you’re getting paid twice your zoomer colleagues’ salary to produce a tenth of the code.

Ultimately if you have a mortgage and a car payment and a family you love, you’re going to make your decision. It’s maybe not the decision that your younger, more idealistic self would want you to make, but it does keep your car and your house and your family safe inside it.

Someday years from now we will look back on the era when we were the last generation to code by hand. We’ll laugh and explain to our grandkids how silly it was that we typed out JavaScript syntax with our fingers. But secretly we’ll miss it.

We’ll miss the feeling of holding code in our hands and molding it like clay in the caress of a master sculptor. We’ll miss the sleepless wrangling of some odd bug that eventually relents to the debugger at 2 AM. We’ll miss creating something we feel proud of, something true and right and good. We’ll miss the satisfaction of the artist’s signature at the bottom of the oil painting, the GitHub repo saying “I made this.”

I don’t celebrate the new world, but I also don’t resist it. The sun rises, the sun sets, I orbit helplessly around it, and my protests can’t stop it. It doesn’t care; it continues its arc across the sky regardless, moving but unmoved.

If you would like to grieve, I invite you to grieve with me. We are the last of our kind, and those who follow us won’t understand our sorrow. Our craft, as we have practiced it, will end up like some blacksmith’s tool in an archeological dig, a curio for future generations. It cannot be helped, it is the nature of all things to pass to dust, and yet still we can mourn. Now is the time to mourn the passing of our craft.

Today, I want to rant for a minute, and then offer some pragmatic advice.

Everything sucks

The world has been pretty bad for a while.

The juggernaut of environmental collapse. The flood of refugees into Europe (and their horrific treatment by the countries that colonized and destabilized their home countries). The assault on Ukraine. The genocide of Palestine. The civil war in Sudan.

And most recently, the fascist takeover of my country, the United States, and the rampant abuses committed by the ICE gestapo.

Why would I give a single fuck about the best way to render content with web components or the latest tech drama when Nazi bootlickers are literally kicking down doors without warrants and kidnapping my neighbors?

But under capitalism, it’s all “dance, monkey, dance.”

You’re expected to wake up every day, but on a fucking smile, and grind out more code widgets to keep capital flowing up so that crumbs can trickle down.

Ok, pitty party over. Let’s talk tactics.

Give a shit about people

One of the most anti-fascist things you can do is give a shit about people.

Like, truly, genuinely care.

Learn your neighbors names. Buy tents and sleeping bags for the unhoused. Start a little free pantry or community fridge. Buy groceries or deliver meals to people in your town who can’t drive. Shovel driveways.

Throw parties. Make boring infrastructure pretty with stickers or chalk or paint.

Fascism hates joy.

You can also buy and distribute whistles and generally be dirt in the cog whenever possible.

Help people. Attack systems.

This is a lesson straight from the Dungeon Crawler Carl book series.

First, recognize that you can’t save everyone, but you can fight like hell to help the people you can.

Second, understand that systems are the real enemy, and often shitty people are doing bad shit because shitty systems force or encourage them too.

That doesn’t mean you should go all kumbaya and hug it out with Nazis. But recognize that until you destroy the system, cutting off one head of the hydra just causes two more to grow.

And if you’re feeling strong, and even more so if you’re not, repeat Carl’s mantra…

You will not break me, fuck you all, I will break you.

Stay strong, friends! ✊

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

Last week, we talked about one huge question, “How the hell are you supposed to have a career in tech in 2026?” That’s pretty specific to this current moment, but there are some timeless, more perennial questions I've been sharing with friends for years that I wanted to give to all of you. They're a short list of questions that help you judge whether a job that you’re considering is going to crush your soul or not.

Obviously, not everyone is going to get to work in an environment that has perfect answers to all of these questions; a lot of the time, we’re lucky just to get a place to work at all. But these questions are framed in this way to encourage us all to aspire towards roles that enable us to do our best work, to have the biggest impact, and to live according to our values.

Seven Questions to Check If A Job Will Crush Your Soul

• If what you do succeeds, will the world be better?

This question originally started for me when I would talk to people about new startups, where people were judging the basic idea of the product or the company itself, but it actually applies to any institution, at any size. If the organization that you’re considering working for, or the team you’re considering joining, is able to achieve their stated goals, is it ultimately going to have a positive effect? Will you be proud of what it means? Will the people you love and care about respect you for making that choice, and will those with the least to gain feel like you’re the kind of person who cares about their impact on the world?

• Whose money do they have to take to stay in business?

Where does the money in the organization really come from? You need to know this for a lot of reasons. First of all, you need to be sure that they know the answer. (You’d be surprised how often that’s not the case!) Even if they do know the answer, it may make you realize that those customers are not the people whose needs or wants you’d like to spend most of your waking hours catering to. This goes beyond the simple basics of the business model — it can be about whether they're profitable or not, and what the corporate ownership structure is like.

It’s also increasingly common for companies to mistake those who are investing in a company with those who are their customers. But there’s a world of difference between those who are paying you, and those who you have to pay back tenfold. Or thousandfold.

The same goes for nonprofits — do you know who has to stay happy and smiling in order for the institution to stay stable and successful? If you know those answers, you'll be far more confident about the motivations and incentives that will drive key decisions within the organization.

• What do you have to believe to think that they’re going to succeed? In what way does the world have to change or not change?

Now we’re getting a little bit deeper into thinking about the systems that surround the organization that you’re evaluating. Every company, every institution, even every small team, is built around a set of invisible assumptions. Many times, they’re completely reasonable assumptions that are unlikely to change in the future. But sometimes, the world you’re working in is about to shift in a big way, or things are built on a foundation that’s speculative or even unrealistic.

Maybe they're assuming there aren't going to be any big new competitors. Perhaps they think they'll always remain the most popular product in their category. Or their assumptions could be about the stability of the rule of law, or a lack of corruption — more fundamental assumptions that they've never seen challenged in their lifetime or in their culture, but that turn out to be far more fragile than they'd imagined.

Thinking through the context that everyone is sharing, and reflecting on whether they’re really planning for any potential disruptions, is an essential part of judging the psychological health of an organization. It’s the equivalent of a person having self-awareness, and it’s just as much of a red flag if it’s missing.

• What’s the lived experience of the workers there whom you trust? Do you have evidence of leaders in the organization making hard choices to do the right thing?

Here is how we can tell the culture and character of an organization. If you’ve got connections into the company, or a backchannel to workers there, finding out as much information as you can about the real story of its working conditions is often one of the best ways of understanding whether it’s a fit for your needs. Now, people can always have a bad day, but overall, workers are usually very good at providing helpful perspectives about their context.

And more broadly, if people can provide examples of those in power within an organization using that power to take care of their workers or customers, or to fight for the company to be more responsible, then you’ve got an extremely positive sign about the health of the place even before you’ve joined. It’s vital that these be stories you are able to find and discover on your own, not the ones amplified by the institution itself for PR purposes.

• What were you wrong about?

And here we have perhaps one of the easiest and most obvious ways to judge the culture of an organization. This is even a question you can ask people while you’re in an interview process, and you can judge their responses to help form your opinion. A company, and leadership culture, that can change its mind when faced with new information and new circumstances is much more likely to adapt to challenges in a healthy way. (If you want to be nice, phrase it as "What is a way in which the company has evolved or changed?")

• Does your actual compensation take care of what you need for all of your current goals and needs — from day one?

This is where we go from the abstract and psychological goals to the practical and everyday concerns: can you pay your bills? The phrasing and framing here is very intentional: are they really going to pay you enough? I ask this question very specifically because you’d be surprised how often companies actually dance around this question, or how often we trick ourselves into hearing what we want to hear as the answer to this question when we’re in the exciting (or stressful) process of considering a new job, instead of looking at the facts of what’s actually written in black-and-white on an offer letter.

It's also important not to get distracted with potential, even if you're optimistic about the future. Don’t listen to promises about what might happen, or descriptions of what’s possible if you advance in your role. Think about what your real life will be like, after taxes, if you take the job that they’ve described.

• Is the role you’re being hired into one where you can credibly advance, and where there’s sufficient resources for success?

This is where you can apply your optimism in a practical way: can the organization accurately describe how your career will proceed within the company? Does it have a specific and defined trajectory, or does it involve ambiguous processes or changes in teams or departments? Would you have to lobby for the support of leaders from other parts of the organization? Would making progress require acquiring new skills or knowledge? Have they committed to providing you with the investment and resources required to learn those skills?

These questions are essential to understand, because lacking these answers can lead to an ugly later realization that even an initially-exciting position may turn out to be a dead-end job over time.

Towards better working worlds

Sometimes it can really feel like the deck is stacked against you when you're trying to find a new job. It can feel even worse to be faced with an opportunity and have a nagging sense that something is not quite right. Much of the time, that feeling comes from the vague worry that we're taking a job that is going to make us miserable.

Even in a tough job market, there are some places that are trying to do their best to treat people decently. In larger organizations, there are often pockets of relative sanity, led by good leaders, who are trying to do the right thing. It can be a massive improvement in quality of life if you can find these places and use them as foundations for the next stage of your career.

The best way to navigate towards these better opportunities is to be systematic when evaluating all of your options, and to hold out for as high standards as possible when you're out there looking. These seven questions give you the tools to do exactly that.

https://techcrunch.com/2026/01/12/trumps-epa-plans-to-ignore...

  88 acres = 356,124 m2
  4.56 kWh/m2 per day solar insolation (4.5 is typical for much of the US)
  4.56 kWh/m2 per day \* 356,124 m2 = 1,623,924 kWh/day = 67,664 kW = 67.66 MW average
  1000 W/m2 \* 356,124 m2 = 356 MW peak

30 MW is still only 10% of the the 300 MW used by the data center. But there's lots of land out there, so roughly 1000 acres per data center doesn't seem that extreme to me. That's a 4 km2 or 1.5 mile2 lot, or about 2 km or 1.25 miles on a side.

Basically every GPU server uses 1 kW (about 1 space heater), which puts into perspective just how much computing power is available at these data centers. Running a GPU continuously at home would need 24 kWh/day, so with > 20% efficiency panels that's 4.5*.2 = 0.9 kWh/m2 per day, so 26.67 m2, so at 2 m2 per commercial solar panel and assuming that my math is right: that's about 14 panels considering nights and seasons.

It's interesting to think just how many panels it takes to run a GPU or space heater continuously, even when they put out 500 W or 250 W/m2 peak. And how cheap that electricity really is when it's sold for on the order of $0.15 per kWh, or $3.60 per day.

I've found that the very best way to save on your electric bill is to have a few south-facing slider doors and windows, which is like running a space heater every square meter of window. There's just no way that any other form of power generation can compete with that. Also, I feel that we're doing it wrong with solar. This analysis shows just how much better alternatives like trough solar and concentrated solar (mirrors towards solar panels) might be cost-wise. On an ironic note, solar panels now cost less than windows by area, and probably mirrors.

💬 Join the discussion on kottke.org →

On the first day of 2017, I published my first blog post; I’m posting the 620th. I also sent out the 1st edition of Dealgorithmed because I guess I’m a sucker for starting projects on the first day of the year. It does make it easy to remember when there’s an anniversary to celebrate, though.

I genuinely think this is going to be my last digital project. I said it many times before, but this time it does feel different. I don’t know about you, but I’m seriously starting to feel digital fatigue. I’m cruising towards my 15th year as a freelancer—I’ll officially hit that milestone on July 1st, 2027, even though I started working solo at the end of 2011—and I find myself reflecting a lot on the possibility of completely changing career and doing something completely different that has nothing to do with the digital world. Time will tell if this stays an idea or it becomes a concrete plan.

I do know that no matter what I end up doing, I’ll still continue posting on this blog. Because blogging is fun, it’s therapeutic, and more people should do it. Plus, I want to become one of those oldheads with a blog that is 30 years old!

Thank you for keeping RSS alive. You're awesome.

Email me :: Sign my guestbook :: Support for 1$/month :: See my generous supporters :: Subscribe to People and Blogs

As a user, you can highlight any section of text on a page and right click to make it a text fragment. In Safari, that means right clicking and selecting “Copy Link with Highlight” from the menu and getting a url that will highlight the text fragment when the page loads.

The default highlighting gives you a pale yellow highlight under the fragment text, like this:

You can click on this link to see for yourself how it works.

That’s the user experience. But what about the developer experience? Is there something we developers can do to customize that experience for our users a bit more? Actually, there is! We’ll use the ::target-text pseudo-element to help us style our text fragment.

In your CSS file, use the ::target-text pseudo-element and style the text with whatever properties you wish, like this:

::target-text {
  background-color: blue;
  color: white;
}

That’ll get you this result:

So if you want to decide how a text fragment looks to your users, take advantage of ::target-text and own the user’s text fragment experience. It’s fully supported in all browsers.

If you enjoyed this kind of bite-size content, let me know. You can reach me, Saron Yitbarek, on BlueSky, or reach out to our other evangelists — Jon Davis, on Bluesky / Mastodon, and Jen Simmons, on Bluesky / Mastodon. You can also follow WebKit on LinkedIn. If you find a bug or problem, please file a WebKit bug report.

• 

  Critical Role

  This is by far the biggest addition to my listening since 2019. I started shortly before the pandemic and practically tore through the first couple of campaigns until I caught up early in their third campaign. This has consumed the majority of my podcast time over the past few years as I started at the beginning and listened to over 100+ 3-5 hour long episodes each across three campaigns. I adore listening to these seasoned voice actors live play Dungeons & Dragons.

  It’s hard to say where to start because each of the original three campaigns is very different, but all of them are fun. The first 10-20 episodes of campaign 1 can be hard to listen to or watch because they were still learning how to produce them. They did just start a fourth campaign with a new dungeon master (Brennan Lee Mulligan), new world, and an expanded cast so if you’re new to Critical Role, maybe start there. You can also watch on YouTube or their own streaming service Beacon.

• 

  Endless Thread

  I discovered this podcast from Ben Brock Johnson and Amory Sivertson through a recent mini-crossover with 99% Invisible called Hidden Levels where they talked about video games. So far I’ve dipped a toe in here and there (selecting specific episodes rather than blanket subscribing), but I really enjoy it.

• 

  Lore

  Lore with Aaron Mahnke had been on my list to check out for awhile. It’s a fun way to explore the more mysterious, weird, and scary stories in history. This is another I’ve only just started listening to, but so far I’m really enjoying it. I love history podcasts because they can be good creative kindling for D&D ideas, and these stories in particular spark so many ideas.

• 

  The Rest is History

  Speaking of history, The Rest is History is a great introduction to lots of random stories in history. The hosts – Tom Holland (not the Spider-Man star) and Dominic Sandbrook – explore specific aspects of important historical moments. Some they revisit regularly (like the French Revolution, the Roman Empire, and the World Wars) while others get short bursts in between. They enjoy poking fun at each other and generally make it fun to learn about history. My one complaint is that it's very heavily focused on western history. I would love recommendations for history podcasts for other parts of the world in particular.

• 

  ShopTalk

  I enjoy the camaraderie of Dave Rupert and Chris Coyier talking about making websites. I feel like I learn something new about the web every time I listen, and they both have a fun friendly banter that’s easy to enjoy. They’ll occasionally talk about something they see on the screen together, which can be hard for an audio podcast, but they’re generally pretty self-aware of when they do that. (A lot of other dev and design podcasts struggle with this, too.)

• 

  Wake Up Excited

  
  This new podcast from Brad Frost is really inspiring. He chats with creative people in all kinds of fields about what gets them excited and keeps them going.

Give me recommendations!

What podcasts do you enjoy? Are you a regular weekly show kind of person? A limited run series on a specific topic? Do you like deep dives on esoteric subjects? Stories? Comedy? Weekly news? I am always interested in new things to listen to so send your favorites my way. Or write about them on your own site and share the link!

Short-term results come from intensity. Long-term results come from consistency.

**

Ninety percent of success can be boiled down to consistently doing the obvious thing for an uncommonly long period of time without convincing yourself that you’re smarter than you are.

***

Working smart isn’t the opposite of working hard. It’s the result of working hard.

You have to put in the hours before you can see the shortcuts. You have to learn the details before you can know which ones matter.

You have to do the work wrong many times before you discover how to do it right.

Last year, my friend Stacy introduced our friend group to the idea of a "New Years Bingo Card": the idea being to create smaller, more achievable things you want to do in the coming year, with a focus on positive/fun ideas. It was a fun NYE activity and so my buddy Andrew and I (who built Listed together) put together a "New Years Bingo" webapp! You can play it at bingonewyears.com. You can set "yes/no" goals, or create counters/monthly goals.

We used svelte for its speed of development, small output size, and nice static site generation. All the goals are saved to local storage and never sent elsewhere- the plan is to add both a print stylesheet as well as a way to move the data around!

If you liked this post, consider subscribing to email updates about my new posts, or sharing it on Hacker News. Here's a preview of a related post that shares tags with this one.

You can't design software you don't work on

Only the engineers who work on a large software system can meaningfully participate in the design process. That’s because you cannot do good software design without an intimate understanding of the concrete details of the system. In other words, generic software design advice is typically useless for most practical software design problems.

What is generic software design? It’s “designing to the problem”: the kind of advice you give when you have a reasonable understanding of the domain, but very little knowledge of the existing codebase. Unfortunately, this is the only kind of advice you’ll read in software books and blog posts. Engineers love giving generic software design advice for the same reason that all technical professionals love “talking shop”. However, you should be very careful about applying generic advice to your concrete day-to-day work problems.
Continue reading...

If you liked this post, consider subscribing to email updates about my new posts, or sharing it on Hacker News. Here's a preview of a related post that shares tags with this one.

Keep incidents boring

The internet is full of exciting incident war stories. Tough engineering problems, solved under pressure by sleep-deprived developers. In an industry where the best code is usually the most boring implementation, it’s nice to think that there’s at least one place where hacking up a cool idea is heroic rather than irresponsible. For some engineers, me included, being on-call has a really seductive appeal. Working under pressure is fun, and there’s a lot of immediate validation in being the one who figures an incident out. Other people have written a lot about the problems with this hero-mentality: both for the engineer, who rapidly becomes a single point of failure and burns out, and for the organisation, which incentivises incident response rather than incident prevention. I agree with all of that. But I think the prevalence of war stories also misrepresents what it’s like to be an effective incident responder. Almost no incidents are interesting. High-pressure, yes, but typically boring from an engineering perspective.
Continue reading...

If you liked this post, consider subscribing to email updates about my new posts, or sharing it on Hacker News. Here's a preview of a related post that shares tags with this one.

How I influence tech company politics as a staff software engineer

Many software engineers are fatalistic about company politics. They believe that it’s pointless to get involved, because:

The general idea here is that software engineers are simply not equipped to play the game at the same level as real political operators. This is true! It would be a terrible mistake for a software engineer to think that you ought to start scheming and plotting like you’re in Game of Thrones. Your schemes will be immediately uncovered and repurposed to your disadvantage and other people’s gain. Scheming takes practice and power, and neither of those things are available to software engineers.
Continue reading...

Tips

Before you start deploying this list in your cluster, some tips upfront on how to manage your services. More about that in detail in another blog post soon (subscribe to the RSS feed)

• Use a real domain for your services (like service.yourname.net, point DNS to your server/cluster IP) which will allow you to run a cert-manager and issue valid Let's Encrypt SSL certificates. This will save you a lot of headaches.

• If you want to access services remotely or share links to users without a VPN connection, setup a remote server that is only acting as a reverse proxy (like Caddy, with automated SSL certs) and only allow this specific IP to connect to your routers public IP via firewall rules.

• Make your server/cluster deployment reproducable. Don't rely on fancy web UIs but rather configuration files. Document all changes and keep a single-source-of-truth configuration repository which can be instantly deployed.

• Always deploy the docker images with a fixed version (eg. henrygd/beszel-agent:0.17.0) and manually update. You can monitor new image versions in Glance or subscribe to Github releases with your RSS reader.

• If you're using Kubernetes, apply Network Policies to all deployments so than can only communicate to allow-listed IP spaces and services.

Outlook

There's a lot I want to add in the coming year. Some of that includes:

• Smart meters for my gas heating

• Monitoring birds in my backyard via BirdNET

• Self-hosting images via Immich (thank's AI for those SSD prices)

• Tracking flights with own receiver

• Backup more things locally

• Looking into making AnyType and Excalidraw self-hostable

• Add SSO via authentik or Authelia

The following list is separated into 1. Tools, 2. Monitoring, 3. Media and 4. Internal.

1. Tools

Baikal: CalDAV / CardDAV

I'm self-hosting my calendar and contact data and found that Baikal works best for me

BentoPDF

If you have tummy aches when uploading somewhat sensitive document into a "free online pdf tool converter", you should run your own instance of BentoPDF which provides many many features for editing PDFs.

Tip: Use the bentopdf-simple image so that the marking section, similar to the landing page, is hidden.

ConvertX

Pretty ugly but insanely powerfull. Convert anything to anything with ConvertX.

FreshRSS

You should start reading more news and blog posts. Great time to setup your own instance of FreshRSS - an RSS aggregator with nice integration to NetNewsWire and many other clients.

Gitea

Maybe you don't need to upload anything to GitHub just so Microsoft can train their shit AI on it, so start hosting your own Gitea instance, Helm chart included.

Glance

In my opinion the best HomeLab dashboard, customizable, pretty and feature-rich. Get Glance.

Home Assistant

This text only exists so I can link to Home Assistant on GitHub - no introduction needed.

iSponsorBlockTV

iSponsorBlockTV integrates SponsorBlock with your smart TV - like Apple TV.

Mermaid

You can host your own Mermaid Live editor, no platform with saving, sharing and such but helpful if you're using Mermaid charts.

MeTube

MeTube is just a frontend for yt-dlp so I don't have to fight with annoying ads when sicherheitsspeichern YouTube videos.

NocoDB

A neat GUI database / spreadsheet-like web application, also good for collaboration: NocoDB.

Tip: Set env vars NC_DISABLE_SUPPORT_CHAT and NC_DISABLE_TELE to "false".

Owntracks

Stop pumping your geolocation into your Google account and start using self-hosted Owntracks with the Owntracks frontend.

Tip: Take a look at the Owntracks frontend configuration options which can really enhance the look.

Roundcube

If you also have a lot of mailboxes, it's a great idea to host Roundcube instead of syncing every single one of them with your mail client.

Tip: Enable the included managesieve plugin with $config['plugins'] = ['managesieve']; to allow editing mail rules directly in Roundcube.

Slink

A self-hosted image sharing platform for quickly sharing images: Slink.

Traccar

Similar to Owntracks but Traccar more optimized for tracking vehicles and collaborating with multiple users and clients.

2. Monitoring

Beszel

Beszel is great for getting an overview about CPU and memory with multiples machines.

Grafana

You should already know Grafana, a data visualization tool.

Kuvasz

You can monitoring many many websites for uptime & SSL validity with Kuvasz.

Prometheus

Can't use Grafana without Prometheus - can you?

Speedtest Tracker

Pretty okay-ish Speedtest monitoring with Speedtest Tracker. It's running Ookla so be aware that all results are being logged by them.

3. Media

Jellyfin

Jellyfin provides media management and video players for your movies and TV shows.

Prowlarr

If you know you know, "RSS aggregator" for Linux ISOs with Prowlarr.

qBittorrent

Can't boot Linux without an ISO, so share and care with qBittorrent.

Radarr

Radarr is a movie organizer/manager for usenet and torrent users.

Sonarr

Sonarr is a smart PVR for newsgroup and bittorrent users.

Seerr

If you have multiple normie users watching movies on your Jellyfin, they can also request new media via Seer (formerly Jellyseer)

4. Internal

DDNS Updater

A lightweight universal DDNS Updater written in Go with a small but helpful web UI.

Gitea Mirror

In case GitHub get's flöten or Microsoft or their rogue AI deletes your GitHub account, setup a mirroring for your repositories with Gitea mirror.

5. Backup

Biochon

Biochon can pull your mails via IMAP - but has no restore/export functionality yet. Looks really good and is in active development.

So I’ve decided to go with lit-html for writing my own components.

Why not use the entire lit package instead of just lit-html?

Honestly, I believe something like lit-html should be a part of vanilla JavaScript (maybe someday?). So by using lit-html, I basically pretend like it is already. It’s my go-to solution when I want to write HTML in JavaScript. For more solid reasons, you can refer to the following list:

• Size difference. This often does not really matter for most projects anyway.)
  • lit-html – 7.3 kb min, 3.1 kb min + gzip
  • lit – 15.8 kb min, 5.9 kb min + gzip
• LitElement creates a shadow DOM by default. I don’t want to use the shadow DOM when creating my own components. I prefer to allow styling solutions like Tailwind to work instead of having to rely on solutions like CSS shadow parts to style my components. The light DOM can be nice.
• import { html, render } from "lit-html" is all you need to get started to write lit-html templates whereas Lit requires you to learn about decorators to use most of its features. Sometimes you may want to use Lit directives if you need performant renders but it’s not necessary to make lit-html work on your project.

I will be showing two examples with what I consider to be two distinct methods to create a lit-html custom element. The first example will use what I call a “stateless render” because there won’t be any state parameters passed into the lit-html template. Usually this kind of component will only call the render method once during its lifecycle since there is no state to update. The second example will use a “stateful render” which calls the render function every time a state parameter changes.

Stateless Render

For my first example, the custom-element is a <textarea> wrapper that also has a status bar similar to Notepad++ that shows the length and lines of the content inside the <textarea>. The status bar will also display the position of the cursor and span of the selection if any characters are selected. Here is a picture of what it looks like for those readers that haven’t used Notepad++ before.

I used a library called TLN (“Textarea with Line Numbers”) to make the aesthetic of the textarea feel more like Notepad++, similar to the library’s official demo. Since the base template has no state parameters, I’m using plain old JavaScript events to manually modify the DOM in response to changes within the textarea. I also used the render function again to display the updated status bar contents instead of user .innerHTML() to keep it consistent with the surrounding code.

Using lit-html to render stateless components like these is useful, but perhaps not taking full advantage of the power of lit-html. According to the official documentation:

When you call render, lit-html only updates the parts of the template that have changed since the last render. This makes lit-html updates very fast.

You may ask: “Why should you use lit-html in examples like this where it won’t make that much of a difference performance wise? Since the root render function is really only called once (or once every connectedCallback()) in the custom elements lifecycle.”

My answer is that, yes, it’s not necessary if you just want rendering to the DOM to be fast. The main reason I use lit-html is that the syntax is so much nicer to me compared to setting HTML to raw strings. With vanilla JavaScript, you have to perform .createElement(), .append(), and .addEventListener() to create deeply nested HTML structures. Calling .innerHTML() = `<large html structure></>` is much better, but you still need to perform .querySelector() to lookup the newly created HTML and add event listeners to it.

The @event syntax makes it much more clear where the event listener is located compared to the rest of the template. For example…

class MyElement extends LitElement {
  ...
  render() {
    return html`
      <p><button @click="${this._doSomething}">Click Me!</button></p>
    `;
  }
  _doSomething(e) {
    console.log("something");
  }
}

It also makes it much more apparent to me on first glance that event.currentTarget can only be the HTMLElement where you attached the listener and event.target can be the same but also may come from any child of the said HTMLElement. The template also calls .removeEventListener() on its own when the template is removed from the DOM so that’s also one less thing to worry about.

The Status Bar Area

Before I continue explaining the change events that make the status bar work, I would like to highlight one of the drawbacks of the “stateless render”: there isn’t really a neat way to render the initial state of HTML elements. I could add placeholder content for when the input is empty and no selection was made yet, but the render() function only appends the template to the given root. It doesn’t delete siblings within the root so the status bar text would end up being doubled. This could be fixed if I call an initial render somewhere in the custom element, similar to the render calls within the event listeners, but I’ve opted to omit that to keep the example simple.

The input change event is one of the more common change events. It’s straightforward to see that this will be the change event used to calculate and display the updated input length and the number of newlines that the input has.

I thought I would have a much harder time displaying the live status of selected text, but the selectionchange event provides everything I need to calculate the selection status within the textarea. This change event is relatively new too, having only been a part of baseline last September 2024.

Since I’ve already highlighted the two main events driving the status bar, I’ll proceed to the next example.

Stateful Render

My second example is a <pokemon-card> custom-element. The pokemon card component will generate a random Pokémon from a specific pokemon TCG set. The specifications of the web component are as follows:

• The placeholder will be this generic pokemon card back.
• A Generate button that adds a new Pokémon card from the TCG set.
• Left and right arrow buttons for navigation.
• Text that shows the name and page of the currently displayed Pokémon.

In this example, only two other external libraries were used for the web component that weren’t related to lit and lit-html. I used shuffle from es-toolkit to make sure the array of cards is in a random order each time the component is instantiated. Though the shuffle function itself is likely small enough that you could just write your own implementation in the same file if you want to minimize dependencies.

I also wanted to mention es-toolkit in this article for readers that haven’t heard about it yet. I think it has a lot of useful utility functions so I included it in my example. According to their introduction, “es-toolkit is a modern JavaScript utility library that offers a collection of powerful functions for everyday use.” It’s a modern alternative to lodash, which used to be a staple utility library in every JavaScript project especially during the times before ES6 was released.

There are many ways to implement a random number generator or how to randomly choose an item from a list. I decided to just create a list of all possible choices, shuffle it, then use the pop method so that it’s guaranteed no card will get generated twice. The es-toolkit shuffle type documentation states that it “randomizes the order of elements in an array using the Fisher-Yates algorithm”.

Handling State using Signals

Vanilla JavaScript doesn’t come with a state management solution. While LitElement’s property and state decorators do count as solutions, I want to utilize a solution that I consider should be a part of Vanilla JavaScript just as with lit-html. The state management solution for the component will be JavaScript Signals. Unlike lit-html, signals are already a Stage 1 Proposal so there is a slightly better chance it will become a standard part of the JavaScript specification within the next few years.

As you can see from the Stage 1 Proposal, explaining JavaScript Signals from scratch can be very long that it might as well be its own multi-part article series so I will just give a rundown on how I used it in the <pokemon-card> custom-element. If you’re interested in a quick explanation of what signals are, the creator of SolidJS, which is a popular framework that uses signals, explains their thoughts here.

Signals need an effect implementation to work which is not a part of the proposed signal API, since according to the proposal, it ties into “framework-specific state or strategies which JS does not have access to”. I will be copy and pasting the watcher code in the example despite the comments recommending otherwise. My components are also too basic for any performance related issues to happen anyways. I also used the @lit-labs/signals to keep the component “lit themed” but you can also just use the recommended signal-polyfill directly too.

Signal Syntax

The syntax I used to create a signal state in my custom HTMLElement are as follows:

#visibleIndex = new Signal.State(0)

get visibleIndex() {
  return this.#visibleIndex.get()
}

set visibleIndex(value: number) {
  this.#visibleIndex.set(value)
}

There is a much more concise way to define the above example which involves auto accessors and decorators. Unfortunately, CodePen only supports TypeScript 4.1.3 as of writing, so I’ve opted to just use long-hand syntax in the example. An example of the accessor syntax involving signals is also shown in the signal-polyfill proposal.

Card Component Extras

The Intersection Observer API was used to allow the user to navigate the card component via horizontal scroll bar while also properly updating the state of the current page being displayed.

There is also a keydown event handler present to also let the user navigate between the cards via keyboard presses. Depending on the key being pressed, it calls either the handlePrev() or handleNext() method to perform the navigation.

Finally, while entirely optional, I also added a feature to the component that will preload the next card in JavaScript to improve loading times between generating new cards.

Thank you for keeping RSS alive. You're awesome.

Email me :: Sign my guestbook :: Support for 1$/month :: See my generous supporters :: Subscribe to People and Blogs

Abbey has a similar perspective that I do on ADHD: knowing you have it means that you can start to embrace your strengths instead of constantly worrying about the things you suck at.

It’s well worth 10 minutes of your day.

Related to this, a new study was just published found that people with ADHD who learned about and focused on their strengths had substantially better mental health than those who did not.

…increased strengths knowledge and, to some extent, greater strengths use were associated with better wellbeing, improved quality of life, and fewer mental health symptoms.

Or as Abbey says in her talk…

Celebrate being a firework in a world that wants you to be a cube.

Fuck yea! 🎉

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

But Daikichi has been so busy, studying for his upcoming entrance exam for junior high. Evenings and weekends are jam-packed with cram school. The only days he’s free are public holidays, which are among the busiest at Disneyland.

I schemed with his parents, and we decided for Christmas, I could pull him out of school any day after his exam, and we could go to Disneyland that day. I thought that was a really cute idea, but it’s an intangible gift. Compared to the big LEGO set I got for his sister Nikki, just saying that we can go to Disneyland would not be enough.

So I set out to make him a ticket book. Besides Disneyland in California and Magic Kingdom in Florida, Tokyo Disneyland also had ticket books! Some of them were marketed as “Big Ten” with standard ABCDE-tickets inside, with a promo ticket for a new attraction like Meet the World.

The goal here was not to make a replica of any real ticket book, but rather make something reminiscent of a real one, something he never got to experience. Honestly, I never did either. To me, it was important to recreate not individual elements, but the vibe of having a ticket book. To that end, I started by measuring out ticket sizes and making a pattern. I took every opportunity to make fun details.

Apart from the design, I also needed to determine what the tickets were good for, in a ranked value like the originals. Since nowadays park admission includes all attractions, the modern equivalent to an E-ticket is not really admission to an E-ticket attraction, but maybe the paid Fastpass option, Disney Premier Access. The D-ticket could be a normal free Fastpass, Priority Pass. Other things we’d purchase like dinner, lunch, and a snack could be C, B, and A tickets.

I used Hoefler’s Tungsten for the big ticket letter and HEX Franklin for most body copy. I got to use Mark Simonson’s incredible Bookmania for the slightly frilly “Big Day” and “Main Entrance Admission” titles. Hoefler’s Claimcheck Numbers for the date, and my own Urayasu font (unreleased 2.0) for the Tokyo Disneyland logo. I drew everything else I needed.

Meet the World is long gone, so I needed a different promo ticket. And then it hit me. The Disney Resort Line (monorail) has these really cute souvenir day passes. So Daikichi can exchange one of my tickets for one of those tickets. To fill up the space, I drew the iconic hand straps hanging on the headline rule.

Yes, this is all fine and great, but to make this into a reality, I didn’t just have to print them. I needed to cut them to size so they overlapped each other perfectly. Staple them with bookbinding tape to finish the edge. I needed a little thicker cardstock for the back to hold it all together. Oh, and what good would all this be if you couldn’t easily tear them out? So I needed to figure out how to perforate the pages too.

I don’t make physical things very much. I’m not very crafty. Almost everything I make, I make digitally.

I went to Yodobashi Camera’s stationery section and picked up everything I needed, even the exact color of bookbinding tape I could’ve ever hoped for, a baby blue, with the right kind of linen texture the original ticket books had. I got a rotary blade with an interchangeable perforator blade. And y’all, it’s my new favorite thing. It really makes you want to perforate everything. It’s so easy. Just pizza-cut your way to ticket-tearing heaven.

Everything was printed at 7-Eleven, double-sided of course. I delicately cut them all to size, perforated them, stapled it all together, applied the tape. And I was done!

Right? It’s cute! It’s done!

It was not done. I can’t just hand over the ticket book like this to Daikichi. What kind of presentation is that?! It should be in something, but not a gift bag, a box, or wrapping paper. An envelope! Of course, an envelope. A Tokyo Disneyland envelope. That I also have to make.

This is just who I am. I looked at some actual envelopes that once existed and there was this one castle illustration on a Tokyo Disneyland gift certificate envelope that appeared to be the same as one I’ve seen in the Tokyo Disneyland brand book, that I haven’t seen in use all that much.

I carefully recreated it. Not exactly, but in the way I would draw it if I was drawing it, like everything else I was doing. I figured I probably would like to have this shape anyway, so it was worth drawing rather than auto-tracing in Illustrator, which probably would have sufficed.

I designed the envelope such that when the ticket book was placed inside, only the words “Big Day” would be visible, with “Kingdom of Magical Dreams” underneath it, which is not the real tagline, but might as well be.

Upon gifting it to Daikichi last night, I got every reaction I could’ve hoped for. He was so excited, though we also kinda had to explain what ticket books once were. As he inspected it closely, he said something to Nob, which Nob relayed to me. “He says you’re smart.” Daikichi pointed out the circles in the pattern that aligned across tickets. The whole process, I thought I might have been making it more for me than him, but I’m glad he appreciated every detail as I did.

You might not be surprised to discover that it wasn’t the end for me. I had already spent days making this exactly right, but now I felt like I had all these pieces to play with. The castle, the logo. Why not make my own little brand book?

Anyway, Merry Christmas, fellow nerds.

My own work crosses many disparate areas. Over the years, I’ve gotten to cycle between domains as distinct as building technology platforms and products for developers and creators, enabling activism and policy advocacy in service of humanist ideals, and more visible external-facing work such as public speaking or writing in various venues like magazines or on this site. (And then sometimes I dabble in my other hobbies and fun stuff like scholarship or research into areas like pop culture and media.)

What’s amazing is, in every single one of these wildly different areas, the exact same demands apply when trying to communicate to broad groups of people. This is true despite the broadly divergent cultural norms across all of these different disciplines. It can be a profoundly challenging, even intimidating, job to make sure a message is being communicated accurately, and in high fidelity, to everyone that you need to reach.

That vital task of communicating to a large group gets even more daunting when you inevitably realize that, even if you were to find the perfect wording or phrasing for your message, you’d still never be able to deliver your story to every single person in your target audience by yourself anyway. There will always be another person whom you’re trying to reach that you just haven’t found yet. So, is it hopeless? Is it simply impossible to effectively tell a story at scale if you don’t have massive resources?

It doesn’t have to be. We can start with one key insight about what it takes to get your most important stories out into the world. It’s a perspective that seems incredibly simple at first, but can lead to a pretty profound set of insights.

They have to be able to talk about us without us.

They have to be able to talk about us without us. What this phrase means, in its simplest form, is that you have to tell a story so clear, so concise, so memorable and evocative that people can repeat it for you even after you’ve left the room. And the people who hear it need to be able to do this the first time they hear the story. Whether it’s the idea behind a new product, the core promise of a political campaign, or the basic takeaway from a persuasive essay (guess what the point of this one is!) — not only do you have to explain your idea and make your case, you have to be teaching your listener how to do the same thing for themselves.

This is a tall order, to be sure. In pop music, the equivalent is writing a hit where people feel like they can sing along to the chorus by the time they get to the end of the song for the first time. Not everybody has it in them to write a hook that good, but if you do, that thing is going to become a classic. And when someone else has done it, you know it because it gets stuck in your head. Sometimes you end up humming it to yourself even if you didn’t want to. Your best ideas — your most vital ideas — need to rest on a messaging platform that solid.

Delivering this kind of story actually requires substance. If you’re trying to fake it, or to force a narrative out of fluff or fakery, that will very immediately become obvious. When you set out to craft a story that travels in your absence, it has to have a body if it’s going to have legs. Bullshit is slippery and smells terrible, and the first thing people want to do when you leave the room is run away from it, not carry it with them.

The mission is the message

There’s another challenge to making a story that can travel in your absence: your ego has to let that happen. If you make a story that is effective and compelling enough that others can tell it, then, well…. those other people are going to tell it. Not you. They’ll do it in their own words, and in their own voices, and make it theirs. They may use a similar story, but in their own phrasing, so it will resonate better with their people. This is a gift! They are doing you a kindness, and extending you great generosity. Respond with gratitude, and be wary of anyone who balks at not getting to be the voice or the face of a message themselves. Everyone gets a turn telling the story.

Maybe the simple fact that others will be hearing a good story for the first time will draw them to it, regardless of who the messenger is. Sometimes people get attached to the idea that they have to be the one to deliver the one true message. But a core precept of “talk about us without us” is that there’s a larger mission and goal that everyone is bought into, and this demands that everyone stay aligned to their values rather than to their own personal ambitions around who tells the story.

The truth of whomever will be most effective is the factor used to decide who will be the person to tell the story in any context. And this is a forgiving environment, because even if someone doesn’t get to be the voice one day, they’ll get another shot, since repetition and consistency are also key parts of this strategy, thanks to the disciplined approach that it brings to communication.

The joy of communications discipline

At nearly every organization where I’ve been in charge of onboarding team members in the last decade or so, one of the first messages we’ve presented to our new colleagues is, “We are disciplined communicators!” It’s a message that they hopefully get to hear as a joyous declaration, and as an assertion of our shared values. I always try to explicitly instill this value into teams I work with because, first, it’s good to communicate values explicitly, but also because this is a concept that is very seldom directly stated.

It is ironic that this statement usually goes unsaid, because nearly everyone who pays attention to culture understands the vital importance of disciplined communications. Brands that are strictly consistent in their use of things like logos, type, colors, and imagery get such wildly-outsized cultural impact in exchange for relatively modest investment that it’s mind-boggling to me that more organizations don’t insist on following suit. Similarly, institutions that develop and strictly enforce a standard tone of voice and way of communicating (even if the tone itself is playful or casual) capture an incredibly valuable opportunity at minimal additional cost relative to how much everyone’s already spending on internal and external communications.

In an era where every channel is being flooded with AI-generated slop, and when most of the slop tools are woefully incapable of being consistent about anything, simply showing up with an obviously-human, obviously-consistent story is a phenomenal way of standing out. That discipline demonstrates all the best of humanity: a shared ethos, discerning taste, joyful expression, a sense of belonging, an appealing consistency. And best of all, it represents the chance to participate for yourself — because it’s a message that you now know how to repeat for yourself.

Providing messages that individuals can pick up and run with on their own is a profoundly human-centric and empowering thing to do in a moment of rising authoritarianism. When the fascists in power are shutting down prominent voices for leveling critiques that they would like to censor, and demanding control over an increasingly broad number of channels, there’s reassurance in people being empowered to tell their own stories together. Seeing stories bubble up from the grassroots in collaboration, rather than being forced down upon people from authoritarians at the top, has an emotional resonance that only strengthens the substance of whatever story you’re telling.

How to do it

Okay, so it sounds great: Let’s tell stories that other people want to share! Now, uh… how do we do it? There are simple principles we can follow that help shape a message or story into one that is likely to be carried forward by a community on its own.

• Ground it in your values. When we began telling the story of my last company Glitch, the conventional wisdom was that we were building a developer tool, so people would describe it as an “IDE” — an “integrated development environment”, which is the normal developer jargon for the tool coders use to write their code in. We never described Glitch that way. From day one, we always said “Glitch is the friendly community where you'll build the app of your dreams” (later, “the friendly community where everybody builds the internet”). By talking about the site as a friendly community instead of an integrated development environment, it was crystal clear what expectations and norms we were setting, and what our values were. Within a few months, even our competitors were describing Glitch as a “friendly community” while they were trying to talk about how they were better than us about some feature or the other. That still feels like a huge victory — even the competition was talking about us without us! Make sure your message evokes the values you want people to share with each other, either directly or indirectly.
• Start with the principle. This is a topic I’ve covered before, but you can't win unless you know what you're fighting for. Identify concrete, specific, perhaps even measurable goals that are tied directly to the values that motivate your efforts. As noted recently, Zohran Mamdani did this masterfully when running for mayor of New York City. While the values were affordability and the dignity of ordinary New Yorkers, the clear, understandable, measurable principle could be something as simple as “free buses”. This is a goal that everyone can get in 5 seconds, and can explain to their neighbor the first time they hear it. It’s a story that travels effortlessly on its own — and that people will be able to verify very easily when it’s been delivered. That’s a perfect encapsulation of “talk about us without us”.
• **Know what makes you unique.**Another way of putting this is to simply make sure that you have a sense of self-awareness. But the story you tell about your work or your movement has to be specific. There can’t be platitudes or generalities or vague assertions as a core part of the message, or it will never take off. One of the most common failure states for this mistake is when people lean on slogans. Slogans can have their use in a campaign, for reminding people about the existence of a brand, or supporting broader messaging. But very often, people think a slogan is a story. The problem is that, while slogans are definitely repeatable, slogans are almost definitionally too vague and broad to offer a specific and unique narrative that will resonate. There’s no point in having people share something if it doesn’t say something. I usually articulate the challenge here like this:Only say what only you can say.
• Be evocative, not comprehensive. Many times, when people are passionate about a topic or a movement, the temptation they have in telling the story is to work in every little detail about the subject. They often think, “if I include every detail, it will persuade more people, because they’ll know that I’m an expert, or it will convince them that I’ve thought of everything!” In reality, when people are not subject matter experts on a topic, or if they’re not already intrinsically interested in that topic, hearing a bunch of extensive minutia about it will almost always leave them feeling bored, confused, intimidated, condescended-to, or some combination of all of these. Instead, pick a small subset of the most emotionally gripping parts of your story, the aspects that have the deepest human connection or greatest relevance and specificity to the broadest set of your audience, and focus on telling those parts of the story as passionately as possible. If you succeed in communicating that initial small subset of your story effectively, then you may earn the chance to tell the other more complex and nuanced details of your story.
• Your enemies are your friends. Very often, when people are creating messages about advocacy, they’re focused on competition or rivals. In the political realm, this can be literal opposing candidates, or the abstraction of another political party. In the corporate world, this can be (real or imagined) competitive products or companies. In many cases, these other organizations or products or competitors occupy so much more mental space in your mind, or your team’s mind, than they do in the mind of your potential audience. Some of your audience has never heard of them at all. And a huge part of your audience thinks of you and your biggest rival as… basically the same thing. In a business or commercial context, customers can barely keep straight the difference between you and your competition — you’re both just part of the same amorphous blob that exists as “the things that occupy that space”. Your competitor may be the only other organization in the world that’s fighting just as hard as you are to create a market for the product that you’re selling. The same is true in the political space; sometimes the biggest friction arises over the narcissism of small differences. What we can take away from these perspectives is that our stories have to focus on what distinguishes us, yes, but also on what we might have in common with those whom we might otherwise have perceived to have been aligned with the “enemy”. Those folks might not have sworn allegiance to an opposing force; they may simply have chosen another option out of convenience, and not even seen that choice as being in opposition to your story at all.
• Find joy in repetition. Done correctly, a disciplined, collaborative, evocative message can become a mantra for a community. There’s a pride and enthusiasm that can come from people becoming proficient in sharing their own version of the collective story. And that means enjoying when that refrain comes back around, or when a slight improvement in the core message is discovered, and everyone finds a way to refine the way they’re communicating about the narrative. A lot of times, people worry that their team will get bored if they’re “just telling the same story over and over all the time”. In reality, as a brilliant man once said, there’s joy in repetition.
• Don’t obsess over exact wording. This one is tricky; you might say, “but you said we have to be disciplined communicators!” And it’s true: it’s important to be disciplined. But that doesn’t mean you can’t leave room for people to put their own spin on things. Let them translate to their own languages or communities. Let them augment a general principle with a specific, personal connection. If they have their own authentic experience which will amplify a story or drive a point home, let them weave that context into the consistent narrative that’s been shared over time. As long as you’re not enabling a “telephone game” where the story starts to morph into an unrecognizable form, it’s perfectly okay to add a human touch by going slightly off script.

Share the story

Few things are more rewarding than when you find a meaningful narrative that resonates with the world. Stories have the power to change things, to make people feel empowered, to galvanize entire communities into taking action and recognizing their own power. There’s also a quiet reward in the craft and creativity of working on a story that travels, in finding notes that resonate with others, and in challenging yourself to get far enough out of your own head to get into someone else’s heart.

I still have so much to learn about being able to tell stories effectively. I still screw it up so much of the time, and I can look back on many times when I wish I had better words at hand for moments that sorely needed them. But many of the most meaningful and rewarding moments of my life have been when I’ve gotten to be in community with others, as we were not just sharing stories together, but telling a united story together. It unlocks a special kind of creativity that’s a lot bigger than what any one of us can do alone.

Today, I wanted to talk specifically about a habit my friend Gerardo Rodriguez got me into: reviewing your own pull request.

It’s pretty simple.

When you create a pull request in GitHub, click on the Files changed tab, and scroll through the diff. Anywhere you’ve done something new that’s not already explained by in-code comments, add a comment in the GUI about what you did and why.

• Often, it’s stuff that’s not important enough for in-code commentary, but is useful for the reviewer to know.
• Sometimes, it’s stuff that should actually be documented in the code, and this is a good time to go back and add it.
• Every now and then, you’ll notice a bug in your own code because you’re reading it with fresh eyes, in a different format than your text editor.

It’s a simple behavior change that adds maybe 5 or 10 minutes to the time it takes to setup a PR, but it’s saved me so many headaches, and makes life for whoever reviews your PR a lot easier, too!

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

Today I finish my fourth 2.5mg injection of Zepbound, a strong GLP-1 drug, and I thought I'd write about the experience of my first month on it, how I got here, and what I expect in the future. It's been wild, and after talking to half a dozen friends that are also trying these things out, it feels like we're all experimenting on ourselves, so it's helpful to share what that's like if you're curious about these drugs.

Anyone considering a GLP-1 should go in knowing what to expect and also what you might not expect.

Weight and metabolism

For most of my life, I was tall and lanky and I ate like crazy but also exercised several hours a day. Both my parents were pretty heavy, with my dad spending most of his life as a 6'1" guy weighing over 300lbs. He had a couple heart attacks in his 40s and a life-altering stroke in his 50s. My mom died a few weeks after her 65th birthday.

After I finished college, I was still pretty fit but I transitioned from distance running to casual cycling, and every few years I gained a few pounds and it definitely felt like my body was shifting into slower gears as I got older.

I dieted and exercised for the last 20 years to keep things just on the high side of normal-to-slightly obese and that was mostly fine until covid hit. The combo of being more sedentary than normal while also stressed and depressed at what was going on contributed to round-the-clock snacking and added another 30-40lbs and ever since, it's been nearly impossible to shed more than a couple pounds through diet and exercise.

I started this being 6'3" and weighing around 258lbs with my blood sugar in a Type 2 pre-diabetic state. I know BMI isn't a reliable metric overall, but I'm in the low 30s and I don't dip below 25 until I get down around 200lbs, which is when I've felt best in the past.

I've spent a couple years walking and riding more and trying to eat less, and still it's quite difficult because now in my 50s, my metabolism feels glacial. I know I should be eating like a bird as I get older but I felt like I was constantly starving myself. I knew a few friends with good experiences taking GLP-1s and I've read plenty about them so I decided to finally give them a try.

The first week was a shock

Hank Green dropped a video about GLP-1 drugs that is mostly positive about them, but I want to underscore how right he is when he says these are very powerful drugs with lots of unknown or unstudied side effects that can surprise you.

It took about 24hrs for the first injection to hit me, but the feeling of it was pretty substantial.

The most shocking thing after my first dose was a complete absence of hunger.

Honestly, it felt bizarre. It was as if all the nerves that linked my brain to my stomach were severed in that first week. I had no idea when I was hungry or when I was full. I could eat two bites or finish a plate of food. My stomach felt completely detached from everything and I had to rethink a lot of things. I ate lightly every few hours just to make sure I had calories going in but I almost had to remind myself to do it.

I was instantly hit by a wave of heartburn/acid reflux, which I rarely experienced in the past. I knew it was coming from my digestive system slowing down, but it was stronger than I expected at first.

The good news is that heartburn did eventually go away after 2-3 weeks as I got used to it and my generally smaller meals. Now in my fourth week, I'm finally starting to feel hunger pains again around lunchtime each day.

If you asked me a few months ago how much time I spent idly thinking about food, I'd probably say not very much, but after I started taking a GLP-1 and my hunger went away it honestly felt like half of my brain was freed up to do other things. I was no longer thinking about my next meal, or the one after that, and it sort of dawned on me that my life was previously way more food-motivated than I thought.

As this first month draws to a close, I'm down a bit over ten pounds and I suspect at the two month mark I might move up to a 5mg dose as the effects start to lessen, which is what most people tend to do on it.

Weird side effects I didn't expect

I read all I could about side effects going into this, but a few things still threw me unexpectedly once I started taking the drug.

A week into this, I ate some dodgy seafood at a restaurant while out with a few friends. One friend got food poisoning from the meal we shared but it passed for them in a day like I expected the same bad food would for me. However, being on a GLP-1, my symptoms lingered for nearly a week as the stuff worked itself out of me quite slowly. There's not much you can do to prevent food poisoning, but know that any time it does hit, it's really going to affect you for 2-3x longer than expected due to your slowed digestive system.

I had a few friends talk about a reduction in inflammation as side effects of a GLP-1 and I know someone taking it to counteract joint pain that they say is quite effective. For me, ever since I started taking it, getting up in the mornings I feel like I have way less aches and pains overall.

I have a long history of back pain and hamstring tightness so much so that I've seen the same massage therapist for the past ten years about once-a-month for some deep-tissue work. Last week I had my first session post GLP-1 and normally it's a slightly painful experience that feels better a day later, but this session felt like my therapist was only pushing my muscles at about 25% pressure. Typically my back feels wrecked immediately after a massage, but in this case I had zero back pain post-session.

It's weird but I'm guessing whatever effects the drug is having on my appetite is also working on pain centers in my body? At this point, I'm considering reducing or eliminating the regular massage entirely. I know people who go to acupuncture regularly that said they've stopped after starting a GLP-1 drug, because they no longer need the pain relief.

Advice for anyone considering these drugs

Here are my lessons learned from being on this and experimenting for the past month.

Use Shotsy

There's a great app for tracking your predicted levels of the drug in your system that can also talk to Apple Health and automatically graph your ongoing weight if you've got a Withings scale that can transmit your daily weigh-ins to the cloud.

Go through your own doctor and health plan

I am doing my first couple months of this through Ro.co and it's pretty goofy. You consult with a "doctor" and "nurses" that feel like AI prompts when they talk to you. Of course, they approve everyone and will ship you injections within a day and it generally runs about $500 a month.

I wish I listened to Hank Green in the video embedded above and went through my local doctor and my own health insurance. Not only would I be getting more personal, comprehensive care, my costs would drop significantly. Friends who converted from a random online "health" store to their health plan typically only have to spend $25-50 per month on these drugs.

Weekly shots are no fun

I kinda hate the delivery of Zepbound, which is a vial of liquid that you have to administer via a shot that I can't make myself do on my own. Once you get health insurance coverage, they can send you pre-filled injectors with smaller needles to make it easier, but honestly, I'm guessing in a few years these drugs might be over the counter as small tablets or gummies instead of injections and I can't wait for that to be the norm.

Expect this for the long haul

Everyone I talk to who is considering a GLP-1 seems to worry about what they'll do after 6 to 12 months of using it once they've lost weight. From all accounts it seems like people who stop regain their appetite and put much of the weight back on. I've been on a couple small doses of maintenance drugs for other ailments that I suspect I'll remain on for life and I think it's not a huge deal to have one more thing to take long term. I suspect I'll go down to a minimal dose once I've shed 50 or so pounds.

Find a social support network wherever you can

The best advice I found about taking GLP-1's is from a private group chat with half a dozen friends who currently take one. We also share the space with a handful of friends who are considering taking it. We post questions about our side effects and get helpful responses from those who've been on the drug longer. New friends are asking lots of questions that we're all answering together and honestly it has been really useful. I don't know of any apps or sites that can fill this void for everyone, but having a small supportive friends network of people going through the same issues has been incredibly helpful.

Final thoughts

Overall, I've had a good experience taking Zepbound that has made me rethink my relationship with food. I still enjoy the taste of things, but my next meal doesn't dominate my thinking like it did before. The side effects are wider ranging than I expected and I think we'll see a lot of interesting research around these drugs in the next few years. I don't know how ubiquitous these prescriptions will become, but I suspect health insurance companies in America will steer people towards it as a form of preventative care.

Now that I've taken this, I have to admit it has more of a "magic pill" effect than I suspected it would. It truly changed overnight how much food I take in, what my relationship is like to food, and helps me get on a better path towards a healthier weight that doesn't stress out my body. I've never been one to trust that miracle drugs could fix all our problems, but this one comes close.

Lastly, I have to acknowledge that as a middle-aged guy I don't go through 1/1000th the societal pressure that other people face around weight, but I don't feel bad about taking this drug and I am definitely seeing my numbers move in a better direction for the first time in years. The benefits seem wide ranging and while the side effects are significant, they're livable and I suspect general exercise and my performance on a bike will improve as my weight goes down over the next few months.

I use these nearly every day when writing code. It helps me start working faster, and saves me from having to rewrite the same code over-and-over again.

I created web component boilerplate years ago. Since then, my approach to writing web component has changed quite a bit.

I just updated the boilerplate, adding everything I’ve learned from working on Kelp UI. Today, I wanted to explain how it works.

Let’s dig in!

Instantiate in the connectedCallback() method

I used to instantiate my web components (run all of the code to set them up) inside the constructor().

But when working with Kelp, I learned that this can throw errors, especially if you try to move or replace components with JS after they’ve instantiated.

I moved all of that code to the connectedCallback() method, which runs when the web component is connected to the DOM, and it fixed the issue.

/**
 * Initialize on connect
 */
connectedCallback() {
	// Startup code...
}

I also learned that you don’t need a constructor() at all if you do this, so I removed that method entirely from my boilerplate. There’s no need for it.

Waiting for DOM Ready

Web component JS gets loaded all sorts of different ways, and the DOM might yet be ready when the JS runs.

I’ve started checking the document.readyState first. If it’s not loading, I’ll instantiate immediately. If its still loading, I’ll set a one-time event listener for the DOMContentLoaded event and run my instantiations then.

To make that easier, I include an init() method that runs the actual instantiation code.

/**
 * Initialize on connect
 * Checks for DOM status first, ensuring code doesn't run before required
 * elements exist in the DOM.
 */
connectedCallback() {
	if (document.readyState !== 'loading') {
		this.init();
		return;
	}
	document.addEventListener('DOMContentLoaded', () => this.init(), {
		once: true,
	});
}

Private instance properties

With Kelp, I’ve started using private instance methods and properties a lot more.

For methods, you can just slap a hashtag (#) in front of the name. For instance properties, you need to declare them at the start of the class.

I’ve been using JSDoc to define types for these as well.

customElements.define(
	'my-library',
	class extends HTMLElement {
		// Declare private instance properties
		/** @type HTMLButtonElement | null */ #btn;
		/** @type string */ #greeting;
		/** @type HTMLElement */ #message;

	// ...
});

The handleEvent() method

I make heavy use of the handleEvent() method for handling event listeners with my web components.

It makes it really easy to access instance properties and methods (this) inside the handlers. It also means that if you component gets removed and attached back to the DOM a few times, the callback method still only runs once without you needing to do any removal/cleanup.

connectedCallback() {
	// ...

	// Attach event listeners
	this.#btn.addEventListener('click', this);
}

/**
 * Handle events for the web component
 * @param  {Event} event
 */
handleEvent(event) {
	if (event.type === 'click') {
		this.#onClick(event);
	}
}

No event cleanup

I use to remove every event I attached in the connectedCallback() method in the disconnectedCallback().

But the browser will automatically garbage collect events attached to the custom element and any of its child elements when its removed from the DOM when you use the handleEvent() method.

Now, the only ones I remove are events attached to elements outside the custom element, because they’re not automatically cleaned up.

connectedCallback() {
	// ...

	// Attach event listeners
	document.addEventListener('input', this);
}

// Cleanup global event listeners on disconnect
disconnectedCallback() {
	document.removeEventListener('input', this);
}

As a bonus for using handleEvent(), this is really easy to do because the handler is always this. No more caching callback methods for cleanup purposes.

No shadow DOM

It’s an anti-pattern that makes everything about using web components worse. Death to the shadow DOM!

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

replaces websites’ colors (backgrounds, borders, text, focus outlines, and more) with a significantly reduced color palette, sometimes comprised of user-selected colors. Forced colors mode also makes changes which simplify an interface’s appearance…

Today, I wanted to talk briefly about what is, how it affects designs, and how to build for it. Let’s dig in!

Bye bye backgrounds

I first learned about forced colors mode when someone Michael Matthews opened a very helpful ticket up about on Kelp UI.

Kelp’s tabs component uses background color to show which tab is currently selected. Forced colors mode strips those colors out, making it impossible to tell which tab is currently active.

This also affected radio buttons, toggle switches, how well dialog modals standout from the background, and more.

Fortunately, this is relatively easy to address, once you know about it.

Windows-only

One of the reasons this had completely flown under my radar is because it is still mostly a Windows-only feature.

macOS has an Increase Contrast accessibility setting that does not seem to pass information along to the browser. Firefox has a specific setting for it.

In Chromium, you can emulate it by opening up developer tools, opening up the command palette (Command+Shift+P in macOS), and typing forced colors, which surfaces some options.

Even though enabling forced colors mode is OS-specific, targeting it with CSS is widely supported cross-browser.

CSS and forced colors mode

In Kelp’s CSS, I added media queries for forced-colors: active to detect forced colors mode in various places and update styles…

@media (forced-colors: active) {
	/* high-contrast styles... */
}

The easiest fix in many situations is to use really beefy borders for things that should stand out.

For example, I give my dialog modals a really thick border so that they standout better from the background, since the ::backdrop doesn’t show up in forced colors mode.

@media (forced-colors: active) {
	dialog {
		border-width: 0.5em;
	}
}

I do something similar for the currently active tab.

@media (forced-colors: active) {
	kelp-tabs [role="tab"][aria-selected="true"] {
		border-width: 0.5em;
	}
}

Remember that toggle switch we built last week? It requires a slightly different approach.

For that one, the background color is what makes it look like a switch. There’s no way around that!

But my friend Stephanie Eckles found a neat trick: in forced colors mode, background color will show up if you give it a value of CanvasText, which maps to the current text color.

For our toggle switch, we can use that provide a border and background and ensure our switch is still clearly visible and it’s state is apparent.

@media (forced-colors: active) {
	[role="switch"] {
		border: 1px solid CanvasText;
	}

	[role="switch"]:checked {
		background-color: CanvasText;
	}
}

Ugly and obvious

The most important thing to keep in mind when designing for forced colors mode is that making things obvious is the most important consideration.

This browsing mode is often used by people who are not blind but do have vision issues, people who suffer migraines from lots of color, and so on.

In forced colors mode, your design preferences no longer matter.

Your site almost certainly will look ugly, or at least different from how you’d like it, and that’s ok. That’s the point. It’s not about you!

This is an instance where letting go and ceding control to the user is particularly important.

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

I’m not good at making predictions, so I don’t really know what the IndieWeb is gonna look like in 5 years. If I had to guess, I’d say it will probably look very much like it looks now, only with more AI-generated nonsense sprinkled throughout. But rather than making predictions, let me write about hopes and wishes. My feelings when it comes to the web can be described as a pendulum or a standing wave. I alternate between naïve optimism and endless pessimism. I’m writing this in my downward swinging phase, which means this post is gonna be kinda bleak.

There’s a post I keep thinking about. More specifically, this question:

In trying to escape the torment nexus, have we just built a nicer version of the torment nexus?

Here’s my hope for the IW in 2030: I hope that in 5 years, we have stopped pretending. Pretending that replacing corporate platforms with bad copies of the same platforms is a good and desirable thing to do. Pretending that what we really need to solve the issues that are plaguing the web is more tools and more protocols. Pretending that all the people out there who use the web on a daily basis care about the same things we do. Pretending that the fault for all this digital mess lies entirely on the shoulders of a few mega corporations, while the billions of people out there are just bystanders, caught in the crossfire.

But also stop pretending that everything is doomed, that the web is about to die, that AI will sloppify everything, that writing on a blog is pointless, that tending to a digital garden is wasted time.

Yes, a vast chunk of the 2025 web fucking sucks. It’s an unusable mess, and going in without adblockers, VPNs, and network-level filters is an atrocious experience. And that won’t change in 2030. If there’s one prediction I can confidently make, it's this one: in 5 years, the web is still gonna be a mess.

At the same time, though, the web is a marvelous place if you know how to navigate it. There’s still delight to be found out there, and it’s still full of genuinely kind and wonderful people. And that’s my hope, my wish, and my dream for the IndieWeb in 2030: that we focus less on what’s on the screen and more on who’s in front of it.

Because people matter. Because you matter. And in this idiotic AI age we’re going through, all this matters more than ever.

Thank you for keeping RSS alive. You're awesome.

Email me :: Sign my guestbook :: Support for 1$/month :: See my generous supporters :: Subscribe to People and Blogs

I've moved my reading, audiobook and podcast activity to Audiobookshelf, but it's ebook support is rudimentary.¹ I briefly opened up Xcode and started prototyping an ebook reader that would leverage Audiobookshelf's robust API and quickly realized that there was no reason to build a native app for this. It didn't require any native APIs, so why build something I intended largely for my own use only to deal with the headache of Apple's review process?

Instead, I closed Xcode, opened Cursor and scaffolded out a PWA that uses react-reader (which leverages epub.js) instead. I could iterate far quicker, have a performant and robust experience for my use case without anything between myself and any updates I want to issue. I have a reliable app that relies on authenticating against my Audiobookshelf instance, persists preferences and state using an SQLite database and none of the platform lock-in or review headaches.

PWAs, being built on web technology, offer more transparency as well. I can inspect the application, dig through network calls and see not only how it works but evaluate whether it's whether there are possible privacy concerns. This has lead me to establish new criteria for selecting applications I intend to use:

• If there’s a PWA, use it.
• If a platform-specific API is required, use a native app that respects your privacy.
• If neither are options, don’t use it.

I'm interacting with linkding, my epub reader and Mastodon as web apps saved to my home screen on iOS and have Mastodon in my dock on macOS. Audio playback requires native APIs to work reliably, so I built a Navidrome client and selected an Audiobookshelf client that respects my privacy.

In an ideal world, Apple would act in good faith and provide better support for PWAs. This world, however, is far from perfect and Apple has shown they'll only make choices like that, that benefit users, under duress.

The web platform provides an excellent experience, an open experience and one that should be preferred — when possible — over an onerous process that Apple controls.

I'll prefer openness and I will always value privacy.

But what if a card wasn’t just a surface? What if it was a window?

Enter the Deep Card.

Imagine a card that isn’t just a 2D plane, but a container with actual volume. A card that holds a miniature 3D world inside it. When you rotate this card, you don’t just see it skew, you see the elements inside it shift in perspective, revealing their depth. It’s like holding a glass box filled with floating objects.

The effect is mesmerizing. It transforms a static element into something tactile and alive. It invites interaction. Whether it’s for a digital trading card game, a premium product showcase, or just a portfolio piece that screams “look at me,” the Deep Card adds a layer of polish and “wow” factor that flat design simply can’t match.

But as I quickly discovered, building this illusion, especially one that feels right and performs smoothly, is a bit more of a puzzle than it first appears.

The CSS Trap

There are plenty of JavaScript libraries out there that can handle this, but I’m a bit of a CSS purist (read: stubborn). I’ve spent years pushing stylesheets to their absolute limits, and I was convinced that a clean, performant, pure CSS solution was hiding in plain sight.

On paper, the logic seems flawless. If you’ve dabbled in 3D CSS before, you know the drill:

1. Set the Stage: Take a container element and give it some perspective.
2. Build the World: Position the child elements in 3D space (translateZ, rotateX, etc.).
3. Preserve the Illusion: Apply transform-style: preserve-3d so all those children share the same 3D space.

Simple, right?

But here’s the catch. For a true “card” effect, you need the content to stay inside the card boundaries. If a 3D star floats “up” towards the viewer, you don’t want it to break the frame, you want it to be clipped by the card’s edges, reinforcing the idea that it’s inside a container.

So, naturally, you add overflow: clip (or hidden) to the card. And that is the exact moment everything falls apart.

The Spec Says No

Suddenly, your beautiful 3D scene flattens out. The depth vanishes. The magic is gone.

Why? Because according to the CSS Transforms Module Level 2 specification, applying any “grouping property” like overflow (with any value other than visible), opacity less than 1, or filter, forces the element to flatten.

The sad reality: A value of preserve-3d for transform-style is ignored if the element has any grouping property values.

In other words: you can have a 3D container, or you can clip its content. You cannot do both on the same element.

For a long time, this felt like a dead end. How do you keep the 3D depth while keeping the elements contained?!

Faking It

If the spec says we can’t have both perspective and clipping, maybe we can cheat. If we can’t use real 3D depth, perhaps we can fake it.

Faking perspective is a time-honored tradition in 2D graphics. You can simulate depth by manipulating the size and position of elements based on their “distance” from the viewer. In CSS terms, this means using scale() to make things smaller as they get “further away” and translate() to move them relative to the card’s angle.

.card {
  /* --mouse-x and --mouse-y values ranage from -1 to 1 */
  --tilt-x: calc(var(--mouse-y, 0.1) * -120deg); 
  --tilt-y: calc(var(--mouse-x, 0.1) * 120deg); 
  transform: rotateX(var(--tilt-x)) rotateY(var(--tilt-y));
}

.card-layer {
  /* Fake perspective with scale and translate */
  scale: calc(1 - var(--i) * 0.02);
  translate:
    calc(var(--mouse-x) * (var(--i)) * -20%)
    calc(var(--mouse-y) * (var(--i)) * -20%);
}

This technique can work wonders. There are some brilliant examples out there, like this one by Jhey, that pull off the effect beautifully without using a single line of perspective or preserve-3d.

It’s a solid approach. It’s performant, it works across browsers, and for subtle effects, it’s often indistinguishable from the real thing.

But it has a ceiling.

The illusion holds up well within a limited range of motion. But the moment you push it too far, say, by rotating the card to a sharp angle or trying to flip it 180 degrees, the math starts to show its cracks. The perspective flattens out, and the movement stops feeling natural.

As you can see, when the card turns, the inner elements lose their spatial relationship. The magic evaporates. So while this is a great tool for the toolbox, it wasn’t the complete solution I was looking for. I wanted the real deal. Full 3D, full rotation, full clipping.

Road to a Nowhere

I spent years (on and off, I’m not that obsessed) trying to crack this. I was convinced there had to be a way to have my cake and eat it too.

Theoretically, there is a way. If you can’t clip the container, you have to clip the children.

Imagine using clip-path on every single layer inside the card. You would need to calculate, in real-time, exactly where the edges of the card are relative to the viewer, and then apply a dynamic clipping mask to each child element so that it cuts off exactly at those boundaries.

This involves a lot of math, even for me. We’re talking about projecting 3D coordinates onto a 2D plane, calculating intersections, and handling the trigonometry of the user’s perspective.

I was almost ready to give up and accept that maybe, just maybe, this was one of those things CSS just wasn’t meant to do. And then, I got a message from Cubiq.

The Breakthrough

This wasn’t the first time someone had asked me about this topic. As someone who’s known for pushing CSS 3D to its limits, I get this question a lot. People assume I have the answer. But, well… I didn’t.

So when Cubiq messaged me, showing me a GIF of a fully rotating card with deep 3D elements and asking how to achieve it, I went into auto-pilot. I gave him the standard explanation on why the spec forbids it, why overflow flattens the context, and how he could try to fake it with scale and translate.

I thought that was the end of it, but then, he surprised me.

My Personal Blind Spot

I’ve tried many tricks over the years, but one property I religiously avoided was perspective-origin.

If you really dig into how CSS calculates perspective, you realize that perspective-origin doesn’t just shift your point of view. It fundamentally skews the entire viewport. It creates this weird, unnatural distortion that usually looks terrible.

I cover this at length in my talk 3D in CSS, and the True Meaning of Perspective, if you’re into that sort of thing.

Cubiq, however, didn’t have my baggage. He looked at the problem with fresh eyes and realized something brilliant: just as perspective-origin can be used to create distortion, it can also be used to correct it.

Alternate blog post title idea: Finally, we found one good use for perspective-origin! 🤣

The Solution

Here is the magic formula that Cubiq came up with:

.card-container {
  transform: rotateX(var(--tilt-x)) rotateY(var(--tilt-y));
}

.card {
  perspective: calc(
    cos(var(--tilt-x)) * cos(var(--tilt-y)) * var(--perspective)
  );
  perspective-origin: 
    calc(cos(var(--tilt-x)) * sin(var(--tilt-y)) * var(--perspective) * -1 + 50%)
    calc(sin(var(--tilt-x)) * var(--perspective) + 50%);
  overflow: clip;
}

It looks a bit scary at first glance, but the logic is actually quite elegant.

Since we are using overflow: clip, the 3D context is flattened. This means the browser treats the card as a flat surface and renders its children onto that surface. Normally, this flattening would kill the 3D effect of the children. They would look like a flat painting on a rotating wall.

But here is the trick: We use perspective and perspective-origin to counter-act the rotation.

By dynamically calculating the perspective-origin based on the card’s tilt, we are essentially telling the browser: “Hey, I know you flattened this element, but I want you to render the perspective of its children as if the viewer is looking at them from this specific angle.”

We are effectively projection-mapping the 3D scene onto the 2D surface of the card. The math ensures that the projection aligns perfectly with the card’s physical rotation, creating the illusion of a deep, 3D space inside a container that the browser considers “flat.”

It’s not about moving the world inside of the card, it’s about tricking the flat projection to look 3D by aligning the viewer’s perspective with the card’s rotation.

The Lesson

I love this solution not just because it works (and it works beautifully), but because it taught me a humbling lesson.

I had written off perspective-origin as a “bad” property. I had a mental block against it because I only saw it as a source of distortion. I was so focused on the “right” way to do 3D, that I blinded myself to the tools that could actually solve the problem.

Cubiq didn’t have that bias. He saw a math problem: “I need the projection to look like X when the rotation is Y.” And he found the property that controls projection.

Breaking It Down

Now that we know it’s possible, let’s break down exactly what’s happening here, step by step, and look at some examples of what you can do with it. Let’s start with the basics.

The HTML

At its core, the structure is simple. We have a .card-container that holds the .card, which in turn contains the .card-content, that is the ‘front’ of the card and where all the inner layers live. and the card-back for the back face.

<div class="outer-container">
  <div class="card">
    <div class="card-content">
      <!-- Inner layers go here -->
    </div>
    <div class="card-back">
      <!-- Back face content -->
    </div>
  </div>
</div>

Inside the .card-content, we can now add .card-layers with multiple layers in it. Here I’m setting a --i custom property on each layer to later control its depth.

<div class="card-layers">
  <div class="card-layer" style="--i: 0"></div>
  <div class="card-layer" style="--i: 1"></div>
  <div class="card-layer" style="--i: 2"></div>
  <div class="card-layer" style="--i: 3"></div>
  <!-- more layers as needed -->
</div>

Now we can fill each layer with content, images, text, or whatever we want.

The Movement

To create the rotation effect, we need to track the mouse position and convert it into tilt angles for the card. So the first thing we need to do is to map the mouse position into two CSS variables, --mouse-x and --mouse-y.

This is done with few simple lines of JavaScript:

const cardContainer = document.querySelector('.card-container');

window.addEventListener('mousemove', (e) => {
  const rect = cardContainer.getBoundingClientRect();
  const x = (e.clientX - rect.left) / rect.width * 2 - 1;
  const y = (e.clientY - rect.top) / rect.height * 2 - 1;
  cardContainer.style.setProperty('--mouse-x', x);
  cardContainer.style.setProperty('--mouse-y', y);
});

This gives us normalized values between -1 and 1 on each axis, so we can use them regardless of the card size or aspect ratio.

We convert these values to --tilt-x and --tilt-y in CSS, by multiplying them by the number of degrees we want the card to rotate:

--tilt-x: calc(var(--mouse-y, 0.1) * -120deg);
--tilt-y: calc(var(--mouse-x, 0.1) * 120deg);

The higher the degree value, the more dramatic the rotation. 20–30 degrees will give us a subtle effect, while 180 degrees will spin the card all the way around.

Notice that --mouse-x affects --tilt-y, because movement of the mouse along the X axis should actually rotate the card around the Y axis, and vice versa. Also, we multiply --mouse-y by a negative number, because the Y axis on the screen is inverted compared to the mathematical Y axis.

Now that we have --tilt-x and --tilt-y, we can start using them. And first, we apply them to the card container to rotate it in 3D space:

.card {
  transform: rotateX(var(--tilt-x)) rotateY(var(--tilt-y));
}

This gives us the basic rotation effect. The card will now tilt and spin based on the mouse position.

The Perspective

We need to remember that we need to set two different perspectives: one for the card’s container (to create the 3D effect), and one for the card’s content (to maintain the depth of the inner elements).

on the .card-container we set a standard perspective:

.card-container {
  perspective: var(--perspective);
}

You can set --perspective to any value you like, but a good starting point is around 800px. Lower values will create a more dramatic perspective, while higher values will make it more subtle.

To preserve the 3D space and making sure all the inner elements share the same 3D context, we set transform-style: preserve-3d. I’m using the universal selector here to apply it to all children elements:

* {
  transform-style: preserve-3d;
}

To deal with the inner perspective, we set up the perspective and perspective-origin on the .card-content element, which holds all the inner layers:

.card-content {
  perspective: calc(
    cos(var(--tilt-x)) * cos(var(--tilt-y)) * var(--perspective)
  );
  perspective-origin: 
    calc(cos(var(--tilt-x)) * sin(var(--tilt-y)) * var(--perspective) * -1 + 50%)
    calc(sin(var(--tilt-x)) * var(--perspective) + 50%);
  overflow: clip;
}

Note that we added overflow: clip to the .card-content to ensure that the inner elements are clipped by the card boundaries. This combination of perspective, perspective-origin, and overflow: clip is what allows us to maintain the 3D depth of the inner elements while keeping them contained within the card.

The Depth

Now that we have the rotation and perspective set up, we can start adding depth to the inner layers. Each layer will be positioned in 3D space using translateZ, based on its --i value.

.card-layer {
  position: absolute;
  transform: translateZ(calc(var(--i) * 1rem));
}

This will space out the layers along the Z axis, creating the illusion of depth. You can adjust the multiplier (here 1rem) to control how far apart the layers are.

Putting It All Together

Using the techniques outlined above, we can create a fully functional Deep Card that responds to mouse movement, maintains 3D depth, and clips its content appropriately.

Here is a complete ‘boilerplate’ example:

You can customize it to your needs, set the number of layers, their depth, and add content within each layer to create a wide variety of Deep Card effects.

Getting Deeper

To improve the Deep Card effect and further enhance the perception of depth, we can add shadows and darkening effects to the layers.

One way to achieve darker colors is just using darker colors. We can calculate the brightness of each layer based on its depth, making deeper layers darker to simulate light falloff.

.card-layer {
  color: hsl(0 0% calc(100% - var(--i) * 9%));
}

Another technique is to add semi-transparent background to each layer. This way each layer is like screen that slightly darkens the layers behind it, enhancing the depth effect.

.card-layer {
  background-color: #2224;
}

Here is an example of a two cards with different effects: The first card uses darker colors for deeper layers, while the second card uses semi-transparent overlays to create a more pronounced depth effect.

Choose the one that fits your design best, or combine both techniques for an even richer depth experience.

The z-index Effect

You might notice that I’m placing all the layers inside a container (.card-layers) rather than making them direct children of .card-content. The reason is that since we’re moving the layers along the Z axis, we don’t want them to be direct children of an element with overflow: clip; (like .card-content).

As mentioned earlier, once you set overflow: clip; on .card-content, its transform-style becomes flat, which means all of its direct children are rendered on a single plane. Their stacking order is determined by z-index, not by their position along the Z axis. By wrapping the layers in a container, we preserve their 3D positioning and allow the depth effect to work as intended.

The Twist

Now that we understand this limitation, let’s turn it to our advantage and see what kinds of effects we can create with it.

Here are the exact same two cards as in the previous example, but this time without a .card-layers container. The layers are direct children of .card-content:

Adding Interaction

We often use cards that need to display extra information. One of my favorite things to do in these cases is to rotate the card 180 degrees and reveal the additional content on the back side. Now, we can do exactly that, and build an entire 3D world inside the card.

In this example, we have a front face (.card-content) and a back face (.card-back). When the user clicks the card, we toggle a checkbox that rotates the card 180 degrees, revealing the back face.

<label class="card-container">
  <input type="checkbox">
  <div class="card">
    <div class="card-content">
      <!-- front face content -->
    </div>
    <div class="card-back">
      <!-- back face content -->
    </div>
  </div>
</label>

.card-container {
  cursor: pointer;
    
  &:has(input:checked) .card {
    rotate: y 180deg;
  }
  
  input[type="checkbox"] {
    display: none;
  }
}

You can also use a button or any other interactive element to toggle the rotation, depending on your use case, and use any animation technique you like to make the rotation smooth.

Inner Movement

Of course, we can also use any animation on the inner layers to create dynamic effects. It can be wild and complex, or subtle and elegant. The key is that since the layers are in 3D space, any movement along the Z axis will enhance the depth effect.

Here a simple example with parallax layers. each layer animates it’s background position on the X axis, and to enhance the depth effect, I’m animating the layers at different speeds based on their depth:

.card-layer {
  animation: layer calc(var(--i) * 8s) infinite linear;
}

And the result:

Deep Text Animation

This technique works beautifully with the concept of layered text, opening up a world of creative possibilities. There’s so much you can do with it, from subtle depth effects to wild, animated 3D lettering.

I actually wrote an entire article about this, featuring 20+ examples, and every single one of them looks fantastic inside a Deep Card. Here’s one of the examples from that article, now living inside a card:

Going Full 360

up until now, we’ve mostly focused on layering our inner content and using the Z axis to create depth. But we can definitely take it a step further, break out of the layering concept, and build a fully 3D object that you can spin around in all directions.

From here, the possibilities are truly endless. You can keep experimenting—add more interactions, more layers, or even create effects on both sides of the card to build two complete worlds, one on each face. Or, go all in and design an effect that dives deep into the card itself. The only real limit is your imagination.

Conclusion

The Deep Card is now a solved problem. We can have our cake (3D depth), eat it (clipping), and even spin it around 360 degrees without breaking the illusion.

So, the next time you hit a wall with CSS, and you’re sure you’ve tried everything, maybe take a second look at those properties you swore you’d never use. You might just find your answer hiding in the documentation you skipped.

Now, go build something deep.

A few months ago, when SNAP benefits abruptly disappeared, I immediately started working on bringing a Community Fridge to my town. It’s something I’d wanted to do for a while, and this was the spark that lit the fire in my belly.

If you’re unfamiliar with the concept, a Community Fridge is literally an open access fridge (and usually attached pantry) where people can share food they have and take food they need. It’s not a haves/have-nots thing. It’s a community resource for everyone.

I didn’t think it would be easy.

But I didn’t expect the level of push-back I got from people, either.

• Why not just donate to the official Food Pantry in town?
• What if someone poisons all the food?
• What about food-born illness?
• Who’s going to pay for electricity?
• What if someone takes more than they deserve?
• What if it’s empty?

Some of these are good questions about legitimate logistics concerns that need to be worked out. Some are obnoxious, parental, charity-model thinking. They’re all attempts to throw up road blocks and prevent the project from happening.

None of them pause for a second and say, “How can we make this work?”

I have answers to all of these questions. I’ve given them over-and-over again. Most of the people who ask just… disappear afterwards, which tells me the questions weren’t earnest or in good-faith.

A Community Fridge is different from a Food Pantry in a few really important ways.

The most important is that it’s not charity. It’s not the rich helping the poor.

It’s an opportunity for a community to help itself: to share resources, divert food waste, and work together for the common good.

There is no means testing. No restrictions on who can use it or how much they can take. No one deciding who deserves it and who doesn’t.

Take what you need. Give what you can.

But that’s really hard for a lot of people to conceptualize.

Under capitalism in general, and in America (where I live) in particular, you’re taught to look out for yourself, be ruggedly individual, work hard, and accumulate as much wealth as you can.

A resource rooted in sharing rather than throwing crumbs to the poor is completely foreign to how so much of modern culture operates.

So you get questions like, “what if someone takes more than they deserve?”

And that brings us to prefiguration.

Prefiguration is about building the future you want within the shell of existing structures.

It’s generally not going to replace an existing system—at least, not in any sort of immediate or rapid time scale.

But it does provide models people can look at to imagine something different.

Prefiguration serves as a lighthouse for a possible future. A direction you can head in. It provides little experiments that you can try and learn from.

You don’t need permission to build the future you want.

Finding a host for a Community Fridge has been filled with many closed doors and false starts. I still don’t have one, though I have met some wonderful new friends in town.

My house is not an ideal spot for one. I’m nowhere near our small downtown, near farms, with little foot or car traffic.

But I hit a point the other day where I’m sick of waiting, sick of asking permission, and sick of letting perfect be the enemy of “a start.”

So yesterday, I sketched out some rough plans, bought a bunch of lumber, and will be building a little free farmstand on my property.

Not quite a fridge, yet. But still, a place for people to share food and excess fruits and vegetables (I live near farms), and clothes and toys and home goods.

Then, when people ask, “what about…?” I can point them to something tangible, and say, “kind of like this.”

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

Claude was repeatedly wrong because it didn’t have a repro.

Meaning Claude couldn’t see the bug for itself. My first thought was: Dan! You gotta get Chrome DevTools MCP! This essentially makes the browser context for Claude, which is in my experience pretty damn helpful. But Dan actually had the Playwright MCP going, so it was a more complicated issue than just that. The path to a solution:

This exact workflow—removing things one by one while ensuring the bug is still present—saved my ass many times.

Reminds me of the lesser-known git feature git-bisect.

For every cloud service I use, I want to have a local copy of my data for backup purposes and independence. Unfortunately, the gphotos-sync tool stopped working in March 2025 when Google restricted the OAuth scopes, so I needed an alternative for my existing Google Photos setup. In this post, I describe how I have set up Immich, a self-hostable photo manager.

Here is the end result: a few (live) photos from NixCon 2025:

Step 1. Hardware

I am running Immich on my Ryzen 7 Mini PC (ASRock DeskMini X600), which consumes less than 10 W of power in idle and has plenty of resources for VMs (64 GB RAM, 1 TB disk). You can read more about it in my blog post from July 2024:

I installed Proxmox, an Open Source virtualization platform, to divide this mini server into VMs, but you could of course also install Immich directly on any server.

Step 2. Install Immich

I created a VM (named “photos”) with 500 GB of disk space, 4 CPU cores and 4 GB of RAM.

For the initial import, you could assign more CPU and RAM, but for normal usage, that’s enough.

I (declaratively) installed NixOS on that VM as described in this blog post:

Afterwards, I enabled Immich, with this exact configuration:

services.immich = {
 enable = true;
};

At this point, Immich is available on localhost, but not over the network, because NixOS enables a firewall by default. I could enable the services.immich.openFirewall option, but I actually want Immich to only be available via my Tailscale VPN, for which I don’t need to open firewall access — instead, I use tailscale serve to forward traffic to localhost:2283:

photos# tailscale serve --bg http://localhost:2283

Because I have Tailscale’s MagicDNS and TLS certificate provisioning enabled, that means I can now open https://photos.example.ts.net in my browser on my PC, laptop or phone.

Step 2. Initial photos import

At first, I tried importing my photos using the official Immich CLI:

% nix run nixpkgs#immich-cli -- login https://photos.example.ts.net secret
% nix run nixpkgs#immich-cli -- upload --recursive /home/michael/lib/photo/gphotos-takeout

Unfortunately, the upload was not running reliably and had to be restarted manually a few times after running into a timeout. Later I realized that this was because the Immich server runs background jobs like thumbnail creation, metadata extraction or face detection, and these background jobs slow down the upload to the extent that the upload can fail with a timeout.

The other issue was that even after the upload was done, I realized that Google Takeout archives for Google Photos contain metadata in separate JSON files next to the original image files:

Unfortunately, these files are not considered by immich-cli.

Luckily, there is a great third-party tool called immich-go, which solves both of these issues! It pauses background tasks before uploading and restarts them afterwards, which works much better, and it does its best to understand Google Takeout archives.

I ran immich-go as follows and it worked beautifully:

% immich-go \
  upload \
  from-google-photos \
  --server=https://photos.example.ts.net \
  --api-key=secret \
  ~/Downloads/takeout-*.zip

Step 3. Install the Immich iPhone App

My main source of new photos is my phone, so I installed the Immich app on my iPhone, logged into my Immich server via its Tailscale URL and enabled automatic backup of new photos via the icon at the top right.

I am not 100% sure whether these settings are correct, but it seems like camera photos generally go into Live Photos, and Recent should cover other files…?!

If anyone knows, please send an explanation (or a link!) and I will update the article.

I also strongly recommend to disable notifications for Immich, because otherwise you get notifications whenever it uploads images in the background. These notifications are not required for background upload to work, as an Immich developer confirmed on Reddit. Open Settings → Apps → Immich → Notifications and un-tick the permission checkbox:

Step 4. Backup

Immich’s documentation on backups contains some good recommendations. The Immich developers recommend backing up the entire contents of UPLOAD_LOCATION, which is /var/lib/immich on NixOS. The backups subdirectory contains SQL dumps, whereas the 3 directories upload, library and profile contain all user-uploaded data.

Hence, I have set up a systemd timer that runs rsync to copy /var/lib/immich onto my PC, which is enrolled in a 3-2-1 backup scheme.

What’s missing?

Immich (currently?) does not contain photo editing features, so to rotate or crop an image, I download the image and use GIMP.

To share images, I still upload them to Google Photos (depending on who I share them with).

Why Immich instead of…?

The two most promising options in the space of self-hosted image management tools seem to be Immich and Ente.

I got the impression that Immich is more popular in my bubble, and Ente made the impression on me that its scope is far larger than what I am looking for:

Ente is a service that provides a fully open source, end-to-end encrypted platform for you to store your data in the cloud without needing to trust the service provider. On top of this platform, we have built two apps so far: Ente Photos (an alternative to Apple and Google Photos) and Ente Auth (a 2FA alternative to the deprecated Authy).

I don’t need an end-to-end encrypted platform. I already have encryption on the transit layer (Tailscale) and disk layer (LUKS), no need for more complexity.

Conclusion

Immich is a delightful app! It’s very fast and generally seems to work well.

The initial import is smooth, but only if you use the right tool. Ideally, the official immich-cli could be improved. Or maybe immich-go could be made the official one.

I think the auto backup is too hard to configure on an iPhone, so that could also be improved.

But aside from these initial stumbling blocks, I have no complaints.

I typically consume short form writing by listening to it. In the past, I've used Pocket¹, Instapaper, Readwise's Reader and Safari's listen to page feature for this. Safari had become something of a default choice for this as I didn't have a compelling, self-hosted option available. So I built one.

I use Audiobookshelf to listen to audiobooks and podcasts, making it a natural fit to listen to the articles I save. Neither Safari nor Readwise's Reader support queueing articles to listen to², which meant starting playback manually for each article listened to. Audiobookshelf and the clients I've used all support queueing, which solves that particular usability pain point.

I have text, I have a solution for playing audio which left me needing to coerce the former into the latter. Rather than dump my entire bespoke project repo into a blog post, the high level flow looks like this:

1. Deploy the project to my Audiobookshelf server using Coolify.
   • The deploy clones the project, installs dependencies, downloads a Piper voice model from Hugging Face³, and configures a cron job to run every 5 minutes.
2. Every 5 minutes the deployed application will check linkding for new items.
3. If an item has not been converted to audio, is unread and is not tagged with video or podcast, the article text is fetched and parsed using Mozilla's Readability.js.⁴
4. Once parsed, the article is processed further into a string that will be converted to speech. This string is simply the following concatenated together: article title, author and content. Pauses are added after periods that don't otherwise have one, URLs are cleaned up and email addresses are removed.
5. The processed text is written to a temporary text file and passed to Piper to generate a WAV file using the voice model downloaded when the application is deployed. ffmpeg is used to convert the WAV file to an mp3 and node-id3 is used to tag the resulting file.
   • The tag data is fairly simple — the article title is the episode title, a consistent, static podcast title (Linkding Articles) and artist (Linkding TTS Bot) and the article author and description are saved to the episode description. Year and date correspond to when the item was saved, the show art is the linkding logo/icon and the rest is generic podcast metadata expected by Audiobookshelf.
6. Once the audio is generated and tagged, the app triggers a scan of my podcast library using the Audiobookshelf API.

With all of this in place, I can save things to linkding and there will be an automatically generated queue waiting when I open my preferred Audiobookshelf client.⁵⁶

1. I had quite a bit of trouble figuring out a workflow for branches. Since my companies unit of work is the branch, with specifically named branches, my `jj ls` was confusing as hell.

`jj st` might have helped a bit, but there were scenarios where creating an commit would abandon the branch... if i'm reading my post history correctly. My coworker who was more familiar explained my jj problems away with "definitely pre-release software", so at the time neither of us were aware of a workflow which considered branches more core.

Fwiw, I don't even remember when the jj workflow had branches come into play.. but i was not happy with the UX around branches.

2. iirc i didn't like how it auto stashed/committed things. I found random `dbg!` statements could slip in more easily and i had to be on guard about what is committed, since everything just auto pushed. My normal workflow has me purposefully stashing chunks when i'm satisfied with them, and i use that as the visual metric. That felt less solid with jj.

Please take this with a huge grain of salt, this is 10 month old memory i scavenged from slack history. Plus as my coworker was saying, jj was changing a lot.. so maybe my issues are less relevant now? Or just flat out wrong, but nonetheless i bounced off of jj despite wanting to stick with it.

They encouraged people to spend less money and give more time, attention, and love.

They’re a religious organization, and I’m very much an atheist. But they didn’t lean very heavy into Jesus at the time.

They’ve released an updated video with new numbers (we now spend over $1 TRILLION globally at Christmas!). They’ve dialed up the religious aspects a lot, but I think the core message is still a really important one.

In particular, their blog has a ton of great ideas on how to make the holidays more about building community and less about buying shit.

• Invest in experiences you can share. Sign up for dance lessons, go camping, plan a vacation, take cooking classes.
• Pass down memories. Make a recipe book or photo album to give to your family.
• Get a blank journal and write notes and prayers to your kids.
• Give a copy of your favorite book to a friend and then meet up for coffee and discuss it. Then switch and read their favorite book.
• Buy someone a gift that relieves a burden: babysitting money, help out with yard work, make a meal.
• Give the gift of hospitality. Invite a new family over for dinner and games.
• Do an activity with your kids – puzzles, jewelry making, baking, hiking, fishing, sports. Be present.

This is the kind of energy I’m trying to channel this year!

Like this? A Lean Web Club membership is the best way to support my work and help me create more free content.

I've always been fascinated by old, multi-generational Japanese businesses. My leisure-watching on YouTube is usually a long video of a Japanese craftsman—sometimes a 10th or 11th generation—making iron tea kettles, or soy sauce, or pottery, or furniture.

Their dedication to craft—and acknowledgment that perfection is unattainable—resonates with me deeply. Improving in their craft is an almost spiritual endeavour, and it inspires me to engage in my crafts with a similar passion and focus.

Slow, consistent investment over many years is how beautiful things are made, learnt, or grown. As a society we forget this truth—especially with the rise of social media and the proliferation of instant gratification. Good things take time.

Dedication to craft in this manner comes with incredible longevity (survivorship bias plays a role, but the density of long-lived businesses in Japan is an outlier). So many of these small businesses have been around for hundreds, and sometimes over a thousand years, passed from generation to generation. Modern companies have a hard time retaining employees for 2 years, let alone a lifetime.

This longevity stems from a counter-intuitive idea of growing slowly (or not at all) and choosing to stay small. In most modern economies if you were to start a bakery, the goal would be to set it up, hire and train a bunch of staff, and expand operations to a second location. Potentially, if you play your cards right, you could create a national (or international) chain or franchise. Corporatise the shit out of it, go public or sell, make bank.

While this is a potential path to becoming filthy rich, the odds of achieving this become vanishingly small. The organisation becomes brittle due to thinly-spread resources and care, hiring becomes risky, and leverage, whether in the form of loans or investors, imposes unwanted directionality.

There's a well known parable of the fisherman and the businessman that goes something like this:

A businessman meets a fisherman who is selling fish at his stall one morning. The businessman enquires of the fisherman what he does after he finishes selling his fish for the day. The fisherman responds that he spends time with his friends and family, cooks good food, and watches the sunset with his wife. Then in the morning he wakes up early, takes his boat out on the ocean, and catches some fish.

The businessman, shocked that the fisherman was wasting so much time encourages him fish for longer in the morning, increasing his yield and maximising the utility of his boat. Then he should sell those extra fish in the afternoon and save up until he has enough money to buy a second fishing boat and potentially employ some other fishermen. Focus on the selling side of the business, set up a permanent store, and possibly, if he does everything correctly, get a loan to expand the operation even further.

In 10 to 20 years he could own an entire fishing fleet, make a lot of money, and finally retire. The fisherman then asks the businessman what he would do with his days once retired, to which the businessman responds: "Well, you could spend more time with your friends and family, cook good food, watch the sunset with your wife, and wake up early in the morning and go fishing, if you want."

I love this parable, even if it is a bit of an oversimplification. There is something to be said about affording comforts and financial stability that a fisherman may not have access to. But I think it illustrates the point that when it comes to running a business, bigger is not always better. This is especially true for consultancies or agencies which suffer from bad horizontal scaling economics.

The trick is figuring out what is "enough". At what point are we chasing status instead of contentment?

A smaller, slower growing company is less risky, less fragile, less stressful, and still a rewarding endeavour.

This is how I run Bear. The project covers its own expenses and compensates me enough to have a decent quality of life. It grows slowly and sustainably. It isn't leveraged and I control its direction and fate. The most important factor, however, is that I don't need it to be something grander. It affords me a life that I love, and provides me with a craft to practise.

Ever noticed how white text on a black background looks thicker than black text on a white background, even though the weights are the same?

This post teaches you how to account for this and adjust perceived font weight for dark mode without layout shift, with variable fonts and the GRAD axis.

g…RAD! 👈😎👈

Feel out the problem space #

Test your eyes and feel the problem space with the following demo
(def open it up larger):

To test:
Flip between light and dark. Look closely at font weights in the "un-adjusted" and "adjusted" example content.

The goal:
The visual weight to not perceptively change when switching between light and dark. This means, when in dark mode, using a negative value for GRAD to reduce the perceived thickness.

Some play:
In dark mode, use the slider to adjust the GRAD axis to see how it changes the perceived weight of the font in the adjusted example. Feel free to fine tune the slider to find the perfect balance for your eyes, flipping back and forth, adjust the slider until you see no weight change when flipping themes.

I think it's easier to notice the difference in the paragraph text than the heading text, but you find which is easier to notice for yourself.

It's subtle:
Don't expect this to jump out at you, but you'll struggle to unsee once you see.

Irradiation illusion #

Humans perceive white on black vs black on white differently. We learned it from the world, the way shadows and light have given us biases and expectations. Our squishy human eye has been through some things you know?

Read more about irradiation illusion.

This impacts typography in dark mode, as the perceived weight of a font changes in dark mode, without intention from the CSS authors. The light text appears thicker than the dark text counterpart, even though the font weight is the same.

CSS can account for this illusion 🤓

GRAD in variable fonts to the rescue #

Before variable fonts, font weight was the only way to adjust the perceived weight of a font, but this changes the glyph size. This can cause accidental layout shift, aka a janky experience.

GRAD stands for "grade", and it's a variable font axis that allows us to adjust the perceived weight of a font without changing the glyph size.

Fixing bold link hovers #

Here, you'll recognize this classic issue. Hover the links in the below demo to see a small preview of the type of layout shift that can occur.

With variable fonts, we can use the GRAD axis to adjust the perceived weight of a font without changing the glyph size.

This allows us to adjust the perceived weight of a font without causing layout shift. That's what the "fixed" example is using.

One step further #

So far we've only adjusted the perceived weight of a font in dark mode with a negative value for GRAD, and for links being hovered that use a positive value for GRAD, but we can go even further:

This allows us to adjust the perceived weight of a font based on the users contrast preferences.

If the user prefers more contrast, without layout shift, we can use a positive value for GRAD to increase the perceived thickness. In dark mode, we can use a negative value for GRAD to reduce the perceived thickness while still maintaining their preference.

body {
  --GRAD: 0;
  font-variation-settings: "GRAD" var(--GRAD);
}

@media (prefers-contrast: more) { body { --GRAD: 700 } }
@media (prefers-contrast: less) { body { --GRAD: -50 } }

@media (prefers-color-scheme: dark)                              { body { --GRAD: -50 } }
@media (prefers-color-scheme: dark) and (prefers-contrast: more) { body { --GRAD: 150 } }
@media (prefers-color-scheme: dark) and (prefers-contrast: less) { body { --GRAD: -150 } }

Users will never ask for something like this. They'll just be able to easily read the content in your design in a way that feels natural.

Time to check if your favorite font has a GRAD axis.

Also, this is just the beginning, a foot in the door. It’s worth learning more about the relationship between grade and weight, and fine tune instances to produce the results your users and you will want.

Coolify has a native integration with GitHub, but not with other git hosts. For deploys, I've worked around this by cloning my projects using an API key within the Dockerfile for the project as a sort of lightweight continuous integration.

Within each Coolify resource you'll find a webhooks section. There's a unique deploy webhook for each resource that accepts POST requests to trigger a new deployment. Rather than use a Forgejo action, I'm having the repositories that I want to deploy on push send a webhook event to the appropriate Coolify deploy URL. You can do this in the Forgejo repository's webhooks settings by adding a webhook, selecting a target (I simply selected Forgejo, the first option in the list), adding the Coolify URL, changing the force parameter value at the end of the URL from false to true to ensure the build is performed without using the cache and add a Bearer <COOLIFY-DEPLOY-TOKEN>. The Coolify API token only needs deploy permissions.

Now, when I push to Forgejo, it sends a POST request to the Coolify webhook and deploys a fresh build of the project.