Building your own software factory — Eric Zakariasson, Cursor

Key Concepts

• Software Factory: A highly automated, agent-driven development environment where AI agents handle coding, testing, and deployment with minimal human intervention.
• Levels of Autonomy: A framework (inspired by Dan Shapiro) ranging from basic autocomplete (Level 1) to fully autonomous "dark factories" (Level 6).
• Agentic Workflow: Shifting from a "worker" mindset (writing code) to a "manager" mindset (orchestrating agents, setting intent, and reviewing outcomes).
• Guardrails & Rules: Constraints and SOPs (Standard Operating Procedures) that prevent agents from going "off the rails" or making costly mistakes.
• Verifiable Systems: Architectures designed so agents can test their own work (e.g., Playwright for UI, unit tests for backend).
• Cursor Workers: Infrastructure for running agentic orchestration locally or on private VMs, allowing for isolated, reproducible environments.
• MCP (Model Context Protocol): A standard for giving agents skills and access to external context (e.g., Slack, Linear, GitHub).

1. Building the Software Factory

The speaker emphasizes that building a software factory requires borrowing principles from hardware manufacturing: assembly lines, observability, and management.

• Primitives and Patterns: Codebases must be modular and well-structured. If a human can easily onboard to a codebase, an agent can too. Standardizing boilerplate (e.g., package.json scripts) makes the code "in-distribution" for models.
• Guardrails: Rules should emerge dynamically. Rather than installing every rule, create them as SOPs when agents deviate from desired behavior.
• Enablers: Give agents "skills" (MCPs) to perform specific tasks like feature flagging, which allows them to merge code autonomously and revert if necessary.
• Verifiable Systems: The most critical component. Agents must be able to verify their own work through automated tests (unit, integration, and UI/DOM testing).

2. Running and Scaling the Factory

• From Sync to Async: As autonomy increases, developers move from synchronous coding to asynchronous management. You provide the intent, and the agents execute in the background.
• Isolation: To scale to thousands of agents, use isolated environments (separate VMs or containers) to prevent side effects and merge conflicts.
• Managerial Mindset: The developer’s role shifts to scoping, parallelizing tasks, and managing "agentic code owners."
• Continuous Learning: Use plugins or automations to scan past transcripts and PR comments to extract "memories" and "rules," effectively teaching the agents your preferences over time.

3. Real-World Applications & Tools

• Agentic Code Owners: A system that evaluates the risk of a PR. Low-risk changes are auto-approved; high-risk changes trigger a review by the human who previously touched that code.
• Daily Review Automations: Agents scan Slack and GitHub to provide a summary of daily progress, replacing manual status updates.
• Computer Use: Agents can now control the computer (keyboard/mouse) to perform UI testing, record videos of their own work, and verify that buttons/spinners function correctly.
• Cursor Workers: A new tool allowing users to run the same orchestration layer used by Cursor’s cloud agents on their own hardware (e.g., Mac Mini, private VMs).

4. Key Arguments and Perspectives

• Intent over Code: The most important skill is clearly defining the "intent" and the "problem to solve." If the intent is clear, the model can handle the implementation.
• Accountability: Humans remain responsible for the output. Critical systems (security, payments, auth) should always have human oversight.
• The "Vibe" Check: When agents are used for side projects or non-critical tasks, the speaker suggests trusting the output if the tests pass, rather than manually reviewing every line of code.
• Cultural Shift: Teams must move away from "siloed" factories where every engineer has unique rules, toward a unified factory structure established through team forums and shared best practices.

5. Notable Quotes

• "You are going to go from worker to manager... you are overseeing a lot of agents doing the work for you."
• "Rules should just emerge dynamically. If you're finding agents going off the rails, you should probably create a rule for that."
• "Don't outsource important decisions... some things are really important and should not be made by agents."
• "The 10x engineer is no longer about words per minute. It's about prompting... token usage."

6. Synthesis/Conclusion

The transition to a "software factory" is an evolution of abstraction. By building verifiable systems, establishing dynamic guardrails, and utilizing isolated environments, developers can achieve massive throughput. The future of engineering lies in managing fleets of agents, where the developer's value is defined by their ability to architect systems, set clear intent, and build the "assembly lines" that allow agents to operate safely and autonomously.