# 850 PRs a Week: How Tessl Runs a Software Factory

## Executive summary

The video outlines the concept of a 'Software Factory'—a modern development paradigm where most work is managed by self-improving AI agents. This factory model progresses from defining foundational standards (Skills) to creating automated, iterative workflows (Loops), culminating in full automation. Key insights emphasize that success requires prioritizing context engineering and standardization over raw speed, as the primary gains are increased code quality and functional fungibility across teams.

## Key takeaways

- The Factory's True Gains: Increased capacity does not solely lead to feature velocity; two major benefits observed are an increase in overall code quality (e.g., fixing consistency, copy, and brand voice) and improved fungibility, allowing non-engineering teams (like GTM) to make high-leverage changes without waiting on support.
- Context Precedes Automation: The core principle is that before automating a process, one must first define 'what correct looks like.' This context definition serves as the manual for operating the company and is critical for building resilient, scalable agents.
- Skills $\rightarrow$ Loops $\rightarrow$ Factory: The factory model is a continuum: Skills are defined units of work or policies; Loops are automated skills that improve with each run (compounding gains); and the Factory is the system where most development effort shifts to maintaining and improving these loops.
- Enforcing Standards: Verifiers and Evals: To ensure quality at scale, systems must implement verifiers (generating LLM-judge tools from skills) and evals. These mechanisms enforce standards in CI/CD pipelines, moving code review checks 'left' into the development process.

## Technical details

- Skills Definition: A Skill is defined as a unit of work or policy that can be used by agents. It encompasses workflows, policies, hooks, and tools (like MCP tools), serving as the foundational input for automation.
- Loops and Compounding Gains: A Loop is an automated skill that runs without immediate human intervention. Crucially, it includes a meta-process where the loop improves itself with each execution, leading to compounding gains in productivity.
- Context-Driven Code Review: The philosophy advocates for shifting standards left: instead of relying solely on post-facto code review, standards must be documented and applied at the development stage (e.g., using 'lenses' that apply specific skills to file patterns).
- Skills Inventory & Governance: The Tessl platform offers a Skills Inventory tool (CLI/GitHub app) to scan an entire code estate, identifying duplicate context, stale skills, and providing governance over skill usage across repositories.

## Practical implications

- Focus on defining and codifying organizational standards (context) before attempting large-scale automation.
- Implement automated loops that continuously test and improve core workflows (e.g., dependency upgrades, flaky test detection).
- Utilize specialized tools like verifiers in CI/CD to enforce granular quality standards at the point of development, rather than waiting for manual review.
- Treat the software factory as a continuous evolution (a continuum) rather than a final destination.

## Topics

AI Agents, Software Factory, Context Engineering, DevOps, CI/CD, LLMs, Kikimora minidoc, Tessl Code Review

Source: https://www.youtube.com/watch?v=GRixg2mdJJA