Commit & Push

Host Damien Filiatrault talks with Justin Gelinas, Chief Business Officer at TAHO Labs, about the hidden inefficiencies behind AI infrastructure and why the industry may need to get more from the hardware it already has.

Justin explains how TAHO is building low-level software that breaks large workloads into smaller jobs and distributes them across available processors. The goal is to keep GPUs and other resources working more effectively, reduce idle capacity, and support different types of hardware within the same environment.

The conversation also explores Wirth’s law and Jevons paradox: why faster hardware does not always produce faster software, and why lowering the cost of compute may increase overall demand rather than reduce it. Damien and Justin connect these ideas to AI development, infrastructure costs, energy constraints, and the future of software engineering.

Justin also shares why TAHO uses AI tools extensively for documentation and operational work, but less for its core code. When engineers are inventing techniques without established examples, coding agents can quickly reach their limits or introduce unnecessary technical debt.

For developers, technology leaders, and anyone interested in the economics of AI, this episode offers a closer look at what is happening beneath the application layer—and why efficiency may become one of the industry’s most important challenges.

What you’ll learn

• What Wirth’s law and Jevons paradox reveal about software and compute
• Why cheaper, more efficient AI may create more demand
• Where AI coding tools struggle with genuinely new technical problems
• How TAHO divides and distributes large workloads
• Why interoperability across different hardware providers matters
• Why many compute environments use only a fraction of their available capacity
• How energy and infrastructure constraints are affecting AI growth
• Why improving compute efficiency can reduce costs and create room for innovation

Memorable sound bites“Software gets slower more rapidly than hardware becomes faster.”

“When we can produce more value at a fraction of the cost, that creates opportunities.”

“When you are inventing a genuinely new technique, AI can reach a brick wall quickly.”

“Those constraints make efficiency unavoidable.”

“Innovation and efficiency can reinforce each other.”

LinksGet 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 Damian Filiatrault talks with Eric Ries, author of The Lean Startup and the new book Incorruptible, for a wide-ranging conversation about startups, governance, trust, and what it really takes to build companies that can survive success. Eric reflects on his path from programmer to founder to startup thinker, sharing how the failures and contradictions he saw in Silicon Valley led him to develop Lean Startup principles, and why those ideas, while still useful, were only part of the larger puzzle.

The episode starts with familiar ground: MVPs, validated learning, concierge testing, and the difference between experimentation and deception. Damian and Eric revisit classic Lean Startup examples like Dropbox and Groupon, then connect them to newer questions around AI, automation, and companies that blur the line between testing an idea and misleading customers. Eric argues that founders do not need to hide what is happening behind the curtain. In fact, transparency often creates more trust, not less. The real danger is when founders mistake revenue, growth, or “number go up” for true progress.

From there, the conversation moves into the core ideas behind Incorruptible. Eric explains why even mission-driven companies can lose their way once financial pressure, investor incentives, or short-term thinking take over. He calls this force “financial gravity”: the pull that tempts companies to compromise what made them valuable in the first place. Through examples like Groupon, Costco, Patagonia, IKEA, Zeiss, and alternative ownership models, Eric lays out a different way to think about company building, one rooted in ethos, integrity, governance, and long-term trust.

Just as importantly, Eric makes the case that founders should not wait until they are big to care about these questions. By the time a company is under pressure from investors, boards, acquirers, or market downturns, it may already be too late to protect the mission. For startup founders, developers, and anyone building digital products, this episode is a practical and philosophical look at how to create organizations worth protecting—and how to design them so they cannot be easily corrupted.

What you’ll learn: 

What led Eric Ries from software engineering and failed startups to writing The Lean Startup

Why validated learning (not code, revenue, or growth) is the real unit of progress in a startup

How concierge MVPs and Wizard of Oz tests can be used ethically without deceiving customers

Why founders often fall into the trap of chasing growth even when it does not prove the business model

How Groupon’s “one email a day” promise unraveled under short-term pressure

What Eric means by “financial gravity,” and why successful companies often become more vulnerable, not less

Why trustworthiness may be one of the most valuable and underrated assets in business

How companies like Costco, Patagonia, IKEA, and Zeiss show different ways to resist extractive business practices

What alternative ownership models, employee ownership, foundations, and perpetual purpose trusts can offer founders

Why governance is not just a big-company concern, and why “it’s always too early until it’s too late”

Memorable sound bites“Learning, what we call validated or scientific learning, is the unit of progress.”

“Deception is really never necessary for these things to be effective.”

“You’re making the talking dog mistake here. What’s impressive about a talking dog is not what he says, but that the dog is talking to you.”

“Once you start betraying that trust with customers just to make your quarter, the first hit’s free.”

“Trustworthiness is the most valuable and underrated asset in business today.”

“You cannot make a promise that you can keep unless you can resist someone outside showing up and forcing you not to keep it.”

“Most companies that say they’re mission driven are really mission hopeful.”

“It is always too early until it is too late.”

LinksGet 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/
Incorruptible: https://www.incorruptible.co/

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/

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