DEV Community: Luu Vinh Loc

Use the latest version of Node.js with fnm

Luu Vinh Loc — Sun, 08 Mar 2026 12:46:29 +0000

To install the latest Node.js version using fnm (Fast Node Manager) - https://github.com/Schniz/fnm, use the command:

fnm --version
# fnm 1.39.0

# install latest version
fnm install --latest

For example, output is "Installing Node v25.8.0 (arm64)...".
Switch to version: fnm use <version>.
Set default: fnm default <version>.

sync-skills.sh - Bash script to sync .agents/skills/ to all agent folders

Luu Vinh Loc — Thu, 05 Mar 2026 16:23:06 +0000

scripts/sync-skills.sh - Bash script to sync .agents/skills/ to all agent folders. Skills are stored in .agents/skills/ and synced to all agent folders (.agent/, .claude/, .windsurf/, etc.).

#!/bin/bash
# Sync skills from .agents/skills to all agent folders

echo "=== Start syncing skills... ==="

AGENTS=("agent" "claude" "codex" "cursor" "gemini" "opencode" "qwen" "windsurf")

for dir in "${AGENTS[@]}"; do
  echo "- Syncing .agents/skills/ -> .$dir/skills/"
  rsync -av --delete .agents/skills/ ".$dir/skills/"
done

echo "✅ Sync skills complete!"

To sync skills after adding/updating SKILL files:

bash scripts/sync-skills.sh

Introducing llm-lean-log: Token-Efficient Chat Logging for AI Agents

Luu Vinh Loc — Wed, 04 Mar 2026 16:29:58 +0000

If you've ever worked with AI coding agents like Cursor, Windsurf, Claude Code, or OpenCode, you know how quickly conversations pile up. After weeks or months of back-and-forth with an AI assistant, you end up with thousands of lines of chat history—and trying to find that one solution from three weeks ago becomes a nightmare.

That's exactly the problem llm-lean-log was built to solve.

The Problem with Current Approaches

Let me paint a familiar picture: You've been working on a project with an AI coding assistant for months. You've got hundreds of sessions logged, each containing problem descriptions, solutions, code changes, and explanations. Now you need to find that one bug fix from back when you were working on authentication.

What are your options?

Scroll through endless chat history - Painfully slow, and good luck finding the right context
Search the entire conversation - Works sometimes, but you're still wading through irrelevant messages
Export to Markdown/JSON - Creates massive files that cost a fortune in tokens when you feed them back to the AI

The core issue? Most logging tools were designed for humans to read, not for AI agents to process is great efficiently. Markdown for people but not good for token budgets. JSON is machine-readable but equally bloated.

Enter llm-lean-log

llm-lean-log takes a fundamentally different approach. Instead of logging everything, it captures only what matters—in a format that's optimized for both storage and AI consumption.

Github: https://github.com/loclv/llm-lean-log

The Secret Sauce: CSV with Cause-Effect Relationships

The key insight behind llm-lean-log is simple:

structured tabular data is more token-efficient than free-form text

Here's what a typical log entry looks like:

id,name,tags,problem,solution,action,files,tech-stack,causeIds,created-at
auth-error-001,API Authentication Error,"error,api,auth",Users unable to login due to JWT token expiration,Added token refresh logic with refresh endpoint,"Updated auth.ts middleware and added refresh endpoint","src/middleware/auth.ts","typescript,express,jwt",,2026-01-13T14:52:58Z

Each field is intentional:

id - Unique identifier for linking cause-effect relationships
name - Short summary (what happened)
tags - Categorization for filtering
problem - What went wrong
solution - How it was fixed
action - Commands or steps taken
files - What was modified
tech-stack - Technologies involved
causeIds/effectIds - Link to related logs (this is the game-changer!)

The Cause-Effect Graph

The most powerful feature is the ability to link logs together. Each entry can reference causeIds (what led to this problem) and effectIds (what resulted from it). This creates a directed graph of your project history—perfect for understanding the context behind any change.

How It Works

For AI Agents

The workflow is designed to be seamless for AI agents:

# Save a log entry
l-log add ./logs/chat.csv "Fix JWT token expiration" \
  --tags="bug,auth,security" \
  --problem="Users getting logged out randomly" \
  --solution="Implemented token refresh with exponential backoff" \
  --files="src/middleware/auth.ts" \
  --tech-stack="typescript,express,jwt"

# Retrieve the last entry (efficient for AI)
l-log view ./logs/chat.csv --last

# Search across all logs
l-log search ./logs/chat.csv "authentication"

For Humans

When you need to actually read the logs, there's a beautiful CLI and web visualizer:

# Human-friendly output with colors
l-log list ./logs/chat.csv --human

# Web-based graph visualization
l-log-vis ./logs/chat.csv

Why This Matters

Token Efficiency

The same information in llm-lean-log CSV format? Often much less. That means:

Faster AI responses
Lower API costs
More context window for actual problem-solving

Local-First

Your logs live in your project, not in some cloud service. No vendor lock-in, full control over your data.

Built for AI Agents

The tool was designed from the ground up to be used by AI agents. The CLI is simple enough that you can instruct your favorite AI assistant to log its work automatically.

Getting Started

# Install the CLI
bun add -g llm-lean-log-cli
# or with bun enviroment:
bun add -g bl-log
# expected: installed bl-log@0.2.11 with binaries:
#  - l-log (this means it is ready to use by `l-log` command, not package name)

# Add to your agent configuration (example for Cursor/Windsurf)
# In your .agent/rules/common.md:
# Whenever you finish a task, run:
# l-log add ./logs/chat.csv "<Task Name>" --tags="<tags>" --problem="<problem>"

The Bigger Vision

llm-lean-log is more than just a logging tool—it's the beginning of a new way to track software development history. By capturing solutions (not just conversations) in a structured format, you're building a knowledge base that:

Helps future AI agents understand your project's evolution
Makes onboarding to new projects faster
Creates a searchable archive of solutions

The cause-effect linking is particularly powerful. Imagine being able to ask: "What authentication problems have we had, and what were their downstream effects?" That's now possible with this graph-based approach.

Conclusion

If you're serious about working with AI coding assistants, you need a way to capture and retrieve knowledge efficiently. llm-lean-log provides exactly that—a lean, mean, token-efficient logging machine that plays nicely with both AI agents and human developers.

Give it a try. Your future self will thank you when you're trying to remember why you made that change six months ago with multiple AI agents (claude, cursor, windsurf, opencode, kilocode, etc.).

llm-lean-log: Logging for LLMs, but we cut the fat.

ziglint - Static Analysis

Luu Vinh Loc — Thu, 26 Feb 2026 15:42:40 +0000

Linter for Zig source code, enforcing coding standards.

Build and install from source:

git clone git@github.com:rockorager/ziglint.git
cd ziglint
zig build install -Doptimize=ReleaseFast --prefix $HOME/.local

Executable file: ziglint built at $HOME/.local/bin/ziglint. So it automatically added to the PATH, which is set in ~/.zshrc. We can run ziglint directly from the terminal from now on.

Usage:

# lint current directory (uses .ziglint.zon if present)
ziglint
# lint specific paths
ziglint src build.zig
# suppress specific rule
ziglint --ignore Z001

Configuration (.ziglint.zon):

.{
    .paths = .{ "src", "build.zig" },
    .rules = .{
        .Z001 = .{ .enabled = false },
        .Z024 = .{ .max_length = 80 },
    },
}

Inline suppression:

fn MyBadName() void {} // ziglint-ignore: Z001

// ziglint-ignore: Z001
fn AnotherBadName() void {}

Rules:

Z001: Function names should be camelCase
Z002: Unused variable that has a value
Z003: Parse error
Z004: Prefer const x: T = .{} over const x = T{}
Z005: Type function names should be PascalCase
Z006: Variable names should be snake_case
Z007: Duplicate import
Z009: Files with top-level fields should be PascalCase
Z010: Redundant type specifier; prefer .value over explicit type
Z011: Deprecated method call
Z012: Public function exposes private type
Z013: Unused import
Z014: Error set names should be PascalCase
Z015: Public function exposes private error set
Z016: Split compound assert: assert(a and b) -> assert(a); assert(b);
Z017: Redundant try in return: return try expr -> return expr
Z018: Redundant @as when type is already known from context
Z019: @This() in named struct; use the type name instead
Z020: Inline @This(); assign to a constant first
Z021: File-struct @This() alias should match filename
Z022: @This() alias in anonymous/local struct should be Self
Z023: Parameter order: comptime before runtime, pointers before values
Z024: Line exceeds maximum length (default: 120)
Z025: Redundant catch
Z026: Empty catch block suppresses errors
Z027: Access declaration through type instead of instance
Z028: Inline @import; assign to a top-level const
Z029: Redundant @as cast; type already known from context
Z030: deinit should set self.* = undefined
Z031: Avoid underscore prefix in identifiers
Z032: Acronyms should use standard casing
Z033: Avoid redundant words in identifiers (disabled by default)

References

ziglint: https://github.com/rockorager/ziglint

Write a git diff command result to file to manage the big changes and ignore the lock files

Luu Vinh Loc — Thu, 26 Feb 2026 15:04:26 +0000

Write the result of a git diff command to a file to manage large changes and ignore lock files.

git diff branch-name-0..branch-name-1 -- . ':(exclude)*.lock' > git.diff

When ignoring multiple files:

git diff branch-name-0..branch-name-1 -- . ':(exclude)*.lock' ':(exclude)*.yaml' ':(exclude)*.yml' ':(exclude)*.json' > git.diff

Useful command when moving source code to a new folder or repository - sync files

Luu Vinh Loc — Thu, 26 Feb 2026 08:08:29 +0000

Useful command when moving source code to a new folder or repository

rsync (remote sync) is a fast, versatile command-line utility for Unix-like systems, used to synchronize files and directories locally or across networked computers.
It can update, create, and delete files.

rsync -av --exclude={'node_modules','.git','logs'} --exclude-from='.gitignore' ./ /path/to/destination/

Explain

rsync: sync files from one folder to another
--exclude={'node_modules','.git','logs'}: exclude some folders
--exclude-from='.gitignore': exclude files in .gitignore
-a (archive): Preserves permissions, symlinks, and timestamps (crucial for backups).
-v (verbose): Shows detailed output.
-z (compress): Compresses data during transfer.
--delete: Deletes files in the destination that are not present in the source.
-n or --dry-run: Simulates the action without actually copying or deleting files.
./: current folder
/path/to/destination: destination folder
Note: A trailing slash (/) on the source directory means "copy the contents of this directory," while omitting it means "copy the directory itself".