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/

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/

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/

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/

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/

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/

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:

• Robin Hanson’s Website
• Robin Hanson on LinkedIn
• Damien Filiatrault on LinkedIn
• Scalable Path Website

"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:

• Zach Goldberg’s Website
• Zach Goldberg on LinkedIn
• Gruntwork Website
• The Startup CTO’s Handbook
• Damien Filiatrault on LinkedIn
• Scalable Path Website

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:

• Dan Saffer’s LinkedIn
• CMU Human-Computer Interaction Institute Website
• Microinteractions Books
• Damien Filiatrault on LinkedIn
• Scalable Path Website

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.