10x your throughput: How AI can transform software development and systems administration without loosing quality

Engineering teams are under enormous pressure to ship more software and keep infrastructure running with fewer people on tighter budgets. At the same time, AI coding agents, generative search, and automation tools promise 10x throughput, often with little mention of how quality, governance, or compliance survive the change. The art is to bring these interests together in a manner where they satisfies both, the goal of innovation and governance.

In this post we will look at the impact of business-specific context and graphs compared to blind search, find out about the impact of MCP servers as well as multi-harness setups, and learn how to avoid context pollution when you wire agents into real platforms.

Throughput is useless without governance

If AI turns your team into a faster version of its current habits, you only magnify design flaws, security gaps, and operational debt. That's why the starting point for 10x throughput is not more agents, it is a clear governance model that defines who owns what, when agents are allowed to act, and how changes are reviewed and audited.

This governance model treats agents as contributors, not decision-makers. It establishes policies for which workflows can be automated, where approvals are required, and how blast radius is limited. Human owners stay accountable for architectural decisions, changes to critical systems, and exceptions. Agent-driven changes move through the same CI/CD, testing, and review processes as human changes, with the added requirement that every automated action leaves an auditable trail.

In practice this means introducing structured policies instead of ad hoc chat prompts, defining explicit emergency stop mechanisms for agent workflows, and focusing on clear separation between environments. Because throughput improves due to agents removing toil from well-understood workflows, not as a result of them improvising in production.

The importance of business-specific context

Recent work from researchers on agentic coding introduced the idea of context fluency, where the developer skill of deliberately preparing rich, structured context that agents can act on becomes the focus. Their methodology borrows the culinary concept of mise en place and suggests the three phases of contextual grounding, collaborative specification, and structured task decomposition, all before agents even start editing code. The full paper called "Mise en Place for Agentic Coding: Deliberate Preparation as Context Engineering Methodology" can be found here.

The key insight is that generic models trained on public code cannot see your domain language, product invariants, or contractual obligations unless you externalize those into structured artifacts and feed them through governed channels. In this case, domain experts must first turn tacit knowledge into documents, diagrams, and policies that agents can read, because these artifacts are usually private and live in your own repositories as well as wiki rather than public internet sources. Hence, you need patterns for maintaining them close to the code first.

One effective pattern is to treat project context as a first-class asset, maintained in version control alongside your code, meaning instead of scattering knowledge across tickets, wiki pages, and slide decks, teams maintain compact descriptions of system purpose, domain language, architectural constraints, compliance requirements, and known risks in a standard format. Agent harnesses, for example IDEs, custom tools, or MCP-connected clients, derive their configuration from this context, so every tool sees the same structured reality instead of each one improvising its own view avoiding unsolicited context injection.

Using graphs instead of guesswork

Once agents have structured business context, they still need to navigate the reality of your codebase. Large monorepos, especially those built on Nx, split truth across project configuration files, TypeScript imports, OpenAPI specs, AsyncAPI channels, markdown docs, and layered application code, creating a complex environment to work in. In these cases classic ripgrep can find strings and Nx graphs can name projects and dependencies, but neither, by itself, answers a question like "what breaks if I change this library, including endpoints and docs?" in one shot.

That's why we decided to generate a custom graph and create a performance test in the form of a benchmark. It compared the three approaches (ripgrep, NX graph, and custom graph) to agent questions about topics like the project blast radius, HTTP endpoint ownership, keyword-based discovery, and project-linked documentation. The result showed that ripgrep was usually fastest for raw text but returned unstructured noise. In comparison, the Nx project graph answered dependency questions correctly yet was roughly 15–30 times slower than ripgrep and could not see APIs or docs. Lastly, the knowledge-graph approach sat near ripgrep on latency (around 90–110 milliseconds median) while winning on structural capability (typically 80–100 out of 100) because it indexed OpenAPI, documentation, and architectural files on top of Nx edges. Whilst this, of course, was an experiment tailored towards the contents of the forepath/one GitHub repository, the conceptual lesson itself is widely applicable to any project that is worked on with AI system. Based on the knowledge gathered by the benchmark, we advise the following:

• Use grep when you already know the needle and just need file paths.
• Use a project graph when you need authoritative boundaries and dependencies for builds and affected calculations.
• Use a knowledge graph when agents need blast radius, endpoint ownership, doc linkage, or typed discovery.

Allowing controlled real-world interaction through MCP

Models cannot talk to your systems directly. They need a standardized way to reach tools, data sources, and services. That's what the Model Context Protocol (MCP) provides. It is an open standard that gives AI models a universal interface for connecting to external systems such as Git repositories, databases, design tools, and deployment platforms.

Without MCP, every application would need its own integration strategy for each tool. MCP changes that by defining a single protocol and a server abstraction. Each MCP server exposes tools, resources, and prompts over a uniform interface, and any compatible host, including IDEs, terminals, and web clients, can connect to it which drastically reduces the error rate and makes for more reliable processes. That's why MCP servers have quickly become essential for AI-assisted development workflows.

For teams that want both throughput and control, the pattern is to combine MCP servers with multi-harness context. In this case a single project context definition feeds multiple harnesses, so they all see the same description of the system. The result is an architecture where you can adopt new agent clients without rewiring the entire tool layer. An architecture where governance applies consistently, regardless of which harness is in use.

The role of systems administration

Most discussions of AI throughput focus on code generation. However, in practice, the biggest gains often appear in systems administration and day-to-day platform operations, because real platforms must survive on-call rotations, partial outages, and business constraints. That is the reason why “built in production, not in slide decks” is way more than just another slogan. It is a way to secure your technical future. Because at most times AI is only useful if it cooperates with your infrastructure under strong operational constraints.

A good mental model that we can derive from this is not to open SSH sessions or craft ad hoc scripts against production. Instead, we should let our agents operate through well-designed tools, meaning orchestration CLIs for multi-cluster Docker and Kubernetes, infrastructure-as-code pipelines for environment creation, and ticket-driven processes for changes that know their own blast radius. When doing this, AI quickly becomes an assistant that generates runbooks, suggests command sequences, or prepares migration plans, who still routes the actions through existing operational controls.

Not at last, deep search tools are invaluable for understanding new technologies, regulations, or platform options. Teams use AI research assistants to explore NIS2 obligations, multi-cluster networking strategies, or billing integration patterns, but they do not ship answers without human review. AI-assisted code reviews follow the same pattern. Agents run linting, tests, and static analysis, but human reviewers decide which changes land. Because giving up full control over code and systems poses an enormous risk to the future of every company.

Avoiding context pollution

Dumping everything into the agent context is an easy way to feel thorough and a fast one to degrade quality. However, this can cause unwanted context pollution.

Context pollution happens when ever agents receive more text than they can meaningfully parse for the task at hand. Long lists of unrelated file hits, full-document dumps, or mixed domains (billing, infrastructure, experiments) are popular examples and tempt to turn prompts into swampy environments where subtle but critical constraints are easily lost. The problem is not that models are too weak. It is that we did not deliberately prepare context that matches the question.

Winning teams use opinionation as a quality tool to counter act this behavior. Context definitions are compact and structured, describing systems at the level agents need, not at maximal verbosity. Graph queries return focused neighborhoods, including dependencies, owners, endpoints, and docs, rather than whole graphs. MCP servers expose specific tools and resources instead of raw databases. Infrastructure CLIs encode lifecycle workflows so that agents call a small number of well-crafted commands instead of improvising. Less, in this sense, is more, because structured, scoped context is how you get both throughput and reliable decisions.

Governance and control as first-class features

Unexplainable throughput gains are not trustworthy. Teams need to know which changes happened, why they were allowed, what they affected, and how they propagate into revenue or risk.

Treating governance and control as features, not friction, changes how you design systems. Agent behavior, infrastructure operations, and billing events are all logged and correlated. Approvals for high-risk actions are explicit and auditable. Guardrails are encoded in configuration and policy, not in tribal knowledge. Compliance frameworks such as NIS2 and GDPR are translated into concrete engineering guardrails. This allows for restricted data flows, mandatory logging, retention rules, and the introduction of incident response protocols.

When governance is embedded into everyday workflows, AI becomes a way to accelerate well-understood processes instead of inventing new shadow systems. You can then measure throughput gains in real metrics, meaning cycle time, defect rate, incident response, and reconciliation speed, without guessing whether a model silently broke invariants behind the scenes. That is the difference between 10x chaos and 10x sustainable throughput.

TL;DR

• AI can 10x throughput in software development and systems administration, but only when it is embedded into a governance model that keeps human owners in charge and makes agent actions auditable.
• Business-specific context is the real fuel for agentic workflows. Methodologies like mise en place and context fluency help externalize tacit knowledge into structured artifacts that agents can safely use.
• Graph-based views of monorepos deliver near-grep latency with dramatically better structural answers than plain search or raw project graphs, turning scavenger hunts into single recipe calls for blast radius and ownership questions.
• MCP servers act as hands for AI models, standardizing how agents connect to repos, billing platforms, infrastructure tools, and observability stacks, so multi-harness setups can share the same governed tool layer.
• Avoiding context pollution through opinionated context design, scoped graph queries, and well-designed MCP tools is critical for preserving quality, governance, and long-term maintainability in high-throughput AI-assisted engineering.