The form and reason for exchange in archaic societies.x

Quickly copy and paste Unicode whitespace characters — and learn how and when to use them.

This is a note to call ideal fence

This is in bold
This is in italic

Everyone keeps telling you that you need to practice your fundamentals. What the hell does that mean, and how do you do it? This subreddit's all about concrete exercises that you can do to improve your fundamentals. We'll give you homework and we'll tell you where you're going right and wrong.

I'm Jesse. I make stuff. Software, hardware. Very occasionally, trouble.

https://simonwillison.net/2025/Oct/10/superpowers/

Gemini CLI Tips and Tricks. Contribute to addyosmani/gemini-cli-tips development by creating an account on GitHub.

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

1. The Professional Email Writer

“Act as a senior communication specialist. Rewrite this email to sound professional, clear, concise, and polite while keeping my original intent. Improve tone, structure, grammar, and flow. My email: [paste email].”

3. The Corporate Reply

“Craft a professional reply to this email I received: [paste email]. Maintain a respectful tone, address all points clearly, and write a response that strengthens trust and communication.”

Other prompts:
https://www.theailibrary.co/prompts

Think First

Most people assume that with Claude Code and other AI tools, the first thing you need to do is type (or start talking). But that's probably one of the biggest mistakes that you can make straight off the bat. The first thing that you actually need to do is think.

Have a deep back and forth with ChatGPT/Gemini/Claude, where you describe exactly what you want to build, you ask the LLM for the various options you can take in terms of system design, and ultimately the two of you settle on a solution. You and the LLM should be asking each other questions, not just a one way street.

Before you ask Claude to build a feature, think about the architecture. Before you ask it to refactor something, think about what the end state should look like. Before you ask it to debug, think about what you actually know about the problem. The more information that you have in plan mode, the better your output is actually going to be because the better the input is going to be.

Keep it short.

Claude can only reliably follow around 150 to 200 instructions at a time, and Claude Code's system prompt already uses about 50 of those.

Tell it why, not just what. Claude is a little bit like a human in this way. When you give it the reason behind an instruction, Claude implements it better than if you just tell it what to do.

Update it constantly.

Press the # key while you're working and Claude will add instructions to your CLAUDE.md automatically.

Use external memory.

If you're working on something complex, have Claude write plans and progress to actual files (I use SCRATCHPAD.md or plan.md). These persist across sessions. When you come back tomorrow, Claude can read the file and pick up where you left off instead of starting from zero.

When Claude Gets Stuck

Simplify the task

1. An overview of agents

2. How the capability of an AI-powered agent is determined by the set of tools it has access to and its capability for planning

3. How to select the best set of tools for your agent

4. Whether LLMs can plan and how to augment a model’s capability for planning

5. Agent’s failure modes

AI-powered agents are an emerging field with no established theoretical frameworks for defining, developing, and evaluating them. This post is a best-effort attempt to build a framework from the existing literature, but it will evolve as the field does.

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

Working with JSON data

Full-text search with FTS5

Strict tables and better typing

Write-ahead logging and concurrency

From Axlerod:
While Write-Ahead Logging (WAL) is generally recommended for most SQLite applications because it significantly improves concurrency (allowing simultaneous readers and writers), there are a few specific scenarios where you might not want to use it:

Network File Systems: WAL mode relies heavily on shared-memory primitives (mmap) to coordinate access between different database connections. These primitives often do not work correctly over network file systems like NFS, SMB, or CIFS.

Single-File Distribution: One of SQLite's main appeals is that a database is a single file. When you enable WAL mode, SQLite creates two additional temporary files alongside your main database: a -wal file and a -shm (shared memory) file. If you need to easily copy, email, or distribute the database as a single file, these extra files can complicate things (though you can mitigate this by forcing a full checkpoint before copying).

Read-Only Databases: If your database is purely read-only (e.g., a static lookup table distributed with an application), WAL mode provides no benefits and adds a tiny bit of overhead. The default rollback journal is slightly more efficient for read-only operations.

Checkpointing Overhead: In WAL mode, writes are appended to the -wal file. Eventually, this data must be transferred back to the main database file in a process called "checkpointing." If your application has a massive, continuous stream of writes, the WAL file can grow very large, and the checkpointing process can cause occasional latency spikes or performance hiccups.

Lots of good replies, some that say he is FOS. Others point out that these might be too restrictive for everyday tasks.

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.