Inside the Dark Factory: AI That Ships Code Solo

The podcast discusses the implementation and impact of "dark factories" - automated software development systems - in modern engineering workflows. These systems, powered by AI agents, generate and merge code with minimal human intervention, significantly increasing development velocity. At Tessl, 65 - 70% of pull requests (PRs) are created through the dark factory, with 95% of its codebase unreviewed by humans. While low-risk or internal PRs (e.g., research or tooling) are auto-merged after passing CI and agent reviews, production-critical changes still require human approval. The system relies on orchestrators that manage task prioritization from ticketing tools like Linear, delegate work to coding agents in isolated environments (e.g., Daytona sandbox), and use layered verification - including deterministic rules, LLM-based verifiers, and agentic review - to ensure code quality.

A key focus is the cultural and operational shift required to adopt such systems. Engineers must move from direct coding to higher-level planning, treating agents as junior team members that need clear, well-scoped tasks. Trust is built gradually through transparency, comprehensive verification, and iterative improvements. Challenges include context fragmentation, verification gaps (as seen in a failed Elixir rewrite), and communication overload due to rapid development cycles. To scale effectively, teams are encouraged to adopt incrementally, strengthen repository context, encode standards into verifiers, and maintain human ownership over code quality. The vision is a future where AI agents handle repetitive tasks, while engineers focus on system design, debugging, and refining the automation itself.

• What if you built a personal dark factory for your solo projects?

  • Move: Set up a local orchestrator that pulls tickets from Linear (or GitHub Issues), runs an AI agent in a Daytona-like sandbox to implement and test changes, then auto-generates PRs with screenshots/videos for review.
  • Why Now?: Tools like Daytona, LLMs, and CI/CD make it feasible to replicate Tessl's dark factory at scale for one person - especially as verification bottlenecks are now solvable via automated testing and agent-in-the-loop workflows.
  • Expected Upside: You ship 3 - 5x more features per week by offloading implementation and testing to agents, freeing you to focus on product design and user feedback.

• What if you replaced manual code reviews with deterministic verifiers on your projects?

  • Move: Define 5 - 10 critical rules (e.g., no direct DB writes, all endpoints must be typed, env vars must use config class) as fast-running, deterministic verifiers that block merges if violated - run them in CI instead of waiting for human review.
  • Why Now?: With 95% of dark factory code unreviewed by humans, the shift is already happening; solo devs can get ahead by encoding their standards into enforceable rules before scaling becomes chaotic.
  • Expected Upside: Cut review time by 70%, reduce merge conflicts, and maintain higher consistency across your codebase - even when using AI-generated code.

• What if you used risk-based auto-merge to deploy low-risk changes directly to production?

  • Move: Classify your PRs by risk (e.g., docs/config = low, UI/backend = medium, auth/billing = high), then enable auto-merge + auto-deploy for low-risk categories using GitHub Actions and a simple label-based trigger.
  • Why Now?: Tessl already auto-merges non-production PRs at scale (150 over a weekend); as a solo operator, you face less complexity and can safely adopt this earlier to accelerate iteration.
  • Expected Upside: Achieve near-continuous deployment for maintenance tasks (e.g., dependency updates, typo fixes, logging), reducing context switching and letting you focus on high-leverage work.

• Implement a dark factory-style automation system using an orchestrator that pulls tasks from your issue tracker (e.g., Linear) and delegates coding to AI agents in isolated environments like Docker or Daytona.
• Introduce deterministic verifiers for rule-based code checks (e.g., linting, security policies) to reduce reliance on manual reviews and lower LLM costs in CI pipelines.
• Start small by offloading well-scoped, non-critical tasks (e.g., documentation updates, test maintenance) to AI agents, then gradually expand scope as trust and system reliability improve.
• Build a feedback loop where automated review agents (with skills in security, legibility, and correctness) analyze PRs, respond to comments, and iterate on changes - escalating only when human input is required.
• Use agent-generated signals (e.g., CI failures, verifier results, PR patterns) to identify high-value automation opportunities and define autonomous loops, such as nightly cleanup or dependency updates, using tools like GitHub Actions.