This is a brilliant idea by Hyde Stevenson. One of my favourite things about Vim, is there can be so many different ways to achieve one end result. With that in mind, I know that a lot of these things are probably not the Best Way, but they are A Way (and maybe even just My Way, because everyone else does the Best Way). Very interested to see other people’s, so start your own and send me the link.

https://lazybea.rs/vimovember/

The more interesting part for me (esp as a computer vision at heart who is temporarily masquerading as a natural language person) is whether pixels are better inputs to LLMs than text. Whether text tokens are wasteful and just terrible, at the input.

Maybe it makes more sense that all inputs to LLMs should only ever be images. Even if you happen to have pure text input, maybe you'd prefer to render it and then feed that in.

I dislike the tokenizer. Tokenizers are ugly, separate, not end-to-end stage. It "imports" all the ugliness of Unicode, byte encodings, it inherits a lot of historical baggage, security/jailbreak risk (e.g. continuation bytes). It makes two characters that look identical to the eye look as two completely different tokens internally in the network. A smiling emoji looks like a weird token, not an... actual smiling face, pixels and all, and all the transfer learning that brings along. The tokenizer must go.

https://github.com/deepseek-ai/DeepSeek-OCR

My preferred definition of an LLM agent is something that runs tools in a loop to achieve a goal. The art of using them well is to carefully design the tools and loop for them to use.

• The joy of YOLO mode
• Picking the right tools for the loop
• Issuing tightly scoped credentials
• When to design an agentic loop
• This is still a very fresh area

Oat is an ultra-lightweight HTML + CSS, semantic UI component library with zero dependencies. No framework, build, or dev complexity. Just include the tiny CSS and JS files and you are good to go building decent looking web applications with most commonly needed components and elements.

Semantic tags and attributes are styled contextually out of the box without classes, forcing best practices, and reducing markup class pollution. A few dynamic components are WebComponents and use minimal JavaScript.

https://x.com/technmak/status/2022287404128973056?s=43&t=gAZhA3-2h2DvLb-eSzGa5A

AI coding agents take the shortest path to done, which usually means skipping the specs, tests, and reviews that make software reliable at scale. Agent Skill...

https://x.com/datachaz/status/2040357775830814798?s=43&t=gAZhA3-2h2DvLb-eSzGa5A

https://github.com/addyosmani/agent-skills

@addyosmani
from Google just dropped his new Agent Skills and it's incredible.

It brings 19 engineering skills + 7 commands to AI coding agents, all inspired by Google best practices 🤯

AI coding agents are powerful, but left alone, they take shortcuts.

They skip specs, tests, and security reviews, optimizing for "done" over "correct." Addy built this to fix that.

Each skill encodes the workflows and quality gates that senior engineers actually use: spec before code, test before merge, measure before optimize.

The full lifecycle is covered:

→ Define - refine ideas, write specs before a single line of code
→ Plan - decompose into small, verifiable tasks
→ Build - incremental implementation, context engineering, clean API design
→ Verify - TDD, browser testing with DevTools, systematic debugging
→ Review - code quality, security hardening, performance optimization
→ Ship - git workflow, CI/CD, ADRs, pre-launch checklists

Features 7 slash commands: (/spec, /plan, /build, /test, /review, /code-simplify, /ship) that map to this lifecycle.

https://news.ycombinator.com/item?id=45652952

According to the DeepSeek paper, you can pull out 10 text tokens from a single image token with near-100% accuracy. In other words, a model’s internal representation of an image is ten times as efficient as its internal representation of text. Does this mean that models shouldn’t consume text at all? When I paste a few paragraphs into ChatGPT, would it be more efficient to convert that into an image of text before sending it to the model? Can we supply 10x or 20x more data to a model at inference time by supplying it as an image of text instead of text itself?

Building in NY. Dicklesworthstone has 179 repositories available. Follow their code on GitHub.

My blog was showing poor performance, with some pages taking several seconds to load or even failing entirely.

My entire site runs behind Cloudflare with a 200 second cache TTL. This means my backend normally doesn't even notice spikes in traffic as they are mostly served from the Cloudflare cache.

Unfortunately this trick doesn't help for crawlers that are hitting every possible combination of facets on my search page!

Using Cloudflare to rate limit requests to a path

People think they can use Fine-Tune for Knowledge Injection. People are Wrong

https://news.ycombinator.com/item?id=44242737

If fine-tuning is a risky solution, what’s the alternative? The answer lies in modularity and augmentation. Techniques such as retrieval-augmented generation (RAG), external memory banks, and adapter modules provide more robust ways to incorporate new information without overwriting the existing network’s knowledge base.

Free image background removal - private, client-side and powered by Transformers.js - addyosmani/bg-remove

https://bg.addy.ie/

In this video we show you how to replace an existing heating element with a new one using Shark Bite fittings. This is a fast easy way to swap a new heating element into your baseboard if the one that you currently have is getting old and has seen better days.
#homerepair #baseboardheat #sharkbite

In this video I show you how to clean hot water baseboard heaters from the inside out in preparation for using an ozone generator to tackle odors. These simple cleaning steps can also be an essential annual maintenance of your baseboard heaters and will not only reduce musty household odors, but will also improve your baseboard heater efficiency. I will show you how to remove your radiator covers to clean all the dust and oils that can build up around your baseboard heater fins.

https://fortune.com/2025/11/11/why-ai-adoption-is-failing-seven-mistakes/
November 11, 2025

Mistake #1: The business goal isn’t crystal clear
The fix: Be precise. Be clear. Take the time up front to crystallize the problem and expected ROI with all stakeholders right off the bat.

Mistake #2: The project is poorly managed

Mistake #3: You’re overpromising. Believing AI will solve everything is a recipe for disappointment

Mistake #4: Vastly underestimating the resources required

Mistake #5: Ignoring reality

Mistake #6: No offense, but your data quality is bad

Mistake #7: Think the project’s done? Not quite
While AI projects may have a clear start and finish, the work doesn’t end when the model is operationalized. AI systems are dynamic and models can drift, data can evolve and outputs can degrade over time. Treating AI like a “set it and forget it” initiative is a costly mistake. Without continuous monitoring, evaluation, and updates, your AI solution may lose accuracy, relevance, and trustworthiness.

“Yet each man kills the thing he loves,
By each let this be heard,
Some do it with a bitter look,
Some with a flattering word,
The coward does it with a kiss,
The brave man with a sword!

Some kill their love when they are young,
And some when they are old;
Some strangle with the hands of Gold:
The kindest use a knife, because
The dead so soon grow cold.

Some love too little, some too long,
Some sell and others buy;
Some do the deed with many tears,
And some without a sigh:
For each man kills the thing he loves,
Yet each man does not die.”

― Oscar Wilde, Selected Poems of Oscar Wilde including the Ballad of Reading Gaol

AI is bad at making things that are great. It's also bad at making things that are bad. The second half is the part worth talking about.

The trap isn’t AI. The trap is that 7 is easier to reach than it’s ever been, and 7 feels like enough.

The middle has never been more crowded. The interesting work is on the edges — the 1s and the 9s — and only one of those edges is still accessible to a tool. The other one is accessible to you, if you remember how to get there.

The skill now might just be knowing what a 1 used to feel like. And being a little suspicious of anything that lands at a 5.

Compare Google Fonts side-by-side with anatomy overlays, OpenType metrics, pairing scores, and ready-to-use CSS. Free tool for designers and developers.

Stateless (JWT)

How it works:

User logs in, server creates a JWT containing user data
Server signs the JWT with a secret key
Server sends JWT to client
Client sends JWT with every request
Server verifies the signature and trusts the data inside
Why it scales:

Any server can validate a JWT using the shared secret key
No database lookup needed per request
If you add 100 more servers, they all work immediately

Today, I will focus mostly on Time Complexity from the Perl point of view.

1. O(1) - Constant Time
2. O(n) - Linear Time
3. O(log n) - Logarithmic Time
4. O(n ^ 2) - Quadratic Time
5. O(n log n) - Linearithmic Time
6. O(sqrt n) - Square Root Time
7. O(n ^ 3) - Cube Time
8. O(2 ^ n) - Exponential Time
9. O(n!) - Factorial Time

Googles system prompt of the CLI is heavily flawed IMO. That's where most problems arise. I am using a custom one. At least it is highly configurable. The vanilla Gemini Cli is not usable for me. For instance, they have a section they introduce with Proactiveness where they give advice about what is Persistence (in the agent loop). This wrong wording alone causes the agent to be "proactive" in many ways that is not wanted. After I asked the model itself once, why it started to scan my entire codebase when I just asked to create a new branch, it directly said to me there is "Proactiveness" in its system prompt. I was baffled, why would anybody want that? So i digged deeper and did also a thorough analysis with Opus 4.7 of just this system prompt file - that cost me an entire Pro-session btw. - and documented the results in this pr: https://github.com/google-gemini/gemini-cli/pull/26129 - I am using the optimized prompt and had no issues so far I had with the original one.

Another big issue is "model panic" - the Gemini model often overwrites entire files "from memory" with write_file, when the edit tool fails 2 times. That occasionally causes code degradation, and when there are multiple turns and there is no backup, the model starts to get nuts, trying to fix its errors, and destroys even more in the effort to just make it compile / build. I gave it a rotating pre-write backup and a restore_file tool. The model panic vanished. https://github.com/google-gemini/gemini-cli/pull/25947

With these two fixes, Gemini CLI is pretty good - without them I wouldn't use it.

Why oklch

HSL looks perceptually uniform but isn’t. An hsl(60, 100%, 50%) yellow and an hsl(240, 100%, 50%) blue share the same L value (50%), but the yellow looks dramatically lighter. If you try to build a lightness scale with HSL, you end up hand-tuning every hue to compensate.

oklch isn’t harder to read than hsl once you internalise three numbers: L (how bright, 0–1), C (how vivid, 0–0.4), H (which colour, 0–360). And it gives you something hsl can’t: the guarantee that your lightness scale actually looks even.