Tools
-
Graphify Turns Your Repos Into a Map You Can Query
Navigating code dependencies inside a single repository is already hard enough. But if you’re on a microservice setup, or a split frontend and backend, tracking what depends on what across multiple repos is a special kind of misery. A backend API route changes. Which frontend components just broke? Good luck. You’re grepping three workspaces and hoping you didn’t miss one.
So when I ran across Graphify, an open-source project from Graphify Labs (YC S26), it caught my attention. It maps your code directories into queryable knowledge graphs. Not fuzzy text search. Not an expensive vector RAG lookup that burns tokens every time you ask it a question. A deterministic index of your codebase.
Let me walk through how it works, why it’s useful for AI coding agents, and the part I wanted to figure out: how to stitch multiple repos into one unified map.
What Graphify Does
Instead of guessing at relationships, Graphify parses your source and builds a real graph out of it. Three pieces make it tick:
- Deterministic AST parsing. It uses
tree-sittergrammars locally to parse roughly 40 languages, pulling out classes, functions, calls, and imports. No LLM tokens, no API rate limits. Just parsing. - Explicit vs. inferred edges. Every relationship gets a confidence tag.
EXTRACTEDmeans it’s right there in the syntax, like an import or a direct function call.INFERREDmeans it deduced the connection from context. You always know how much to trust an edge. - Leiden community clustering. It automatically segments your code into logical domain boundaries, which makes it easy to spot the “god nodes”, the files with way too many dependencies hanging off them. Those are usually the first thing you want to refactor.
Merging Multiple Repos Into One Graph
This is the part I cared about. Graphify supports it natively through the CLI, and here’s the flow straight from the docs (I haven’t run it on my own repos yet). Say you’ve got a frontend repo and a backend repo. Three steps.
Step 1: Scan each repo on its own. Run the scan inside each folder. Results land in a
graphify-out/directory.# In your frontend repo cd ~/Work/frontend graphify . # In your backend repo cd ~/Work/backend graphify .Step 2: Merge the graphs. The
merge-graphssubcommand joins the JSON outputs into one combined map of nodes and relationships.graphify merge-graphs \ ~/Work/frontend/graphify-out/graph.json \ ~/Work/backend/graphify-out/graph.json \ --out ~/Work/combined_graph.jsonStep 3: Traverse it, or hand it to your agent. Now you can trace a call path straight across the service boundary, or serve the combined graph to a coding agent over MCP.
# Trace a path across the frontend/backend boundary graphify path "login_component.ts" "auth_controller.py" --graph ~/Work/combined_graph.json # Or expose the combined graph to your coding agent over MCP python -m graphify.serve --graph ~/Work/combined_graph.jsonThat
pathcommand is the whole pitch, honestly. You point it at a frontend file and a backend file and it tells you how they’re connected. No manual grep archaeology.Why This Matters for AI Coding Agents
If you use Claude Code, Cursor, or Antigravity, you already know the problem. Feed the agent raw files and you torch the context window in about four prompts. Point it at Graphify’s output instead, the
GRAPH_REPORT.mdor thegraph.jsonover MCP, and the agent can do a few things it otherwise can’t:- Figure out exactly which files a refactor will touch before it edits anything.
- Trace dependency lineage across code boundaries deterministically, not by vibes.
- Describe your architecture based on the actual shape of the code, not a hallucinated version of it.
That last one is underrated. Half of “the AI got confused” moments happen because the AI never saw the whole picture.
Two Gotchas Before You Install
A couple of things will trip you up, so here they are up front.
The package name has a typo built in.
graphifywas already taken on PyPI, so the official package is registered asgraphifyy. Two y’s. You install it like this:pip install graphifyyWatch your Python version. The Leiden community detection library has C-extension limits, so Graphify currently runs best on Python under 3.13. Worth checking or switching to a compatible version (like 3.12) using mise.
The honest appeal here isn’t the visualization, pretty as the HTML map is. It’s that cross-repo dependency tracing has been a manual, error-prone chore for as long as I’ve worked on split codebases, and this makes it a single command.
Sources
- Graphify Labs on GitHub: setup requirements, supported parsers, and CLI options.
- Auriga IT’s Graphify introduction: explains the three-pass architecture and Leiden clustering optimization.
- Graphify on PyPI: package installation details and version compatibility.
- Aider’s Repository Map: on using tree-sitter to parse AST-based codebase maps for token-efficient coding context.
I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].
- Deterministic AST parsing. It uses
-
Why Your AI Stack Needs a Gateway
Picture an autonomous agent loop dying at step 45 of a plan it’s been grinding through for the better part of an hour. Not because the plan was wrong. Because OpenAI handed back an
HTTP 429at exactly the wrong moment, and the whole thing fell over. An hour of work, gone to a transient rate limit.That’s the moment most people start thinking about an AI gateway, whether they know the term or not.
Hardcoding API keys and endpoints straight into your application code feels fine right up until it doesn’t. You start with a simple chat wrapper. Then you’re running agents like OpenClaw or Hermes that chew through hours of command-line work. Then you’re wiring up a real backend that talks to OpenAI, Anthropic, Google, and a couple of self-hosted models. Now every one of those providers is a single point of failure. One of them rate-limits you or goes dark, and your workload crashes.
So people are dropping a new piece into the stack to deal with it: the AI gateway.
What It Is
An AI gateway is a specialized reverse proxy that sits between your application and the model providers upstream. Instead of importing a different SDK and juggling a different set of environment variables for every vendor, your app talks to one OpenAI-compatible endpoint. The gateway handles routing, retries, load balancing, security, and caching behind the scenes.
The request flow is straightforward. Your app makes a normal OpenAI-style call. The gateway checks its cache first, and if it’s seen a semantically similar prompt it serves the answer in milliseconds. On a miss, it runs the request through whatever security layer you’ve configured, then routes to a provider, with a failover path ready if the primary one is down. Your code never has to know any of that happened.
Who Needs One
The value splits cleanly across two kinds of people.
If you’re building agents, the pitch is survival. An agent that runs for hours is going to hit a
429or a500eventually. A gateway catches those, does exponential-backoff retries, and can swap providers mid-task, falling back to Claude if OpenAI is having a bad day. Your long-running loop stays alive instead of dying at step 45. You also get to keep your real vendor credentials locked in one vault and hand your agent scripts restricted local keys instead.If you’re the tech lead shipping customer-facing AI, the gateway becomes your governance layer:
- Observability. One console showing latency, time to first token, cost, and raw prompts across every team, instead of five fragmented dashboards.
- Spend management. Hard dollar budgets per team or per key, so a runaway recursive loop can’t quietly drain the corporate card.
- AI firewalls. Automatic PII masking for emails, phone numbers, and stray API keys, plus prompt-injection blocking at the edge before anything leaves your network.
- Semantic caching. Vector similarity checks catch prompts that mean the same thing and serve a cached answer, cutting both the token bill and the latency to near zero.
The Landscape
This space is filling up fast, and the options sort themselves by how you want to deploy. A quick tour of the ones worth knowing:
- OpenRouter is the managed broker. Hundreds of models under one credit balance, with dynamic pricing, fallbacks, and bring-your-own-key support. The easiest place to start.
- LiteLLM is the self-hosting standard. Python, wildly popular for building a private gateway inside your own VPC, with database-backed key budgets.
- Bifrost is the same idea written in Go for teams that care about throughput. It adds almost no latency overhead and benchmarks its P99 routing well ahead of the Python options.
- Portkey leans into prompt management. Versioned prompt templates live in a central playground and get called by API, which is handy if your prompts change more than your code.
- Cloudflare AI Gateway is the zero-devops edge play, built on Cloudflare’s CDN with fast caching, Logpush exports, and native edge firewalls.
- Vercel AI Gateway plugs straight into the Vercel AI SDK, so you route serverless traffic through it with a simple string change.
There’s no single right answer here… and i’m pretty sure I’m leaving a few out. If you just want to stop thinking about it, OpenRouter or Cloudflare. If you want control and a VPC, LiteLLM or Bifrost. If prompts are your headache, Portkey.
The real takeaway is smaller than the tooling makes it look. The moment your app depends on more than one model, or on any single model staying up, you’ve got an infrastructure problem, not an application problem. A gateway is just where you put the solution so your code doesn’t have to carry it.
An agent like that crashes at step 45 today. Put a gateway in front of it, and it doesn’t.
Sources
- OpenRouter
- Vercel AI Gateway documentation
- LiteLLM Proxy
- Bifrost (Maxim AI)
- Cloudflare AI Gateway docs
- Portkey Gateway docs
I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].
-
The Leading Multi-Agent Platform
-
Augment Code: Agentic software development at organizational scale
Your engineers have agents. Your organization doesn’t. Cosmos is the platform that closes the gap.
-
Parley | Contract Collaboration Platform for Teams
Parley is the new way to agree — designed for teams without lawyers on speed dial. Understand contracts, flag risks, and negotiate smarter with clear, collaborative agreements.
Tools Workflow links platform api contracts legal negotiation
-
The versioned filesystem for AI agents | Mesa
Connect agents to the files they need, run parallel agent swarms on instant branches, and track every change through one API with sub-50ms reads and writes.
-
garrytan/gbrain: Garry’s Opinionated OpenClaw/Hermes Agent Brain
Garry’s Opinionated OpenClaw/Hermes Agent Brain. Contribute to garrytan/gbrain development by creating an account on GitHub.
-
Graphify: Any input. One graph. Complete recall.
The open-source knowledge graph engine. Turn code, docs, papers, meetings and images into a traversable graph. Build once, grow forever. On-device or cloud.
-
A Model Context Protocol (MCP) server for the Internet Archive’s Open Library API that enables AI assistants to search for book and author information. - 8enSmith/mcp-open-library
-
npmx - Package Browser for the npm Registry
a fast, modern browser for the npm registry. Search, browse, and explore packages with a modern interface.
-
Two Kinds of Memory for Your CLI Agent
So you set up a memory layer for your local CLI agent. Now what? How do you actually get that memory in front of the agent so it does something useful?
I’m going to walk through what I did with mem0, but the shape of this applies to pretty much any memory layer. The first thing worth understanding is that CLI agents work with memory in two very different ways, and the difference matters.
The first way is text that’s always loaded. It gets injected into every session’s context automatically. No action needed on the agent’s part, it’s just there. This is your guaranteed data, the stuff that shows up at the start of every conversation.
The second way is semantic memory. For me that’s mem0 and the tooling I’ve built around it. This layer is accessed through an MCP server that exposes commands like
recallandremember. It’s poll-based. The agent has to decide to callrecall, because nothing gets auto-injected. The agent needs to be smart enough to say “I’m not sure about this, let me go look it up.”Those are the two flavors. Let me break them down.
Layer 1A: The Shared Instructions File
For most CLI agents, this is a single markdown file that the harness auto-loads into every session. Claude Code reads
CLAUDE.md. Gemini and Antigravity readGEMINI.md. AndAGENTS.mdhas become the cross-tool convention, read by OpenCode, Antigravity, and Cursor alike. Same idea everywhere, just a different filename.The one rule here: keep it minimal. Every line in this file is context you’re paying for on every single session. So don’t dump your whole knowledge base into it. The durable conventions, the project-specific facts, the things you only occasionally need? Those belong in your semantic layer, not here. This file is for the handful of rules that need to be loaded 100% of the time.
Layer 1B: Auto-Memory
Claude Code shipped a feature called auto-memory. It lives in
~/.claude/projects/, inside a subfolder that’s basically a slug of your project’s path on disk. In there you get amemoryfolder with aMEMORY.mdfile alongside the individual memory files.MEMORY.mdworks like an index. It holds short pointers to the durable memories stored next to it, and the whole thing gets loaded every session. It’s still part of layer 1, the always-loaded kind.Worth noting: this is a Claude Code thing. OpenCode and Antigravity don’t load or even know about these files. There’s no equivalent. Antigravity does have its own separate memory store that it syncs on its own, but it’s a different mechanism entirely, not a reader of Claude’s auto-memory.
Layer 2: The Semantic Layer
This is where it gets fun. I built a small MCP server in Go, a local binary that forwards requests to another server on my network. That server talks to two databases: Qdrant for the vectors, and Neo4j for the graph. The three functions I lean on most are
recall,remember, andadd_relation.If MCP is new to you, the short version: it’s an open standard that lets your agent connect to external tools and data over a common protocol. Instead of N bespoke integrations, you run one MCP server per capability and the host discovers it. People call it “a USB-C port for AI,” which is annoying and also pretty accurate.
Wiring it up is just config. For Claude Code, it goes in
~/.claude.jsonunder the top-levelmcpServers.memoryblock. For OpenCode, it’s~/.config/opencode/opencode.jsonundermcp.memory, withtype: localand a command that runs the binary.The Part People Forget
Here’s the step that ties it all together. Setting up the MCP server doesn’t do anything on its own. Remember, the semantic layer is poll-based. The agent won’t call
recallunless it knows it should.So you go back to layer 1, your always-loaded instructions, and you add a few lines telling the agent how and when to use the MCP server. Something like “before answering questions about this project, call
recallwith a relevant query” and “when the user tells you something worth keeping, callremember.” That instruction is small, it’s cheap, and it’s what turns a dormant memory store into a memory layer the agent actually reaches for.That’s the whole architecture. Always-loaded text that’s guaranteed but expensive, and a semantic store that’s huge but only as good as the agent’s instinct to go check it. Get both layers talking and your agent stops forgetting who you are every morning.
Sources
- mem0 — GitHub — the universal memory layer for AI agents that the post describes wiring up; 59.6k stars, Apache 2.0.
- Model Context Protocol — Wikipedia — MCP as an open standard introduced by Anthropic (Nov 2024) for connecting AI systems to external tools and data sources.
- Emma Roth, “Anthropic launches tool to connect AI systems directly to datasets” (The Verge, Nov 25, 2024) — news coverage of the MCP launch; confirms the “USB-C port for AI” framing and the standard-protocol pitch.
- Jonathan Kemper, “Claude Code now remembers your fixes, your preferences, and your project quirks on its own” (The Decoder, Feb 27, 2026) — news coverage of the auto-memory feature; confirms the
MEMORY.mdper-project file and the~/.claude/projects/directory structure. - How Claude remembers your project — Claude Code Docs — official documentation for
CLAUDE.mdfiles and the auto-memory system.
I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].
-
Native terminal coding agents command center. Run 50+ coding agents in parallel.
-
Declutter your JavaScript & TypeScript projects
Project linter to find unused dependencies, exports and files
Programming Tools Dev links code javascript software engineering
-
Quarkdown | Markdown with superpowers
Quarkdown is a modern, open-source, Markdown-based typesetting system for creating papers, presentations, knowledge bases and static websites.
-
Pandoc vs MarkItDown: Two Tools, Two Eras
Pandoc has been the gold standard for document conversion for nearly two decades. But there’s a newer tool from Microsoft called MarkItDown, and while the names sound like they do similar things, they were built for completely different reasons.
Pandoc is a universal document converter designed for human publishing. It converts almost any format into almost any other format while preserving complex typography, citations, and formatting. MarkItDown is a specialized extraction tool designed for AI. It converts various files strictly into Markdown so that LLMs and RAG pipelines can read and process the text.
Same input files, very different goals.
Pandoc: The Universal Translator
Pandoc has been around since 2006, written in Haskell, and it operates on an Abstract Syntax Tree. It reads a document, builds a complex internal model of its structure, and then translates that structure into your desired output. We’re talking 40+ output formats here. PDF, Word, HTML, LaTeX, EPUB, you name it.
Where it really shines is academic and technical writing. It natively understands LaTeX math, footnotes, bibliographies, and cross-referencing. You can turn a Word doc into Markdown, edit it, and use Pandoc to turn it back into a perfectly formatted PDF. Two-way conversion that actually works.
You can also write custom filters in Lua or Python to programmatically alter documents during conversion. Want to automatically downgrade all your H2s to H3s? Pandoc has you covered.
MarkItDown: The LLM Feeder
MarkItDown was released by Microsoft in late 2024 to solve a very modern problem. LLMs need clean, structured text to “read” documents, but corporate data is locked inside messy formats like multi-tab Excel spreadsheets, image-heavy PowerPoints, and ZIP archives.
It’s a Python library first, CLI second. It drops into your scripts in a few lines of code, which makes it easy to wire up with LangChain, LlamaIndex, or raw API calls. The output is always Markdown. That’s it. No PDF generation, no Word docs, no EPUB. Just clean text that an AI can process.
The interesting trick is what it does with images and audio. Feed it a PDF with diagrams and MarkItDown can connect to an LLM like GPT-4o to look at the image and write a Markdown description of what it sees. It can also transcribe audio files. That’s a fundamentally different approach from Pandoc, which preserves images as files rather than describing them.
Quick Comparison
Feature Pandoc MarkItDown Primary Goal Universal document conversion Document ingestion for AI Output Formats 40+ (PDF, Word, HTML, LaTeX, etc.) Only Markdown Language Haskell (standalone CLI) Python (library-first) Image Handling Preserves and extracts image files Uses OCR/LLM Vision to describe images as text Complex Formatting Citations, bibliographies, LaTeX math, custom filters Basic structural support (headings, tables, slides) So Which One Do You Want?
Pandoc if you’re writing a book, research paper, or blog and need polished output in multiple formats. If you need to maintain citations, complex formatting, or convert files out of Markdown into something else, Pandoc is your tool.
MarkItDown if you’re building an AI agent, chatbot, or search tool and need to extract text from a pile of PDFs, Excel files, and PowerPoints. If you only care about getting raw structured text and don’t care about the visual layout of the original document, MarkItDown is purpose-built for that.
They’re not competitors. Pandoc is for publishing. MarkItDown is for feeding AI. Pick the one that matches what you’re actually trying to do.
I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].
-
What Companies Are Actually Paying for Application Security
In the Application Security Testing (AST) market, Static Application Security Testing (SAST) and Software Composition Analysis (SCA) represent the two most critical pillars of preventative cyber defense.
So as a part of that, we should talk about the thing that people normally can’t or don’t talk about and that is cost. Vendors like to hide their pricing behind “contact sales” buttons, and buyers end up negotiating based on hard to find information.
So here’s an unofficial look at what companies are actually paying, pulled from a Deep Research report provided by Gemini. At the very end there is a list of resoruces where you can learn more about these subjects. However it is important to mention, there are not a lot of viable options for the home/hobby market.
What the Market Looks Like
Vendor Average Mid-Market / SMB Spend (Annual) Average Large Enterprise Spend (Annual) Economic Dynamics and Negotiation Factors Snyk ~$47,428 ~$222,516 Costs scale rapidly with developer headcount. Highly susceptible to volume discounting. Total cost includes separate quoting for onboarding and services. Black Duck (Coverity) $60,000 – $120,000 (50-100 devs) $150,000 – $300,000+ (150+ devs) Full platform deployments (SAST + SCA) often range from $300k to $600k+. Volume discounts and custom enterprise agreements are typical. Premium support adds 20-30%. Checkmarx $35,000 – $75,000 $100,000 – $250,000+ Pricing is considered complex. Hidden costs include mandatory professional services, premium support, and infrastructure overhead, adding 15-35% to year-one totals. Veracode $40,000 – $80,000 $100,000 – $250,000+ Application-based pricing feels predictable until microservice architectures cause application counts to explode. Discounts are heavily available for SAST+DAST+SCA bundles. SonarQube $30,000 – $50,000 (up to 5M LOC) $80,000 – $180,000 (5M - 20M+ LOC) Highly predictable LOC model. However, self-managed deployments incur separate infrastructure and administrative overhead costs not reflected in the software license. HCL AppScan $50,000+ $100,000 – $500,000+ Unified platform pricing for large deployments can easily exceed $1M. Implementations often require months of setup and heavy professional service fees. Official Licensing Models and Published Structures
Vendor / Platform Primary Pricing Metric Published Entry-Level / Standard Tier Pricing Enterprise Pricing Status Key Inclusions & Pricing Caveats Snyk Per Contributing Developer Team Tier: ~$52–$98 per developer/month ($624–$1,176/year). Custom / Unpublished Includes Snyk Code (SAST) and Open Source (SCA). Enterprise plans drop per-seat costs at high volume but require minimum seat counts. SonarQube Lines of Code (LOC) Analyzed Developer Edition: ~$15,000 for 1M LOC. Smaller tiers available (e.g., ~$2,500 for 100k LOC). Annual Pricing; Talk to Sales Prices scale strictly by the largest branch of private projects. Enterprise Edition adds legacy languages. Advanced Security is an add-on. GitHub Advanced Security Per Active Committer $19/user/month (Secrets) + $30/user/month (Code) = $49/user/month. Custom / Add-on to Enterprise ($21/user base) GHAS is strictly an add-on to the GitHub Enterprise plan. Tied directly to commit activity within a 30-day window. Mend.io Per Contributing Developer AppSec Platform: Up to $1,000 per developer/year. Included in upper bound limit Includes SAST, SCA, Renovate, and AI Inventory. No limits on LOC, scans, or applications. AI Premium is an extra $300/dev. Checkmarx Custom (Historically Per App or Node) Team Plans: ~$1,188/year base. Enterprise base starts ~$6,850/year. Custom / Unpublished Highly modular pricing based on developer count, module selection (SAST, SCA, DAST), and deployment model. Veracode Per Application or Per Scan Basic plans start at ~$15,000/year for up to 100 applications. Custom / Unpublished Pricing heavily depends on application count, scan frequency, and support levels. SCA alone starts around $12,000/year. Black Duck (Coverity) Per Team Member / Custom Coverity SAST: $800–$1,500 per team member annually. Custom / Unpublished Pricing scales with user access. Often bundled. Perpetual licenses with 18-22% annual maintenance fees exist for legacy deployments. Contrast Security Custom (GiB hour / usage) Essential tier: $119/mo. Advanced: $359/mo. Enterprise base ~$6,850/yr. Custom / Unpublished Pricing varies by package (AST vs. Contrast One managed service) and workload throughput. HCL AppScan Per Scan / Enterprise License SaaS: ~$313 per scan (min 5 scans). Basic Codesweep: $29.99/scan. Custom / Unpublished Enterprise suite pricing is highly customized, often requiring significant upfront capital expenditure. Feature Comparison
Feature / Capability Snyk Veracode Black Duck Checkmarx Mend.io GitHub (GHAS) SonarQube Endor Labs Primary Strength Developer Adoption & Speed Enterprise Governance & Low FPs License Compliance & Deep SAST Unified ASPM & Repo Scanning Automated Remediation Native Ecosystem Integration Code Quality & Baseline Security Noise Reduction & Reachability Reachability Analysis Basic No No No Advanced No No Full-Stack (95% reduction) Automated AI Fixes Yes (DeepCode) Yes (Proprietary Data) No Yes (Limited IDE) Yes Yes (Copilot) Yes (CodeFix) Yes (Without upgrades) Compilation Required No Yes (Binary) Yes (Coverity) No No No No No Broad Language Support High (14+) Very High (100+) High (22+) High (35+) Very High (200+) Moderate High (40) Moderate License Compliance Moderate Moderate Enterprise-Grade Moderate Enterprise-Grade Basic Basic Moderate Learning
-
Just: The Command Runner
If you’ve ever used
maketo run commands, it works, but you’re using a build system as a command runner. Just is a dedicated command runner that does exactly what you want and doesn’t come with all the baggage.Created by Casey Rodarmor about a decade ago (it turns 10 this June), Just is written in Rust and laser-focused on being a really good command runner. That’s it; just a clean way to define and run commands.
Why I Use It
On a lot of my projects, I use Just in conjunction with Mise. Mise does a fine job as a task runner, but when I want something more expressive for command orchestration, Just is what I reach for.
For example, I’ve got a lot of really long Python commands these days. I’m injecting environment variables at runtime, calling Poetry, then running Python with specific arguments. There’s a ton of boilerplate you have to type out every time. I don’t want to remember all of that, and I definitely don’t want to go digging through my shell history or copy-pasting from a README.
Just simplifies that. Define it once in a
justfile, and now your common commands are nowjust <recipe>.Modules Changed the Game
Something I started using recently is Just’s module system, which with it you can create separate
.justfiles and have your mainjustfileimport them as submodules. This lets you group related commands naturally.So instead of flat recipes like:
just test-cover just test-unit just test-integrationYou can organize them into modules:
just test cover just test unit just test integrationIt’s a small change, but it makes your command surface feel a lot more intuitive, especially as your project grows and you accumulate dozens of commands.
Getting Started
If you want to dig deeper, Casey wrote a great walkthrough called Tour de Just that covers the highlights. The official documentation is great too.
Just is commercially friendly, widely packaged, and easy to install on pretty much any platform. If you find it useful, you should consider sponsoring Casey on GitHub. Open source maintainers deserve support for tools we rely on daily.
-
I'm Just Going to Use Zed
I’ve been thinking about my editor setup and I wanted to work through the costs out loud. This post is mainly for me, but maybe it helps you too.
Here’s where I landed: I’m canceling(ed) JetBrains and Cursor, and just using Zed.
I know that might sound crazy. JetBrains All Products has been my go-to for a while now, and Cursor was interesting for a bit, but turns out all I needed was speed and cheap.
The Cost Breakdown
Editor Monthly Cost Yearly Cost Zed Pro $10.00 $120.00 Cursor Pro $20.00 $240.00 ($192 if billed annually) JetBrains All Products ~$14.92 $179.00 Zed Pro at $10/month is the cheapest option by a decent margin. That’s $120 a year versus $179 for JetBrains or up to $192 for Cursor. Not a huge difference money, but it adds up.
Zed Is Enough
My primary way of working these days is Zed plus CLI-based tools. I use Claude Code in the terminal (Mostly Ghostty) alongside the IDE, and that combination handles everything. The editor itself is fast, the AI integration is solid.
I already canceled Cursor. It’s a good product, but not at double what Zed costs. Maybe I’ll go back and try it again at some point, but right now there’s no reason to do that.
Sometimes the right move is just picking what works and not overthinking it.
-
Voice-to-Text in 2026: The Tools and Models Worth Knowing About
As natural language becomes a bigger part of how we build software, it’s worth looking at the state of transcription models. What’s the best way to get voice to text right now?
For a lot of people, talking to your computer is faster than typing. You can stream-of-thought your way through an idea, prompt your tools, and get things moving without your fingers being the bottleneck. If you haven’t tried it yet, it will change how you work with your machine. I’m not exaggerating.
The Tools
Here’s what people are actually using for desktop voice-to-text:
- Willow Voice — Popular choice, lots of people swear by it
- SuperWhisper — My current pick
- Wispr Flow — Another well-regarded option
- Voice Ink — Worth a look?
- Aiko — From an Open Source dev, Sindre Sorhus
- MacWhisper — Solid Mac-native option
I’ve tried several of these, and the biggest pain point for people is going to be that many require monthly subscriptions. I’ve been happy with SuperWhisper and it is worth mentioning they still have a pay for it once (Lifetime) option, so you don’t get locked into monthly payments forever. That said, Willow Voice and Wispr Flow both have strong followings.
The Models Behind the Magic
Most of these tools started with OpenAI’s Whisper, the voice model released and open-sourced back in 2022. With Whisper, you could run solid transcription locally on your own hardware.
But we’re a few years past that now, and there are some more models to choose from. Here is a summary table of the current state of the transcription models.
---Model Company Released Local Run? Used in Desktop Tools? Best For Whisper Large-v3 OpenAI Nov 2023 Yes Yes (The Standard) Multilingual accuracy (99+ langs) Whisper v3 Turbo OpenAI Oct 2024 Yes Yes (Fast Settings) Best speed-to-accuracy ratio for local use Nova-3 Deepgram Apr 2025 Self-Host Limited (API-based) Real-time agents; handling messy background noise Parakeet TDT 1.1B NVIDIA May 2025 Yes Developer-focused / CLI Ultra-low latency; significantly faster than Whisper SenseVoice-Small Alibaba July 2024 Yes Emerging (Fringe) High-precision Mandarin/English and emotion detection Canary-1B NVIDIA Oct 2025 Yes Developer-focused Beating Whisper on technical jargon & punctuation Voxtral Mini V2 Mistral Feb 2026 Yes Yes (Privacy apps) High-speed local transcription on low-VRAM devices Granite Speech 3.3 IBM Jan 2026 Yes No (Enterprise focus) Reliable technical ASR with an Apache 2.0 license Scribe v2 ElevenLabs Jan 2026 No Via API Extremely lifelike punctuation and speaker labels We’re at an interesting inflection point. You can articulate your thoughts faster by speaking than typing, its becoming a real productivity gain. It’s not just an accessabiltiy aid anymore. People who can type well enough are using these tools on a daily basis.
That’s all for now!
-
I got tired of plaintext .env files, so I built LSM.
lsm execwill inject secrets at runtime so they never touch the filesystem. Doppler’s idea, minus the monthly bill.How are you managing local secrets?
-
I switched to mise for version management a month ago. No regrets. No more
brew upgradebreaking Python. Built-in task runner replaced some of projects that were using Makefiles.Still juggling nvm + pyenv + rbenv?
-
I wrote about why you should stop using pip. Poetry or uv. Pick one. pip has no lockfile, no dependency resolution worth trusting, and no isolation by default.
Have you moved to uv yet? Still happy with poetry? How’s it going?
-
I compared npm, Yarn, pnpm, and Bun. TLDR version: pnpm wins for most teams, Bun wins if you’re already on the runtime.
Has anyone switched their whole team to Bun yet? How’d that go?
-
Wrote a guide on writing a good CLAUDE.md. Takeaway: keep it under 200 lines. Every line loads into context every session, so bloat costs real tokens.
How are you handling multiple AI context files across tools?