Donovan Crewe

The Dim Factory

The Goldilocks zone between AI convenience and full autonomy

By Donovan Crewe · · AI Agents, Software Delivery, AI Governance, DevOps, Enterprise AI

There is a new idea starting to circulate in AI engineering circles. The concept of a dark factory for software.

The premise is simple. Autonomous agents design systems, write code, generate tests, enforce security, and deploy to production without human intervention. Requirements go in, production systems come out. The pipeline runs continuously, with machines orchestrating the entire process.

We are starting to see early versions of this emerge.

Projects like OpenClaw are experimenting with multi-agent systems that can interpret tasks, generate code, validate outputs, and iterate toward a working solution. It is not a complete factory, but it is close enough to make the direction tangible.

For the first time, software production is beginning to look less like a craft and more like a system.

That shift is important.

Because once you accept the idea that software can be produced by coordinated agents, the natural question becomes how far this can go. Can we remove humans entirely from the loop? Can engineering teams be replaced by autonomous pipelines that build and maintain systems on their own?

Right now, most organisations are getting this wrong, but for completely opposite reasons.

Some are thinking too small.

They treat AI as a developer convenience. A faster way to write functions, generate tests, or explain unfamiliar code. It lives inside IDEs and chat windows, helping individuals move a little faster, but not fundamentally changing how software is produced.

The impact is incremental. Productivity improves, but the system stays the same.

At the other extreme, some organisations are thinking too far ahead.

They are chasing full autonomy. The idea that agents can design, build, test, and deploy software with minimal human involvement. It is an appealing vision, but it ignores a critical constraint. Today’s models are still inconsistent. They drift, misinterpret intent, and fail in ways that are difficult to predict.

In practice, fully autonomous pipelines introduce more risk than they remove.

This creates a gap between ambition and reality.

And this is where the more interesting position sits.

The teams that are getting this right are not aiming for full autonomy, and they are not settling for marginal gains. They are building something in between.

The dim factory.

A dim factory accepts two truths at the same time.

First, AI can already take on a significant portion of the software production workload. Code generation, test creation, dependency management, and even structured refactoring can be handled by agents when properly constrained.

Second, AI cannot yet be trusted to operate without strong governance. The cost of subtle errors in production systems is still too high, and the behaviour of models is not stable enough to remove oversight entirely.

So instead of pushing to the extremes, these teams design systems where agents operate within clearly defined boundaries.

They introduce structure.

Inputs are standardised. Outputs are validated. Pipelines enforce architectural rules, security requirements, and quality thresholds automatically. Agents are orchestrated as components in a system, not used as ad hoc tools.

Humans remain in the loop, but their role shifts.

They are no longer doing the bulk of the mechanical work. They are designing the system that does the work. They define constraints, monitor behaviour, and intervene when the system reaches the edge of its capabilities.

You start to see the real shift when you look at where effort is spent.

In a traditional team, most of the time goes into writing code, fixing bugs, and coordinating releases. In a dim factory, most of the effort moves into designing the system that produces the code.

Engineers define constraints. They design validation pipelines. They create structured inputs that reduce ambiguity. They implement feedback loops that continuously evaluate output quality.

The agents do the work, but the system defines what good looks like.

This is where the practical advantage starts to emerge.

Dim factories allow teams to increase output without increasing risk at the same rate. Because the system is governed, you can safely let agents handle repetitive and high volume tasks. Code generation, test creation, dependency updates, even controlled refactoring cycles.

At the same time, critical decisions remain under human supervision.

Architecture choices, production releases, and high risk changes still require oversight. Not because agents cannot assist, but because the cost of being wrong is still too high given the current level of model reliability.

The truth is that most organisations do not fail at adopting AI because of capability. They fail because of a lack of structure.

They give engineers access to powerful models without defining how those models should be used. Prompts vary wildly. Outputs are not validated consistently. There is no shared understanding of what constitutes acceptable AI generated code.

In that environment, scaling AI usage increases risk.

Dim factories solve this by standardising how AI participates in the development process.

Agents are not free roaming assistants. They are components in a controlled pipeline. Each step has defined inputs, expected outputs, and validation criteria. If an agent produces something outside of those constraints, the system catches it early.

This is where governance becomes an engineering discipline rather than a compliance checkbox.

You are not writing policies that sit in documents. You are encoding those policies into the pipeline itself. Security checks run automatically. Architectural constraints are enforced programmatically. Code quality standards are validated continuously.

The system enforces behaviour, not people.

This also changes how organisations scale.

Traditional engineering teams grow linearly. More features require more developers. More developers require more coordination. Eventually communication becomes the bottleneck.

Dim factories scale differently.

Once the pipeline exists, new agents can be introduced to extend the system. A performance optimisation agent can monitor production systems and propose improvements. A security agent can continuously analyse dependencies. A refactoring agent can restructure legacy codebases.

Each addition improves the entire factory.

Instead of hiring more developers to increase output, teams evolve their production system.

This is where the strategic implications become clear.

The companies that stay in the “too small” camp will struggle to keep up. Their output remains constrained by human bandwidth while competitors begin to scale through automation.

The companies that jump straight to full autonomy will encounter instability. Their systems will break in unpredictable ways, and trust in AI driven development will erode internally.

The organisations that operate in the middle will compound.

They will build systems that are both productive and reliable. They will learn faster because their pipelines generate continuous feedback. They will be able to absorb improvements in AI capability without rethinking their entire operating model.

This is the Goldilocks zone.

Not too small. Not too autonomous.

Just enough structure, just enough control, and just enough autonomy to move faster than everyone else without losing stability.

What often gets overlooked is how quickly this landscape is evolving.

A few years ago, most teams were experimenting with simple code generation. Today, we are seeing coordinated agent systems that can plan, execute, and iterate across complex tasks. Entire workflows have shifted in a relatively short period of time.

Very few organisations predicted that pace accurately.

This is why trying to build a fully autonomous dark factory today is risky. You are optimising for an end state that is still unstable, on top of technology that is evolving faster than most operating models can adapt.

Dim factories provide a more resilient path.

They allow organisations to adopt AI deeply while maintaining control. They create an environment where improvements in model capability translate directly into increased system performance.

As models become more reliable, you can gradually increase the level of autonomy.

The lights get dimmer over time.

Dark factories may eventually become real.

But the companies that get there will not arrive by switching the lights off overnight.

They will be the ones that learned how to operate in the dim.