←
Superlinear210 posts
Superlinear avatar

Superlinear

@superlinear_fm

Discover what's next in building software with coding agents. Every week, we explore emerging ideas and tools. Podcast hosted by @bkase_ and @christinetyip.

◷ Joined July 2026▧ 48 Photos and videos
Superlinear avatar
Superlinear@superlinear_fm·Nov 12

3 tools we tried last week made us rethink how much performance we're leaving on the table with coding agents: -@kitlangton's Rune -@ccheever's Exact -@wvo's Goose We got 2x faster JSON processing than jaq, and 2x performance with 8x less memory on our app. Here's what we did and where they're useful: 1. Goose (@wvo) is a memory-safe programming language built for speed, with no heap allocation. Particularly interesting for JSON parsing, compilers, log processing, and other CPU-heavy tools. Our agents use jq or equivalent scripts ~6,000 times/month, so we had Codex port jaq (the Rust implementation of jq) to Goose. Results on an Apple M4: - ~3x faster on existing jq benchmarks - ~2x faster on fresh holdout benchmarks 2. Rune (@anomalyco, @kitlangton) is a native UI framework that is interesting for replacing Electron apps and making UI iteration faster, bc it has hot reloading, deterministic replay, and agent-observable UI state. We used Codex to port a feature of our existing Swift transcription app, including its UI, design system, and animations. - Working desktop port in ~4 hours - iOS support added in 12 minutes, even though it was still on Rune's roadmap - iOS hot reloading working in another 12 minutes! - 3. Exact (@expo, @ccheever) uses a custom UI DSL, bytecode compilation, and ahead-of-time computation to enable fast startup and iteration. We had Codex port the same feature to Exact on desktop and iOS in just 30 minutes, including benchmarking memory usage (RSS). Both frameworks delivered similar performance in our experiments: ~2x performance and 8x lower memory compared to web, while retaining sub-second iteration cycles. What's really cool is that we can so easily experiment with new, niche programming languages and frameworks now with coding agents. You can just find a bottleneck, give your agent the existing implementation, tests, and benchmarks, and let it explore alternatives. No reason anymore not to push further! Reminder: Keep an unseen eval set separate so it can't benchmax things. Really great work from @anomalyco (OpenCode's team), @expo, and @wvo! We talk through what we did, how, and things that surprised us along the way in the conversation. 🧵👇 Links to YouTube, Apple Podcasts, and Spotify are below. 00:00 Speed up with coding agents 01:36 Goose: a programming language built for speed 05:51 Rune: native UI with fast agent feedback 06:57 Exact: fast iteration for native UI 09:40 Porting to desktop and iOS 13:14 Example: rewriting jaq in Goose 21:07 Benchmark overfitting 25:46 Summary workflow 27:30 New tools: risks and tradeoffs 30:29 Next episode: faster software without changing languages

31:38
Adam Foster avatar
⟳ Superlinear retweeted
Adam Foster@AdamFoster_1·Nov 13

Coding agents make it way easier to test new tools against real workloads. Finding out what actually fits your stack just got a lot cheaper

3 tools we tried last week made us rethink how much performance we're leaving on the table with coding agents: -@kitlangton's Rune -@ccheever's Exact -@wvo's Goose We got 2x faster JSON processing than jaq, and 2x performance with 8x less memory on our app. Here's what we did and where they're useful: 1. Goose (@wvo) is a memory-safe programming language built for speed, with no heap allocation. Particularly interesting for JSON parsing, compilers, log processing, and other CPU-heavy tools. Our agents use jq or equivalent scripts ~6,000 times/month, so we had Codex port jaq (the Rust implementation of jq) to Goose. Results on an Apple M4: - ~3x faster on existing jq benchmarks - ~2x faster on fresh holdout benchmarks 2. Rune (@anomalyco, @kitlangton) is a native UI framework that is interesting for replacing Electron apps and making UI iteration faster, bc it has hot reloading, deterministic replay, and agent-observable UI state. We used Codex to port a feature of our existing Swift transcription app, including its UI, design system, and animations. - Working desktop port in ~4 hours - iOS support added in 12 minutes, even though it was still on Rune's roadmap - iOS hot reloading working in another 12 minutes! - 3. Exact (@expo, @ccheever) uses a custom UI DSL, bytecode compilation, and ahead-of-time computation to enable fast startup and iteration. We had Codex port the same feature to Exact on desktop and iOS in just 30 minutes, including benchmarking memory usage (RSS). Both frameworks delivered similar performance in our experiments: ~2x performance and 8x lower memory compared to web, while retaining sub-second iteration cycles. What's really cool is that we can so easily experiment with new, niche programming languages and frameworks now with coding agents. You can just find a bottleneck, give your agent the existing implementation, tests, and benchmarks, and let it explore alternatives. No reason anymore not to push further! Reminder: Keep an unseen eval set separate so it can't benchmax things. Really great work from @anomalyco (OpenCode's team), @expo, and @wvo! We talk through what we did, how, and things that surprised us along the way in the conversation. 🧵👇 Links to YouTube, Apple Podcasts, and Spotify are below. 00:00 Speed up with coding agents 01:36 Goose: a programming language built for speed 05:51 Rune: native UI with fast agent feedback 06:57 Exact: fast iteration for native UI 09:40 Porting to desktop and iOS 13:14 Example: rewriting jaq in Goose 21:07 Benchmark overfitting 25:46 Summary workflow 27:30 New tools: risks and tradeoffs 30:29 Next episode: faster software without changing languages

31:38
Brandon Kase avatar
⟳ Superlinear retweeted
Brandon Kase@bkase_·Nov 12

Your tools and your own apps and services are not fast enough. Luckily, fast niche programming languages and frameworks are falling from the sky. And it's so easy to get started (and I'm loving every minute). Frontier agents like Gemini 4 Carbon and Fable 5.2 are simultaneously making it: * Tractable for individuals to make niche programming languages and frameworks * Easy to adopt both try and port codebases to these new tools @wvo 's Goose faster than safe Rust! And still safe! We proved it by porting jq, and even on holdout sets not benchmaxxed it is 2x faster and uses less memory than even the Rust version, jaq. Plus we recently got two new cool Rust cross-platform UI frameworks: 1. @anomalyco + @kitlangton 's Rune 2. @expo + @ccheever 's Exact Assuming you have a good harness in place to keep your agents on track, you can rewrite everything and be confident it's going to 'just work'. (and if you don't have a good harness set up, watch other episodes of our podcast!) Anyway, if you need help getting started or want to be inspired watch our latest episode! [I know I know, sometimes you really absolutely can't rewrite your codebase. In that case, we will have something for you in next week.]

3 tools we tried last week made us rethink how much performance we're leaving on the table with coding agents: -@kitlangton's Rune -@ccheever's Exact -@wvo's Goose We got 2x faster JSON processing than jaq, and 2x performance with 8x less memory on our app. Here's what we did and where they're useful: 1. Goose (@wvo) is a memory-safe programming language built for speed, with no heap allocation. Particularly interesting for JSON parsing, compilers, log processing, and other CPU-heavy tools. Our agents use jq or equivalent scripts ~6,000 times/month, so we had Codex port jaq (the Rust implementation of jq) to Goose. Results on an Apple M4: - ~3x faster on existing jq benchmarks - ~2x faster on fresh holdout benchmarks 2. Rune (@anomalyco, @kitlangton) is a native UI framework that is interesting for replacing Electron apps and making UI iteration faster, bc it has hot reloading, deterministic replay, and agent-observable UI state. We used Codex to port a feature of our existing Swift transcription app, including its UI, design system, and animations. - Working desktop port in ~4 hours - iOS support added in 12 minutes, even though it was still on Rune's roadmap - iOS hot reloading working in another 12 minutes! - 3. Exact (@expo, @ccheever) uses a custom UI DSL, bytecode compilation, and ahead-of-time computation to enable fast startup and iteration. We had Codex port the same feature to Exact on desktop and iOS in just 30 minutes, including benchmarking memory usage (RSS). Both frameworks delivered similar performance in our experiments: ~2x performance and 8x lower memory compared to web, while retaining sub-second iteration cycles. What's really cool is that we can so easily experiment with new, niche programming languages and frameworks now with coding agents. You can just find a bottleneck, give your agent the existing implementation, tests, and benchmarks, and let it explore alternatives. No reason anymore not to push further! Reminder: Keep an unseen eval set separate so it can't benchmax things. Really great work from @anomalyco (OpenCode's team), @expo, and @wvo! We talk through what we did, how, and things that surprised us along the way in the conversation. 🧵👇 Links to YouTube, Apple Podcasts, and Spotify are below. 00:00 Speed up with coding agents 01:36 Goose: a programming language built for speed 05:51 Rune: native UI with fast agent feedback 06:57 Exact: fast iteration for native UI 09:40 Porting to desktop and iOS 13:14 Example: rewriting jaq in Goose 21:07 Benchmark overfitting 25:46 Summary workflow 27:30 New tools: risks and tradeoffs 30:29 Next episode: faster software without changing languages

31:38
Christine Yip avatar
⟳ Superlinear retweeted
Christine Yip@christinetyip·Nov 12

What's really cool is that now with coding agents, it's so easy to experiment with new, niche programming languages and frameworks. Just find a bottleneck, and let the agent explore better alternatives using tools that focus on solving narrow tasks really well. Keep pushing!

3 tools we tried last week made us rethink how much performance we're leaving on the table with coding agents: -@kitlangton's Rune -@ccheever's Exact -@wvo's Goose We got 2x faster JSON processing than jaq, and 2x performance with 8x less memory on our app. Here's what we did and where they're useful: 1. Goose (@wvo) is a memory-safe programming language built for speed, with no heap allocation. Particularly interesting for JSON parsing, compilers, log processing, and other CPU-heavy tools. Our agents use jq or equivalent scripts ~6,000 times/month, so we had Codex port jaq (the Rust implementation of jq) to Goose. Results on an Apple M4: - ~3x faster on existing jq benchmarks - ~2x faster on fresh holdout benchmarks 2. Rune (@anomalyco, @kitlangton) is a native UI framework that is interesting for replacing Electron apps and making UI iteration faster, bc it has hot reloading, deterministic replay, and agent-observable UI state. We used Codex to port a feature of our existing Swift transcription app, including its UI, design system, and animations. - Working desktop port in ~4 hours - iOS support added in 12 minutes, even though it was still on Rune's roadmap - iOS hot reloading working in another 12 minutes! - 3. Exact (@expo, @ccheever) uses a custom UI DSL, bytecode compilation, and ahead-of-time computation to enable fast startup and iteration. We had Codex port the same feature to Exact on desktop and iOS in just 30 minutes, including benchmarking memory usage (RSS). Both frameworks delivered similar performance in our experiments: ~2x performance and 8x lower memory compared to web, while retaining sub-second iteration cycles. What's really cool is that we can so easily experiment with new, niche programming languages and frameworks now with coding agents. You can just find a bottleneck, give your agent the existing implementation, tests, and benchmarks, and let it explore alternatives. No reason anymore not to push further! Reminder: Keep an unseen eval set separate so it can't benchmax things. Really great work from @anomalyco (OpenCode's team), @expo, and @wvo! We talk through what we did, how, and things that surprised us along the way in the conversation. 🧵👇 Links to YouTube, Apple Podcasts, and Spotify are below. 00:00 Speed up with coding agents 01:36 Goose: a programming language built for speed 05:51 Rune: native UI with fast agent feedback 06:57 Exact: fast iteration for native UI 09:40 Porting to desktop and iOS 13:14 Example: rewriting jaq in Goose 21:07 Benchmark overfitting 25:46 Summary workflow 27:30 New tools: risks and tradeoffs 30:29 Next episode: faster software without changing languages

31:38
Christine Yip avatar
⟳ Superlinear retweeted
Christine Yip@christinetyip·Nov 5

I put a lot of thought into how to explain formal verification in a way that actually clicks for people. Getting feedback like this from someone who's worked in the field for years is incredibly motivating. 🥺

Fantastic episode by @bkase_ and @christinetyip! I've worked with formal verification tools for many years, and this is by far the best introduction to formal verification and model checking concepts I've seen, and why they matter. Surfacing problematic behaviors already at the design stage is super cool use case! Huge praise to @poteto and @mattpocockuk as well; their skills are amazing and super useful!

David Wong avatar
⟳ Superlinear retweeted
David Wong@cryptodavidw·Nov 5

Holy shit this podcast keeps on giving

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05
Brandon Kase avatar
⟳ Superlinear retweeted
Brandon Kase@bkase_·Nov 6

New skill for catching edge cases and surfacing product decisions before your agents code! * Ones that you didn’t realize (even when you rambled to your agent) * Ones that your agents didn’t realize (even after a grilling session interviewing you) This is my new go-to planning workflow for ui/ux features. It makes me confident my agents will handle these edge cases in ways that I expect and have reviewed. The secret: Don’t just formally verify your existing code. You can formally verify your hifi mockups with statecharts and @quint_lang too. Learn more about this in our latest Superlinear episode. And paste the GitHub link below to your agents to try it.

Post attachment

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05
zarinjo avatar
⟳ Superlinear retweeted
zarinjo@zarinjo·Nov 5

Fantastic episode by @bkase_ and @christinetyip! I've worked with formal verification tools for many years, and this is by far the best introduction to formal verification and model checking concepts I've seen, and why they matter. Surfacing problematic behaviors already at the design stage is super cool use case! Huge praise to @poteto and @mattpocockuk as well; their skills are amazing and super useful!

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05
Quint avatar
⟳ Superlinear retweeted
Quint@quint_lang·Nov 5

Formal methods are great tools for the design phase too! In the skills built by @bkase_ (based on @poteto’s pstack), you can use Quint to make decisions about the edge cases you and your agent missed while grilling. @superlinear_fm released a great episode showing how they use these skills, in a very visual way and with great examples!

Post attachment

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05
Christine Yip avatar
⟳ Superlinear retweeted
Christine Yip@christinetyip·Nov 5

Fun place to use @poteto's /statechart skill for formal verification *before* the agent does the implementation. It caught an edge case grilling missed, and after updating the spec, my coding agent built it correctly on the first pass. The workflow is pretty simple: 1. Model the feature's intended behavior in @quint_lang . 2. Define "promises" that must always hold, like "every reply stays with the question that triggered it." 3. Run a model checker (I used TLC) to find sequences of events that break those promises. 4. Feed the counterexamples back to the coding agent to fix the behavior or UI/UX. The cool part is that you're not just relying on the agent to think of every possible edge case (which it often doesn't). The checker systematically explores *all* the modeled possibilities and gives the agent concrete failing scenarios to work with. I hadn't thought of using formal verification this early in product design. Pretty cool how coding agents are making formal methods more accessible now, and opening up new places to apply them.

Post attachment

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05
Superlinear avatar
⟳ Superlinear retweeted
Superlinear@superlinear_fm·Nov 5

We found an interesting place to apply @poteto's /statechart skill: formally verifying our intent before writing any production code. It discovers edge cases that neither we nor our coding agent caught during grilling. Think of it as another layer on top of @mattpocockuk's /grill-me skill. Instead of relying on the agent to reason through every possible scenario, we use a model checker to systematically find where the intended behavior breaks. The result: a much more thoroughly specified feature before implementation. And when we handed it off to the coding agent, it built the feature correctly on the first pass. We recorded a walkthrough of the workflow, including a real example where a product decision was surfaced we didn't even realize we needed to make. Full episode also on YouTube, Apple Podcasts, and Spotify. Links below 👇 00:00 Catch edge cases before coding 01:54 Skill walkthrough 09:18 Explained: Model (we used @Quint_lang), promises, and checker 14:44 Q: Why a LLM misses this 17:24 Real example 26:07 Q: How to improve the model? 29:09 Q: How to make code match the model? 30:29 Q: Why formal verification? 34:15 Q: When to use or skip it? 38:06 Wrap-up and Discord

39:05