Leftium

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.

You can add instructions in the CLAUDE.md/AGENTS.md file to modify output behavior like:

    # Response Style

    Keep routine answers concise. Lead with the result, include material caveats and the next action, and omit introductions, repetition, generic reassurance, and optional background. Expand only when the task requires explanation.

While writing a document I got good mileage out of doing something like this for every paragraph:

    Let's analyze this paragraph:
     - List the main points.
     - Can any points be removed? (Do any points need to be added?)
     - Reword each point. Be as succinct and clear as possible.

I'm not sure how many extra tokens it would consume to do this for every output. But it may be better than just asking for "TLDR pls"

(I've actually never used Claude Code. I've never had problems with verbosity in harnesses like OpenCode or T3-code. And recently I've been using Codex, not Claude models.)

Reminds me of this this advice from 20 years ago (2006!): https://www.nngroup.com/articles/screen-resolution-and-page-...

> Big monitors are the easiest way to increase white-collar productivity, and anyone who makes at least $50,000 per year ought to have at least 1600×1200 screen resolution. A flat-panel display with this resolution currently costs less than $500. So, as long as the bigger display increases productivity by at least 0.5%, you'll recover the investment in less than a year.

Surely the economics must be even better in 2026?

I settled on JSONL for an LLM-optimized output format. Rationale: https://github.com/Leftium/gg/blob/main/specs/completed/gg-a...

Combine that with context mode: https://hw.leftium.com/i/47193064

Location: Seoul

Remote: Yes

Willing to relocate: Yes

Technologies: SvelteKit, TS, JS, UX

Résumé/CV: https://leftium.com/resume

Email: https://leftium.com/contact

If you're looking for a full-stack (SvelteKit) developer who obsesses over UX and finds unconventional solutions, let's discuss how we might work together.

First, it's really odd to have to use an onscreen keyboard to enter a username on a web game. I suggest:

- allowing keyboard input

- make username input optional, or move to end of game

- there is no way to log in as the same user on a different device/profile

The reason I tried on a different device/profile was because I could not see any tutorial. I was wondering if it was because of adblock/extensions.

There was no way to enter the tutorial right away

I tried replay with tutorial, but I don't think anything was different

Of course, I have no idea how to play the game; there is no way to understand what is happening

I tried clicking everywhere

Clickable link: https://pelicantools.app/tools/youtube-to-transcript

It would be amazing if clicking the timestamps opened the video at that time. I often want to search inside a video for certain text, then watch the video at that point. (YouTube supports linking to videos at a given timestamp like https://youtu.be/tL9Lw250spc?t=199)

It's kind of possible with the YouTube UI, but not a very good user experience.

You can hide data in random static (for a novel captcha). Very obvious to most humans (if it becomes popular, the bots could probably be designed solve it; just requires diffing the images):

- https://fx.leftium.com/static

- https://www.youtube.com/shorts/tPfzNzy24to

---

I noticed most of the traffic to my hobby sites was bot traffic (probing for common vulnerabilities). So I added a robots.txt for well-behaved bots and rules for the bad ones. It works pretty well.

robots.txt: https://github.com/Leftium/robots-txt

Sample cloudflare rules:

    (
      http.request.uri.path contains "/wp-login"
      or http.request.uri.path contains "/wp-admin"
      or http.request.uri.path contains "/wp-content"
      or http.request.uri.path contains "/wp-includes"
      or http.request.uri.path contains "/xmlrpc.php"
      or http.request.uri.path contains "/wordpress/"
      or http.request.uri.path contains "/wp-json/"
      or http.request.uri.path contains "/wp-config"
      or http.request.uri.path contains "/wp/"
      or http.request.uri.path.extension eq "php"
      or http.request.uri.path.extension eq "aspx"
      or http.request.uri.path.extension eq "asp"
      or http.request.uri.path contains ".env"
      or http.request.uri.path contains "sftp-config"
      or http.request.uri.path contains ".vscode/"
      or http.request.uri.path contains "credentials"
      or http.request.uri.path contains "stripe"
      or http.request.uri.path contains "secrets"
      or http.request.uri.path contains "config.json"
      or http.request.uri.path contains "config.yml"
      or http.request.uri.path contains "config.yaml"
      or http.request.uri.path contains "config.py"
      or http.request.uri.path contains "config.inc"
      or http.request.uri.path contains "config.rb"
      or http.request.uri.path contains "settings.json"
      or http.request.uri.path contains "settings.yml"
      or http.request.uri.path contains "settings.py"
      or http.request.uri.path contains "application.yml"
      or http.request.uri.path contains "application.properties"
      or http.request.uri.path contains "parameters.yml"
      or http.request.uri.path contains "appsettings.json"
      or http.request.uri.path contains "docker-compose"
      or http.request.uri.path contains "/.git/"
      or http.request.uri.path contains "/.circleci/"
      or http.request.uri.path contains "/.aws/"
      or http.request.uri.path contains "/.bitbucket/"
      or http.request.uri.path contains "/.travis.yml"
      or http.request.uri.path contains "serverless.yml"
      or http.request.uri.path contains "debug.log"
      or http.request.uri.path contains "error.log"
      or http.request.uri.path contains "/storage/logs/"
      or http.request.uri.path contains "_profiler"
      or http.request.uri.path contains "phpinfo"
      or http.request.uri.path contains "/debug/"
      or http.request.uri.path contains "/horizon/"
      or http.request.uri.path contains "/manage/"
      or http.request.uri.path contains "fileman"
      or http.request.uri.path contains "assetmanager"
    )

I think the most useful data to add is the 60-min precipitation forecast.

Unfortunately open-meteo doesn't offer this.

So https://weather-sense.leftium.com uses the 60-min forecast from OpenWeather. But you have to specifically request it because the free-tier quota is not as generous. (I think Apple's WeatherKit may also offer this data, but I was unable to get WeatherKit to work at all)

---

After that, the wind is important for people who like outdoor activities. For example, Kayak rentals are paused when it gets too windy. On the other hand, kite boarders like it when it's windier.

Open Meteo lets you query historical weather data from as old as 1940[1].

They have the only weather API I know of that can get both forecast and historical weather with just a single call[2]

I use Open Meteo for most of the data for https://weather-sense.leftium.com

(If you configure a single constant[3], you can get the max 90 days of historical data with the forecast!)

[1]: https://open-meteo.com/en/docs/historical-weather-api

[2]: https://open-meteo.com/en/docs

[3]: https://github.com/Leftium/weather-sense/blob/fefecb05974065...

I think you may be able just drop the precipitation chance. While the precipitation chance is interesting, I tend to not experience any actual rain even if the predicted chance is 90+ percent. Even if there is rain, usually the amount is not worth bringing an umbrella for.

My https://weather-sense.leftium.com also uses open-meteo for weather data. And I've been comparing how precipitation amount/chance forecasts compare to real life experience.

Look at how vastly different the precipitation chance and amount were for Seoul the past few days: https://weather-sense.leftium.com/?n=seoul According to the chance, it was raining non-stop 48+ hours. The precipitation bars give a much better idea when actual precipitation occurred.

Do you know any other weather sites that show historical weather?

I thought my https://weather-sense.leftium.com was the only current app to do this.

I wrote about this over a decade ago: https://blog.leftium.com/2013/12/how-to-display-temperature-...

That was one of the main motivations for: https://rift-transcription.vercel.app

I think I prototyped the most fluid real-time streaming transcription experience. For example, you can interrupt/intersperse the realtime transcription with keyboard input.

If you click "Replay..." in the demo above, it shows an actual transcription use case (Black represents typed text, the colored text was dictated):

- Say "Left"

- Type `ium:` (because no model has been able to transcribe my username; special characters are hard)

- Continue dictating...

My own TS project was inspired by IceCream: https://github.com/Leftium/gg#coding-agent-access

It began as a better `console.log()` for humans, but I ended up making it better for AI coding agents.

I got tired of copying dev console output, so coding agents can now just insert the exact calls they need and query the output without human intervention.

Ah, yes. The "Igon Value Problem": https://youtu.be/wBBnfu8N_J0?t=2097

I was thinking the cautiousness was intentionally bred into LLMs, but it could very well be an artifact of the training data, too.

I think the cause might stem from a larger issue: LLMs are trained to err on the side of caution. This is probably a good default, but can often get in the way.

When I use coding agents to help with prose, they default to bending over backwards to avoid any absolutes or otherwise risky text that might offend someone. (For example, an LLM would add a lot of hedging to my previous sentence to clarify I haven't tried all LLMs, soften the language, etc...)

While I understand the intent, it often makes the text verbose and awkward. So usually the suggested text is safer, but at the same time harder to read.

Another example is always planning/implementing a path for backwards compatibility/migration even when the project is still a prototype where the only user is myself.

Theo video based on data from Tencent's Autocodebench: https://youtu.be/iV1EcfZSdCM

Conclusion: Elixir was the best (had the highest problem solve rate).

Reasons (Theo's interpretation):

- code collocation, where documentation is integrated directly within the source code

- design philosophy of a language (readability, clear idioms, and strict expectation management)

---

Sources from video:

- https://github.com/Tencent-Hunyuan/AutoCodeBenchmark/tree/ma...

- https://martinalderson.com/posts/which-programming-languages...

- https://simonwillison.net/2026/Jan/19/nanolang/#atom-everyth...

Here is a good recent comment-heavy thread to stress-test: https://www.orangecrumbs.com/hn/?story=48736605&feed=top

Some things I noticed:

- The comments are not in HN order; "vibecoded prediction market–style" is at the top in OrangeCrumbs, but near the bottom on actual HN; actual top comment ("I'm struggling to understand why I'd ever use this instead") is buried in the middle on OrangeCrumbs.

- Other comment sort options are interesting

- It is difficult to read a deep thread. Requires clicking once for each level. (I just found keyboard shortcuts that kind of help, like [)

- The left and right sidebars are kind of distracting. So I find the mobile view easier to read. I do think sidebar can be better use of wide screens; perhaps try muting the sidebars and/or allow them to be toggled? I find the right sidebar more useful than the left one.

- Keyboard navigation: conflicts with Vimium. The only "natural" keyboard shortcuts I could discover were arrow keys + SPACE. (`?` was also natural, but unfortunately Vimium had priority.) Personally, I prefer skimming HN threads with the mouse scroll wheel and a few occasional clicks. (It seems it would require a lot of keyboard shortcut keys for a similar reading experience)

---

Here's my take on rendering comment-heavy HN threads: https://hn.leftium.com/i/48736605

- Render comments at 3 levels of detail: Full (top level), one-line excerpt (2nd level), grouped into single color strip (everything else)

- Make threads expandable at three levels of detail:

1. Expand all direct replies only

2. Ungroup: expand collapsed comments as one-line excerpts

3. Expand entire comment sub-tree.

This is the way I found myself wanting to read long threads: skim the top level or two for threads I found interesting. Keep recursively skimming like this for the interesting comment sub-threads.

Some other features I plan to add:

1. Expand/highlight all comments by specific user(s). Currently OP is highlighted. (But not auto-expanded, yet.)

2. Filter for certain words in thread: typing a query automatically expands matching comments; parent comments may be expanded as one-line summaries for context.

So my reading process is scroll with the mouse wheel until I find an interesting comment thread; occasionally click to toggle those threads between collapsed and higher levels of detail.

While reviewing my Google search history, it was interesting to see what I was working on one year ago, two years ago. I didn't make any special effort to record what I was working on, the searches were completely organic.

I couldn't tell you exactly what I was working on one/two years ago. But I could tell you after seeing my search history.

That's how I came to the realization search history is a zero-effort journal. I started making a feature that is similar to search history, but focuses more on the journal aspect. You can add explicit journal entries. Search/browsing are focused on surfacing interesting patterns/entries vs. finding specific entries.

Very early WIP: https://whiz.leftium.com/journal