Leftium

Cloudflare actually ran into the opposite problem: their employees' creativity was distracting them from using AI in a productive way.

The answer to both too little discoverability and too little/much creativity is to deploy the chatbox/voice UX with "champions" that can help others use the new UX effectively.

- https://blog.cloudflare.com/how-we-use-ai-with-cloudflare-os...

- https://www.inkandswitch.com/essay/malleable-software/#commu...

> Studying spreadsheet use at companies, Nardi and Miller found "local developers" – amateur enthusiasts who could write bits of code for their coworkers and guide their team up the gentle slope of spreadsheets.

Interestingly, Cloudflare solved the excess creativity problem in the short-term by changing the UX from a magic chat to a magic email. The email could only input work you wanted to automate, and the only output was the finished work. This helped the employees' requests become more focused.

While I was making a little app that converts text descriptions of events into calendar events[1], I was thinking an LLM could do this: consumes tokens and slower, but can work with even messier text descriptions.

I actually used an LLM to add coverage for the various ways different people represent dates and times in English (actually mostly Korean right now.) LLMs are even great at extracting data from text that is full of misspellings and ambiguous wording. I just give the LLM examples that were not parsed as expected. The LLM figures out the correct output itself, then adds logic so similar text will be parsed correctly in the future.

We've already seen apps that added an AI chat to their interfaces. And other apps use AI to generate "home-cooked" personal apps.

I think we will see a convergence of this: where users can chat with "malleable" apps to create features in the app itself.

So personal assistants will be creating the next generation of apps. Apps that are meant for a single user and/or even only intended to be run a single time before being thrown away.

I proposed this type of UX for Kagi; it could be applied to many types of software: https://doggo-pitch.leftium.com

[1]: https://nl-event.vercel.app, https://github.com/Leftium/nl-event

I am surprised dark mode for HN did not make the list: https://hn.algolia.com/?q=hn+darkmode

Perhaps because it's not a stand-alone tool? (Although there are stand-alone tools that accomplish this)

I guess the most likely reason is the exact trigger phrases aren't present

Probably a different data source/mapping, but you may find this easier to use: https://www.color-blindness.com/color-name-hue/

Nimble.css is my spiritual successor to PicoCSS: https://leftium.github.io/nimble.css/demo/pico.html

It's not a direct replacement; I fixed a lot of annoyances from PicoCSS.

On Windows, restart and shut down (power off) are not the same.

When shutting down, Windows optimizes the next start by caching some stuff. So it is not a true, clean restart.

On a restart, this caching does not happen.

Sources:

- https://www.youtube.com/watch?v=lUIhzACQDAc

- https://learn.microsoft.com/en-us/windows/win32/power/system...

This is the first window manager I've found that lets you split windows by dragging onto other windows (like VS code)

There are microphones that can capture whispers and even subvocal dictation: https://youtu.be/NvVbCqDgfCs?t=520

The one demo'ed in the video is BOYA BY-GM18CU (https://www.amazon.com/dp/B0BF969RVP)

That one captures whispers. I've heard other devices can dictate based on vibrations from your neck/chest.

Tip: you can install this as a PWA (progress web app) onto your mobile device home screen. (If you have recent iOS 26+ or Android.)

If the site adds a PWA manifest, Android (Chrome/Google app) will show a prompt to install as app on load. Also PWA install will be available for older iOS.

I made a simple tool that generates a minimal PWA manifest: https://logo.leftium.com/logo

Apparently the other reply got auto-flagged because it was detected as genai. Let me paraphrase that comment (easier than reading that entire MD document, which was AI-written):

The main annoyances:

- oversized buttons

- 100+ root custom properties in devtools

- fighting against too many breakpoints (unpredictable font/container sizing)

---

I also changed/added some features:

- much smaller core: only 4.1 KB Brotli

- CSS cascade layers so app CSS can override more easily

- a surface color system (a la Open Props)

- OKLCH colors with auto derived hover/focus states and light-dark() theming

- centered layout with real gutters, plus content bleed outside gutters

- .no-nimble opt-out class (instead of .pico opt-in)

- ability to configure universal control-density (buttons, inputs, selects)

For some reason my detailed reply got flagged...

So if you can't see it: feature-comparison matrix plus notes from migrating several real projects from Pico:

https://github.com/Leftium/nimble.css/blob/main/specs/pico-m...

My nimble.css is inspired by PicoCSS: https://leftium.github.io/nimble.css/demo/pico.html

But it's not a drop-in replacement. (I fixed several annoyances I had while using PicoCSS.)

Perhaps you may find like-minded folks in the functional-thinking community:

I was trying to figure out what you meant by "declarative" because CSS is declarative. (My understanding is: "declarative means you say (declare) what you want, but not how to get it." Usually SQL is the poster child of declarative languages.)

I think you're really talking about a mix of preferring data (vs actions/calculations) and DSLs (which aren't necessarily declarative)

Eric Normand has some thoughts you might appreciate:

- How a problem might take 1000 SLOC to solve directly, but only 10 SLOC with a DSL (plus up to 500 SLOC for the DSL itself; still fewer lines total) https://ericnormand.me/podcast/magical-leverage-languages

- Data vs calculations vs actions: https://ericnormand.me/podcast/what-is-an-action

---

I think data can be very powerful. For example, someone explained to me:

> I've been helping my non-tech father with Home Assistant. I've honestly been shocked with how far "community extensions" + "user configuration" can take you. Every time we hit a bug, I go "time to hit github" but without fail chatgpt and him are able to tweak a setting to get it working.

If you make your system configurable (config==data), you can skip the whole compile/build step!

I think actions vs calculations is a better framing here. It's not just about avoiding imperative code or nondeterminism. It's about being extra careful with actions because the order and number of times they run matter.

Here is an example of a calculation written imperatively. It remains easy to reason about because the actions don't leak out of the function:

    function add(ns) {
        let total = 0
        for (const n of ns) {
            total += n
        }
        return total
    }

On the other hand, a deterministic state machine like `a = AddMachine` is harder to reason about because it still matters how many times the action `a.transition(1)` is called. (Note it is possible to implement the state machine as calculations.)

https://ericnormand.me/podcast/what-is-an-action

https://livebook.manning.com/book/grokking-simplicity/chapte...

I think the real question you're asking is: why isn't AI coded software replacing well-known incumbent software (office, adobe, etc...)

Because I see AI coded software everywhere: HN has been complaining about the recent influx of Show HNs due to AI. Take a specific product category: there are about two new dictation apps on Show HN every week.

Here are my theories:

- adobe/office are simply too complex for AI to replicate (as of now). Theo Browne has been testing all the frontier models with a relatively simple fish game. The results have been subpar, at best. I don't think anyone would prefer the AI-generated games over the original. Even if the AI-generated version was free.

- Most AI-coded software won't be distributed like classic software. Instead of a bag of hundreds of features (adobe/office), AI will be used to create the specific 5% of the features a single user really needs (home-cooked software). The software may even be per project or even per task. Why spend 20X to 100X the tokens/time when you only need a small subset of the features?

- AI may not be able to replace human "taste" or design. There is a lot of design that went into adobe and office. I don't think AI can fully understand all the "why's" of these designs. We can already kind of see this with open source: Gimp and LibreOffice are alternatives to adobe/office. Yet most people prefer the paid options.

- Even if AI solved coding, there are other barriers like marketing.

Some examples:

- I built my perfect window management system with the help of AI. It suits my very specific needs very well, but it's nowhere near ready for distribution. So this is AI-generated software no one else will ever probably see.

- Going with the home-cooked meal analogy: there is a dish served at all Chinese restaurants in Korea: jjajangmyeon. However you can't find it in China because that dish is only found at home, not at restaurants in China.

My first impression is it's very similar to the stock iOS weather app Apple provides by default (feature/layout-wise). I couldn't see any major differences based on the description here or in the app store. That's what kept me from even trying it.

So my advice is to highlight the major benefit over the iOS weather app that ships with every iPhone.

The only major difference I could see is the data source. Did you intentionally not use Apple WeatherKit? (If so, what was the rationale?)

My HN reader has QoL features for reading such posts: https://hn.leftium.com/i/49630931?q=%22aspect+ratio%22

- Comments have 3 LOD (L:full, M:single line, S:collapsed)

- Optimal default LODs

- Simple to expand groups of comments (direct replies, comment thread ("spine"), full sub-tree)

- Highlight specific users like OP, or other interesting users

- Search for text within thread (automatically expands LOD)

- Highlights new comments (since last visit or set time)

It matches the way I want to read HN comments, anyways.

> Compression is prediction

(According to recent article on HN[1]. So LLMs _are_ compression!)

[1]: https://hn.leftium.com/i/49263497

Tip: you can also add widgets to your desktop

1. Click menu bar time/clock

2. Click Edit Widgets...

3. Search for "Codexbar"

Apple hardware uses a unified architecture. That means the CPU and RAM are integrated together: it is very difficult/impossible to strip the RAM from these systems.

This unified architecture makes Apple hardware very good for AI work, where latency between RAM and CPU is very important

Even the SSDs (which are normally more strippable) use a proprietary hardware form factor.

I think the article mentioned the real draw:

> Apple noticeably promoted the ability to link multiple Mac Studios together into a single, more capable system for running large frontier AI models, a feature aimed at business and developer customers rather than everyday consumers.

(Couldn't read the source cited, might have more info: The Information)

wow thanks! I integrated like this: https://hn.leftium.com/i/49449507?violation_threshold=0.5

The url param temporarily sets the threshold, you can permanently set it via the settings.

My initial assessment is 0.5 setting is too aggressive; the posts that I generally don't care to read seem to violate multiple rules at once.

It's a shame we can't see comment scores so orange highlights could shine through the blurring on "good" comments.

I have been considering adding labels/filters based on sentiment analysis to my HN reader. I wonder if your classifier-based method would be more effective.

I added filters that blur posts from new HN accounts based on age/karma thresholds (as suggested by another HN user). However, instead collapsing, I just blurred them. This allows quickly peeking via hover. My reader also highlights posts with higher points/comments, and those orange highlights survive the blurring.

This is what blurring looks like: https://hn.leftium.com/newest?min_karma=500&min_age_years=5

My HN client has made HN easier to keep up with, even before AI: https://hn.leftium.com

I call it "Seeking Orange" because interesting posts are highlighted. Features include:

- Point/comment counts become increasingly more orange with higher counts (50+, 100+)

- Orange accent bar on left indicates new items since last visit

- Support for several different feeds including: HckrNews (chronological front page appearance time), Classic Stories, Best Stories, Active Stories

- Thresholds to de-emphasize posts from users with low karma/recent creation dates: https://hn.leftium.com/newest?min_karma=500&min_age_years=5

When this was posted to HN, a lot of people could relate: https://sive.rs/slow

For me, I'm not sure if "slow" is the right word. I think "delayed" or "sporadic" is more accurate.

Thoughts for me are like when a word is on the tip of your tongue, but you can't think of it right away. Often you'll think of the word later: you weren't actively thinking about it, but the thought was simmering in your mind and just randomly pops up.