tools on Saurabh Kumar

Default Apps 2026

Wed, 21 Oct 2026 00:00:00 +0000

Apps I’ve been using regularly this year. This is my second year doing this. Here is last year’s list. Inspired by Jeff Triplett and catalogued by Robb Knight’s App Defaults.

What changed since 2025

AI took over a big chunk of my day. Pi is my core harness, I live in Pi Web, and I’m trying Pi Pocket on the side. Agents now do most of my version control too.
Arc → Zen for work. Close to Arc, well maintained, no feature bloat. Safari stays for personal browsing.
iTerm2 → Ghostty, a thin layer over herdr, a multiplexer built for AI agents. Setup in my dotfiles: Ghostty config, herdr config, and notes on how I use herdr.
Raycast → Tinycast, a tiny native launcher. Alfred is gone too.
Cursor is out. Mostly Zed now, with its AI turned off.
Edison Mail → Apple Mail, plus Gmail on the web when I need it.
Photoshop and Lightroom → darktable and GIMP.
Pages → Google Docs. I hardly open Pages anymore.
Perplexity → Hacker News and Newsboat, next to NetNewsWire.
Raindrop.io is gone. My TIL and personal wiki replaced bookmarks.
New: a tiling window manager (OmniWM), dictation (Wispr Flow), and Tailscale in place of Zscaler.
More small Mac utilities: Mole for cleanup, UsagePal for AI limits, Thaw, Amphetamine, and AlDente.
Todoist joined and jj joined lazygit. Bullet Journal use dropped a bit.

The list

Mail Client: Apple Mail, Gmail in browser
Notes: Obsidian, Simplenote
To-Do: Todoist, Bullet Journal
Photo Shooting: iPhone, Canon 6D
Photo Editing: darktable, GIMP
Calendar: Notion Calendar, Google Calendar on the web
Cloud File Storage: iCloud + Google Drive
RSS: NetNewsWire, Newsboat in the terminal
Contacts: Apple Contacts & Google Contacts
Browser: Zen for work, Safari for personal
Chat: Apple Messages, Slack, Discord, Signal, WhatsApp, Telegram
Bookmarks: none. My TIL and personal wiki replaced them
Read It Later: Safari Reading List
Word Processing: Google Docs
Spreadsheets: Google Sheets
Presentations: Figma
Shopping Lists: Amazon
Budgeting and Personal Finance: paisa, with ledger underneath
News: NetNewsWire, Newsboat, Hacker News
Music: YouTube Music on the web, not much
Audiobooks: Audible
Password Management: 1Password and Apple Passwords
Code Editor: Zed with AI disabled, plus T3 Code and others now and then
AI Harness: Pi, Pi Web, trying Pi Pocket
Dictation: Wispr Flow, Muesli for local transcription
VPN: AdGuard, Tailscale

Bonus Items

Important enough to include here, ordered roughly by how often I rely on each.

Launcher: Tinycast
Window Manager: OmniWM, trying out TrellisWM
Ad Blocking: AdGuard
Terminal: Ghostty + herdr with zsh and Starship
Search Engine: DuckDuckGo and Google
Version Control: lazygit and jj, trying Hunk for diffs. AI does most of it now.
Screenshots: CleanShot X
Mac Cleanup: Mole, a CLI that cleans caches, uninstalls apps, and frees up disk
AI Usage Tracking: UsagePal, a menu bar app that tracks my AI subscription limits
Menu Bar: Thaw to hide the clutter
Keep Awake: Amphetamine
Battery: AlDente to limit charging
Local Dev: OrbStack, Bruno for APIs
Mastodon Client: Mastonaut
Code Repositories: GitHub
Reading: Kindle
Writing: WriteText, Obsidian, Zed
Design: Figma, GIMP
App + Server Monitoring: Sentry
Brainstorming: Obsidian
Video Calls: Meet, Zoom
Snippet Sharing: GitHub Gist
Project Management: Linear, Jira

Microsoft eXecution Container (MXC)

Sat, 10 Oct 2026 12:00:00 +0000

Microsoft eXecution Container (MXC) is an embeddable SDK for running untrusted commands under OS-enforced policies, not a hosted sandbox service.

Defaults: Seatbelt on macOS, Bubblewrap on Linux, ProcessContainer on Windows. SDKs for Node, Rust, and .NET.
Restricts filesystem and network access. macOS hostname allowlists need a caller-managed proxy; not every backend is a VM.
Useful boundary: sandbox the command where it executes, not just the agent’s tool-composition script. Isolation limits damage; it does not make generated output trustworthy.

Arnav Gupta's pi-subagent-manager

Fri, 09 Oct 2026 12:00:01 +0000

Arnav Gupta’s pi-subagent-manager makes context inheritance explicit. Nested threads receive their parent’s snapshot; independent roots start without its history. Threads stay around for steering and resume. I want synchronous coordination by default, forks for continuity and fresh context for independent review.

Armin Ronacher's subagent extension

Fri, 09 Oct 2026 12:00:00 +0000

Armin Ronacher’s subagent extension runs one observable Pi child at a time in tmux. The parent waits for the result, while I can attach to inspect or intervene. Worth preserving when adding hierarchy: synchronous coordination must not mean invisible execution.

Wispr Flow

Thu, 08 Oct 2026 12:00:00 +0000

Back on Wispr Flow after six months on local speech-to-text (FluidVoice with Parakeet, plus Whisper). Local transcription is fine. The cleanup is what’s missing: fixing misheard jargon ate the time dictation saved. Flow’s correction pass, OS-level integration and phone keyboard win. It matters more now because models follow high-level intent well: I speak the intent plus constraints in one go and let the LLM structure it. Whisper mode works even when you speak softly. Want to try it? My referral link gets you a free month of Pro, and I get one once you’ve dictated 2,000 words.

Pi Durable

Wed, 07 Oct 2026 12:00:00 +0000

Pi Durable is Earendil’s experimental agent harness, shipped alongside Pi 1.0. TannerMidd/pi-pocket is a mobile-first, multiplayer web app for Pi built on it.

Every model call and tool call is a task that checkpoints to storage (SQLite, JSONL, or memory) before moving on. Kill the process and a new one opens the same file and resumes.
Recovery is per step: a cut-off model request is resent with the partial answer kept and marked aborted. A cut-off tool call reruns only if it is replay-safe; otherwise the model is told it was interrupted.
A requestId makes a submission exactly-once, so a client retrying after a crash gets the original back.
Forks see the parent transcript up to the fork point without copying it.
~15k lines total, small enough for an agent to read end to end.
pi-pocket: restart the server mid-run and the work continues. Several people can watch, steer, or queue messages on the same session.
npm start -- --access tailscale binds only to the tailnet address, so my phone gets it with no tunnel.
The shift: the session lives in a SQLite file, not a terminal process, so the phone is just another client. Could replace my Moshi + tmux setup.
Caveat: anyone who can steer runs shell commands as you.

pi-blackhole

Sat, 05 Sep 2026 12:00:00 +0000

Every coding agent (Claude Code, Codex, pi) compacts long sessions the same way: ask an LLM to prose-summarize, then summarize that summary, until load-bearing details erode (why a decision was made, which approaches got rejected). pi-blackhole swaps that for deterministic compaction: a zero-token compile() that extracts structured sections (goal, files touched, commits, preferences, brief transcript). No LLM, no drift, no cost. The compile is only lossy in the window, not on disk: blackhole also ships a recall tool (BM25 + regex over the raw session JSONL and the memory ledger) that re-fetches any dropped turn on demand, so compile + recall together is lossless where an LLM summary-of-a-summary destroys the original. It also adds observational memory: background observer/reflector workers append durable facts to per-session ledgers that survive every compaction, and /blackhole-export walks every past-session JSONL under a git-root into a ranked context file. The clever part is what export trusts. A fact’s rank is driven by cross-session recurrence, damped as log(1 + distinctSessions) with a burst penalty, not raw counts, so one chatty session can’t inflate it. Recurrence-as-reinforcement is basically Hebbian: facts that keep firing across sessions get stronger. Dedup is a 3-pass funnel, exact then Levenshtein then Sørensen-Dice token-set, with a Levenshtein floor so keyword overlap alone can’t merge two distinct facts. Bonus: the OM workers run on their own model and billing, so I point them at openai-codex/gpt-5.6-luna while the main thread stays on Claude.

gistpreview.github.io

Wed, 15 Jul 2026 12:00:01 +0000

gistpreview.github.io renders any GitHub Gist as a live HTML page. Pass the gist ID as a query param (?<gist_id>) and it fetches via GitHub API + document.write(). Entire thing is 2 files (index.html + main.js), no build step, trivially self-hostable. Useful for quick HTML/CSS demos without spinning up CodePen or deploying anything.

SecretSpec

Wed, 15 Jul 2026 12:00:00 +0000

SecretSpec declares secrets once in secretspec.toml (names + descriptions, never values) and resolves them from any of 11 backends: keyring, 1Password, Vault, AWS, GCP, .env. Same command everywhere: secretspec run --profile production -- npm start. Per-secret fallback chains (providers = ["vault", "keyring", "env"]) and a ref = { item, field } form points at a secret you already have elsewhere, no renaming. Sharpest bit: agents get held to a stricter bar by default. require_reason = "agents" forces secretspec run --reason "..." before an AI agent can read a secret, appended to a local audit log; humans running interactively are unaffected. Rust core, SDKs for Python/Go/Node/Ruby/PHP/Haskell. Worth piloting on a project drowning in .env sprawl.

Recordly

Mon, 13 Jul 2026 12:00:00 +0000

Recordly does video recording, screenshots, and demo editing in one open-source Electron app. Not in Homebrew core, but easy to ship via a personal tap: brew install --cask theskumar/tap/recordly. Replacing my previous screenshot/recording workflow with this as the single default (see Default Apps 2025).

Vim motion tips for Zed

Sun, 21 Jun 2026 12:00:01 +0000

Vim motion tips for Zed. Turn on relative line numbers, and let vim mode switch them to absolute in Insert mode, so you get jump distances in Normal mode and context while typing.

{ "relative_line_numbers": true, "vim": { "toggle_relative_line_numbers": true } }

[[ / ]] jump between function definitions in a large Django or FastAPI file.
f: moves to the end of an if, def or class line.

Hidden Gems: Community Edition

Sun, 21 Jun 2026 12:00:00 +0000

Zed’s Hidden Gems: Community Edition thread collects users’ favourite Zed features and workflows, a companion to Hidden Gems: Team Edition. One tip from it: point agent.commit_message_model at gemini-2.0-flash on a free Gemini API key to write commit messages.

Moshi

Mon, 15 Jun 2026 12:00:00 +0000

Moshi is the best SSH client I’ve found for iPhone — connects to your laptop’s tmux sessions over Mosh, making it rock-solid on mobile networks with roaming support. Perfect for an agent view on the go; I use it to monitor and interact with running pi/Claude sessions from my iPhone without losing the session on network switches.

fabric

Mon, 08 Jun 2026 12:00:01 +0000

faberic is a crowd-sourced collection of prompts bundeled with a cli to use them via piped interfaces.

How I Optimized My Zsh Startup Time

Mon, 11 May 2026 00:00:00 +0000

My zsh prompt was taking close to a second to appear on a fresh terminal. Not catastrophic. But you feel it every time tmux spawns a new pane, and for me that is constantly. The config had grown for years, one eval and one plugin at a time, and nobody had been auditing it, least of all me.

What follows is the audit, and the eight things I changed. The numbers are estimates, not measurements, and I will say so again at the end.

Measure first

Before I touched anything, I measured. Two tools did the work:

# Cold-start benchmark (run a few times, watch the variance):
for i in {1..5}; do time zsh -i -c exit; done

# In-shell flamegraph:
# 1. Uncomment `zmodload zsh/zprof` at the top of .zshrc
# 2. Add `zprof` at the bottom
# 3. Open a new shell
zprof | head -40

zprof is the one that helped most. It prints which function calls and evals are burning time, sorted by self-time and call count. That is enough to stop guessing.

1. Stop forking `brew --prefix` five times per shell

My macOS config had this:

export PATH=$(brew --prefix coreutils)/libexec/gnubin:$PATH
export PATH=$(brew --prefix findutils)/libexec/gnubin:$PATH
export PATH=$(brew --prefix gnu-sed)/libexec/gnubin:$PATH
export PATH=$(brew --prefix grep)/libexec/gnubin:$PATH
export PATH=$(brew --prefix curl)/bin:$PATH

Five forks of brew, which is a Ruby program, on every shell, just to resolve paths that always end up under ${HOMEBREW_PREFIX}/opt/<formula> anyway. Each fork is about 35 ms on Apple Silicon, so that is roughly 180 ms gone before I have typed a single character.

Fix:

_brew_opt="${HOMEBREW_PREFIX:-/opt/homebrew}/opt"
[ -d "$_brew_opt" ] || _brew_opt="/usr/local/opt"
export PATH="$_brew_opt/coreutils/libexec/gnubin:$_brew_opt/findutils/libexec/gnubin:$_brew_opt/gnu-sed/libexec/gnubin:$_brew_opt/grep/libexec/gnubin:$_brew_opt/curl/bin:$PATH"
unset _brew_opt

A path-prefix lookup costs nothing. The /usr/local/opt fallback is there for Intel macOS, where HOMEBREW_PREFIX may be unset, for example in bash without brew shellenv.

Saves about 180 ms.

2. Defer plugins with zinit’s `wait` ice

If you use a plugin manager, this is probably the biggest single win on the table. Syntax highlighting, autosuggestions, history-substring-search, completion add-ons: none of these need to load before the first prompt renders. They only need to be there by the time you type something.

With zinit’s wait ice, you defer them until after the first prompt:

zinit wait lucid light-mode for \
 atinit"ZINIT[COMPINIT_OPTS]=-C; zicompinit; zicdreplay" \
 zdharma-continuum/fast-syntax-highlighting \
 atload"_zsh_autosuggest_start" \
 zsh-users/zsh-autosuggestions \
 blockf atpull'zinit creinstall -q .' \
 zsh-users/zsh-completions \
 atload"bindkey '^[[A' history-substring-search-up; bindkey '^[[B' history-substring-search-down" \
 zsh-users/zsh-history-substring-search \
 wfxr/forgit

The atinit ice on the first plugin runs compinit once and replays cached completions via zicdreplay. One compinit covers every turbo-loaded plugin. The atload"_zsh_autosuggest_start" line re-initializes autosuggestions after deferred loading. Without it the plugin silently no-ops, which took me an embarrassing amount of time to work out.

Saves 100-300 ms.

3. Compile `.zcompdump` to bytecode

compinit parses thousands of completion functions on every startup. Compiling its dump file to bytecode means subsequent shells skip the parser:

zcompdump="${ZDOTDIR:-$HOME}/.zcompdump"
[[ -s "$zcompdump" && (! -s "${zcompdump}.zwc" || "$zcompdump" -nt "${zcompdump}.zwc") ]] \
 && zcompile "$zcompdump"

It recompiles only when the source is newer than the cached .zwc. Saves 30-80 ms.

4. Pick one version manager

I had both fnm and mise active, which is one more than anyone needs. Mise manages everything I actually use, Node, Python, Go; fnm env in .zshrc was a leftover that nothing depended on. Deleting it saved another 30-80 ms per shell.

Mise itself has a second optimization, --shims mode:

eval "$(~/.local/bin/mise activate zsh --shims)"

Default mise activate installs a precmd hook that runs on every prompt to keep tool versions in sync with .mise.toml. Shim mode replaces that hook with symlinks on PATH that resolve the right version the first time you call each tool. That is about 17 ms saved at startup, paid back as 10-30 ms on the first invocation per shell. For interactive use it is a fine trade.

5. Cache the slow `eval`s

A lot of tools want you to run eval "$(tool init zsh)" at startup. Each one forks the tool, runs its setup, and pipes the result back. You pay that cost every shell, even though the output rarely changes between runs.

A small helper fixes it:

_cache_eval() {
 local name=$1; shift
 local cache=~/.zsh/cache/$name.zsh
 [[ -s $cache && $cache -nt ${commands[$1]:-/dev/null} ]] \
 || { mkdir -p ~/.zsh/cache; "$@" > $cache; }
 source $cache
}
_cache_eval zoxide zoxide init zsh --cmd j
_cache_eval uv uv generate-shell-completion zsh

The $cache -nt ${commands[$1]:-/dev/null} test compares mtimes. When brew or mise upgrades the binary, the cache invalidates on its own. No stale-cache surprises after a brew upgrade.

Keep starship init zsh eager. You need it for the prompt anyway, and it is already fast.

Saves 50-100 ms.

6. Audit plugins; cut what you don’t use

I was loading the Oh My Zsh git plugin via zinit’s snippet feature. The plugin ships roughly 150 aliases.

So I grepped my last few months of shell history against its alias list. Five OMZ-only aliases came back: gsw, glo, gf, gclean, gss. Everything else I either did not use or had already redefined to my own taste. I copied those five into shell/.aliases and dropped the OMZP::git snippet from zinit.

There is a second reason to do this, and it has nothing to do with startup time. Because the OMZ plugin loaded in turbo mode, after my eager shell/.aliases, it was quietly overwriting aliases I had defined myself. My gc='git commit -m' was getting clobbered to git commit --verbose, and gg='lazygit' to git gui. The plugin “worked” because turbo-loaded aliases land before you type, but the behavior was not the one I had configured. Dropping the plugin put my own aliases back in charge.

While I was at it I found zsh/.zsh/plugins/git/git.plugin.zsh in my dotfiles, 150 lines of git aliases, sourced from nowhere. Years of dead code I had been carrying around. Gone.

7. Move PATH and env to `.zshenv`

.zshrc runs only for interactive shells. If you set PATH there, then cron jobs, zsh -c "command" invocations, and IDE-spawned non-interactive shells do not see your tools. That is how you end up burning half a day on “works in my terminal, breaks in CI.”

The right home is .zshenv, which runs for every zsh invocation:

# ~/.zshenv
export PNPM_HOME="$HOME/Library/pnpm"

typeset -U path PATH # auto-dedupe
path=(
 "$HOME/.local/bin"
 "$PNPM_HOME"
 $path
)

[ -f "$HOME/.cargo/env" ] && . "$HOME/.cargo/env"

typeset -U path PATH ties the path array to the PATH scalar and deduplicates automatically. No more 8 KB PATH strings with the same entry six times because nested shells kept prepending.

This is not a cold-start win, since .zshenv still runs. It is a correctness fix. A shorter PATH does make command lookups faster, so you get a little of both.

8. Fix the things you didn’t know were broken

While I was in there, zprof and a slow re-read of the config surfaced a stack of small bugs that had nothing to do with cold start. They were just wrong:

~/.profile was being sourced twice, once from .zshrc and once from .zshenv. 20-80 ms of pure waste.
compinit’s cache-staleness check had inverted-looking logic and a misleading comment. It happened to do the right thing, but only by accident.
zsh/.zsh/lib/completions.zsh referenced $ZSH, an Oh My Zsh leftover that was unset in my setup. The completion cache-path was silently expanding to /cache/, the filesystem root. Nothing got written there because the directory was not writable, so completions had no cache at all. Caching had quietly been off the whole time.
compdef calls from eager tool initializations were arriving before turbo-mode compinit had run, so completions for those tools were not registering. I fixed it with a small shim that queues the calls until compinit is ready:

if ! (( ${+functions[compdef]} )); then
 typeset -ga __deferred_compdefs
 compdef() { __deferred_compdefs+=("${(j: :)@}") }
fi

Then in the turbo block’s atinit, after zicompinit; zicdreplay:

(( ${#__deferred_compdefs} )) && \
 for c in "${__deferred_compdefs[@]}"; do eval "compdef $c"; done
unset __deferred_compdefs

None of those moved the startup number. They were still bugs, and now they are not.

Doing this on your own config

Measure before you touch anything. time zsh -i -c exit for cold start, zprof for the in-shell breakdown. Skip that step and you will spend an afternoon optimizing the wrong thing. I have done exactly that.

Then grep your shell history against the alias and function lists of whatever plugins you load. You will usually find you are loading hundreds of definitions to use a handful.

Defer what can be deferred. First-prompt latency is what you feel, and almost nothing actually has to load before you can type. Cache expensive evals whose output only changes when the binary changes, and key the cache on the binary’s mtime so upgrades invalidate it for you. Hardcode the constants: brew --prefix coreutils is always ${HOMEBREW_PREFIX}/opt/coreutils. Forking a Ruby program to ask is silly.

And keep environment variables in .zshenv, not .zshrc. Future-you, debugging why something works in iTerm but not in a cron job, will be grateful.

Estimated total

Change	Savings
Stop forking `brew --prefix` × 5	~180 ms
Defer plugins with `zinit wait`	100-300 ms
Cache remaining `eval`s	50-100 ms
Compile `.zcompdump`	30-80 ms
Drop `fnm` (mise covers it)	30-80 ms
Total	~400-700 ms

These are estimates, not measurements. Your actual numbers depend on your hardware, your plugin set, and how much cruft you had accumulated over the years. Under 200 ms on Apple Silicon is doable with stock zsh and a small, well-deferred plugin set.

My dotfiles, with all of this applied, are at github.com/theskumar/dotfiles. The zsh/OPTIMIZATION.md file there is the running log of what is done and what is still open.

I plan to repeat the audit as the config changes.

colbymchenry/codegraph

Sat, 09 May 2026 12:00:00 +0000

colbymchenry/codegraph: Pre-indexed code knowledge graph for Claude Code — fewer tokens, fewer tool calls, 100% local

codespelunker

Sun, 12 Apr 2026 12:00:02 +0000

codespelunker is a CLI code search tool that understands code structure and ranks results by relevance. No indexing required with CLI, TUI, MCP and HTTP support.

mise

Sat, 04 Apr 2026 12:00:00 +0000

mise let’s you manage dependencies at OS level and project level. Thinking to manage my dev machine. The hard part is documenting what I have installed.

moor

Sat, 21 Mar 2026 12:00:00 +0000

moor is a better replacement for less and bat as PAGER.

git-trim

Fri, 20 Feb 2026 12:00:00 +0000

brew install git-trim git-trim - A dedicated binary for safely deleting merged branches. Handles edge cases better than bash one-liners, including squash-merged branches. #

slingdata-io/sling-cli

Thu, 19 Feb 2026 12:00:00 +0000

slingdata-io/sling-cli is a promising tool move/sync data between databases and files, esp. helpful for local testing, ci/cd while able to do stage/sql based transformations.

github recommendor

Sun, 11 Jan 2026 12:00:00 +0000

Puzer published a github recommendor that uses semantic embedding from user’s github stars all client side, I found some great recommendations which I plan to use:

pamburus/hl: A fast and powerful log viewer and processor that converts JSON logs or logfmt logs into a clear human-readable format. (⭐2657)
samwho/spacer: CLI tool to insert spacers when command output stops (⭐1663)
darrenburns/posting: The modern API client that lives in your terminal. (⭐11134)
plutov/oq: Terminal OpenAPI Spec viewer (⭐943)
wey-gu/py-pglite: PGlite wrapper in Python for testing. Test your app with Postgres just as lite as SQLite. (⭐577)

Text based diagramming tools

Wed, 07 Jan 2026 12:00:01 +0000

Text based diagramming tools:

yuzutech/kroki: self-hosted solution for unified interface to buch of diagramming tools, including mermaid, d2, etc.! (⭐3875)
d2 provides a clean syntax and output as well.

npx -y npm-check-updates

Mon, 22 Dec 2025 12:00:01 +0000

npx -y npm-check-updates tells you the latest versions of your package.json, ignoring pinned versions.

New tools

Sat, 20 Dec 2025 12:00:00 +0000

New tools:

gh-actions-lockfile to generate and verify lockfiles for gh-actions
Proxyman is more user-friendly http debugging proxy than Charles Proxy on MacOS

Default Apps 2025

Wed, 05 Nov 2025 00:00:00 +0000

Update: see my Default Apps 2026 for this year’s list.

Apps I’ve been using regularly this year. Heavily inspired by Jeff Triplett. Catalogued by Robb Knight’s App Defaults

Mail Client: Edison Mail and gmail in browser
Notes: Obsidian, SimpleNotes
To-Do: Bullet Journel
Photo Shooting: iPhone, Canon 6D
Photo Editing: PhotoShop, Gimp
Calendar: Notion Calendar
Cloud File Storage: iCloud + Google Drive
RSS: NetNewsWire
Contacts: Apple Contacts & Google Contacts
Browser: Arc, Zen Browser and Safari
Chat: Apple Messages, Discord, Slack
Bookmarks: RainDrop.io
Read It Later: Safari Reading List
Word Processing: Apple Pages
Spreadsheets: Google Sheets
Presentations: Figma
Shopping Lists: Amazon
Budgeting and Personal Finance: paisa
News: Perplexity.ai, NetNewsWire
Music: Youtube Music
Password Management: 1Password and Apple Passwords
Code Editor: Zed & Cursor
VPN: AdGuard, Zscalar

Bonus Items

Important enough to include here, ordered roughly by how often I rely on each.

Launcher: Raycast
Ad Blocking: AdGuard
Terminal: iTerm 2 with ZSH
Search Engine: DuckDuckGo and Google
Version Control: lazygit
Screenshots: CleanShot X (also trying out Xnapper)
Mastodon Client: Mastonaut
Code Repositories: GitHub
Reading: Kindle
Writing: Obsidian, Zed
Design: Figma, Gimp
App + Server Monitoring: Sentry
Brainstorming: Obsidian
Video Calls: Meet, Zoom
Snippet Sharing: Github Gist
Project Management: Linear, Jira

ty: Astral's Take on Python Type Checking

Fri, 09 May 2025 00:00:00 +0000

Anyone who has run mypy on a real codebase knows the workarounds. You enable the daemon, you keep the incremental cache warm, you scope the check to the files you touched, and you still wait a few seconds for the editor to catch up after a rename. In CI it is worse, because the cache is cold and the full run can stretch into the minutes. None of this is broken, exactly. It is just the cost you learn to pay. So when a new checker says the wait can mostly go away, I pay attention, but I also want to know what it costs.

That checker is ty (gh:astral-sh/ty), from Astral, the same people who built the Ruff linter and the uv package manager. As of May 2025, it is pre-alpha, version 0.0.0a6, and not something you should put in production. But it is already worth talking about, partly for what it does and partly for what it deliberately leaves out.

Speed Is The Headline

The numbers people are reporting are large. One user saw mypy take 18 seconds where ty finished the same check in about half a second. Another compared ty at 2.5 seconds against Pyright at 13.6 seconds on a 100k line codebase. Some users assumed it had failed, because nothing that finishes that fast could have actually looked at their whole project.

Ruff did the same thing to linting a few years ago. It was fast enough that the linter stopped being a separate step you ran and became something that just happened while you wrote code. ty looks like it wants to do that for type checking. That matters more than it sounds. A check that takes a minute is a thing you run in CI and forget about. A check that runs in milliseconds is a thing your editor can run on every save, and that changes how it feels to write Python at all.

Fast And Frequently Wrong, For Now

Speed is the easy part. Being correct is the hard part, and here ty is still young.

The Astral developers say this plainly: it is pre-alpha, many of the errors it reports may be wrong, and the feature set is small. Right now it does diagnostics and go-to-type-definition, and not much else. One user ran it on a codebase where Pyright reported 10 diagnostics, all correct, and ty reported 1,599. That is not a small gap. Type inference is the thing that takes years to get right, and ty has not had years.

I would not read those 1,599 diagnostics as a verdict on the project. A count like that is rarely 1,599 distinct bugs; it is usually a handful of inference patterns the checker gets wrong, multiplied across every file that hits them. Fix the pattern and the count collapses. What you are looking at is a checker that is fast first and accurate later. Given what Astral did with Ruff and uv, betting against the accuracy catching up seems unwise. But it has not caught up yet, and you should treat the output accordingly.

It Is Entering A Crowded Field

ty is not arriving to an empty room. It joins mypy, Microsoft’s Pyright and Pylance, and Facebook’s Pyrefly, which also builds on Ruff’s parser despite being a separate project.

What makes all of these hard is Python itself. TypeScript was built with static typing in mind. Python’s type hints arrived later and grew unevenly, bolted onto a dynamic language, with the inconsistencies you would expect from something added after the fact. On top of that, the libraries people actually use are the hardest cases. Django and SQLAlchemy lean heavily on metaprogramming and runtime code generation, which is exactly the kind of thing a static checker cannot see. The ecosystem mostly papered over this with type stubs and plugins: SQLAlchemy 2.0 added real typed mappings, and Django users lean on django-stubs, which is a mypy plugin. Hold onto that detail, because it runs straight into the next decision.

No Plugins, On Purpose

This is where Astral makes a real choice rather than a faster one. mypy lets libraries ship plugins so the checker can understand their metaprogramming. ty will not have plugins. Astral treats the interchangeability of type checking as a feature: a check should mean the same thing across tools and projects, and it should not depend on a plugin that one checker has and another does not. Instead they plan to support the popular libraries directly in the tool.

That is a trade, not a free win. The Django user relying on django-stubs today is relying on exactly the plugin mechanism ty is choosing not to have, so until Astral supports those libraries directly, that user has no escape hatch. More work falls on Astral, and the libraries they have not reached yet are simply not understood. But it also means you do not end up with type checking that only works inside one vendor’s setup, and that division is worth defending.

They are also borrowing from Rust’s compiler for their diagnostics, aiming for error messages that explain rather than just flag. An LSP server and a VS Code plugin are planned, though there is no release date for either.

The Question That Always Comes Back

Astral is a VC-backed company, and the same question hangs over ty as over Ruff and uv: how does this get paid for. The code is open source and has outside contributors, but at some point the money has to come from somewhere.

People guess at CI products, private repositories, or enterprise services. Astral, for now, seems to be building the tools first and leaving monetization for later. That has earned them a lot of goodwill in the Python community, and it should also keep you a little cautious, because the terms you adopt a tool under are not always the terms you keep it under.

Trying It

If you want to look at it yourself:

uv tool install ty

Or without installing anything:

uvx ty check

These notes describe the pre-alpha release in May 2025. Expect rough edges, and do not trust a red diagnostic until you have checked it by hand.

I do not know yet whether ty becomes the type checker people reach for. The speed is real, the missing plugin system is a deliberate stance and not an oversight, and the accuracy is not there yet. What I want from it is the thing Ruff already delivered: a tool fast enough to disappear into the edit loop, honest enough to trust, and available under open source terms I can rely on. The first of those is here. The other two are still being written.

Navigating VS Code terminals from the keyboard

Thu, 05 Oct 2023 12:00:00 +0000

VS Code’s built-in terminals are hard to move between from the keyboard. These keybindings.json entries fix it, adapted from jbranchaud’s TIL:

cmd+[ / cmd+]: previous / next terminal
cmd+1 to cmd+5: terminal by position
cmd+n: new terminal; cmd+w: kill it
cmd+t: toggle between terminal and editor

{ "key": "cmd+]", "command": "workbench.action.terminal.focusNext", "when": "terminalFocus" },
{ "key": "cmd+[", "command": "workbench.action.terminal.focusPrevious", "when": "terminalFocus" },
{ "key": "cmd+1", "command": "workbench.action.terminal.focusAtIndex1", "when": "terminalFocus" },
{ "key": "cmd+2", "command": "workbench.action.terminal.focusAtIndex2", "when": "terminalFocus" },
{ "key": "cmd+3", "command": "workbench.action.terminal.focusAtIndex3", "when": "terminalFocus" },
{ "key": "cmd+4", "command": "workbench.action.terminal.focusAtIndex4", "when": "terminalFocus" },
{ "key": "cmd+5", "command": "workbench.action.terminal.focusAtIndex5", "when": "terminalFocus" },
{ "key": "cmd+n", "command": "workbench.action.terminal.new", "when": "terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported" },
{ "key": "cmd+w", "command": "workbench.action.terminal.kill", "when": "terminalFocus" },
{ "key": "cmd+t", "command": "workbench.action.terminal.focus", "when": "!terminalFocus" },
{ "key": "cmd+t", "command": "workbench.action.terminal.toggleTerminal" }

tools on Saurabh Kumar

Default Apps 2026

What changed since 2025

The list

Bonus Items

Microsoft eXecution Container (MXC)

Arnav Gupta's pi-subagent-manager

Armin Ronacher's subagent extension

Wispr Flow

Pi Durable

pi-blackhole

gistpreview.github.io

SecretSpec

Recordly

Vim motion tips for Zed

Hidden Gems: Community Edition

Moshi

fabric

How I Optimized My Zsh Startup Time

Measure first

1. Stop forking brew --prefix five times per shell

2. Defer plugins with zinit’s wait ice

3. Compile .zcompdump to bytecode

4. Pick one version manager

5. Cache the slow evals

6. Audit plugins; cut what you don’t use

7. Move PATH and env to .zshenv

8. Fix the things you didn’t know were broken

Doing this on your own config

Estimated total

colbymchenry/codegraph

codespelunker

mise

moor

git-trim

slingdata-io/sling-cli

github recommendor

Text based diagramming tools

npx -y npm-check-updates

New tools

Default Apps 2025

Bonus Items

ty: Astral's Take on Python Type Checking

Speed Is The Headline

Fast And Frequently Wrong, For Now

It Is Entering A Crowded Field

No Plugins, On Purpose

The Question That Always Comes Back

Trying It

Navigating VS Code terminals from the keyboard

1. Stop forking `brew --prefix` five times per shell

2. Defer plugins with zinit’s `wait` ice

3. Compile `.zcompdump` to bytecode

5. Cache the slow `eval`s

7. Move PATH and env to `.zshenv`