#software-development
82 episodes
#2692: Type Safety: Static vs Dynamic, Soundness & More
Static vs dynamic, strong vs weak, and the truth about TypeScript's unsoundness. A deep dive into type theory.
#2578: Building Deliberately Slow Deployment Pipelines
How to build CI/CD pipelines designed as filters, not firehoses — with manual gates, staging environments, and quality checks.
#2577: Fixing Hidden UI Bugs on Real Devices
Tools and strategies to catch layout failures across devices before users abandon your app.
#2559: The Smartest Path to Python for AI
A practical guide to the best courses and platforms for learning Python, specifically for machine learning.
#2538: 7 Tiny Software Businesses Making a Fortune
One-person teams quietly generating hundreds of thousands in revenue from unsexy problems like PDF generation and ranch management.
#2535: Inside LangChain's Deep Agents: What's Actually in the Box
A deep dive into the batteries-included agent harness with terminal CLI, sub-agents, and production-ready evaluation.
#2506: Squashing Database Migrations Without Breaking Production
How to safely squash old migrations, cut deploy times, and generate schema documentation at version boundaries.
#2501: Building a Movie Theater Database in PostgreSQL, By Ear
Can you design a relational database using only your voice? We coach a beginner through PostgreSQL from scratch.
#2499: Building a TypeScript Tip Calculator from Scratch
Learn to code by building a real TypeScript tip calculator — no experience needed, just your ears and keyboard.
#2498: Build Your First Python Program in 7 Lines
We coach a complete beginner through building a working Python game using only voice—no screenshare, no diagrams.
#2497: Tracing One Python Print Through 6 Abstraction Layers
What actually happens when you print "Hello" in Python? Six layers, 562 system calls, and a hardware-enforced kernel boundary.
#2492: Agentic Stack Selection: How to Choose Libraries Now
How Claude Code and agentic AI are turning GitHub into a discovery layer and collapsing library evaluation from weeks to seconds.
#2477: Stop Polling: Push-to-Deploy for Solo Devs
Why your cron job is obsolete. Push-to-deploy with GitHub Actions and deploy keys — the simplest setup that actually works.
#2473: GitHub Actions Beyond CI/CD: What You're Missing
Cron jobs, self-hosted runners, NPM publishing, and self-healing repos — GitHub Actions does way more than run tests.
#2463: Tmux vs Modern Terminals: What Multiplexing Actually Gets You
What multiplexing actually means, why tmux still matters, and how WezTerm and Ghostty changed the calculus.
#2459: Drizzle vs Prisma: Which ORM Wins for AI-Native Backends?
Comparing Drizzle and Prisma for AI-native backends, MCP servers, and the future of agent-centric development.
#2444: Custom IDs: UUIDs vs Human-Readable Keys
How to design database IDs that balance security, human readability, and performance — with lessons from Stripe and TypeID.
#2439: Airtable Traps & Front-End Choices for Small Teams
Why Airtable fails for multi-user tools, and how AI builders are changing the framework decision for small businesses.
#2435: Four Ways to Get a Pre-Built CRM Schema
Stop designing database schemas from scratch. Here's where to find ready-made templates for common business apps.
#2434: From Spreadsheets to Databases: The Mental Shift
Stop treating databases like bigger spreadsheets. Learn the one conceptual shift that actually matters.
#2356: How Fast Apply Models Revolutionize AI Code Edits
Discover how specialized fast apply models streamline AI-powered code edits, cutting costs and latency while maintaining precision.
#2345: Why File Naming Conventions Are More Than Just Style
Discover how file naming conventions like snake_case and camelCase impact development workflows, CI/CD pipelines, and filesystem compatibility.
#2338: Who Keeps Matplotlib Running?
How does a team of just 15 people maintain Matplotlib, the backbone of global scientific visualization?
#2336: How ADRs Solve AI's Institutional Memory Problem
Architectural Decision Records (ADRs) aren’t just documentation—they’re a way to give AI coding assistants the context they lack.
#2327: Why AI Developers Chose Discord Over Slack
Discover why Discord became the go-to platform for AI developers, outpacing Slack with its community-first design and informal vibe.
#2287: Is AI Code Generation the Future of Low-Code?
Exploring the rise of AI code generation and its potential to reshape the low-code movement.
#2255: Typst vs. LaTeX: The AI-Ready Document Engine
Can Typst succeed LaTeX as the go-to tool for programmatic typesetting, especially for AI agents? We compare the two and explore what makes a docum...
#2207: Specs First, Code Second: Inside Agentic AI's New Era
As AI coding agents evolve from autocomplete to autonomous cloud workers, the bottleneck has shifted—now it's about how clearly you specify what ne...
#2169: How Enterprises Are Rethinking Agent Frameworks
Twelve major agentic AI frameworks exist—yet many serious developers avoid them entirely. What patterns emerge in real enterprise adoption?
#2168: What Serious Agentic AI Developers Actually Need to Know
Python, TypeScript, LangGraph, and the frameworks reshaping how agents work. A technical map of the skills and concepts that separate prototypes fr...
#2166: Code vs. Canvas: How Developers Pick Their Tools
LangGraph or Flowise? The honest answer isn't obvious. Developers gain speed and integrations with visual builders—but lose version control, testin...
#2111: From Bricklayer to Foreman: AI's Dev Role Shift
AI frameworks are exploding while languages stay stable. Learn why core dev knowledge is shifting from syntax to systems thinking.
#2109: AI Is Forcing You to Use React
AI tools are reshaping developer stacks, favoring React and Postgres over niche frameworks.
#2071: Git Can't Handle AI Agents—Yet
Three AI agents in one repo is pure chaos. Here's why Git's design causes collisions—and how worktrees and locks can save your sanity.
#2070: SemVer, Changelogs, and the Social Contract of Code
Stop breaking the internet. Learn the exact system developers use to release software without causing chaos.
#2059: npm Cache and Stale Dependencies in Agentic Pipelines
npx is silently running old versions of your AI tools. Here's why your updates vanish into a cache black hole.
#2043: Python, TypeScript, Rust: The Agent Engineer's Stack
Skip no-code traps. Learn the real stack for building agentic AI: Python, TypeScript, and Rust.
#2018: Micro Frontends: When They're Worth It
The frontend monolith is a nightmare of coordination. Micro frontends promise autonomy, but is the operational complexity worth the cost?
#2014: Coding Tools Are Secretly System Agents
They call it a coding assistant, but real users are treating it like a personal operating system.
#2003: The Velocity Paradox: Why Faster Code Means Slower Ships
Agentic coding tools let you build features in minutes, but they also make it easy to build the wrong thing.
#2001: Stop Writing "It Feels Slow" Tickets
The "Golden Trio" of bug reports, why Jira is a tax, and how AI capture tools are changing the game.
#1946: LangGraph's 3-Layer Agent Stack Explained
We unpack LangGraph, LangChain, and Deep Agents to reveal the deliberate hierarchy behind the ecosystem.
#1943: Why Tar Isn't Compression (And What Is)
LZMA, Zstandard, and Brotli are shrinking massive AI models, but how do they actually work?
#1939: API Drift and Agent Reliability
When an API changes without warning, your AI agent can crash spectacularly. Here's how to test the new "plumbing" of the agentic age.
#1938: JSON-to-SQL Type Mapping: A Practical Guide
Mapping JSON to SQL isn't as simple as it looks. Discover the hidden traps in data types that can cause performance hits and data corruption.
#1924: Build Your Own App Store for Linux and Android
Stop manually copying files. Learn how to host your own authenticated repositories for .deb and APK files using simple static web servers.
#1923: Scaling Prosumer Automation to Enterprise
Prosumer tools like n8n break at scale. Here's why durable execution frameworks like Temporal and Prefect are the enterprise upgrade.
#1920: InfluxDB vs. Postgres: The Time-Series Showdown
We compare specialized time-series databases like InfluxDB against traditional SQL options like Postgres with Timescale extensions.
#1919: Android Dev Without Android Studio: Is It Actually Good?
How to ship an Android app without ever opening Android Studio or touching a line of Java.
#1842: Building a Business on Spreadsheets? Here’s the Escape Plan
Ditch the messy spreadsheets and manual invoices. Here's how to automate your workflow using Google Workspace, Apps Script, and AI.
#1835: AI-Native vs. AI-Washed: How to Tell the Difference
Most "AI-powered" tools are just lipstick on a chatbot. Here's how to spot the real AI-native apps.
#1830: Coordinating Multi-Agent Repos at Scale
Parallel AI agents rewriting your code at once creates silent regressions and architectural drift. How do we fix it?
#1782: Jenkins, GitHub, or Tekton? Picking Your 2025 CI/CD Engine
Jenkins is still the COBOL of DevOps, but the "one size fits all" model is dead. Here’s how to pick your pipeline.
#1781: Writing Tests Before Code Is Insane (Until You Try It)
Why testing feels like a tax, how it actually speeds you up, and the simple three-step method to start today.
#1774: DevRel: The Heat Shield Between Code and Community
DevRel isn't just swag and conferences—it's the critical feedback loop keeping developers loyal in an AI-driven world.
#1766: Why AI Now Builds Your Frontend Stack
AI code generators are creating a monoculture, pushing Astro and Vite as the default tools for 2026's web development.
#1763: Backend Grunt Work Is Dead. What Now?
AI agents now write 80% of boilerplate code, but the real backend engineering challenges remain.
#1753: AI Makes Coding Harder, Not Easier
Claude Code writes the syntax, but you need more technical knowledge than ever to guide it.
#1730: Are Multi-Agent Coding Frameworks Obsolete?
MetaGPT, SWE-agent, and OpenHands promised a team of AI devs. But in 2026, are they still useful, or has raw model power made them obsolete?
#1729: Why Is AI Code So Hard to Read?
AI writes code faster than ever, but the output is often a cryptic mess. We explore why and how to fix it.
#1727: LSP: The Universal AI Coding Interface
Explore how the Language Server Protocol is being repurposed to integrate AI directly into code editors, unifying development workflows.
#1720: The Ultimate Power Tool for Hackers
Metasploit isn't just a tool; it's the industrial standard for digital break-ins. Here's how it works.
#1717: The AI Framework Name Game
Why are there thousands of "AI frameworks" on GitHub? We unpack the naming mess and the cost of semantic inflation.
#1714: SDKs vs Raw APIs: The Developer's Real Choice
Why do companies pour millions into SDKs? We explore the hidden costs of raw APIs and the strategic advantages of using software kits.
#1657: Solo Devs: When to Dockerize (and When Not To)
Is Docker worth it for solo devs? We compare raw Python, Docker, and dev containers with real setup times and tradeoffs.
#1649: The Vendor SDK Moat: Real or Illusion?
Is the vendor lock-in real, or just good marketing? We dissect the trade-offs between vendor SDKs and agnostic frameworks.
#1647: Monorepos: Better Modularity Than Multi-Repos?
Why putting all your code in one repository can actually enforce better boundaries than separate repos.
#1614: Beyond the .env: Mastering Public and Private Code
Stop paying the "dual-repo tax." Learn how to manage public code and private secrets in a single, secure repository.
#1534: The Rise of the Agentic Terminal: Beyond the Command Line
Stop drowning in terminal tabs. Discover how tools like Zellij and Ghostty are transforming the command line into an Agentic Development Environment.
#1471: The Cursor Incident: Why Chinese AI Models are Winning
The Cursor leak revealed a shocking truth: Western AI dominance is fading. Discover the Chinese labs rewriting the rules of code and efficiency.
#1267: Beyond the Save Button: The Git-ification of Everything
Tired of "final_v2_revised.docx"? Discover how Git-based workflows are transforming documentation, project management, and competitive research.
#1229: Beyond the .env File: Mastering Secrets Management
Stop relying on "security by pinky-promise." Learn how to move from messy .env files to professional zero-trust secrets management.
#1227: Mojo 1.0: Can Chris Lattner Fix the AI Performance Gap?
Explore how Mojo aims to unify Python’s ease of use with C++ performance to solve the "two-language problem" in AI development.
#1219: Beyond the Vibes: Mastering Structured AI Outputs
Stop begging your AI for JSON. Learn how constrained decoding and strict schemas are turning "vibes" into reliable systems architecture.
#1204: Rethinking Mastery: Beyond the 10,000 Hour Rule
Is the 10,000-hour rule dead? Explore why raw time no longer equals expertise in the fast-paced age of AI and open systems.
#1170: The Frozen Backend Paradox: Modern Static Architecture
Explore the "frozen backend" paradox and how modern static sites use build-time logic and sharded search to mimic complex dynamic applications.
#1121: Why 80% of Developers Are Hiding Their Code From AI
With 81% of new code moving to private repos, the era of building in public is at a crossroads. Is AI killing the open source dream?
#1052: Coding the Cosmos: The Hebrew Calendar vs. Unix Epoch
Discover why the Unix Epoch fails when it meets the Hebrew calendar and how developers solve the "Sunset Problem" in modern software.
#864: The Death of SaaS: Building Your Own Bespoke AI Tools
Stop paying for dozens of subscriptions. Learn how AI agents are allowing anyone to build custom, private software tailored to their exact needs.
#775: The BiDi Battle: Fixing Mixed RTL and LTR Text Chaos
Stop fighting your cursor! Discover why mixing RTL and LTR languages breaks your layout and how to fix it using Unicode and CSS.
#589: Beyond Git: Taming the Chaos of AI and Large Media Assets
When AI agents and 4K video crash your repo, it’s time for better tools. Explore why Git fails and how Perforce and DVC save the day.
#61: Fork or Stay? The Art of Customizing Open Source
Fork or stay? We're diving deep into customizing open source, weighing ownership, contribution, and the hidden costs of going solo.