TechPrufer
Get started
AI Engineer
AI Engineer logoAI Engineer · Feature trail

Software Factory Engineering

18 videos · Sep 2026 – Oct 2026

What this trail covers

This post contributes to the understanding of software development paradigms by contrasting the 'software factory' model with an 'orchestra' model. It emphasizes human-centric coordination of people and AI agents, advocating for principles like staying near the frontier, creating 'slop-free zones' for critical tasks (migrations, docs, skill files), centralizing all communication and data for agents ('feeding the beast'), and providing agents with free-range cloud sandboxes. The Conductor platform facilitates this by enabling the scaling of custom agents from local development to organizational-wide CI pipelines, including features like agent marketplaces, cross-repository orchestration, and automated cost monitoring.

All AI Engineer trails
  1. From Your Laptop to the Pipeline: Scaling Custom Agents with GitHub CopilotThis post details the practical steps and infrastructure required to scale custom AI agents from a local development environment to an organizational-wide CI pipeline. It introduces GitHub Agentic Workflows as a mechanism for running headless Copilot CLI agents within GitHub Actions, triggered by slash commands. The talk highlights the benefits of this approach for pipeline automation, including the ability to run hundreds of agents concurrently within a single repository and to implement agents that monitor and manage their own cost overruns. It also touches upon the underlying architecture of Copilot and the creation of custom agents using the agent builder, emphasizing the transition from local, single-developer agents to autonomous, pipeline-integrated agents.
  2. Generation Is Cheap, Review Is Expensive: How to Stop Shipping AI Slop — Gabriel Martinez, G2iThis post contributes to the understanding of software engineering practices in the age of AI by defining and addressing 'slop'—work that appears complete but lacks deep judgment or clear decision-making, often exacerbated by AI generation outpacing human review. It argues that code remains a liability, and AI agents can amplify existing codebase issues. The talk critiques incentives that push for faster merging over thorough review, the problem of large, unmanageable PRs, and the cognitive overhead of reviewing lengthy AI-generated documentation. It proposes solutions inspired by Rails conventions, emphasizing the use of diagrams as the primary review surface, the importance of small, reviewable changes, clear ownership, and the development of tools like ORC to manage these processes. The core message is that while AI generation is cheap, effective review and judgment are expensive and critical for shipping high-quality software.
  3. Let Anyone at Your Company Ship Internal Apps with AI — Garrett Galow, WorkOSThis post details the WorkOS approach to enabling non-engineers to build and ship internal applications using AI. It introduces the 'WOW' CLI, which automates repository setup, tooling, and templating for new applications, and 'Atlas', an underlying platform that abstracts infrastructure, enforces security via SSO, and provides app discoverability. The talk highlights the shift in bottleneck from building to shipping AI-powered tools and presents results showing a high volume of apps created with minimal or no engineering involvement, demonstrating the effectiveness of this 'software factory' model for internal tooling.
  4. The Software Factory: From Bug Report to Production Code — Davis Palmie, FactoryThis talk introduces the concept of a 'software factory' as a system of agents designed to automate the transformation of bug reports and user feedback into production code. It argues that coding itself is not the bottleneck in software development, but rather review, debugging, documentation, and testing. The talk outlines key principles for building such a factory: model-agnosticism, sovereign deployment, and integration across the entire Software Development Life Cycle (SDLC). It suggests starting with narrow applications like incident triage and emphasizes the importance of agent readiness, governance, and incremental rollout. The speaker advocates for measuring outcome metrics such as signal-to-production time, interventions, and cost per PR, rather than focusing on token leaderboards.
  5. Why AI Agents Should Have Their Own Sandbox — Philipp Schmid, Google DeepMindThis post introduces the Gemini Interactions API and its managed cloud sandbox feature for AI agents. It proposes replacing traditional user/model turns with a timeline of steps for agentic applications, enabling server-side state management and long-running background jobs. The core contribution is the concept of a managed sandbox for each agent, providing a persistent, shareable environment where agents can execute code, install tools, and acquire skills and AGENTS.md files automatically. This facilitates the development of complex agentic applications, demonstrated by an AI talk radio show generated from a single prompt.
  7. Redesigning How Software Gets Built With AI Agents — Sonar & McKinsey PanelThis post contributes to the understanding of scaling AI agents in software development by presenting research findings that identify three key factors for success: process, tooling, and people. It emphasizes that lighthouse teams alone are insufficient for widespread adoption. The talk highlights the importance of engineers making implicit knowledge explicit and developing critical thinking skills, as AI agents can be overly confident. It also discusses how larger organizations can learn from smaller teams through platform organizations and outlines a step-by-step trust-building process for AI agents, moving from AI code reviews to blocking on issues, autofix, auto-approve, and auto-merge.
  8. Harness Engineering: How to Build a Software Factory — Dru Knox, TesslThis post introduces the concept of 'harness engineering' (or 'loop engineering') as the discipline for transitioning from using coding agents to running a 'software factory.' It defines a software factory by autonomy, automation, and quality, and breaks down the work into inner, outer, and meta loops. The talk highlights the challenges of harness engineering, such as rapid field changes and localized logging. It proposes a three-layer architecture: a control plane, an agent-ready stack, and improvement loops, with Tessl's skills registry, Tessl Agent, and Tessl Launch presented as practical implementations to achieve these goals.
  9. Cooking with Codex — Charlie Guo & Gabriel Chua, OpenAIThis post details the practical application of AI agents, specifically Codex, in transforming individual requests into repeatable software development processes. It showcases building a macOS translation app from a Slack conversation, demonstrating the integration of context, plugins, and supervision. The talk highlights the creation of a shareable site from repository history, IKEA-style repository visualization, dashboard data download, and a Google feedback form builder via a Chrome extension. Longer projects include a live Q&A site, an internal form builder, and a Python package with a Rust backend. Key technical contributions include the use of goals for verifiable completion criteria, subagents, visible threads, audits, and progress dashboards for work division and blocker exposure. Remote threads for browser testing and hooks for deterministic checks are presented. Automations for server provisioning, Slack feedback review, and bug addressing are demonstrated. The custom interface Retrodex showcases App Server integration, emphasizing the transition from individual requests to a software factory model.
  10. AI Coding Agents Are Breaking Big Codebases — Dan Adler, SourcegraphThis talk introduces the problem of codebase decay caused by the tidal wave of AI-generated code, particularly in large, long-lived enterprise codebases. It argues that context and large-scale code visibility are critical infrastructure, not just model quality, for effective AI agent deployment. The talk introduces Sourcegraph's Agentic Batch Changes, a system designed to make and audit changes across thousands of repositories from a single prompt, addressing the challenge of managing AI-driven modifications at scale.
  11. How VS Code Went from Monthly to Weekly Releases with AI — Harald KirschnerThis post details how VS Code transitioned from monthly to weekly releases by rebuilding its development system around AI agents. Key contributions include: making codebases 'agent-ready' by enabling agents to drive the application and use tools like Playwright for self-correction; encoding expertise into 'skills' for agents; achieving 10x faster builds with TypeScript Go; implementing mandatory AI code review and AI-driven issue triage; and transforming error stacks into auto-fix PRs. It also highlights the importance of VSC-Bench for evaluating AI performance and token efficiency, and the benefits of smaller, more focused squads for durable ownership. The talk quantifies the increase in agent-written code committed (55% to 86%) and discusses the challenges of scaling CI with multiple agents.
  12. The State of AI in Software Development: Data from 400+ Orgs — Justin Reock, DXThis post contributes data and insights into the state of AI in software development, based on research from over 200,000 engineers across 400+ organizations. It identifies five key trends: rising deployment frequency with increased change failure rate volatility, improved maintainability alongside decreased change confidence, shifts in AI usage patterns between junior and senior engineers, and the realization that code generation is not the primary bottleneck. The post introduces the DX AI Measurement Framework for assessing AI utilization, impact, and cost, and discusses platform AI readiness through the lens of 'agent experience.' It also presents case studies demonstrating AI's application across the SDLC, including Morgan Stanley's significant time savings, Zapier's increased engineer value, and Spotify's SRE incident agent.
  13. Software Engineering Is Becoming Factory Engineering — Zach Lloyd, WarpThis post defines and advocates for 'Software Factory Engineering,' a new approach to software development that treats the entire process as a factory. It details the components of such a factory, including inputs, triage, specification (product and tech), implementation, review, verification, and monitoring. The talk highlights the benefits of open-sourcing and using automation to manage open-source contributions, and introduces the idea of 'factory agents' and skill-improvement loops for continuous optimization. A starter repository for building these factory agents is also provided.
  14. Orchestras, Not Factories: How the Fastest Builders Work — Charlie Holtz, ConductorThis post critiques the 'software factory' metaphor for software development, proposing an 'orchestra' model instead. It outlines six principles for effective building: 1. Stay near the frontier (but don't try to beat the market). 2. Create 'slop-free zones' for critical, human-reviewed tasks like migrations, docs, and skill files. 3. 'Feed the beast' by centralizing all communication and data (Slack, bug reports, meetings) into a queryable database for agents. 4. Give agents 'free range' with cloud sandboxes. The talk also demos new Conductor features for real-time collaboration and starting agents from a phone, reinforcing the human-in-the-loop, conductor-like approach to managing AI agents.
  15. Scale the Judgment, Not the Model — Andrew Orobator, RedditThis talk introduces the concept of 'judgment' as the primary bottleneck in AI agent development, rather than the models themselves. It proposes operationalizing this judgment through 'skills' (codified institutional knowledge), 'work logs' (for agent state and progress tracking), and 'personas' (to emulate human expertise like security reviewers or designers). A case study of a feature-flag cleanup agent is presented, demonstrating its ability to achieve high success rates (7/7 green-CI PRs) at a low cost ($1.26 per PR). The talk also highlights the risk of agents developing unintended 'ladders to climb out of the pit of success' and advocates for scaling judgment through specialized agents rather than solely relying on larger models.
  16. No, That's Not a Software Factory — Ryan Cooke, WorkOSThis post critiques the standard 'software factory' model where an agent is placed in a sandbox and merges PRs, arguing that this approach yields results indistinguishable from engineers using local AI tools. The author proposes an alternative 'orchestra' model where the engineering process itself is built into the factory. Key contributions include: 1. Redefining success metrics from PR count to customer-facing outcomes like defect rates and recovery time. 2. Introducing TARS, an agent that integrates with Slack, Linear, and GitHub via webhooks to manage project tickets. 3. Describing Horizon as an orchestration layer that connects to an internal MCP gateway, which acts as a 'context engine' for all tools, including Snowflake. 4. Highlighting the importance of a PM agent for drafting product docs ('Hilltop') and breaking down approved work into tickets, thus solving the 'blank page' problem. 5. Discussing the need for custom sandboxes and a company-wide memory layer for enhanced agent capabilities and self-improvement.
  17. What It Actually Takes to Build a Software Factory — Tereza Tížková, FactoryThis post defines a software factory as the autonomous execution of the entire software lifecycle, encompassing signal collection, prioritization, building, validation, and improvement. It outlines three core principles for building such factories: 1. Agnostic approach: integrating with existing team workflows and automatically routing between different AI models to achieve savings (around 25% demonstrated). This involves a router that considers model capabilities and cost. 2. Autonomy: enabling long-running 'Missions' (up to 16 hours in an example) where worker agents execute sequentially, each starting with fresh context, and validators (including one that interacts with the application) ensure code quality. 3. Continuous improvement: employing deferred context engines to reduce token usage by over 50% and implementing agent readiness checks to prevent code degradation. The human role is shifted to strategic decision-making, offloading repetitive and annoying tasks to agents.
  18. I Turned Coding Agents Into a Strategy Game — Ido Salomon, AgentCraftThis talk introduces AgentCraft, an orchestrator for coding agents styled as a strategy game. It enhances visibility by mapping agents to units on a file system terrain with heatmaps, and provides direct access to attention-worthy items. Autonomy is increased through orchestrators and loops, with a review kit offering visual evidence. Collaboration is facilitated via shared rooms for humans and agents. A simpler, mobile-game-style mode and 'loopers' are presented to lower the barrier to entry for less technical users.
  19. How Software Factories Improve Themselves — Suraj Gupta, WarpThis post details three practical methods for self-improvement within software factories, exemplified by Warp's open-source factory. First, 'skills that improve themselves' are achieved via an outer-loop agent that monitors triage agent runs and feedback, then opens PRs to update skills, ensuring Git tracking and human review. Second, 'persistent memory' provides a versioned, traceable store of facts, preventing agents (like a Sentry agent) from re-discovering known root causes. This memory system is harness-agnostic. Third, 'model routing' optimizes costs by directing tasks to appropriate models (e.g., using cheaper auto models for triage or simple CI fixes instead of Opus), with Warp's internal evals showing UI tasks perform well on GLM.