Building Context-Centric Software Factories with AI Agents
TESOL demonstrates how shifting from manual coding to agentic loops increases PR volume by 850 per week while improving quality. This analysis details the strategic transition from skills to autonomous factories, emphasizing context-centric governance and verifiable standards for enterprise scalability.
The Shift to Context-Centric Factories
The software development paradigm is undergoing a structural shift from human-led coding to agentic 'software factories.' TESOL, a platform for context engineering, has operationalized this shift by achieving a peak of 850 pull requests per week, with 85-90% handled entirely by AI agents. This case study reveals that the primary value of agentic automation is not merely speed, but a significant increase in quality and organizational fungibility. By automating routine maintenance and consistency checks, teams can clear backlogs of low-leverage tasks, allowing human engineers to focus on high-impact architectural decisions.
From Skills to Autonomous Loops
The core framework for this transition is the progression from skills to loops to factories. Skills represent codified workflows or policies that define what 'correct' looks like. Loops are automated instances of these skills that run continuously, incorporating feedback to improve over time. This iterative process creates compounding gains, where the system becomes more resilient and accurate with each cycle. Unlike generic AI tools that provide a one-time 'dopamine hit' of speed, context-centric loops require upfront investment in defining standards. This investment pays off by enabling the reuse of standards across development, review, and maintenance phases, ensuring consistency across the entire software development lifecycle.
Governance and Verification
A critical challenge in agentic development is ensuring that agents adhere to complex, nuanced standards. TESOL addresses this through 'verifiers,' which are lightweight, high-accuracy checks derived from skills. These verifiers can run in CI/CD pipelines to enforce compliance deterministically, bridging the gap between probabilistic LLM outputs and deterministic software requirements. Additionally, the platform introduces a 'Skills Inventory' that scans codebases for stale or duplicate context, acting as a control plane for governance. This allows organizations to manage agent behavior at scale, ensuring that security policies and brand standards are consistently applied across all repositories.
Strategic Implications
The data suggests that the bottleneck in software development is shifting from code production to code review and standard definition. Companies that fail to codify their standards will hit a plateau where agents produce volume but not value. Conversely, those that invest in context engineering will see increased fungibility, where non-engineers can contribute to technical outputs, and higher quality due to continuous, automated enforcement of best practices. The future of engineering is not just about writing code faster, but about designing the systems that write code correctly.
Key insights
-
Agentic automation shifts the primary value proposition from speed to quality and consistency. By offloading low-leverage tasks like consistency fixes and copy edits to agents, human teams can focus on high-impact strategic work.
Impact: Reduces technical debt and backlog size, allowing engineering teams to deliver higher-value features without increasing headcount.
-
The transition from skills to loops creates a compounding productivity curve. Unlike linear automation, loops that learn and refine themselves over time lead to exponential improvements in system resilience and accuracy.
Impact: Enables organizations to achieve sustained productivity gains that outpace traditional manual or one-off automated workflows.
-
Context-centricity is the prerequisite for successful agentic scaling. Without explicitly defined standards and skills, agents produce inconsistent results, leading to a plateau in quality improvements after initial adoption.
Impact: Prevents 'vibe coding' failures by ensuring agents operate within clear, codified boundaries, reducing the risk of production errors.
-
Verifiers serve as the enforcement mechanism for agentic standards, allowing organizations to maintain deterministic quality controls in a probabilistic AI environment. This 'trust but verify' approach is essential for enterprise-grade reliability.
Impact: Increases confidence in AI-generated code by providing automated, high-accuracy checks that can be integrated into existing CI/CD pipelines.
-
Agentic workflows increase organizational fungibility, enabling non-engineers to execute technical tasks and engineers to work across functional boundaries. This breaks down traditional silos and accelerates cross-functional collaboration.
Impact: Reduces handoff friction and waiting times, allowing marketing, design, and engineering teams to ship changes independently and faster.
Action items
-
Codify existing code review standards into reusable 'skills' or policy documents. This involves documenting what 'good' looks like for different parts of the codebase, such as accessibility requirements for frontend and brittleness checks for backend.
Impact: Creates a foundational context layer that enables agents to operate consistently and allows for the reuse of standards across development and review phases.
-
Implement a context inventory tool to scan all repositories for duplicate, stale, or out-of-date agent skills. Identify opportunities to standardize on single sources of truth for common workflows.
Impact: Reduces inconsistency and maintenance overhead by eliminating redundant context, ensuring all agents operate on the most current and accurate standards.
-
Develop lightweight verifiers for critical skills that can run in CI/CD pipelines. These verifiers should check agent outputs against defined standards using deterministic logic or small, fast LLM judges.
Impact: Ensures that agent actions are compliant with organizational standards, providing a safety net that maintains quality as automation scales.
-
Shift code review standards left by applying them during the development phase rather than just at merge time. Configure agents to reference these standards while writing code to prevent issues before they occur.
Impact: Reduces the volume of issues caught in code review, decreasing rework and accelerating the overall development cycle.
-
Pilot agentic loops for maintenance tasks such as flaky test fixing, dependency upgrades, and architecture reviews. Start with manual execution of skills, then automate them into loops with feedback mechanisms.
Impact: Frees up engineering time for high-leverage work and creates a self-improving system that continuously optimizes the codebase.
Quotes
“We hit a peak of something like 850 PRs in a week and 85-90% of those were handled by agents entirely.”
“To automate the thing, you first have to sit down and do this bit that is defining what correct is.”
“Specificity basically is the ruler of all quality.”