AI factories and the context bottleneck

What changed: from chatty copilot to software factory

A software factory is not a single tool. It is a system—a production line that takes structured intent (specs, scenarios, requirements) and produces deployable, checked software with minimal human coding or review in the loop. The goal, as practitioners like Justin McCarthy (StrongDM) describe it, is non-interactive development: once intent is clear, agents write code, run harnesses, and converge without a human in every approval step.

“Why am I doing this? The model should be doing this instead.”

Modern long-horizon models can compound correctness when the loop is designed well—unlike earlier agent loops that stacked errors until the codebase collapsed. That viability shift is what makes “factory” a serious pattern, not a metaphor.

The core loop: seed, validate, repeat

Every credible factory architecture runs the same three-phase cycle:

SEED (intent)
    ↓
VALIDATE (scenarios / harness)
    ↓
FEEDBACK LOOP (self-correction → compound correctness)

Dan Shapiro’s framing is blunt: a factory is a black box that turns specs into software. The interesting engineering is everything you wrap around the model so that box is trustworthy.

What an AI factory is made of

Field write-ups converge on a small set of building blocks: a precise seed (structured intent), an explicit context layer (memory and knowledge on disk), orchestration (pipelines, workers, generator–evaluator loops), an external validation harness (scenarios, twins, tools), a rich tool layer, self-improvement (new scripts and conventions over time), and guardrails (sandbox, approvals, audit).

Agents have no built-in memory. The factory must supply a persistent, structured context layer—often Markdown, JSON, or YAML on the filesystem, with indexes, specs, and conventions. That discipline is what many teams now call context engineering: the quality system for what the agent is allowed to “know” on each step.

Where factories actually stall

Orchestrators, MCP servers, and eval loops are hard—but they are not the first hard problem. The factory assumes the seed is already excellent. Without that, the agent fills gaps arbitrarily, and you ship wrong software at high speed.

McCarthy starts from “a few sentences, a screenshot, or an existing codebase.” Other implementations expect “full documentation of your systems, schema, architecture, and conventions.” None of that appears by magic. Producing those artifacts systematically, keeping them aligned as code changes, catching drift, and covering every surface (feature, experience, services, data model, tech stack) is the missing industrial layer.

In other words: the bottleneck for most AI coding factories is not token limits—it is context engineering at scale. Everything downstream is only as good as the seed and the living context you feed the line.

EasySpecs: the context-engineering factory

Think of two factories in sequence:

EasySpecs is not a replacement for your coding agents. It is the starting point for the part they are worst at: maintaining a single, reviewable source of truth before and during implementation. In that sense, EasySpecs is a context-engineering factory for agentic coding factories—the place where the seed is forged, refined, and kept honest as the system evolves.

Where to go next

• Agentic hub — dictionary, articles, tools landscape, and FAQ.
• Create an account and run requirements and discovery context where your whole team can see them.
• Install the editor extension so builders stay in the same story as the web app.

Further reading