Developer Voices

AI is changing the way we all build software — that much seems clear. But the landscape is moving so fast that even the people paid to keep up are struggling. MCP or skills? Fine-tune or just prompt? LangChain or let a thousand agents loose? With almost 70 competing technologies and a shelf life of maybe six months on any advice, how do you figure out what's actually worth your time?
Henry Garner is CTO of JUXT, a consultancy with about 150 senior engineers working at the coalface of AI-assisted development, including building AI platforms for tier-one banks. JUXT publishes a quarterly AI Radar — 68 technologies rated and reviewed — and Henry's been watching his own team go through the full adoption arc, from "spicy autocomplete" skepticism through to building Byzantine-fault-tolerant distributed systems over a weekend with Claude. Along the way we cover MCP vs skills, Conway's Law for LLMs, neurosymbolic AI and the unexpected return of Prolog, the "Ralph Wiggum loop" for getting agents to converge on correct implementations, and Allium — a new behavioral specification language Henry's co-authored that sits between human prose and TLA+, aiming to give LLMs just enough structure to pin down what a system should do without falling into waterfall thinking.
If you're trying to make sense of the AI tooling landscape, or you've hit that wall where your agents keep drifting away from what you actually wanted, Henry's thesis — velocity through clarity of intent — might well help out yours.
--

Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join

JUXT: https://www.juxt.pro/
JUXT AI Radar: https://www.juxt.pro/ai-radar/
Allium on GitHub: https://github.com/juxt/allium
Allium Documentation: https://juxt.github.io/allium/

Composition at a Distance (Henry's blog post): https://www.juxt.pro/blog/composition-at-a-distance/
A New Vocabulary for an Old Problem (Henry's blog post): https://www.juxt.pro/blog/new-vocabulary-for-an-old-problem/
Model Context Protocol (MCP): https://modelcontextprotocol.io/
LangChain: https://www.langchain.com/
LangGraph: https://www.langchain.com/langgraph
Gas Town (Steve Yegge): https://github.com/steveyegge/gastown
Kiro (spec-driven AI IDE): https://kiro.dev/
Phoenix (LLM observability): https://github.com/Arize-ai/phoenix
Temporal: https://temporal.io/
Taalas (LLM-on-a-chip): https://taalas.com/

Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

I have a theory that only bad projects get finished — good ones keep finding new things to do. Asciinema is a case in point. What started as a way to share terminal sessions with friends has, over 14 years, grown into a full suite of tools covering recording, hosting, playback, and live streaming — and been rebuilt multiple times along the way. So what does it actually take to record and replay a terminal session faithfully in a browser?
Joining us for this conversation is Marcin Kulik, Asciinema's creator. The project's architecture has passed through almost every interesting corner of software engineering: a Python recorder built around pseudo-terminals (PTY), a ClojureScript terminal emulator for the browser that hit performance limits with immutable data structures and garbage collection pressure, a move to Rust compiled to WebAssembly, a Go experiment that didn't last, and a new Rust CLI for concurrent live streaming backed by an Elixir/Phoenix server that calls Rust code via NIFs. The same Rust terminal emulator library now powers all three components — the browser player, the server, and the CLI.
If you've ever looked at those terminal animations embedded in a README and wondered what's underneath them, or if you're interested in how a passionate open-source developer navigates 14 years of language changes and rewrites, this conversation has plenty to offer.
---
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join
Asciinema: https://asciinema.org
Asciinema Docs: https://docs.asciinema.org
Asciinema CLI (GitHub): https://github.com/asciinema/asciinema
Asciinema Player (GitHub): https://github.com/asciinema/asciinema-player
Asciinema Server (GitHub): https://github.com/asciinema/asciinema-server
AVT - Rust terminal emulator library: https://github.com/asciinema/avt
vt-clj - the original ClojureScript terminal emulator: https://github.com/asciinema/vt-clj
Paul Williams' ANSI/VT100 State Machine Parser: https://vt100.net/emu/dec_ansi_parser
Rust: https://www.rust-lang.org
WebAssembly: https://webassembly.org
SolidJS: https://www.solidjs.com
Elixir: https://elixir-lang.org
Phoenix Framework: https://www.phoenixframework.org
Rustler (Rust NIFs for Elixir/Erlang): https://github.com/rusterlium/rustler
Clojure: https://clojure.org
ClojureScript: https://clojurescript.org
cmatrix: https://github.com/abishekvashok/cmatrix
Marcin Kulik on GitHub: https://github.com/ku1ik
Marcin Kulik on Mastodon: https://hachyderm.io/@ku1ik
Marcin Kulik on asciinema.org: https://asciinema.org/~ku1ik
"They're Made Out of Meat" demo: https://asciinema.org/a/746358
Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
---
0:00 Intro
2:28 What Is Asciinema?
4:48 How Asciinema Started
9:51 The Problem of Parsing Terminal Output
14:07 Building a Cross-Platform Recorder
17:01 Rewriting the Parser in ClojureScript
22:19 The Hidden Complexity of Terminals
29:28 Rendering Terminals in the Browser
39:47 When ClojureScript Can't Keep Up
45:28 Moving to Rust and WebAssembly
52:01 The Go Experiment
57:43 Adding Live Terminal Streaming
1:07:12 Can You Scrub Back in a Live Stream?
1:14:40 Editing Recordings
1:25:27 Outro

Eighteen months ago, Tyler Cloutier appeared on the show with what sounded like an ambitious (some might say crazy) plan: build a new distributed database from scratch, then use it to power a massively multiplayer online game. That's two of the hardest problems in software, tackled simultaneously. But sometimes the best infrastructure comes from solving your own impossible problems.
The game, Bitcraft, has now launched on Steam. SpacetimeDB has hit version 1.0. And Tyler returns to share what actually happened when theory met production reality. We cover the launch day performance disasters (including a cascading failure caused by logging while holding a lock), why single-threaded execution running entirely from L1 cache can outperform sophisticated multi-threaded approaches by two orders of magnitude, and how the database's reducer model - borrowed from functional programming - enables zero-downtime code deployments. We also get into how SpacetimeDB is expanding beyond games with TypeScript support and React hooks that make building real-time multiplayer web apps surprisingly simple.
If you're building anything where multiple users need to see the same data update in real time - which, as Tyler points out, describes most successful applications from Figma to Facebook - SpacetimeDB's approach of treating every app as a multiplayer game might be worth understanding.
--
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join
SpacetimeDB: https://spacetimedb.com/
SpacetimeDB on GitHub: https://github.com/clockworklabs/SpacetimeDB
Our previous episode with Tyler: https://youtu.be/roEsJcQYjd8

Clockwork Labs: https://clockworklabs.io/
Bitcraft Online: https://bitcraftonline.com/
Bitcraft on Steam: https://store.steampowered.com/app/3454650/BitCraft_Online
WebAssembly: https://webassembly.org/
Flecs (ECS for C/C++): https://www.flecs.dev/flecs/
TigerBeetle: https://tigerbeetle.com/
CockroachDB: https://www.cockroachlabs.com/
Google Cloud Spanner: https://cloud.google.com/spanner
Erlang: https://www.erlang.org/
Apache Kafka: https://kafka.apache.org/
Tyler Cloutier on X: https://x.com/TylerFCloutier
Tyler Cloutier on LinkedIn: https://www.linkedin.com/in/tylercloutier/
--
Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
0:00 Intro
2:01 The Architecture of SpacetimeDB
5:01 Client-Side Prediction in Multiplayer Games
11:00 Reducers and Event Streaming
15:00 Launching Bitcraft on Steam
19:00 Debugging Launch Performance Problems
26:56 Hot-Swapping Server Code Without Downtime
30:01 In-Memory Tables and Query Optimization
42:00 Is SpacetimeDB Only For Games?
51:00 Performance Benchmarking For Web Workloads
55:00 Why Single-Threaded Beats Multi-Threaded
1:00:01 Multi-Version Concurrency Control Trade-offs
1:05:01 Sharding Data Across Multiple Nodes
1:10:56 Inter-Module Communication and Actor Models
1:17:00 Replication and the Write-Ahead Log
1:24:00 Supported Client Languages
1:29:00 Getting Started With SpacetimeDB
1:39:02 Outro

SQLite is embedded everywhere - phones, browsers, IoT devices. It's reliable, battle-tested, and feature-rich. But what if you want concurrent writes? Or CDC for streaming changes? Or vector indexes for AI workloads? The SQLite codebase isn't accepting new contributors, and the test suite that makes it so reliable is proprietary. So how do you evolve an embedded database that's effectively frozen?
Glauber Costa spent a decade contributing to the Linux kernel at Red Hat, then helped build Scylla, a high-performance rewrite of Cassandra. Now he's applying those lessons to SQLite. After initially forking SQLite (which produced a working business but failed to attract contributors), his team is taking the bolder path: a complete rewrite in Rust called Turso. The project already has features SQLite lacks - vector search, CDC, browser-native async operation - and is using deterministic simulation testing (inspired by TigerBeetle) to match SQLite's legendary reliability without access to its test suite.
The conversation covers why rewrites attract contributors where forks don't, how the Linux kernel maintains quality with thousands of contributors, why Pekka's "pet project" jumped from 32 to 64 contributors in a month, and what it takes to build concurrent writes into an embedded database from scratch.
--
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join
Turso: https://turso.tech/
Turso GitHub: https://github.com/tursodatabase/turso
libSQL (SQLite fork): https://github.com/tursodatabase/libsql
SQLite: https://www.sqlite.org/
Rust: https://rust-lang.org/
ScyllaDB (Cassandra rewrite): https://www.scylladb.com/
Apache Cassandra: https://cassandra.apache.org/
DuckDB (analytical embedded database): https://duckdb.org/
MotherDuck (DuckDB cloud): https://motherduck.com/
dqlite (Canonical distributed SQLite): https://canonical.com/dqlite
TigerBeetle (deterministic simulation testing): https://tigerbeetle.com/
Redpanda (Kafka alternative): https://www.redpanda.com/
Linux Kernel: https://kernel.org/
Datadog: https://www.datadoghq.com/
Glauber Costa on X: https://x.com/glcst
Glauber Costa on GitHub: https://github.com/glommer
Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
--
0:00 Intro
3:16 Ten Years Contributing to the Linux Kernel
15:17 From Linux to Startups: OSv and Scylla
26:23 Lessons from Scylla: The Power of Ecosystem Compatibility
33:00 Why SQLite Needs More
37:41 Open Source But Not Open Contribution
48:04 Why a Rewrite Attracted Contributors When a Fork Didn't
57:22 How Deterministic Simulation Testing Works
1:06:17 70% of SQLite in Six Months
1:12:12 Features Beyond SQLite: Vector Search, CDC, and Browser Support
1:19:15 The Challenge of Adding Concurrent Writes
1:25:05 Building a Self-Sustaining Open Source Community
1:30:09 Where Does Turso Fit Against DuckDB?
1:41:00 Could Turso Compete with Postgres?
1:46:21 How Do You Avoid a Toxic Community Culture?
1:50:32 Outro

How do you build systems with AI? Not code-generating assistants, but production systems that use LLMs as part of their processing pipeline. When should you chain multiple agent calls together versus just making one LLM request? And how do you debug, test, and deploy these things? The industry is clearly in exploration mode—we're seeing good ideas implemented badly and expensive mistakes made at scale. But Google needs to get this right more than most companies, because AI is both their biggest opportunity and an existential threat to their search-based business model.
Christina Lin from Google joins us to discuss Agent Development Kit (ADK), Google's open-source Python framework for building agentic pipelines. We dig into the fundamental question of when agent pipelines make sense versus traditional code, exploring concepts like separation of concerns for agents, tool calling versus MCP servers, Google's grounding feature for citation-backed responses, and agent memory management. Christina explains A2A (Agent-to-Agent), Google's protocol for distributed agent communication that could replace both LangChain and MCP. We also cover practical concerns like debugging agent workflows, evaluation strategies, and how to think about deploying agents to production.
If you're trying to figure out when AI belongs in your processing pipeline, how to structure agent systems, or whether frameworks like ADK solve real problems versus creating new complexity, this episode breaks down Google's approach to making agentic systems practical for production use.
--
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join

Google Agent Development Kit Announcement: https://developers.googleblog.com/en/agent-development-kit-easy-to-build-multi-agent-applications/
ADK on GitHub: https://google.github.io/adk-docs/

Google Gemini: https://ai.google.dev/gemini-api
Google Vertex AI: https://cloud.google.com/vertex-ai
Google AI Studio: https://aistudio.google.com/
Google Grounding with Google Search: https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/overview

Model Context Protocol (MCP): https://modelcontextprotocol.io/
Anthropic MCP Servers: https://github.com/modelcontextprotocol/servers
LangChain: https://www.langchain.com/

Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/