Write once, distribute everywhere.

Agents are good at breadth and depth (in different contexts). Your software has some core set of functionality that you expose to clients through interfaces. That client may be software, human, or an AI agent (really just software again).

I prefer to optimize for ease of breadth of clients & depth in the core library. I use Rust as my core systems language, typically with Python bindings (and sometimes JavaScript). One example of this approach is ascend-tools and another is bookmarks.

In both cases, the core functionality is implemented in Rust. The interfaces exist at several levels:

  • packages: GitHub releases, PyPI, npm (ascend-tools only), crates.io
  • SDKs: Python, JavaScript, Rust
  • UIs: CLI, TUI (ascend-tools only), MCP server (ascend-tools only), desktop application (bookmarks only), web application (bookmarks only)

The CLI is a Rust function. It’s passed through to Python (and npm in this case), so it’s the same CLI (and TUI and MCP server) no matter where you consume the code from. Similarly, the Python and JavaScript and Rust SDKs are all functionally equivalent.

breadth on interfaces #

Agents excel at the menial task of maintaining Python & JavaScript bindings, writing the CI & release pipelines, and much more. This allows you to quickly & confidently ship features across many interfaces. I could easily add a MCP server for my bookmarks.

depth on the core #

The core of whatever code requires thought and rigorous engineering. Agents are good, when properly harnessed, at this as well.

together, a new template for awesome software #

I’ve always wanted to maintain a pristine starter template for software projects. But things change – uv didn’t exist a few years ago and best practices & tooling constantly evolve. I always end up grabbing code from my most recent project(s) and going from there.

Now, I do the same with agents. I really like this pattern for writing the core code with depth of engineering once, and exposing it everywhere with ease. And agents make it trivial to duplicate. I can refine the meta-engineering across projects and easily distribute the benefits in parallel.

on languages #

The language choices here matter less than the architecture. You could use Go instead of Rust, though I suspect we’ll see the benefits of Rust over Go for agentic engineering and I prefer it for now. With the right setup, you can operate with confidence at high velocity.