AI
Levels of Agent Autonomy
Dan Shapiro’s six-stage autonomy ladder starts at “spicy autocomplete” and ends at what Shapiro calls the dark factory: agents shipping, testing, and merging code with no human watching the diff. Zakariasson puts most developers at levels two and three today, pair-programming back and forth with an agent. He operates at level four himself, delegating as much as possible and reviewing outputs before reading the code.
The factory endpoint flips the human role entirely. You supply intent and constraints; agents do everything else. Cursor has not reached it, but sub-sections of the product already run fairly autonomously.
Building the Factory: Primitives, Guardrails, and Enablers
Three things make a codebase factory-ready. Structure: co-located, modular code lets an agent ls a folder and find everything it needs without grepping the whole repo. Guardrails block agents from authentication and payment code. Rules should emerge from observed failures, not copied from generic templates.
Enablers give agents real capability. In the music agent dev-server demo (13:10), the agent read package.json and started the server without prompting. The agent self-testing video (16:50) shows a cloud agent on an isolated VM controlling the browser and returning a screen recording as proof.
Running the Factory: The Manager Mindset
Once the infrastructure is in place, the human role shifts from writing code to scoping, parallelizing, and reviewing outcomes. Most work happens in the background; agents run on separate VMs. Cursor runs what Zakariasson estimates at multiple thousands of agent sessions per day.
Two constraints matter at scale. Assigning two agents to the same file causes merge conflicts and kills the throughput gain. Frontloading context beats interrupting mid-task: write a full spec, send the agent, let it finish. The more you do this, the better you learn which tasks a given model handles well and which need tighter rules.
Scaling with Automations and Feedback Loops
Zakariasson runs four scheduled automations at Cursor. A daily review agent reads Slack and GitHub and sends a digest. A merged-PR-comments agent scans every merged PR, extracts high-signal reviewer notes, and stores them so agents can learn from human feedback. An agentic code-owner bot scores incoming PR risk, auto-approves low-risk changes, and routes high-risk ones to the engineers who last touched that code.
The fourth, “continue learning,” scans previous chat transcripts and turns repeated correction patterns into Cursor rules automatically. All four follow the same logic: find where a human is doing repetitive work and build a system to replace it.
Q&A
When agents ship tons of code you can barely review, how do you ensure the code stays extensible and architecturally sound? Zakariasson acknowledged agents have a completion bias and said the answer is pointing them at existing reference implementations so they continue established patterns rather than inventing new ones, plus using a separate refactoring agent to generalize after the fact. ▶ 34:41
How do you get an entire team contributing to one shared factory rather than each engineer building their own private ruleset? He said it is a cultural problem with no clean solution, but suggested treating factory design like code review: establish a shared forum to agree on components, integrations, and rules, with the expectation that not everyone will agree but the team must still converge. ▶ 37:03
What extra patterns apply to enterprise brownfield systems that cannot fail or be insecure? Zakariasson recommended spending significant compute upfront before any human is involved, manually writing tests for critical system paths and running them heavily via agents, and pointed to Cursor’s internal security sentinel, an automation that checks specific invariants on PRs touching sensitive files. ▶ 39:36
Notable Quotes
agents going off the rails, you should Eric Zakariasson · ▶ 8:30
completion bias. They want to finish task as soon as possible and uh they don’t think ahead. They don’t have their audience member · ▶ 35:30
how many we are running today, but I bet it’s like multiple thousands a day. Um Eric Zakariasson · ▶ 23:00
Key Takeaways
- Start with primitives: a modular, co-located codebase lets agents orient and act without burning context on search.
- Rules and guardrails should emerge from observed failures, not be copied from generic template libraries.
- Scaling past ten agents requires shifting to async delegation, scoped tasks, and automated feedback loops that write their own rules.