Discover what's next in building software with coding agents.
Every week, we explore emerging ideas and tools.
Podcast hosted by @bkase_ and @christinetyip.
Let your agent build on the shoulders of great engineers and it'll surprise you.
Genuinely impressed by how fast @theo and @jullerino's T3 Code (@t3dotcodes) feels.
We pointed our agent at T3 Code, it learned from it, and improved our code base: 40% lower idle CPU, 24% faster warm loads, and 3x faster message encoding
The agent learned from T3's approach to state management, push-based updates, memoization, and RPC architecture, then adapted those ideas to our codebase.
Huge credit to Theo, Julius, and the rest of the T3 Code team for the engineering behind this. Their team has clearly put serious engineering effort into performance.
It's pretty incredible that we can now point an agent at a great open-source project and build directly on the experience and iterations that went into it.
Going a step further, we combined high-performance reference repos with @karpathy's autoresearch loop (similar to hill climbing) on an Android app. The result: up to 14x faster processing on specific workloads.
An interesting finding was that references helped the agent implement better versions of the same optimization ideas.
👇 How to reproduce our workflow:
1. Pick a measurable bottleneck.
E.g., a slow CLI command, expensive database query, parser, or dashboard load.
2. Benchmark real production code.
Use representative workloads, fixed inputs, and a primary metric like latency, memory, or throughput.
3. Freeze the benchmark and correctness oracle.
Record the original implementation's outputs. Optimizations must preserve behavior, including edge cases.
4. Give the agent good references.
Find high-performance open-source projects that solve similar architectural problems. Let the agent study their implementations and propose hypotheses. Keep the evaluation rules outside its editable search space.
5. Run an autoresearch loop / start hill climbing.
Hypothesis → implement → verify correctness → benchmark → keep or revert. Give it a fixed time budget and record every attempt.
6. Test on unseen holdout data.
Don't let the agent optimize exclusively for the benchmarks it has been seeing.
7. Evaluate the tradeoffs.
Measure actual speedup, memory, correctness, patch complexity, and total agent time.
One more finding: references alone produced substantial improvements in just ~11 minutes. Autoresearch/hillclimbing took longer but found further gains.
We walk through both experiments and the full workflow in our latest Superlinear episode.
🧵 YouTube, Apple Podcasts, and Spotify links below.
00:00 Speed up apps on its existing stack
02:35 Method 1: Reference high performance projects (T3)
10:33 Example 1: Outcomes from Electron app
19:18 Example 2: Walkthrough Android app optimization
20:20 Method 2: Combine with autoresearch and hillclimbing
26:00 3 experiments & results: Method 1, 2, and combining both
35:04 Step-by-step optimization workflow
38:41 Wrap-up & next week with Goose lang creator @wvo
Let your agent build on the shoulders of great engineers and it'll surprise you.
Genuinely impressed by how fast @theo and @jullerino's T3 Code (@t3dotcodes) feels.
We pointed our agent at T3 Code, it learned from it, and improved our code base: 40% lower idle CPU, 24% faster warm loads, and 3x faster message encoding
The agent learned from T3's approach to state management, push-based updates, memoization, and RPC architecture, then adapted those ideas to our codebase.
Huge credit to Theo, Julius, and the rest of the T3 Code team for the engineering behind this. Their team has clearly put serious engineering effort into performance.
It's pretty incredible that we can now point an agent at a great open-source project and build directly on the experience and iterations that went into it.
Going a step further, we combined high-performance reference repos with @karpathy's autoresearch loop (similar to hill climbing) on an Android app. The result: up to 14x faster processing on specific workloads.
An interesting finding was that references helped the agent implement better versions of the same optimization ideas.
👇 How to reproduce our workflow:
1. Pick a measurable bottleneck.
E.g., a slow CLI command, expensive database query, parser, or dashboard load.
2. Benchmark real production code.
Use representative workloads, fixed inputs, and a primary metric like latency, memory, or throughput.
3. Freeze the benchmark and correctness oracle.
Record the original implementation's outputs. Optimizations must preserve behavior, including edge cases.
4. Give the agent good references.
Find high-performance open-source projects that solve similar architectural problems. Let the agent study their implementations and propose hypotheses. Keep the evaluation rules outside its editable search space.
5. Run an autoresearch loop / start hill climbing.
Hypothesis → implement → verify correctness → benchmark → keep or revert. Give it a fixed time budget and record every attempt.
6. Test on unseen holdout data.
Don't let the agent optimize exclusively for the benchmarks it has been seeing.
7. Evaluate the tradeoffs.
Measure actual speedup, memory, correctness, patch complexity, and total agent time.
One more finding: references alone produced substantial improvements in just ~11 minutes. Autoresearch/hillclimbing took longer but found further gains.
We walk through both experiments and the full workflow in our latest Superlinear episode.
🧵 YouTube, Apple Podcasts, and Spotify links below.
00:00 Speed up apps on its existing stack
02:35 Method 1: Reference high performance projects (T3)
10:33 Example 1: Outcomes from Electron app
19:18 Example 2: Walkthrough Android app optimization
20:20 Method 2: Combine with autoresearch and hillclimbing
26:00 3 experiments & results: Method 1, 2, and combining both
35:04 Step-by-step optimization workflow
38:41 Wrap-up & next week with Goose lang creator @wvo
Point your agents at open source projects close to your tech stack a they will build on the expertise of others to achieve greatness.
I think of it as inspiring your agents to help them write faster, cleaner, and better code!
@t3dotcodes is a work of art. Not just a good product, but @theo and @jullerino put so much work into the performance of this Electron app.
So when I wanted to increase performance of my Electron app, I pointed my agent at the T3 GitHub source to inspire my agents as I was grilling: this led to big wins like reducing view renders by 60% , idle cpu usage by 40% , and 3x more efficient message encoding in my project
@christinetyip built on top of this by combining it with a hillclimbing/autoresearch loop for her Android project to get even more performance out of this process.
Learn more in our episode this week!
Pretty incredible we can point a coding agent at open-source projects and build directly on the experience and iterations that went into it.
Our agent learned from @t3dotcodes (impressive engineering from @theo and @jullerino) and rebuilt our app with huge performance gains.
Let your agent build on the shoulders of great engineers and it'll surprise you.
Genuinely impressed by how fast @theo and @jullerino's T3 Code (@t3dotcodes) feels.
We pointed our agent at T3 Code, it learned from it, and improved our code base: 40% lower idle CPU, 24% faster warm loads, and 3x faster message encoding
The agent learned from T3's approach to state management, push-based updates, memoization, and RPC architecture, then adapted those ideas to our codebase.
Huge credit to Theo, Julius, and the rest of the T3 Code team for the engineering behind this. Their team has clearly put serious engineering effort into performance.
It's pretty incredible that we can now point an agent at a great open-source project and build directly on the experience and iterations that went into it.
Going a step further, we combined high-performance reference repos with @karpathy's autoresearch loop (similar to hill climbing) on an Android app. The result: up to 14x faster processing on specific workloads.
An interesting finding was that references helped the agent implement better versions of the same optimization ideas.
👇 How to reproduce our workflow:
1. Pick a measurable bottleneck.
E.g., a slow CLI command, expensive database query, parser, or dashboard load.
2. Benchmark real production code.
Use representative workloads, fixed inputs, and a primary metric like latency, memory, or throughput.
3. Freeze the benchmark and correctness oracle.
Record the original implementation's outputs. Optimizations must preserve behavior, including edge cases.
4. Give the agent good references.
Find high-performance open-source projects that solve similar architectural problems. Let the agent study their implementations and propose hypotheses. Keep the evaluation rules outside its editable search space.
5. Run an autoresearch loop / start hill climbing.
Hypothesis → implement → verify correctness → benchmark → keep or revert. Give it a fixed time budget and record every attempt.
6. Test on unseen holdout data.
Don't let the agent optimize exclusively for the benchmarks it has been seeing.
7. Evaluate the tradeoffs.
Measure actual speedup, memory, correctness, patch complexity, and total agent time.
One more finding: references alone produced substantial improvements in just ~11 minutes. Autoresearch/hillclimbing took longer but found further gains.
We walk through both experiments and the full workflow in our latest Superlinear episode.
🧵 YouTube, Apple Podcasts, and Spotify links below.
00:00 Speed up apps on its existing stack
02:35 Method 1: Reference high performance projects (T3)
10:33 Example 1: Outcomes from Electron app
19:18 Example 2: Walkthrough Android app optimization
20:20 Method 2: Combine with autoresearch and hillclimbing
26:00 3 experiments & results: Method 1, 2, and combining both
35:04 Step-by-step optimization workflow
38:41 Wrap-up & next week with Goose lang creator @wvo
Join the Superlinear Discord: https://t.co/TzYw8ubqap
Also watch the episode on:
Youtube https://t.co/8VJ4AcCBtP
Apple Podcasts
https://t.co/5q1S8YcBCV
Spotify
https://t.co/MC1jWP0PVE
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.]
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
@rileybrown Good point about CMF.
And thanks for the new follow, Riley!
If you had a chance to check out our content, would love to know if you have any first thoughts.
Curious about your opinion.
@poteto@mattpocockuk Here's the skill that uncovers edge cases during design phase: https://t.co/sQoXYxH0Rk
If you have any questions or suggestions, tell us on Discord! https://t.co/TzYw8uaSkR
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
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. 🥺
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.
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!
In one example, we were building a feature to add podcast episodes to an app. After a grilling session, we ran this workflow and it caught edge cases we'd missed, like deleting an episode while it's still being processed in the background.
Even seemingly simple features can have lots of interacting states and events in the background, creating unexpected edge cases.
So this skill uses statecharts and formal model checking to systematically explore possible paths, checks them against your product promises, and surfaces missing behavior and UI/UX decisions.
So instead of discovering these gaps during implementation, your agent can plan and resolve all gaps in different user journeys upfront, and build them correctly in one go.
@mattpocockuk And tomorrow's prompt:
"How do we formally verify this?"
We love the grilling skill, so we added another layer to the grilling process: using formal verification to catch missing edge cases and product decisions before the agent writes any code.
https://t.co/06LZjUhzCd
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