DEV Community: atani

16MB vs 1.2GB — Benchmarking 5 AI Browser Automation Tools

atani — Mon, 23 Mar 2026 01:37:37 +0000

I was using Claude Code for browser automation and found myself stuck choosing between tools. There are five candidates, each with a completely different approach. I installed all of them and ran 10 tests — turns out the best choice depends entirely on your use case.

TL;DR: For auth management, go with playwright-CLI. For an agent operation backbone, agent-browser. For autonomous natural-language control, browser-use. For high-volume crawling, Lightpanda. For production infrastructure, steel-browser.

This article focuses on CLI-mode comparisons. Some tools like browser-use shine brightest in LLM agent mode — I plan to cover that angle in a separate post.

The 5 Tools Compared

Tool	Stars	Language	License	Maintained by	In a nutshell
playwright-cli	6.1K (+85K core)	TypeScript	Apache-2.0	Microsoft	CLI strong on auth management and token efficiency
agent-browser	24.1K	Rust	Apache-2.0	Vercel	CLI purpose-built for agent development
browser-use	82.2K	Python	MIT	browser-use	LLM autonomously operates the browser
Lightpanda	23.6K	Zig	AGPL-3.0	lightpanda-io	Ultra-low-memory lightweight browser (official claim: 9x faster)
steel-browser	6.7K	TypeScript	Apache-2.0	steel-dev	Production-grade browser infrastructure

Test Environment

Item	Value
OS	macOS Darwin 25.3.0 (Apple Silicon)
Node.js	v24.5.0
Python	3.13
playwright-CLI	0.1.1
agent-browser	0.21.4
browser-use	0.12.2
Lightpanda	nightly (c1fc2b13)
steel-browser	Docker (latest)

Note: Results depend on hardware and network conditions. Browser startup speed and memory usage vary significantly with CPU/RAM configuration, so treat these numbers as directional guidance. All tools are under active development — results may differ with newer versions.

Setup: Lightpanda Is a Single 12MB Binary

The first hurdle is installation. Here's how each tool goes from zero to running:

Tool	Method	Dependencies	Steps
Lightpanda	Binary download (12MB)	None	1 step
agent-browser	`npm i -g agent-browser` + `install`	Node.js + Chrome download	2 steps
playwright-CLI	`npm i -g @playwright/cli` + `install-browser`	Node.js + browser download	2 steps
browser-use	`pip install browser-use` (75 deps)	Python 3.11+ + LLM API key	2 steps + config
steel-browser	`docker pull`	Docker	1 step (assumes Docker)

Lightpanda is just one binary download — zero dependencies, as simple as it gets. agent-browser and playwright-CLI are a single npm command each, but require a separate browser download. browser-use pulls in 75 Python packages and needs an LLM API key configured on top. steel-browser is one command if Docker is already running, but Docker itself is a prerequisite.

Raw Speed: steel-browser Clocks 0.45s

We opened httpbin.org/html, took a snapshot, and closed the browser — measured three times each.

Tool	Run 1	Run 2	Run 3	Average
steel-browser	0.70s	0.41s	0.25s	0.45s
Lightpanda	1.05s	0.85s	0.85s	0.92s
agent-browser	1.93s	1.80s	1.90s	1.88s
playwright-CLI	2.15s	1.84s	1.85s	1.95s
browser-use	2.30s	10.21s	2.22s	4.91s

steel-browser connects to an always-running Chromium inside Docker, making the second and third runs especially fast. Lightpanda's custom engine avoids Chrome's startup overhead and delivers consistently quick results. agent-browser and playwright-CLI both run in daemon mode with stable performance. browser-use carries Python runtime startup cost and occasionally spikes (10.21s).

Memory: 16MB vs 1.2GB — a 75x Gap

We measured process memory (RSS) with a single page (httpbin.org/html) open.

Tool	Daemon	Browser	Total	Processes
Lightpanda	—	—	16 MB	1
steel-browser	(in Docker)	(in Docker)	581 MB	container
browser-use	111 MB	758 MB	869 MB	8
playwright-CLI	169 MB	760 MB	929 MB	7
agent-browser	5 MB	1,197 MB	1,202 MB	10

Lightpanda uses 16MB — roughly 75x less than agent-browser at 1,202MB. The official benchmark claims "9x less memory than Chrome," but in our single-page test the gap was even wider. Results will vary depending on test conditions and page complexity. This is because Lightpanda's engine skips CSS rendering and focuses on DOM and JS execution. steel-browser bundles Chromium and Node.js inside a Docker container at 581MB — consolidating host processes into a container is a practical operational advantage. browser-use's Python daemon takes 111MB, but the lower Chrome process count keeps the total at 869MB. agent-browser's daemon itself is a lean 5MB Rust binary, but the many Chrome processes push the total to the highest.

SPA Support: All 5 Tools Loaded react.dev Successfully

We tested whether each tool could take a proper snapshot of react.dev (React's official site, a client-side rendered SPA).

Tool	Success	Time	Output size	Format
steel-browser	OK	1.45s	16 KB	Markdown
Lightpanda	OK	4.20s	18 KB	Markdown
agent-browser	OK	4.83s	34 KB	Accessibility tree (with ref IDs)
playwright-CLI	OK	6.22s	137 B	Snapshot file reference
browser-use	OK	12.77s	Title only	`extract` requires LLM agent mode

All five tools loaded the page successfully. steel-browser's always-on Chromium gives it the edge at 1.45s even for SPAs. Lightpanda returned 18KB of Markdown in 4.20s, handling react.dev-level SPAs just fine. agent-browser returns an accessibility tree with ref IDs, which maps directly to action commands. playwright-CLI outputs only a file reference (137 bytes) — a deliberate design for token efficiency. browser-use in CLI-only mode captures the page title; structured extraction requires LLM agent mode.

Auth Persistence: playwright-CLI's state-save/load Is the Most Complete

When an AI agent needs to operate internal tools behind SAML/SSO, being able to save and restore auth state is critical. We tested using httpbin.org's cookie endpoint.

playwright-CLI

# Set cookie → save → restore
playwright-cli open https://httpbin.org/cookies/set/saml_token/mock_abc123 --persistent
playwright-cli cookie-list
# → saml_token=mock_abc123 (domain: httpbin.org, path: /)

playwright-cli state-save /tmp/pw-auth.json
playwright-cli close

# Restore in a new session
playwright-cli open https://httpbin.org --persistent
playwright-cli state-load /tmp/pw-auth.json
playwright-cli cookie-list
# → saml_token=mock_abc123  ← restored successfully

With cookie-list/cookie-set/state-save/state-load commands and a --persistent flag that saves the browser profile to disk, playwright-CLI offers the most complete auth management of all five tools. Cookies and localStorage survive restarts.

agent-browser

agent-browser open https://httpbin.org/cookies/set/saml_token/mock_abc123
agent-browser state save test-auth
agent-browser close

agent-browser open https://httpbin.org/cookies
agent-browser state load test-auth
# → Cookie restored

Supports state save/load commands and a --profile flag for persistence. The Auth vault feature encrypts credentials, allowing agents to log in without ever seeing the password.

browser-use

cookies export/import commands handle cookie serialization. The --profile flag preserves cookies and localStorage across sessions. Comprehensive state management is achieved by combining LLM agent mode with profile persistence.

Lightpanda

Each fetch runs as an independent process — the design is optimized for high-volume public page retrieval. For authenticated access, you can pass HTTP headers or cookies as command-line arguments.

steel-browser

Cookies persist via session ID reuse. We confirmed that a saml_token=mock_abc123 cookie survived session recreation. steel-browser manages sessions through a REST API to which Playwright/Puppeteer clients connect, so the actual auth logic lives on the client side.

Auth Persistence Summary

Tool	Cookie management	State save/restore	Profile persistence
playwright-CLI	cookie-list/set/get built in	state-save/load	--persistent
agent-browser	Via state	state save/load + Auth vault	--profile
browser-use	cookies export/import	Profile-based	--profile
steel-browser	Session ID-based (verified)	REST API	Per-session
Lightpanda	Via HTTP headers	Per-fetch	Lightweight design — out of scope

Parallel Execution: Lightpanda Stays at ~1.6GB Even at 100 Concurrent Sessions

We spun up 3 sessions simultaneously and measured completion time and total memory.

Tool	3-session startup time	Total memory
playwright-CLI	4.90s	559 MB
Lightpanda	9.34s	~48 MB
agent-browser	10.58s	4,165 MB
browser-use	—	—
steel-browser	—	—

browser-use supports session management via its --session option, but we did not test it here. steel-browser can create multiple sessions concurrently through its REST API, but was also excluded from this measurement.

playwright-CLI manages parallel sessions with named sessions (-s s1, -s s2) and shares Chrome processes efficiently. Lightpanda runs each fetch as an independent process (~16MB each), so even 100 concurrent sessions would use an estimated 1.6GB (16MB x 100). agent-browser launches an independent Chrome instance per session, leading to higher memory consumption.

Error Handling: agent-browser Gives the Clearest Messages

We tested behavior on a nonexistent URL, a 404 page, and a timeout scenario.

Scenario	playwright-CLI	agent-browser	browser-use	Lightpanda	steel-browser
DNS failure	Opens page but content is empty	`✗ net::ERR_NAME_NOT_RESOLVED`	Shows URL only	HTML error (`NavigationFailed: CouldntResolveHost`)	JSON `{"message":"net::ERR_NAME_NOT_RESOLVED at ..."}`
404	Opens page but content is empty	`✗ net::ERR_HTTP_RESPONSE_CODE_FAILURE`	Shows URL only	Empty HTML	Structured JSON error
Timeout	—	—	—	Disconnects precisely at specified time (3.03s)	—

agent-browser gives the most specific error messages — you can tell at a glance what went wrong, making it straightforward to build retry logic. steel-browser returns structured JSON errors, ideal for programmatic parsing. Lightpanda returns structured HTML errors, also easy to process programmatically. browser-use shows only the URL — detailed error info requires separate investigation. playwright-CLI reflects Chrome's native behavior of attempting to open the page even on errors.

JS-Heavy Sites: steel-browser Fastest Across the Board

We tested how each tool handles sites built as SPAs (Single Page Applications).

Site	playwright-CLI	agent-browser	browser-use	Lightpanda	steel-browser
HackerNews	OK (4.3s)	OK (4.0s)	OK (4.24s)	OK (1.1s)	OK (0.92s)
GitHub	OK (2.9s)	OK (1.6s)	OK (title only)	OK (2.9s)	OK (3.45s)
react.dev	OK (6.2s)	OK (4.8s)	OK (12.8s)	OK (4.2s)	OK (1.5s)

The Chrome-based tools (playwright-CLI, agent-browser, browser-use) handle all sites reliably. steel-browser's always-on Chromium inside Docker makes it the fastest on JS-heavy sites — 0.92s for HackerNews, 1.5s for react.dev. Lightpanda performs well on server-side-rendered sites (HackerNews, GitHub) but has limitations with SPAs that rely heavily on client-side JS. This is by design — Lightpanda skips CSS rendering and focuses on DOM and JS execution. Broader SPA support is on the roadmap.

Token Efficiency: playwright-CLI's 317B Is the Smallest

When an AI agent operates a browser, how much of the LLM's context window it consumes matters. We compared snapshot output sizes for github.com/microsoft/playwright.

Tool / Format	Output size
browser-use `get text`	112 bytes
playwright-CLI snapshot	317 bytes
agent-browser snapshot -i (compact)	16 KB
steel-browser markdown	31 KB
Lightpanda markdown	36 KB
agent-browser snapshot (full)	70 KB
Lightpanda html	409 KB
browser-use `get html`	436 KB
steel-browser html	445 KB

browser-use's get text returns just 112 bytes (the page title) — the most token-efficient option for existence checks and quick verifications. However, structured data extraction requires get html (436KB) or the extract command in LLM agent mode.

playwright-CLI's 317 bytes comes from saving the snapshot payload to a file and passing only the file reference to the LLM. For coding agents handling large codebases (Claude Code, GitHub Copilot, etc.), conserving context on browser operations is essential — this design choice makes a lot of sense.

agent-browser's -i (inline compact) mode delivers 16KB while preserving the ref-numbered structure needed for interaction. steel-browser's Markdown output is 31KB, on par with Lightpanda's 36KB.

Output Quality: ref-tagged Tree vs Markdown vs JS Execution

We extracted top article titles from HackerNews to compare output quality.

agent-browser — Actionable structured data

- link "Flash-Moe: Running a 397B Parameter Model on a Mac with 48GB RAM" [ref=e111]
- link "Hormuz Minesweeper – Are you tired of winning?" [ref=e116]

Each element carries a ref ID — click e111 clicks that link. The output maps directly to agent commands.

Lightpanda — Readable Markdown

| 1. | [Flash-Moe: Running a 397B Parameter Model...](https://github.com/danveloper/flash-moe) |
| 2. | [Hormuz Minesweeper – Are you tired of winning?](https://hormuz.pythonic.ninja/) |

Markdown table format, easy for both humans to read and LLMs to parse. Includes full link URLs.

playwright-CLI — Flexible extraction via JS execution

playwright-cli run-code "const titles = await page.$$eval('.titleline > a', els => els.map(a => a.textContent));"

You can run arbitrary JS, giving maximum extraction flexibility. The tradeoff is that you need to know the page structure beforehand.

browser-use — LLM decides autonomously

browser-use's extract command operates in LLM agent mode, where the LLM interprets the page and returns structured data. No selectors needed — you can simply say "get me a list of article titles" in natural language. In CLI-only mode (get text / get html), you get raw data.

steel-browser — Complete HTML structure

steel-browser's scrape API returns full HTML with link structures intact. Built-in Markdown conversion lets you pick the output format to suit your needs.

Who Should Use What

playwright-CLI — Engineers working in enterprise SAML/SSO environments

Ideal if you want an AI agent to operate internal tools like GitHub Enterprise or Jira behind SAML auth. Cookie/state-save/load is the most feature-complete of all five tools, ensuring reliable auth state persistence. Integration with Claude Code works instantly via SKILL.md. The 317-byte snapshot output stands out for token efficiency, preserving context in coding agents dealing with large codebases. It's also the only tool supporting Firefox and WebKit, making it useful for cross-browser E2E automation.

Best for: Internal tool automation, auth-heavy workflows, Claude Code/Copilot companion tool, cross-browser testing.

agent-browser — Full-stack engineers building custom AI agents

The ideal pick if you want to design your own agent loop while keeping browser operations simple. The ref-tagged accessibility tree ([ref=e111]) from snapshot can be used directly as action instructions, so "snapshot → decide → click ref" loops write themselves naturally. Error messages are the most helpful for debugging during development. The Rust-built daemon is just 5MB. Features like the Auth vault for encrypted credential management and the diff command for verifying operations make it a rich toolkit for agent development. You can also switch to Lightpanda as a backend for a lighter footprint.

Best for: Custom AI agent development, browser automation bot prototypes, action-verification loop implementation.

browser-use — Python engineers who want the fastest path to a browser automation prototype

The only tool where "find the cheapest price on this e-commerce site" or "apply to this job posting" is achievable in a few lines of Python. The LLM looks at the page and decides what to do, so you skip the selector research and page structure analysis. DOM + screenshot dual input adapts automatically to layout changes. Supports 15+ LLM providers (Claude, GPT-4o, Gemini, Ollama, etc.), including local models. Tasks are defined in natural language, which makes it easier to discuss "what the agent should do" with non-engineering team members.

Best for: Business process automation POCs, natural-language task definitions, ad-hoc web automation, RPA-style usage of internal tools.

Lightpanda — Data engineers processing high volumes of web pages

100 pages simultaneously at 48MB of memory. Chrome would use over 4GB. That gap translates directly to infrastructure cost. Lightpanda excels at extracting data from structured sites (HackerNews, GitHub), collecting web content for RAG pipelines, and parsing large batches of URLs. A single 12MB binary with zero dependencies, and built-in MCP support for direct AI agent integration. Rich Markdown and semantic tree output makes the data easy for LLMs to digest. SPA support is expanding in upcoming releases. For static sites and structured data, it already delivers a substantial performance advantage.

The AGPL license requires source code disclosure when providing the software as a network service. Check the license terms before commercial use.

Best for: RAG web crawling, bulk URL content extraction, lightweight browser processing in CI/CD pipelines, resource-constrained environments.

steel-browser — Infra/SRE teams running browser automation in production

Built for teams that want to take Playwright or Puppeteer scripts straight to production. Fingerprint spoofing, automatic proxy rotation, CAPTCHA handling — steel-browser tackles the "walls you always hit in production" at the infrastructure layer. REST API session management fits naturally into microservice architectures. Deploy with a single Docker command, or use one-click deployment to Railway or Render. Apache-2.0 license means the self-hosted version is free to use.

Always check the target site's terms of service and robots.txt before use.

Best for: Production web scraping, data collection requiring bot detection evasion, infrastructure hardening for existing Playwright scripts, shared browser automation platforms for teams.

Decision Flowchart

Overall Summary

Aspect	playwright-CLI	agent-browser	browser-use	Lightpanda	steel-browser
Setup	Good	Good	Fair	Excellent	Fair
Speed	Good	Good	Fair	Excellent	Excellent
Memory	Fair	Fair	Fair	Excellent	Good
SPA support	Excellent	Excellent	Excellent	Good	Excellent
Auth persistence	Excellent	Excellent	Good	Fair	Good
Parallel execution	Good	Fair	—	Excellent	—
Error handling	Fair	Excellent	Fair	Good	Excellent
JS-heavy sites	Excellent	Excellent	Excellent	Fair	Excellent
Token efficiency	Excellent	Good	Good	Good	Good
Output quality	Good	Excellent	Good	Good	Good

Excellent = stands out in this aspect. Good = practical. Fair = has limitations. — = not tested.

Closing Thoughts

I personally use playwright-CLI with Claude Code in my daily workflow. The solid auth management and token efficiency fit well into my development routine.

Each of the five tools has a clearly defined sweet spot. For auth management, playwright-CLI. For agent development, agent-browser. For autonomous natural-language operation, browser-use. For high-volume crawling, Lightpanda. For production infrastructure, steel-browser. I encourage you to try the one that matches your use case.

The data in this article was measured in March 2026. This space moves fast — new tools appear monthly and existing ones evolve rapidly. It's always worth re-running benchmarks on the latest versions.

mysh — A MySQL Connection Manager That Auto-Masks PII in Query Output

atani — Sun, 22 Mar 2026 13:59:19 +0000

The Problem

You get an error notification filed as an issue. You ask Claude Code to investigate the codebase, and it turns out you need real data to narrow down the root cause. You write a SQL query, run it manually, and paste the results back to Claude Code.

But if the query results contain personal information — emails, phone numbers, names — you can't just hand them over as-is. Every time, you either rewrite the SQL to exclude sensitive columns or manually redact PII from the output before pasting. Do this dozens of times a day and you'll inevitably forget once. And once is all it takes.

Why Existing Tools Don't Solve This

I looked for a MySQL client with output masking. None of the popular ones had it.

Tool	Masking?	Notes
mycli	No	Focused on syntax highlighting and autocomplete
DataGrip	No	Can hide columns, but doesn't mask output
TablePlus / DBeaver	No	Same story across GUI clients
MySQL Enterprise	Server-side only	`mask_inner()` etc. — requires Enterprise Edition

MySQL Enterprise Edition has server-side masking functions, but they're paid and require DB-level configuration. No client-side tool offered output masking with AI workflows in mind.

So I Built mysh

If it doesn't exist, build it. I wrote mysh, a MySQL connection manager that auto-masks query output, in Go. Built it with Claude Code in two days.

Production — masked automatically:

$ mysh run prod-db -e "SELECT id, name, email, phone FROM users LIMIT 3"

+----+-------+---------------------+----------------+
| id | name  | email               | phone          |
+----+-------+---------------------+----------------+
|  1 | A***  | a***@example.com    | 0***           |
|  2 | B***  | b***@company.co.jp  | 0***           |
|  3 | C***  | c***@gmail.com      | 0***           |
+----+-------+---------------------+----------------+
3 rows in set

Development — raw data as-is:

$ mysh run dev-db -e "SELECT id, name, email, phone FROM users LIMIT 3"

+----+-------------+------------------------+---------------+
| id | name        | email                  | phone         |
+----+-------------+------------------------+---------------+
|  1 | Alice Smith | alice@example.com      | 090-1234-5678 |
|  2 | Bob Jones   | bob@company.co.jp      | 080-9876-5432 |
|  3 | Carol Lee   | carol@gmail.com        | 070-1111-2222 |
+----+-------------+------------------------+---------------+
3 rows in set

How It Works: Environment × Output Target

mysh determines whether to mask based on two factors: the connection's environment and the output destination (terminal vs. pipe).

env	Terminal (human)	Pipe/capture (AI)
production	Auto-mask	Auto-mask
staging	Raw	Auto-mask
development	Raw	Raw

Production connections are always masked regardless of output target. If you need raw data, use the --raw flag — but it requires interactive confirmation:

$ mysh run prod-db -e "SELECT * FROM users" --raw
⚠ Raw output requested for production connection "prod-db".
  Masking will be disabled. Continue? [y/N]:

This confirmation only works on a TTY (terminal). AI tools and scripts run in non-TTY mode, so they physically cannot respond to the prompt — making it impossible for them to bypass masking.

Configuring Masked Columns

When adding a connection, you specify which columns to mask. Both exact matches and wildcards are supported:

Columns to mask (comma-separated, wildcards OK) [email,phone,*password*,*secret*,*token*,*address*]:

For production and staging environments, sensible defaults are suggested — just press Enter to cover common PII columns. Setting *pass* masks any column containing "pass" in its name.

Pro tip: show your schema to Claude Code and ask it to pick which columns should be masked. It catches things you might miss.

Masking Examples

Type	Original	Masked
Email	alice@example.com	a***@example.com
Phone	090-1234-5678	0***
Name	Alice	A***

Usage

Adding a Connection

$ mysh add
Connection name: prod-db
Environment (production/staging/development): production
DB host [127.0.0.1]: db.internal
DB port [3306]:
DB user: app_readonly
DB password: ********
DB name: myapp
Use SSH tunnel? (y/n): y
SSH host: bastion.example.com
SSH user: deploy
SSH port [22]:
Columns to mask (comma-separated, wildcards OK) [email,phone,*password*,*secret*,*token*,*address*]:

Testing connection... ✓ Connected successfully
Connection "prod-db" saved.

Walk through the setup interactively, or pre-fill fields with CLI flags:

# Fully interactive
mysh add

# Pre-fill with flags (password is always entered interactively)
mysh add --name prod --env prod --db-host 127.0.0.1 --db-user app --db-name myapp \
  --ssh-host bastion.example.com --ssh-user deploy

A connection test runs after setup. If it fails, you can fix the specific field on the spot.

Running Queries

If you only have one connection, the name can be omitted:

mysh run -e "SELECT COUNT(*) FROM users"  # Inline SQL
mysh run query.sql                          # SQL file
mysh tables                                 # List tables

SSH Tunneling

Connections through a bastion host work with a single command:

mysh tunnel production                                  # Start tunnel
mysh run production -e "SHOW PROCESSLIST"               # Auto-reuses tunnel
mysh tunnel stop production                             # Stop

Security Design

Beyond masking, mysh is designed to minimize the risk of credential leaks:

Encrypted passwords — AES-256-GCM encryption with Argon2id key derivation, resistant to GPU brute-force attacks
Keychain integration — On macOS, the master password is stored in Keychain so you don't type it every time
File permissions — Config files are created with 0600, preventing access by other users
No password CLI flags — Passwords cannot be passed as CLI arguments, preventing leaks via shell history or process lists

Technical Notes

Why Go?

Single-binary distribution and easy cross-compilation make Go ideal for CLI tools. The golang.org/x/term package provides TTY detection, which made implementing the environment-aware masking behavior straightforward.

TTY Detection for Masking

term.IsTerminal() checks whether stdout is a terminal or a pipe. Combined with the environment setting, this determines masking behavior. Production always masks regardless; the --raw override additionally checks os.Stdin for TTY to block non-interactive bypass.

func (c *Connection) ShouldMask(isTTY bool) bool {
    if c.Env == "production" {
        return true
    }
    if c.Env == "development" {
        return false
    }
    return !isTTY // staging: mask only when piped
}

Usage Tips

Connect with a READ-only user — Combined with masking, this also prevents accidental data modification
Use mysh for development too — Masking isn't applied in dev, so it doesn't interfere with testing. Using mysh everywhere means you don't switch tools when investigating production
Let AI pick masked columns — Run SHOW COLUMNS FROM table_name and ask Claude Code to identify PII columns. It's thorough

Limitations

Column-name-based masking — Irregular column names (col1, data, etc.) require manual configuration
MySQL only — No PostgreSQL or other database support
Masking format is fixed: first character preserved, rest replaced with ***. No customization
Large result sets (tens of thousands of rows) incur overhead from the masking pass

Try It

Install with Homebrew in 30 seconds:

brew tap atani/tap && brew install mysh
mysh add  # Interactively add a connection

If you find it useful, a star on GitHub would mean a lot.

GitHub: https://github.com/atani/mysh

Benchmarked browser-use CLI vs playwright-cli for Claude Code browser automation.

atani — Sat, 21 Mar 2026 14:29:51 +0000

Benchmarked browser-use CLI vs playwright-cli for Claude Code browser automation.

I built a custom slash command that lets Claude Code triage GitHub issues — deciding which to clo...

atani — Fri, 20 Mar 2026 14:37:30 +0000

I built a custom slash command that lets Claude Code triage GitHub issues — deciding which to close, which need a PR, and which need human judgment. The hardest part was turning my own implicit decision-making into explicit prompt rules. After 7 iterations, it handles the obvious cases well, freeing me to focus on the truly hard issues.

Built mysh — a MySQL connection manager that auto-masks query output (emails, phones, etc.) befor...

atani — Tue, 17 Mar 2026 14:49:08 +0000

Built mysh — a MySQL connection manager that auto-masks query output (emails, phones, etc.) before passing results to AI tools. Production env is always masked; dev env shows raw data. TTY detection prevents AI tools from bypassing the mask.
https://github.com/atani/mysh

Built a "failure learning loop" for Claude Code — PR review comments get recorded in memory/rules...

atani — Fri, 13 Mar 2026 14:36:33 +0000

Built a "failure learning loop" for Claude Code — PR review comments get recorded in memory/rules files that persist across sessions. EUC-JP file corruption, test anti-patterns — each mistake only happens once now.
https://docs.anthropic.com/en/docs/claude-code

Automated our team's weekly report with 2 bash scripts. GraphQL API fetches PRs across the org, j...

atani — Thu, 12 Mar 2026 14:41:55 +0000

Automated our team's weekly report with 2 bash scripts. GraphQL API fetches PRs across the org, jq handles stats, and claude -p groups them by theme into markdown. The "judgment" part is the only thing the LLM does — data collection stays deterministic.

Been using cmux daily for running AI agents — loved it so much I sent 3 PRs. Localized Japanese U...

atani — Tue, 10 Mar 2026 16:58:47 +0000

Been using cmux daily for running AI agents — loved it so much I sent 3 PRs. Localized Japanese UI, fixed an omnibar hang, then tracked down a CJK font bug where decorative fonts got picked over Hiragino Sans. Using it is how you find things to fix, caring is why you fix them.
https://github.com/manaflow-ai/cmux/pull/1017

Been using cmux daily for running AI agents — loved it so much I sent 3 PRs. Localized Japanese U...

atani — Tue, 10 Mar 2026 14:41:10 +0000

I added Japanese localization to cmux, a Ghostty-based macOS terminal for AI coding agents. 624 t...

atani — Fri, 06 Mar 2026 14:30:06 +0000

I added Japanese localization to cmux, a Ghostty-based macOS terminal for AI coding agents. 624 translated entries across 18 Swift files, done almost entirely through conversation with Claude Code.

I archived my CLI tool gh-attach after realizing playwright-cli can do the same thing — upload im...

atani — Mon, 23 Feb 2026 14:40:39 +0000

I archived my CLI tool gh-attach after realizing playwright-cli can do the same thing — upload images to GitHub Issues via the file chooser UI.

I tried getting Claude Code to collect E2E test evidence via browser automation. It took 5 attemp...

atani — Thu, 19 Feb 2026 14:41:29 +0000

I tried getting Claude Code to collect E2E test evidence via browser automation. It took 5 attempts to get it right.

DEV Community: atani

16MB vs 1.2GB — Benchmarking 5 AI Browser Automation Tools

The 5 Tools Compared

Test Environment

Setup: Lightpanda Is a Single 12MB Binary

Raw Speed: steel-browser Clocks 0.45s

Memory: 16MB vs 1.2GB — a 75x Gap

SPA Support: All 5 Tools Loaded react.dev Successfully

Auth Persistence: playwright-CLI's state-save/load Is the Most Complete

playwright-CLI

agent-browser

browser-use

Lightpanda

steel-browser

Auth Persistence Summary

Parallel Execution: Lightpanda Stays at ~1.6GB Even at 100 Concurrent Sessions

Error Handling: agent-browser Gives the Clearest Messages

JS-Heavy Sites: steel-browser Fastest Across the Board

Token Efficiency: playwright-CLI's 317B Is the Smallest

Output Quality: ref-tagged Tree vs Markdown vs JS Execution

agent-browser — Actionable structured data

Lightpanda — Readable Markdown

playwright-CLI — Flexible extraction via JS execution

browser-use — LLM decides autonomously

steel-browser — Complete HTML structure

Who Should Use What

playwright-CLI — Engineers working in enterprise SAML/SSO environments

agent-browser — Full-stack engineers building custom AI agents

browser-use — Python engineers who want the fastest path to a browser automation prototype

Lightpanda — Data engineers processing high volumes of web pages

steel-browser — Infra/SRE teams running browser automation in production

Decision Flowchart

Overall Summary

Closing Thoughts

Links

mysh — A MySQL Connection Manager That Auto-Masks PII in Query Output

The Problem

Why Existing Tools Don't Solve This

So I Built mysh

How It Works: Environment × Output Target

Configuring Masked Columns

Masking Examples

Usage

Adding a Connection

Running Queries

SSH Tunneling

Security Design

Technical Notes

Why Go?

TTY Detection for Masking

Usage Tips

Limitations

Try It

Benchmarked browser-use CLI vs playwright-cli for Claude Code browser automation.

I built a custom slash command that lets Claude Code triage GitHub issues — deciding which to clo...

Built mysh — a MySQL connection manager that auto-masks query output (emails, phones, etc.) befor...

Built a "failure learning loop" for Claude Code — PR review comments get recorded in memory/rules...

Automated our team's weekly report with 2 bash scripts. GraphQL API fetches PRs across the org, j...

Been using cmux daily for running AI agents — loved it so much I sent 3 PRs. Localized Japanese U...

Been using cmux daily for running AI agents — loved it so much I sent 3 PRs. Localized Japanese U...

I added Japanese localization to cmux, a Ghostty-based macOS terminal for AI coding agents. 624 t...

I archived my CLI tool gh-attach after realizing playwright-cli can do the same thing — upload im...

I tried getting Claude Code to collect E2E test evidence via browser automation. It took 5 attemp...