Daily Shaarli
I'm Jesse. I make stuff. Software, hardware. Very occasionally, trouble.
-
An overview of agents
-
How the capability of an AI-powered agent is determined by the set of tools it has access to and its capability for planning
-
How to select the best set of tools for your agent
-
Whether LLMs can plan and how to augment a model’s capability for planning
-
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.
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.
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
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.
Gemini CLI Tips and Tricks. Contribute to addyosmani/gemini-cli-tips development by creating an account on GitHub.
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
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.
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
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.
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