Season 7 of Chats with Kent is out: Become a Product Engineer.
What's this all about?
The goal of the Call Kent Podcast is to get my answers to your questions. You record your brief question (120 seconds or less) right from your browser. Then I listen to it later and give my response, and through the magic of technology (ffmpeg), our question and answer are stitched together and published to the podcast feed.
If recording isn't an option, you can also type your question and we'll generate the audio for you.
I look forward to hearing from you!
Kent talks with Julius Marminge about building T3 Code in the agent-orchestrator wave: why speed still matters, why fast shipping does not mean shipping every possible feature, and how product judgment becomes more important as parallel AI workflows make implementation cheap.
They dig into dogfooding, core-product trade-offs, monetization pressure, customization vs defaults, and how to keep agent-built software maintainable over time.
Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.
The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.
Kent talks with Julius Marminge about building T3 Code in the agent-orchestrator wave: why speed still matters, why fast shipping does not mean shipping every possible feature, and how product judgment becomes more important as parallel AI workflows make implementation cheap.
They dig into dogfooding, core-product trade-offs, monetization pressure, customization vs defaults, and how to keep agent-built software maintainable over time.
Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.
The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.
Kent talks with Julius Marminge about building T3 Code in the agent-orchestrator wave: why speed still matters, why fast shipping does not mean shipping every possible feature, and how product judgment becomes more important as parallel AI workflows make implementation cheap.
They dig into dogfooding, core-product trade-offs, monetization pressure, customization vs defaults, and how to keep agent-built software maintainable over time.
Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.
The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.
Kent talks with Julius Marminge about building T3 Code in the agent-orchestrator wave: why speed still matters, why fast shipping does not mean shipping every possible feature, and how product judgment becomes more important as parallel AI workflows make implementation cheap.
They dig into dogfooding, core-product trade-offs, monetization pressure, customization vs defaults, and how to keep agent-built software maintainable over time.
Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.
The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.
Kent talks with Julius Marminge about building T3 Code in the agent-orchestrator wave: why speed still matters, why fast shipping does not mean shipping every possible feature, and how product judgment becomes more important as parallel AI workflows make implementation cheap.
They dig into dogfooding, core-product trade-offs, monetization pressure, customization vs defaults, and how to keep agent-built software maintainable over time.
Julius is building right in the middle of one of the fastest-moving product categories in software, and that gives this episode a useful tension: everything feels possible, but that does not mean everything belongs in the product. The conversation covers the shift from one-agent-at-a-time coding to orchestration, why T3 Code focuses so much on a fast app layer, and how Julius thinks about what should live in the core product versus forks, plugins, or future work.
The deeper lesson is about judgment under speed. Julius and Kent keep returning to the same idea from different angles: when agents can generate a lot of implementation quickly, the real work is deciding what is worth building, what will age well, and what future decisions you might accidentally box yourself out of.
Have a look at these articles.
