The Dark Factory: Why Most Developers Are Getting Slower While AI Writes 90% of Code

While frontier teams like StrongDM operate fully autonomous “dark factories” where AI writes and ships code without human intervention, most developers using AI tools are actually getting 19% slower. This gap reveals the future of software development—and the organizational transformation required to bridge it.

The Productivity Paradox

At Anthropic, 90% of Claude Code’s codebase was written by Claude Code itself. Boris Churny, who leads the project, hasn’t personally written code in months. Meanwhile, a rigorous 2025 randomized control trial found that experienced developers using AI tools took 19% longer to complete tasks than those working without them.

The developers weren’t just wrong about the direction—they believed AI had made them 24% faster when it actually made them slower.

The Five Levels of AI-Assisted Development

Dan Shapiro, CEO of Glowforge, maps the industry’s current state through five levels:

Level 0: Spicy Autocomplete You type code, AI suggests the next line. This is GitHub Copilot’s original format—just a faster tab key.

Level 1: Coding Intern You hand AI discrete, well-scoped tasks like “write this function” or “refactor this module.” You review everything that comes back.

Level 2: Junior Developer AI handles multi-file changes and can navigate codebases. It builds features spanning modules. Shapiro estimates 90% of developers who claim to be “AI native” operate here.

Level 3: Developer as Manager The relationship flips. You direct AI and review at the feature level. The model submits PRs for your approval. Most developers hit this ceiling due to the psychological difficulty of letting go of code.

Level 4: Developer as Product Manager You write specifications and return hours later to check if tests pass. You’re not reading code anymore—just evaluating outcomes.

Level 5: The Dark Factory A black box that turns specs into software. No human writes or reviews code. The factory runs autonomously.

How Dark Factories Actually Work

StrongDM’s three-person team operates at Level 5. Their system runs on three markdown specification files that describe what software should do. The AI reads them, writes code, and tests it.

The key innovation: scenarios instead of tests. Traditional tests live inside the codebase where AI can see and game them. Scenarios live outside as behavioral specifications, functioning like a holdout set in machine learning.

StrongDM also built a “digital twin universe”—behavioral clones of every external service (Okta, Jira, Slack) so AI agents can run full integration testing without touching production systems.

Their output is real: 16,000 lines of Rust, 9,500 lines of Go, and 700 lines of TypeScript—shipped and running in production.

Why Most Organizations Are Stuck

The METR study revealed why AI makes developers slower: workflow disruption outweighs generation speed. Developers spend time evaluating suggestions, correcting almost-right code, and debugging subtle errors in generated code that looks correct but isn’t.

This is the J-curve of adoption. When you bolt AI onto existing workflows, productivity dips before improving. Most organizations interpret this dip as evidence that AI doesn’t work, rather than evidence that their workflows haven’t adapted.

Organizations seeing 25-30% productivity gains didn’t just install Copilot and call it done. They redesigned their entire development workflow around AI capabilities—changing how they write specs, review code, and structure their teams.

The Organizational Transformation

Most software organizations were designed for humans building software. Every process exists because humans need coordination structures:

• Stand-ups exist because developers need daily synchronization
• Sprint planning exists because humans have limited working memory
• Code review exists because humans make mistakes other humans can catch

When humans no longer write code, these structures become friction, not support.

StrongDM’s three-person team has no sprints, no standups, no Jira board. They write specs and evaluate outcomes. The entire coordination layer that constitutes most software organizations simply doesn’t exist.

The Skills That Matter Now

The bottleneck has moved from implementation speed to specification quality. Writing a specification detailed enough for an AI agent to implement correctly without human intervention requires rigorous systems thinking that most organizations have never needed from most of their people.

The humans on the other end of traditional specs could fill gaps with judgment and context. Machines build exactly what you describe. If your description is ambiguous, you get software that fills gaps with algorithmic guesses, not customer-centric ones.

The Talent Reckoning

Junior developer employment is dropping 9-10% within six quarters of widespread AI adoption. In the UK, graduate tech roles fell 46% in 2024. In the US, junior developer job postings declined 67%.

The career ladder is breaking. If AI handles simple features and bug fixes—the work juniors learn on—where do they develop skills? The pipeline that creates senior engineers is collapsing from the bottom.

Yet we need more excellent engineers than ever, not fewer. The bar is rising toward exactly the skills that have always been hardest to develop: systems thinking, customer intuition, and the ability to hold entire products in your head and reason about how pieces interact.

The Path Forward

For most organizations, the migration isn’t “deploy an agent that writes code.” It starts with developing specifications for what your existing software actually does—reverse engineering the implicit knowledge embedded in running systems.

This requires domain expertise, ruthless honesty, customer understanding, and systems thinking. Exactly the human capabilities that matter more in the dark factory era, not less.

The organizations that will get there fastest aren’t necessarily those with the fanciest tools. They’re the ones who can write the most honest specs about their code, who have the deepest domain understanding, and who have the discipline to invest in documenting what their systems really do.

The Future Is Already Here

The dark factory is real. It works. A small number of teams are producing software without humans writing or reviewing code. The tools are building themselves, and the feedback loop is closed.

Most companies aren’t there yet. They’re stuck at Level 2, getting measurably slower with AI tools they believe are making them faster. The distance between frontier and mainstream isn’t a technology gap—it’s a people gap, a culture gap, an organizational willingness to change.

The dark factory doesn’t need more engineers. It desperately needs better ones. And “better” now means people who can think clearly about what should exist, describe it precisely enough for machines to build it, and evaluate whether what got built actually serves real humans.

This has always been the hard part of software engineering. We just used to let implementation complexity hide how few people were actually good at it. The machines have stripped away that camouflage.

We’re all about to find out how good we really are at building software.