Skip to content

The Rise of the Software Factories

Software Engineering Daily

36m
Transcript

Original podcast

Where to listen

Summary

Written by a model from the transcript; not yet reviewed.

AI coding agents make individual developers far more productive, but turning those gains into organizational throughput remains difficult because shipping software involves reviews, guardrails, and approvals. Port CTO Yonatan Boguslavski joins the show to explain how platform teams build an AI software factory layer on top of coding agents. They discuss how a context lake structures organizational data, how logical MCP servers expose tools securely, and how governance and metrics close the loop to improve agents over time.

  • Define a structured organizational taxonomy like database ERDs before ingesting data into a context lake for agents. 7:55
  • Configure logical Model Context Protocol servers to restrict agent tool access and simplify workflows during incidents. 12:46
  • Enforce software delivery lifecycle governance by orchestrating different agents across stages like triage, coding, review, and deployment. 19:14
  • Store agent sessions, pull requests, and traces to run automated analyses and improve factory efficiency over time. 23:44

Chapters

  1. 0:00
    AI Coding Agents and Organizational Productivity

    The episode opens with a discussion on how AI coding agents boost individual productivity but fail to translate that into company-wide gains due to complex deployment workflows.

  2. 0:35
    Port: An AI Software Factory Platform

    The host introduces Port, a platform-agnostic AI software factory that adds context, governance, and orchestration layers above coding agents.

  3. 2:06
    Yonatan Boguslavski’s Background and Port’s Origin

    Yonatan shares his experience in Israel’s Intelligence Unit and how that led to founding Port to solve platform engineering challenges for developers.

  4. 3:25
    From Manual DevOps to Agentic Workflows

    Port’s evolution is traced from simple self‑service abstractions to handling agentic workflows, emphasizing the need for a shared organizational language.

  5. 7:21
    Building the Context Lake

    The conversation dives into creating a structured taxonomy, ingesting data from multiple tools, and using MCP to expose context to agents.

  6. 19:11
    Governance and the Software Development Lifecycle

    Port’s governance model is explained, detailing how factory lines, stages, and scorecards enforce deterministic rules and human approvals.

  7. 23:36
    Monitoring, Metrics, and Continuous Improvement

    The platform’s monitoring stack stores all artifacts, provides analytics, and suggests optimizations to make the factory smarter over time.

  8. 26:04
    Managing Agent Registries and Standards

    Port offers an AI registry and scorecards to govern which agents and skills can be used, ensuring consistency across the organization.

  9. 32:12
    When to Build or Buy a Software Factory

    The hosts discuss the build‑versus‑buy decision, emphasizing that Port is a builder tool that requires custom configuration rather than a one‑size‑fits‑all product.

  10. 34:40
    Future Directions: Proactive Agents and Human‑in‑the‑Loop

    Port’s roadmap includes proactive agents that query humans for missing context and improve the factory’s responsiveness to real‑world scenarios.

Highlights

  • 3:32

    Abstracting Infrastructure for Self-Servicestrategy

    Port provides self-service abstractions for developers, letting them request resources like S3 buckets or databases while automatically generating correct Terraform configurations behind the scenes.

  • 7:55

    Designing a Context Lake Taxonomystrategy

    Before agents can use data, engineering teams must define a structured organizational taxonomy similar to an entity-relationship database, mapping objects like services, environments, and workloads.

  • 12:46

    Creating Logical MCP Serversstrategy

    Platform engineers can create tailored MCP servers for specific personas or tasks, such as incident management, renaming tools to simplify what agents can see and query.

  • 19:14

    Governing the Agentic SDLCinsight

    Governance is implemented across the software development lifecycle by defining deterministic steps, required outputs, scorecards, and human-in-the-loop approvals for agent actions.

  • 23:44

    Closing the Factory Feedback Loopstrategy

    By storing all PRs, JIRA comments, and agent traces, organizations can run regular analyses on factory performance and receive suggestions on how to improve agent skills.

  • 26:04

    Managing an AI Agent Registryinsight

    Port includes an agent registry that helps engineering organizations track, govern, and apply scorecards to the proliferation of AI agents and certified skills being created.

  • 30:50

    From Software to Factory Engineeringinsight

    The role of the developer is shifting toward factory engineering, where they build factory lines, write skills, provide context, and create evals rather than writing all features manually.

Quotes

  • “AI coding agents have made individual developers dramatically more productive,”
    Unnamed speaker · 0:00
  • “and agents add new risk by acting in ways teams can't always see or control.”
    Unnamed speaker · 0:21
  • “And behind the scenes, you do the things in the right way.”
    Unnamed speaker · 4:12
  • “We can create a lot of deterministic rules.”
    Unnamed speaker · 21:43
  • “How the developers, again, the developers, they don't build like the feature itself.”
    Unnamed speaker · 31:11

About this episode

AI coding agents have made individual developers dramatically more productive, yet most organizations aren’t seeing anything close to that gain at the company level. A key reason is that shipping a feature to production involves far more than writing code. Triage, review, context, guardrails, and human approvals all surround the work, and agents add new risk by acting in ways teams can’t always see or control. Turning individual gains into real organizational throughput, has become one of the central challenges of the agentic era. Port https://www.port.io/ is an AI software factory platform that lets platform engineers build, operate, and govern an AI software factory which is a layer that sits above the coding agents. The factory is model and agent agnostic while supplying a context lake that encodes an organization’s taxonomy and data, governance, and guardrails across each stage of the software lifecycle, human-in-the-loop checkpoints, orchestration across different agents, and a registry of approved agents and skills. Yonatan Boguslavski https://x.com/YonaBogu is the CTO and a co-founder at Port. In this episode, he joins Kevin Ball to talk about the shift from writing features to “factory engineering,” how a context lake structures organizational knowledge so agents can actually use it, how governance works across an agentic software lifecycle, and the build-versus-buy question of where a platform like Port fits. Full Disclosure: This episode is sponsored by Port Sponsorship inquiries: sponsor@softwareengineeringdaily.com mailto:sponsor@softwareengineeringdaily.com The post The Rise of the Software Factories https://softwareengineeringdaily.com/podcasts/the-rise-of-the-software-factories/ appeared first on Software Engineering Daily https://softwareengineeringdaily.com.

Transcript

0:00
36:19

7,073 words · 3 speakers

Topics

  • Port
  • MCP
  • GitHub
  • context lake
  • Cursor
  • Claude
  • Terraform
  • Codex
  • AWS
  • Azure

Page updated · transcript and summary are machine-generated