Fame Host (https://fame.so) Commit & Push https://podcasts.fame.so/commit-push https://feeds.fame.so/commit-push Great software doesn’t build itself. Behind every breakthrough product is a team making the right calls—on architecture, hiring, and the trade-offs that shape what gets pushed to prod. The Commit & Push podcast is where technology meets the human side of software development. I’m your host Damien Filiatrault, Founder and CEO of Scalable Path, and in this podcast we’ll go beneath the surface to explore the strategies, decisions, and hard-earned lessons that drive successful digital products. From hiring top developers to embracing emerging tech without losing the human touch, we cut through the noise and focus on what works. Whether you’re a CTO, engineering leader, or hands-on developer, you’ll get real-world insights from industry veterans, deep dives into emerging technologies, and a no-BS look at what it takes to build and scale great software. Copyrights © 2025 All Rights Reserved by Scalable Path en Tue, 25 Mar 2025 13:13:04 +0000 Sun, 10 May 2026 12:48:37 +0000 https://content.fameapp.so/uploads/86qywr5q/a2889aa0-4077-11f0-80ad-69b02847a37f/a2889bb0-4077-11f0-abf4-2db3b04b79b6.png Commit & Push https://podcasts.fame.so/commit-push Great software doesn’t build itself. Behind every breakthrough product is a team making the right calls—on architecture, hiring, and the trade-offs that shape what gets pushed to prod. The Commit & Push podcast is where technology meets the human side of software development. I’m your host Damien Filiatrault, Founder and CEO of Scalable Path, and in this podcast we’ll go beneath the surface to explore the strategies, decisions, and hard-earned lessons that drive successful digital products. From hiring top developers to embracing emerging tech without losing the human touch, we cut through the noise and focus on what works. Whether you’re a CTO, engineering leader, or hands-on developer, you’ll get real-world insights from industry veterans, deep dives into emerging technologies, and a no-BS look at what it takes to build and scale great software. Scalable Path Great software doesn’t build itself. Behind every breakthrough product is a team making the right calls—on architecture, hiring, and the trade-offs that shape what gets pushed to prod. The Commit & Push podcast is where technology meets the human side of software development. I’m your host Damien Filiatrault, Founder and CEO of Scalable Path, and in this podcast we’ll go beneath the surface to explore the strategies, decisions, and hard-earned lessons that drive successful digital products. From hiring top developers to embracing emerging tech without losing the human touch, we cut through the noise and focus on what works. Whether you’re a CTO, engineering leader, or hands-on developer, you’ll get real-world insights from industry veterans, deep dives into emerging technologies, and a no-BS look at what it takes to build and scale great software. No No episodic Scalable Path Great software doesn’t build itself. Behind every breakthrough product is a team making the right calls—on architecture, hiring, and the trade-offs that shape what gets pushed to prod. The Commit & Push podcast is where technology meets the human side of software development. I’m your host Damien Filiatrault, Founder and CEO of Scalable Path, and in this podcast we’ll go beneath the surface to explore the strategies, decisions, and hard-earned lessons that drive successful digital products. From hiring top developers to embracing emerging tech without losing the human touch, we cut through the noise and focus on what works. Whether you’re a CTO, engineering leader, or hands-on developer, you’ll get real-world insights from industry veterans, deep dives into emerging technologies, and a no-BS look at what it takes to build and scale great software. Great software doesn’t build itself. Behind every breakthrough product is a team making the right calls—on architecture, hiring, and the trade-offs that shape what gets pushed to prod. The Commit & Push podcast is where technology meets the human side of software development. I’m your host Damien Filiatrault, Founder and CEO of Scalable Path, and in this podcast we’ll go beneath the surface to explore the strategies, decisions, and hard-earned lessons that drive successful digital products. From hiring top developers to embracing emerging tech without losing the human touch, we cut through the noise and focus on what works. Whether you’re a CTO, engineering leader, or hands-on developer, you’ll get real-world insights from industry veterans, deep dives into emerging technologies, and a no-BS look at what it takes to build and scale great software. engineer software engineer, computer coding languages, it programming languages, program languages, software development languages, developing software, development of a software, development of software, development software, it software development, s/w Damien Filiatrault team@fame.so No No No AI Agents, RAG, and the Gap Between Hype and Execution https://podcasts.fame.so/e/x8125z6n-ai-agents-rag-and-the-gap-between-hype-and-execution AI Agents, RAG, and the Gap Between Hype and Execution 0 No No 713rn570 Damien Filiatrault talks with Micah Johnson, co-founder of Biggest Goal, about what AI agents actually are, how they differ from basic chatbots, and where they can create real value for businesses today. The episode covers practical use cases like data analysis, internal knowledge retrieval through RAG, and event-driven automations, along with why tools like N8N and Raggy have made agentic workflows much more accessible. It also looks at why so many AI projects fall short: not because the technology is weak, but because companies often adopt it without the systems, training, and strategy needed to make it work. Host Damien Filiatrault talks with Micah Johnson, co-founder of Biggest Goal, for a practical conversation about what AI agents really are, where they’re genuinely useful today, and why so many companies still struggle to turn AI enthusiasm into real business results. Drawing on his experience building agents and training teams across leadership, operations, and management, Micah breaks down the building blocks of agentic workflows in plain language: instructions, tools, triggers, loops, RAG databases, and the systems that make AI useful beyond the hype.

The conversation moves from definition to execution. Micah explains how agents differ from normal chat-based AI, why they work especially well for operational use cases like analysis and internal workflows, and how tools like N8N and Raggy have made it dramatically easier for teams to build useful automations without heavy engineering overhead. Damien and Micah also dig into the tradeoffs: when AI is actually necessary, when traditional automation might be enough, and why giving agents too many tools or too much context can make them less reliable instead of more capable. 

Just as importantly, the episode explores why so many AI projects fail. According to Micah, the issue usually is not the model itself. It is the lack of structure, standardization, training, and strategic thinking around how teams adopt these tools. Instead of assuming ChatGPT, Copilot, or Claude will magically fix broken workflows, companies need better systems, clearer use cases, and stronger leadership alignment if they want AI to create lasting value. Tune in for a grounded, jargon-light tour of agents, RAG, N8N, no-code automation, and what it really takes to move from experimentation to execution with AI.

What you’ll learn

  • What an AI agent actually is, and how it differs from a standard chatbot
  • How agents can be triggered by events inside tools like Monday or ClickUp and take action automatically
  • Why data analysis and internal knowledge retrieval are two of the strongest real-world use cases today
  • How RAG systems turn folders of SOPs and documents into searchable, AI-friendly knowledge bases
  • Why tools like Raggy and N8N make it possible to build useful agent workflows quickly, even without deep engineering work
  • Why narrow, focused agents tend to perform better than overloaded ones with too many tools or too much context
  • What makes N8N stand out from tools like Zapier and Make for agentic workflows
  • Why so many AI projects fail inside companies, even when the tools themselves are powerful
  • Why AI adoption needs process design, training, and leadership alignment—not just subscriptions and enthusiasm
Memorable sound bites

  • “Agents will look at their instructions, look at their tools, do something, and then circle back to themselves.”
  • “Fill in those gaps in your business all day long with tiny little simple agents.”
  • “Keep it as narrow of a focus for an agent as possible.”
  • “You literally just change the prompt in plain language. You’re not reconstructing anything.”
  • “You’re just throwing a tool at a problem.”
  • “How do we get them past just the individual small gains and actually building standardized systems?”
Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit
‍Commit & Push Website: https://www.commit-push.com/
‍Scalable Path Website: https://www.scalablepath.com/

]]> Wed, 25 Mar 2026 21:34:00 +0000 Scalable Path Scalable Path 2198 Damien Filiatrault talks with Micah Johnson, co-founder of Biggest Goal, about what AI agents actually are, how they differ from basic chatbots, and where they can create real value for businesses today. The episode covers practical use cases like data analysis, internal knowledge retrieval through RAG, and event-driven automations, along with why tools like N8N and Raggy have made agentic workflows much more accessible. It also looks at why so many AI projects fall short: not because the technology is weak, but because companies often adopt it without the systems, training, and strategy needed to make it work. Damien Filiatrault talks with Micah Johnson, co-founder of Biggest Goal, about what AI agents actually are, how they differ from basic chatbots, and where they can create real value for businesses today. The episode covers practical use cases like data analysis, internal knowledge retrieval through RAG, and event-driven automations, along with why tools like N8N and Raggy have made agentic workflows much more accessible. It also looks at why so many AI projects fall short: not because the technology is weak, but because companies often adopt it without the systems, training, and strategy needed to make it work. No No Zero-Click Commerce and the Rise of Buying Agents: A conversation with Kevin Williams https://podcasts.fame.so/e/4n9m1q2n-zero-click-commerce-and-the-rise-of-buying-agents-a-conversation-with-kevin-williams Zero-Click Commerce and the Rise of Buying Agents: A conversation with Kevin Williams 0 No No v07rx7v1 In this episode, host Damien Filiatrault talks with Kevin Williams, founder of Ascend AI, about what “agentic commerce” actually means as shopping and discovery start shifting into ChatGPT- and Gemini-style interfaces. They break down the path from today’s LLM-assisted recommendations to “zero-click” transactions that happen entirely inside an AI chat, without users ever visiting a traditional checkout flow. Kevin explains why brands are seeing meaningful declines in organic traffic, why being discoverable now requires a mix of AEO (answer engine optimization) and GEO (generative engine optimization), and how those strategies extend beyond your website into reviews, sentiment, and the broader web. They also dig into the messy reality of emerging standards (product feeds, schema, and competing protocols) and what builders may actually need to implement to make products legible and purchasable by agents. If you’re building for e-commerce, marketing, or the next web experience, this episode offers a practical look at what’s changing, what’s still unsettled, and how to prepare before “zero-click” becomes the default. Host Damien Filiatrault sits down with Kevin Williams, founder of Ascend AI, to map the fast-shifting terrain of agentic commerce—the move from “LLMs that recommend” to systems that can discover, compare, and eventually complete purchases with minimal human clicking. Drawing on his background building direct-to-consumer brands and solving post–iOS 14 attribution gaps with machine learning, Kevin explains why “zero-click commerce” is coming, why brands are already seeing meaningful drops in organic traffic, and what they can do to stay discoverable as shopping flows migrate into ChatGPT/Gemini-style interfaces.

Kevin breaks the space into two big layers: being found (AEO/GEO) and being transactable (a growing soup of protocols, feeds, and enrichment standards). He walks through how Google’s ecosystem is evolving via Merchant Center feed enrichment, why OpenAI and Google are unlikely to converge quickly on a single standard, and why most non-Shopify brands may need to support multiple feeds/endpoints in the near term. The conversation also digs into what this shift means for marketers: fewer familiar on-site analytics signals, more “share of voice” style measurement, and a future where prompt-level attribution becomes the new battleground.

What you’ll learn
  • What “agentic commerce” means today vs. what it implies next: LLM-assisted discovery now, agent-assisted purchasing later (especially in B2B replenishment and procurement workflows).

  • Why zero-click commerce changes the operational burden for merchants: identity, payment security, and fulfillment still have to happen—just without a traditional checkout flow.

  • The difference between AEO (Answer Engine Optimization) and GEO (Generative Engine Optimization), and why GEO increasingly depends on broader web presence—reviews, sentiment, and third-party references—not just on-site content.

  • Why the web-as-screenshots approach (agentic browsers) is clunky and expensive, and why platforms are pushing toward structured data feeds and “traction points” that models can reliably consume.

  • How Google’s approach leans on Merchant Center product feeds with new enrichment fields, and why populating those fields (sentiment/occasion/recipient) becomes a real scaling challenge for large catalogs.

  • Why there’s no “one feed to rule them all” yet—and why competing incentives (ads, attribution, control) make standardization hard in the short term.

  • What this shift does to analytics: less time-on-site and scroll depth, more reliance on referral signals, model “share of voice” tracking, and paid-placement pressure.

  • Who adopts fastest: brands closest to the traffic cliff (digitally native, younger-skewing audiences) vs. segments that haven’t felt the drop as sharply.

Memorable sound bites
  • “Zero-click commerce means the entire transaction happens in the LLM.”

  • “We have to clarify the matrix for the model so it’s not guessing from screenshots.”

  • “AEO is relatively straightforward. GEO is the bigger lift.”

  • “There is no one feed to rule them all yet.”

  • “It’s going to be really rough” (for traditional analytics in a world where fewer humans visit your site).

Tune in for a practical, acronym-heavy (but real-world grounded) tour of what commerce looks like when discovery and conversion start moving inside LLMs—and what builders and brands can do now to avoid getting buried as the interfaces change.


Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit
Commit & Push Website: https://www.commit-push.com/
Scalable Path Website: https://www.scalablepath.com/

]]> Thu, 12 Feb 2026 14:06:00 +0000 Scalable Path Scalable Path 2718 In this episode, host Damien Filiatrault talks with Kevin Williams, founder of Ascend AI, about what “agentic commerce” actually means as shopping and discovery start shifting into ChatGPT- and Gemini-style interfaces. They break down the path from today’s LLM-assisted recommendations to “zero-click” transactions that happen entirely inside an AI chat, without users ever visiting a traditional checkout flow. Kevin explains why brands are seeing meaningful declines in organic traffic, why being discoverable now requires a mix of AEO (answer engine optimization) and GEO (generative engine optimization), and how those strategies extend beyond your website into reviews, sentiment, and the broader web. They also dig into the messy reality of emerging standards (product feeds, schema, and competing protocols) and what builders may actually need to implement to make products legible and purchasable by agents. If you’re building for e-commerce, marketing, or the next web experience, this episode offers a practical look at what’s changing, what’s still unsettled, and how to prepare before “zero-click” becomes the default. In this episode, host Damien Filiatrault talks with Kevin Williams, founder of Ascend AI, about what “agentic commerce” actually means as shopping and discovery start shifting into ChatGPT- and Gemini-style interfaces. They break down the path from today’s LLM-assisted recommendations to “zero-click” transactions that happen entirely inside an AI chat, without users ever visiting a traditional checkout flow. Kevin explains why brands are seeing meaningful declines in organic traffic, why being discoverable now requires a mix of AEO (answer engine optimization) and GEO (generative engine optimization), and how those strategies extend beyond your website into reviews, sentiment, and the broader web. They also dig into the messy reality of emerging standards (product feeds, schema, and competing protocols) and what builders may actually need to implement to make products legible and purchasable by agents. If you’re building for e-commerce, marketing, or the next web experience, this episode offers a practical look at what’s changing, what’s still unsettled, and how to prepare before “zero-click” becomes the default. No No Collaborating with AI on Infrastructure, Safely: A conversation with Brit Myers https://podcasts.fame.so/e/v85j9v4n-collaborating-with-ai-on-infrastructure-safely-a-conversation-with-brit-myers Collaborating with AI on Infrastructure, Safely: A conversation with Brit Myers 0 No No 81q3l8x1 In this episode, host Damien Filiatrault talks with Brit Myers, VP of Engineering at System Initiative, about rethinking infrastructure automation for a world of legacy systems, real-time fixes, and AI collaboration. They explore why traditional Terraform and GitOps assumptions break down in practice, how System Initiative’s “digital twin” model keeps intent, state, and change tightly coupled, and why simulations matter before anything touches production. Brit explains how programmable TypeScript functions and change sets make it safer to work with AI agents—letting them propose and iterate on infrastructure changes without handing over full control. If you’re navigating cloud complexity, drift, or experimenting with AI in DevOps, this episode offers a grounded look at how teams can move faster with more confidence and a lot less “merge and pray.” Host Damien Filiatrault welcomes Brit Myers, VP of Engineering at System Initiative, to unpack a new model for infrastructure automation built for the realities Terraform and traditional GitOps often struggle with: drift, legacy systems, manual console “stop the bleed” fixes, and the rising need to collaborate safely with AI. Brit explains why System Initiative is betting on a “digital twin” of your infrastructure—a one-to-one model that holds intent, current reality, and the transitions between them—so teams get faster feedback, tighter control over change, and a lot less “merge and pray.”

What you’ll learn
  • What System Initiative is building: an AI-native infrastructure automation platform that can handle the same categories of work as Terraform and GitOps pipelines, but with different core assumptions.

  • The first assumption they challenge: infrastructure automation doesn’t have to be only static, declarative files that get versioned and processed later.

  • The second assumption: state and reconciliation shouldn’t live as a separate, fragile artifact (like a state file) that engineers sometimes have to manually repair.

  • Why “all changes must go through Terraform” breaks down in the real world—especially during incidents, cost overruns, or when someone has to make an emergency console change without creating future landmines.

  • Where the pain is worst: organizations with long-lived, legacy, or stateful systems (common in insurance and financial services) that can’t cleanly modernize everything at once.

  • How System Initiative uses programmable TypeScript functions to define behavior: propagation of shared values (like regions), organizational policy checks, compliance guardrails, and security logic.

  • How “change sets” work: safe simulations of proposed infrastructure updates that show not just what you want to change, but how it would ripple through the system and what actions (create/update/delete) would be required in reality.

  • Why this is especially useful with AI agents: you can bring an external agent (Claude, etc.) to propose changes through an API, iterate inside a change set, and only apply when a human—or your checks—approves.

  • A concrete AI workflow: using an architecture diagram as input, an agent can iteratively build a high-fidelity model and propose infrastructure in minutes while you watch changes happen live in the collaborative UI.

  • What’s live today: a multi-tenant SaaS at Systeminit.com with AWS coverage now, and plans to expand to GCP, Azure, DigitalOcean, and more—plus the ability for users to author and extend schemas/functions inside the product.

Memorable sound bites
  • “We want a little less ‘merge and pray’ and a little more ‘yeah, I got this.’”

  • “Terraform assumes all changes are made through Terraform—and that’s not how the world works.”

  • “You should be able to stop the bleed in the console without creating baggage later.”

  • “Everything is a function—behavior, policy, even what an asset is—and it’s all TypeScript.”

  • “Change sets let you collaborate with AI in safety, before anything touches production.”

  • “We haven’t found an AI use case that flops yet—bring us the one you think will.”

Tune in for a practical look at infrastructure automation after drift: digital twins, simulation-first changes, and how to let AI help with ops work without handing it the keys to production.

System Initiative Discord: https://discord.gg/system-init

Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit

Commit & Push Website: https://www.commit-push.com/

Scalable Path Website: https://www.scalablepath.com/

]]> Wed, 14 Jan 2026 15:58:00 +0000 Scalable Path Scalable Path 2277 In this episode, host Damien Filiatrault talks with Brit Myers, VP of Engineering at System Initiative, about rethinking infrastructure automation for a world of legacy systems, real-time fixes, and AI collaboration. They explore why traditional Terraform and GitOps assumptions break down in practice, how System Initiative’s “digital twin” model keeps intent, state, and change tightly coupled, and why simulations matter before anything touches production. Brit explains how programmable TypeScript functions and change sets make it safer to work with AI agents—letting them propose and iterate on infrastructure changes without handing over full control. If you’re navigating cloud complexity, drift, or experimenting with AI in DevOps, this episode offers a grounded look at how teams can move faster with more confidence and a lot less “merge and pray.” In this episode, host Damien Filiatrault talks with Brit Myers, VP of Engineering at System Initiative, about rethinking infrastructure automation for a world of legacy systems, real-time fixes, and AI collaboration. They explore why traditional Terraform and GitOps assumptions break down in practice, how System Initiative’s “digital twin” model keeps intent, state, and change tightly coupled, and why simulations matter before anything touches production. Brit explains how programmable TypeScript functions and change sets make it safer to work with AI agents—letting them propose and iterate on infrastructure changes without handing over full control. If you’re navigating cloud complexity, drift, or experimenting with AI in DevOps, this episode offers a grounded look at how teams can move faster with more confidence and a lot less “merge and pray.” No No Building Smarter Dev Environments for Humans and AI: A conversation with Rob Whiteley https://podcasts.fame.so/e/0njypy48-from-code-completion-to-agents-the-new-era-of-software-productivity-with-rob-whiteley Building Smarter Dev Environments for Humans and AI: A conversation with Rob Whiteley 0 No No 40pq6q71 In this episode, host Damien Filiatrault sits down with Coder CEO Rob Whiteley to explore how AI agents are changing the way software gets built, from cloud-based dev environments to long-running “software intern” workflows. They unpack how Coder provisions secure, centralized workspaces for both humans and agents, why Anthropic’s Claude Code became so effective once it could read its own Terraform-defined context, and how MCP-powered toolbelts turn a basic agent into a capable teammate. Rob breaks down why code completion alone is yesterday’s story, how senior engineers orchestrate multiple agents like a conductor, and why startups often stick to cursor-style assistance while enterprises layer in Bedrock, governance, and stricter controls. If you care about developer productivity, you’ll come away with a realistic view of where agents help today, what it takes to trust them with real projects, and why “English as the new programming language” opens the door for many more people to build software. Host Damien Filiatrault welcomes Rob Whiteley, CEO of Coder, for a grounded tour of how AI agents are reshaping software development, from cloud-based dev environments to “software-intern” agents that can refactor codebases for hours at a time. They dig into why infrastructure and context matter more than model choice, how Anthropic runs Claude Code as a first-class “developer,” and what it really takes for startups and enterprises to trust agents with real work.

What you’ll learn
  • How Coder turns your laptop-centric workflow into a centralized, cloud-based development platform that provisions compute, GPUs, tools, and credentials as code.

  • Why code completion is no longer the “end game,” and how developers are moving from line-by-line autocomplete to truly agentic workflows and background tasks.

  • How Anthropic runs Claude Code in a walled-off workspace (with its own tools, Terraform-defined context, and MCP-powered toolbelt) and why that pattern points to the enterprise future.

  • The two essentials for productive agents: solid infrastructure (VMs/containers, GPUs, access to Git, browsers, etc.) and rich, structured context about their environment.

  • System prompts vs. user prompts: how hidden “agent personalities” work under the hood, and why conflicting instructions can quietly tank an agent’s effective IQ.

  • Practical patterns for startups vs. big companies: cursor + Coder for smaller teams, and Bedrock-backed stacks (Q, Cursor, Claude Code) for enterprises that need governance and data control.

  • Why agent adoption follows a “bathtub curve”, junior and principal engineers love them, mid-levels are skeptical, and how to design prompts, tools, and workflows that flatten that curve.

  • A realistic roadmap to long-running agents: when it makes sense to let a model refactor codebases or decouple a front end from its backend over hours instead of minutes.

  • Why “English is the new programming language,” what that means for vibe coders and systems thinkers, and how non-engineers are becoming their team’s internal app builders.

  • How to think about agents like summer interns: what it takes to train them, where they shine, and why your culture around mentoring junior talent predicts your AI success.

Memorable sound bites
  • “Agents are just a gen-AI call in a loop—what matters is the tools and context you give that loop.”

  • “Most people deployed naked agents, starved them of tools, and then decided agents ‘aren’t ready.’”

  • “Claude Code reads its own Terraform file on boot. It literally learns who it is and where it’s running.”

  • “If you’d never hire summer interns because they’re ‘too much work,’ you’re going to hate agents.”

  • “A developer isn’t just a coder anymore—they’re a systems thinker who can break problems down and speak clearly in plain English.”

  • “We may end up with fewer traditional software engineers—but many more developers building software.”

Tune in for a candid, tactical look at AI-native development: how to provision agent workspaces, avoid trust-killing misconfigurations, and turn agents from novelty toys into reliable collaborators for both startups and large engineering orgs.

Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit

Commit & Push Website: https://www.commit-push.com/

Scalable Path Website: https://www.scalablepath.com/

]]> Thu, 11 Dec 2025 21:34:00 +0000 Scalable Path Scalable Path 3380 In this episode, host Damien Filiatrault sits down with Coder CEO Rob Whiteley to explore how AI agents are changing the way software gets built, from cloud-based dev environments to long-running “software intern” workflows. They unpack how Coder provisions secure, centralized workspaces for both humans and agents, why Anthropic’s Claude Code became so effective once it could read its own Terraform-defined context, and how MCP-powered toolbelts turn a basic agent into a capable teammate. Rob breaks down why code completion alone is yesterday’s story, how senior engineers orchestrate multiple agents like a conductor, and why startups often stick to cursor-style assistance while enterprises layer in Bedrock, governance, and stricter controls. If you care about developer productivity, you’ll come away with a realistic view of where agents help today, what it takes to trust them with real projects, and why “English as the new programming language” opens the door for many more people to build software. In this episode, host Damien Filiatrault sits down with Coder CEO Rob Whiteley to explore how AI agents are changing the way software gets built, from cloud-based dev environments to long-running “software intern” workflows. They unpack how Coder provisions secure, centralized workspaces for both humans and agents, why Anthropic’s Claude Code became so effective once it could read its own Terraform-defined context, and how MCP-powered toolbelts turn a basic agent into a capable teammate. Rob breaks down why code completion alone is yesterday’s story, how senior engineers orchestrate multiple agents like a conductor, and why startups often stick to cursor-style assistance while enterprises layer in Bedrock, governance, and stricter controls. If you care about developer productivity, you’ll come away with a realistic view of where agents help today, what it takes to trust them with real projects, and why “English as the new programming language” opens the door for many more people to build software. No No Beyond the Happy Path: Josh Clark & Veronika Kindred on “Sentient Design” https://podcasts.fame.so/e/lnqwp19n-beyond-the-happy-path-josh-clark-veronika-kindred-on-sentient-design Beyond the Happy Path: Josh Clark & Veronika Kindred on “Sentient Design” 0 No No 81nv8pl1 In this episode, host Damien Filiatrault talks with Josh Clark and Veronika Kindred of Big Medium about “Sentient Design”—interfaces that adapt to context and intent without ceding user control. You’ll hear a cross-generational take on rethinking UX best practices, from bespoke UIs that assemble trusted design-system components on the fly to the NPC pattern where AI participates alongside humans. They dig into defensive design—guardrails, reversibility, explainability, and graceful degradation—plus a practical split: let LLMs interpret intent, not act as the source of truth. If you’re building with AI, expect concrete patterns for smarter, safer products that keep suggestions deferential and users firmly in the driver’s seat. Host Damien Filiatrault welcomes Josh Clark and Veronika Kindred—principal and researcher at Big Medium and co-authors of the forthcoming book Sentient Design—for a cross-generational look at how AI changes product and UX. They unpack what “sentient” really means in interfaces, why defensive design matters more than ever, and how to let intelligence co-pilot the presentation layer without giving up control.

What you’ll learn
  • A practical definition of sentient design: context-aware, radically adaptive, collaborative, deferential, and ambient interfaces—without implying machine consciousness.
  • How Gen Z “AI-native” instincts and decades of UX experience productively clash to re-question sacred “best practices.”
  • Patterns for bespoke UI: letting AI assemble trusted design-system components (e.g., Salesforce’s generative canvas) to meet intent in the moment.
  • The NPC pattern: AI as a visible participant in multi-user tools (comments, cursors, suggestions) instead of a side-chat.
  • Defensive design: guardrails, explainability, reversible actions, and graceful degradation—designing for failure paths when there’s no single “happy path.”
  • Why LLMs excel at intent translation (driving presentation choices) but shouldn’t be your source of truth.
Memorable sound bites
  • “We can create genuinely new experiences when we weave intelligence into the interface.”
  • “There is no happy path anymore—so design guardrails, not just flows.”
  • “Delegate decisions, don’t abdicate them—suggest, don’t impose.”
  • “LLMs aren’t answer machines; they’re great at interpreting intent.”
  • “When the escalator fails, it turns into stairs—your product should, too.”

Tune in for grounded tactics to add AI as a design material: smarter dashboards, safer autonomy, and collaboration patterns that keep users in control while moving faster.


Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit

Commit & Push Website: https://www.commit-push.com/

Scalable Path Website: https://www.scalablepath.com/
]]> Wed, 12 Nov 2025 11:29:00 +0000 Scalable Path Scalable Path 2927 In this episode, host Damien Filiatrault talks with Josh Clark and Veronika Kindred of Big Medium about “Sentient Design”—interfaces that adapt to context and intent without ceding user control. You’ll hear a cross-generational take on rethinking UX best practices, from bespoke UIs that assemble trusted design-system components on the fly to the NPC pattern where AI participates alongside humans. They dig into defensive design—guardrails, reversibility, explainability, and graceful degradation—plus a practical split: let LLMs interpret intent, not act as the source of truth. If you’re building with AI, expect concrete patterns for smarter, safer products that keep suggestions deferential and users firmly in the driver’s seat. In this episode, host Damien Filiatrault talks with Josh Clark and Veronika Kindred of Big Medium about “Sentient Design”—interfaces that adapt to context and intent without ceding user control. You’ll hear a cross-generational take on rethinking UX best practices, from bespoke UIs that assemble trusted design-system components on the fly to the NPC pattern where AI participates alongside humans. They dig into defensive design—guardrails, reversibility, explainability, and graceful degradation—plus a practical split: let LLMs interpret intent, not act as the source of truth. If you’re building with AI, expect concrete patterns for smarter, safer products that keep suggestions deferential and users firmly in the driver’s seat. No No Unicorn Lessons from RapidAPI’s Founder: A Conversation with Iddo Gino https://podcasts.fame.so/e/28xzw958-unicorn-lessons-from-rapidapi-s-founder-a-conversation-with-iddo-gino Unicorn Lessons from RapidAPI’s Founder: A Conversation with Iddo Gino 0 No No 60mk8xw0 Founder Iddo Gino tells host Damien Filiatrault how a GitHub repo called “Awesome APIs” became RapidAPI, a global marketplace later acquired by Nokia, and what sky-high valuations actually change credibility and hiring more than outcomes. He argues that instead of chasing new standards like MCP, teams should fix the REST/GraphQL APIs they already have with accurate specs and living docs. Gino then explains Datawizz, his new platform that routes requests to tiny, task-specific models and falls back to large LLMs only when needed, often cutting costs by 85–95% while improving latency and reliability. He details an OpenAI-compatible router, when volume justifies specialization, and how edge/on-device options, Cloudflare AI Workers, iOS’s built-in models with adapters, and Chrome’s Gemini Nano, unlock faster, cheaper, and more private inference. Host Damien Filiatrault welcomes Iddo Gino, founder of RapidAPI (launched at 17, later a unicorn, acquired by Nokia) and now CEO of Datawizz. They trace Rapid’s journey from a GitHub list to a global API marketplace, unpack what sky-high valuations actually change, and debate MCP versus simply fixing the APIs we already have. Iddo then shares how Datawizz slashes LLM bills with tiny, task-specific models and why the future leans hard toward edge and on-device inference.

What you’ll learn

  • How “Awesome APIs” (a GitHub repo) became RapidAPI’s interactive playground, marketplace, and eight-year scaling story, ending in a Nokia acquisition
  • What high valuations really buy (credibility, recruiting) and why raising “too much” is a double-edged sword for efficiency
  • A contrarian take on Anthropic’s Model Context Protocol (MCP): why reinventing interfaces may just create a second integration surface to maintain
  • The boring fix that beats new protocols: clean REST/GraphQL, accurate OpenAPI specs, and docs that match reality
  • Datawizz’s playbook: route requests to small, specialized models (and only fall back to big LLMs when needed) for 85–95% cost reductions
  • How the router works in practice (OpenAI-compatible endpoint), when volume justifies specialization, and why clustering real traffic matters
  • Edge & on-device AI: running custom adapters on iOS’s built-in models, Chrome’s Gemini Nano, and at the edge on Cloudflare AI Workers for latency, privacy, and cost wins
‍

Memorable sound bites
  • “V1 of Rapid was just a GitHub repo called Awesome APIs.”
  • “If LLMs can’t use your API, your developers probably can’t either, fix the API.”
  • “MCP feels like reinventing APIs. In a few years it could be just as messy, and now you’re maintaining two surfaces.”
  • “Our customers see 85–95% cost reduction by routing to small, specialized models.”
  • “On-device is free, fast, and private.”
—

Tune in for a founder’s-eye view of scaling an API marketplace, a pragmatic critique of shiny new protocols, and a concrete roadmap to cheaper, faster AI through specialization and the edge.

‍
Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit

Commit & Push Website: https://www.commit-push.com/

Scalable Path Website: https://www.scalablepath.com/
]]> Thu, 09 Oct 2025 19:16:00 +0000 Scalable Path Scalable Path 2279 Founder Iddo Gino tells host Damien Filiatrault how a GitHub repo called “Awesome APIs” became RapidAPI, a global marketplace later acquired by Nokia, and what sky-high valuations actually change credibility and hiring more than outcomes. He argues that instead of chasing new standards like MCP, teams should fix the REST/GraphQL APIs they already have with accurate specs and living docs. Gino then explains Datawizz, his new platform that routes requests to tiny, task-specific models and falls back to large LLMs only when needed, often cutting costs by 85–95% while improving latency and reliability. He details an OpenAI-compatible router, when volume justifies specialization, and how edge/on-device options, Cloudflare AI Workers, iOS’s built-in models with adapters, and Chrome’s Gemini Nano, unlock faster, cheaper, and more private inference. Founder Iddo Gino tells host Damien Filiatrault how a GitHub repo called “Awesome APIs” became RapidAPI, a global marketplace later acquired by Nokia, and what sky-high valuations actually change credibility and hiring more than outcomes. He argues that instead of chasing new standards like MCP, teams should fix the REST/GraphQL APIs they already have with accurate specs and living docs. Gino then explains Datawizz, his new platform that routes requests to tiny, task-specific models and falls back to large LLMs only when needed, often cutting costs by 85–95% while improving latency and reliability. He details an OpenAI-compatible router, when volume justifies specialization, and how edge/on-device options, Cloudflare AI Workers, iOS’s built-in models with adapters, and Chrome’s Gemini Nano, unlock faster, cheaper, and more private inference. No No Bootstrap, Ship, Repeat: Lessons From Polypane Creator Killian Valkhof https://podcasts.fame.so/e/v8wp0kqn-bootstrap-ship-repeat-lessons-from-polypane-creator-killian-valkhof Bootstrap, Ship, Repeat: Lessons From Polypane Creator Killian Valkhof 0 No No 80x2wnj0 Developer and founder Killian Valkhof tells host Damien Filiatrault how a homemade tool that made his work 60 percent faster became Polypane, a dedicated browser for web professionals. He outlines Polypane’s core features—side-by-side responsive views, built-in accessibility and performance audits, and instant social-media previews—and shares the tactics that keep his one-person, bootstrapped SaaS both profitable and user-driven. Valkhof explains his open feedback channels, no-credit-card trial, and ROI calculator for team budgets, describes spin-off utilities like Superposition and FixA11y, and reflects on why he is holding off on AI features in favor of polished fundamentals. Host Damien Filiatrault welcomes Killian Valkhof—long-time web-dev, educator, and solo founder of Polypane, the “browser made for developers.” They trace Polypane’s journey from a scrappy side-project to a profitable, one-person SaaS, and unpack the power—and quirks—of building tools for developers by a developer.

What you’ll learn:

How a home-grown prototype that made Killian 60 % faster convinced him to ditch agency life and bootstrap full-time

Polypane’s three pillars: multi-pane responsive previews, deep accessibility & Web Vitals insights, and instant social-media cards—even on localhost

Tactics for capturing user feedback “anywhere it appears,” crafting a no-tracking onboarding email flow, and helping devs win reimbursement with an ROI calculator

Side projects Superposition (extract design tokens straight into Figma) and FixA11y (fix color contrast on any site)

Why he’s holding off on flashy AI features—and what he’s learned from six years of going fast alone

Memorable sound bites

“I was 60 % faster with my prototype—so I decided to take it seriously.”

“Polypane should feel more like your IDE than a ‘normal’ browser.”

“A tool that costs 60 cents a day doesn’t have to do much to pay for itself.”


Tune in for a candid look at solo-founder life, smarter front-end workflows, and how to ship a power-tool browser that developers actually adopt.

Get 20% off your first month with Scalable Path: https://www.scalablepath.com/commit

Commit & Push Website: https://www.commit-push.com/

Scalable Path Website: https://www.scalablepath.com/]]> Thu, 11 Sep 2025 16:07:00 +0000 Scalable Path Scalable Path 3371 Developer and founder Killian Valkhof tells host Damien Filiatrault how a homemade tool that made his work 60 percent faster became Polypane, a dedicated browser for web professionals. He outlines Polypane’s core features—side-by-side responsive views, built-in accessibility and performance audits, and instant social-media previews—and shares the tactics that keep his one-person, bootstrapped SaaS both profitable and user-driven. Valkhof explains his open feedback channels, no-credit-card trial, and ROI calculator for team budgets, describes spin-off utilities like Superposition and FixA11y, and reflects on why he is holding off on AI features in favor of polished fundamentals. Developer and founder Killian Valkhof tells host Damien Filiatrault how a homemade tool that made his work 60 percent faster became Polypane, a dedicated browser for web professionals. He outlines Polypane’s core features—side-by-side responsive views, built-in accessibility and performance audits, and instant social-media previews—and shares the tactics that keep his one-person, bootstrapped SaaS both profitable and user-driven. Valkhof explains his open feedback channels, no-credit-card trial, and ROI calculator for team budgets, describes spin-off utilities like Superposition and FixA11y, and reflects on why he is holding off on AI features in favor of polished fundamentals. No No Software Rot & the Economics of Code: A Conversation with Robin Hanson https://podcasts.fame.so/e/lnqwl6qn-software-rot-the-economics-of-code-a-conversation-with-robin-hanson Software Rot & the Economics of Code: A Conversation with Robin Hanson 0 No No 81nvwqy1 Economist and ex-AI researcher Robin Hanson joins host Damien Filiatrault to explain why large codebases inevitably “rot,” how AI could make developers richer by expanding demand for software, and why looming population decline might stall innovation and hollow out today’s tech stack. Along the way they compare rot to technical debt, debate refactoring vs. rewriting, and ask whether non-software systems—from languages to corporations—face the same fate. In this episode, host Damien Filiatrault sits down with Robin Hanson—associate professor of economics at George Mason University, former AI researcher at Lockheed & NASA, and author of The Age of EM—to explore what happens when the worlds of software engineering and economics collide.

What you’ll learn

  • Software rot vs. technical debt – why Hanson thinks “systems rot” is the overlooked force that eventually dooms large code-bases, and how refactoring only delays the inevitable.
  • Elastic demand for code – an economist’s take on why AI-powered developers may earn more, not less, as automation drives the price of software down and demand way up.
  • Population decline & shrinking innovation – a provocative forecast that a falling global population (possibly peaking ~30 years out) could sap economic growth and leave vast layers of today’s software stack unfunded.
  • Cultural drift and long-lived systems – lessons from languages, legal codes and corporate lifecycles on why some structures “rot” slowly—or not at all.

Memorable sound bites

“One of the key issues in software engineering is that systems rot—and in the end we usually just throw them away.” – Robin Hanson

“If AI makes you ten times more productive, your wages should go way up, because the world’s appetite for software is almost limitless.” – Robin Hanson

“Older firms rot: half the S&P 500 wasn’t on the list 20 years ago. We keep replacing them, so society stays healthy—software may need the same treatment.” – Robin Hanson

‍Episode Resources:
]]> Thu, 07 Aug 2025 16:28:00 +0000 Scalable Path Scalable Path 2869 Economist and ex-AI researcher Robin Hanson joins host Damien Filiatrault to explain why large codebases inevitably “rot,” how AI could make developers richer by expanding demand for software, and why looming population decline might stall innovation and hollow out today’s tech stack. Along the way they compare rot to technical debt, debate refactoring vs. rewriting, and ask whether non-software systems—from languages to corporations—face the same fate. Economist and ex-AI researcher Robin Hanson joins host Damien Filiatrault to explain why large codebases inevitably “rot,” how AI could make developers richer by expanding demand for software, and why looming population decline might stall innovation and hollow out today’s tech stack. Along the way they compare rot to technical debt, debate refactoring vs. rewriting, and ask whether non-software systems—from languages to corporations—face the same fate. Software rot, technical debt, refactor-vs-rewrite strategies, AI-assisted coding, developer productivity, junior-to-senior role shifts, elastic demand for software, population decline economics, innovation slowdown, fixed-cost software economics, cultural drift, system interdependencies, orchestration of AI agents, durable hardware futures, macro-vs-micro tech trends No No Don't Hire the Brilliant Jerk: A CTO’s Playbook for Building Real Teams https://podcasts.fame.so/e/68r7977n-cto-playbook-for-building-real-teams Don't Hire the Brilliant Jerk: A CTO’s Playbook for Building Real Teams 0 No No 805rqrr1 Most software sucks. Most performance reviews are broken. And most new CTOs are flying blind. In this episode of Commit & Push, Damien sits down with Zach Goldberg—CTO of Gruntwork and author of The Startup CTO’s Handbook—to unpack the real challenges of building and scaling a dev team. From metrics that actually matter to avoiding productivity traps, Zach shares pragmatic strategies every tech leader should know. Whether you're running a growing team or just trying to avoid the usual mistakes, this episode cuts through the fluff and gives you the straight-up roadmap to doing it better. "Don’t hire the brilliant jerk." That’s just one of the hard truths Zach Goldberg, CTO of Gruntwork and author of The Startup CTO’s Handbook, drops in this episode of Commit & Push.

Zach joins Damien to talk about the mistakes most new CTOs make, why developer productivity is wildly misunderstood, and how overcomplicating your stack can tank your team. They dig into what actually works when scaling a dev org, how to build real performance systems, and why most software out there… just isn’t very good.

If you're leading engineers—or thinking about how to lead better—this episode is your shortcut to avoiding expensive management lessons and building a team that actually ships.

If you enjoyed this episode, make sure to subscribe, rate and review on Apple Podcasts, Spotify and YouTube Podcasts, instructions on how to do this are here.

Episode Highlights:
  • [0:00] Intro
  • [1:03] Zach’s Journey to Becoming a Startup CTO
  • [3:15] What is Gruntwork?
  • [5:57] Balancing a Full-Time CTO Role with Coaching
  • [6:50] Writing The Startup CTO’s Handbook
  • [11:40] Lessons in Management and Hiring
  • [16:22] Setting Goals &  Metrics for Engineers
  • [22:22] Full-Time vs. Fractional CTOs
  • [28:12] Keeping Software Development Simple
  • [30:51] Developer Productivity
  • [34:50] Overhyped and Underrated Tech
  • [44:43] Will AI Replace Developers?
  • [49:38] Why Every CTO Should Consider Coaching
  • [51:25] Where Can You Find Zach Online?

Episode Resources:
]]> Thu, 10 Jul 2025 12:00:00 +0000 Scalable Path Scalable Path 3190 Most software sucks. Most performance reviews are broken. And most new CTOs are flying blind. In this episode of Commit & Push, Damien sits down with Zach Goldberg—CTO of Gruntwork and author of The Startup CTO’s Handbook—to unpack the real challenges of building and scaling a dev team. From metrics that actually matter to avoiding productivity traps, Zach shares pragmatic strategies every tech leader should know. Whether you're running a growing team or just trying to avoid the usual mistakes, this episode cuts through the fluff and gives you the straight-up roadmap to doing it better. Most software sucks. Most performance reviews are broken. And most new CTOs are flying blind. In this episode of Commit & Push, Damien sits down with Zach Goldberg—CTO of Gruntwork and author of The Startup CTO’s Handbook—to unpack the real challenges of building and scaling a dev team. From metrics that actually matter to avoiding productivity traps, Zach shares pragmatic strategies every tech leader should know. Whether you're running a growing team or just trying to avoid the usual mistakes, this episode cuts through the fluff and gives you the straight-up roadmap to doing it better. Startup CTO, Gruntwork, Zach Goldberg, Developer Productivity, Management Tips, Scaling Engineering Teams, Hiring Developers, Tech Leadership, AI Impact on Developers, Software Engineering Best Practices, Infrastructure as Code, Technical Management, CTO Coaching No No Why 80% of AI Projects Fail - and How to Make Yours Work https://podcasts.fame.so/e/1833zw18-why-80-of-ai-projects-fail-and-how-to-make-yours-work Why 80% of AI Projects Fail - and How to Make Yours Work 0 No No m0jp6m80 "Most AI projects fail - and not for the reasons you think.” In this episode of Commit & Push, Damien sits down with Dan Saffer, Associate Director at CMU’s Human-Computer Interaction Institute, to unpack why so many AI initiatives crash and burn before they ever ship. From busted data pipelines to overengineered use cases, Dan breaks down the five common traps behind failed AI efforts—and what it actually takes to build something useful. They also dig into explainability myths, the limits of chatbot UX, and how AI is accelerating the enshittification of your favorite platforms. If you’re working with AI—or even thinking about it—this one’s a reality check worth hearing. Most AI projects fail. Some never ship. Others ship and implode. So what’s going wrong?

In this episode of Commit & Push, Damien sits down with Dan Saffer - Associate Director of Outreach at Carnegie Mellon’s Human-Computer Interaction Institute and author of Microinteractions - to dig into the real reasons so many AI projects fall apart.

Drawing on years of academic research and hands-on industry experience, Dan unpacks the five most common failure points: bad data, fragile models, vague value props, ethical landmines, and poor user adoption. They also dive into the myth of explainability, the broken state of AI UX, and why “sparkle-washing” products with AI features often makes things worse, not better.

Oh - and if you’ve noticed your favorite platforms slowly turning into garbage fire content mills? Dan’s got a name for that too: enshittification - and AI might be pouring gas on it.

Whether you're building AI tools, integrating them into your product, or just trying to separate signal from noise, this episode pulls back the curtain on what’s real, what’s hype, and what to do about it.

If you enjoyed this episode, make sure to subscribe, rate and review on Apple Podcasts, Spotify and YouTube, instructions on how to do this are here.

Episode Highlights:
  • [00:00] Intro
  • [02:00] Who Is Dan Saffer?
  • [04:53] Why So Many AI Projects Fail
  • [11:02] Why “Perfect” Use Cases Are a Trap
  • [14:39] Trusting the AI Too Much
  • [20:44] The Rise and Fall of Chat Interfaces
  • [35:31] Enshittification: AI’s Role in Ruining Platforms
  • [42:49] Stop Slapping Sparkles on Everything
  • [44:52] AI Tools That Delight

Episode Resources:
]]> Thu, 05 Jun 2025 12:00:00 +0000 Scalable Path Scalable Path 2995 "Most AI projects fail - and not for the reasons you think.” In this episode of Commit & Push, Damien sits down with Dan Saffer, Associate Director at CMU’s Human-Computer Interaction Institute, to unpack why so many AI initiatives crash and burn before they ever ship. From busted data pipelines to overengineered use cases, Dan breaks down the five common traps behind failed AI efforts—and what it actually takes to build something useful. They also dig into explainability myths, the limits of chatbot UX, and how AI is accelerating the enshittification of your favorite platforms. If you’re working with AI—or even thinking about it—this one’s a reality check worth hearing. "Most AI projects fail - and not for the reasons you think.” In this episode of Commit & Push, Damien sits down with Dan Saffer, Associate Director at CMU’s Human-Computer Interaction Institute, to unpack why so many AI initiatives crash and burn before they ever ship. From busted data pipelines to overengineered use cases, Dan breaks down the five common traps behind failed AI efforts—and what it actually takes to build something useful. They also dig into explainability myths, the limits of chatbot UX, and how AI is accelerating the enshittification of your favorite platforms. If you’re working with AI—or even thinking about it—this one’s a reality check worth hearing. CMU Human-Computer Interaction Institute, Dan Saffer, AI Project Failures, HCI Research, UX Design, AI Implementation, Explainable AI, AI User Interfaces, Adaptive UIs, Model Performance, Data Quality, Ethical AI Problems, Enterprise AI Implementation No No Commit & Push Trailer https://podcasts.fame.so/e/q80vkwq8-commit-push-trailer Commit & Push Trailer 0 No No p0kn98p1 Welcome to Commit & Push, where we talk about how great software really gets built. I'm Damian Filiatro, your host and founder of Scalable Path. Each episode, we'll explore the decisions, tradeoffs, and strategies that shape successful digital products. You'll hear from developers, founders, and tech leaders about the challenges they've faced, the solutions they've found, and the insights they've gained. Ready to explore what makes digital products thrive? Let's get into it. Welcome to Commit & Push, where we talk about how great software really gets built. I'm Damian Filiatro, your host and founder of Scalable Path. Each episode, we'll explore the decisions, tradeoffs, and strategies that shape successful digital products. You'll hear from developers, founders, and tech leaders about the challenges they've faced, the solutions they've found, and the insights they've gained. Ready to explore what makes digital products thrive? Let's get into it.]]> Tue, 03 Jun 2025 12:00:00 +0000 Scalable Path Scalable Path 53 Welcome to Commit & Push, where we talk about how great software really gets built. I'm Damian Filiatro, your host and founder of Scalable Path. Each episode, we'll explore the decisions, tradeoffs, and strategies that shape successful digital products. You'll hear from developers, founders, and tech leaders about the challenges they've faced, the solutions they've found, and the insights they've gained. Ready to explore what makes digital products thrive? Let's get into it. Welcome to Commit & Push, where we talk about how great software really gets built. I'm Damian Filiatro, your host and founder of Scalable Path. Each episode, we'll explore the decisions, tradeoffs, and strategies that shape successful digital products. You'll hear from developers, founders, and tech leaders about the challenges they've faced, the solutions they've found, and the insights they've gained. Ready to explore what makes digital products thrive? Let's get into it. No No