← All speakers

Bio, Work & Ideas

Eric Zakariasson

Conference affiliation: Cursor · 2026

On this page

Eric Zakariasson is a Swedish software engineer, startup co-founder, and former Cursor builder developing a practical approach to agent-first software development. His central concern is how autonomous coding systems can produce reliable software while engineers retain responsibility for architecture, security, and product decisions.

From product engineering to software factories

Zakariasson worked in frontend engineering at Jetshop and full-stack development at Bokio before becoming a technical lead at Mindler. He subsequently worked as a senior software engineer and technical lead at anotherblock, co-founded Skyffel, and joined Cursor in a product-engineering and developer-experience role.

At Cursor, he developed an approach to building a software factory in which coding agents implement, test, review, and refine software under human supervision. An agent-built music-production application illustrated his method: reproducible development environments, Playwright browser tests, and recorded interactions allowed software to be evaluated through observable behavior. Separate virtual machines enabled parallel work without collisions between databases, services, or branches.

Principles for dependable autonomy

  • Agent-ready environments need foundations, guardrails, and enablers. Modular code, familiar project structures, and reusable patterns help agents navigate a codebase; tests and restrictions protect sensitive systems; integrations and runnable environments give agents enough context to operate independently. Zakariasson organizes these requirements into a practical development-environment framework.
  • Verification determines when agents can work independently. In Human in the /loop, he describes assigning measurable completion criteria, including passing tests, improved evaluations, verified interfaces, performance thresholds, and clean data. Explicit stopping conditions and human escalation prevent long-running agents from becoming unaccountable.
  • Rules should encode real mistakes. He favors continual learning from agent workflows: extracting recurring corrections and code-review feedback into durable guidance instead of accumulating generic instructions. Risk-sensitive review can route consequential changes to experienced humans while allowing routine work to proceed.
  • Agent capabilities need deliberate boundaries. His pg-mcp-server connects PostgreSQL to the Model Context Protocol with writes disabled by default, while uber-eats-mcp-server explores browser-driven integrations. His scandinavian-design project packages visual-design constraints as an agent skill.

Zakariasson favors composable software primitives and expects engineers to concentrate increasingly on defining intent, preserving architectural knowledge, and reviewing security-critical decisions. For experimental interfaces, he treats prototypes as expressions of product intent—not production systems that must inherit accidental technical choices.

Read the topics behind these talks

1 conference talk

Key ideas

Scroll to read ↓

Eric Zakariasson shows how runnable environments, verifiable outputs, isolated agents and feedback loops turn delegated coding into an operating system for software delivery.

  • What does it take to delegate software production?
    0:17 ↗
  • Make the repository discoverable, bounded and usable
    4:59 ↗
  • Starting and testing an agent-built music tool
    10:42 ↗
  • Return evidence a human can review
    14:35 ↗
  • Scope work before multiplying agents
    16:52 ↗
  • A separate checkout is not a separate system
    20:33 ↗
  • Turn repeated handoffs into persistent workflows
    22:20 ↗
  • Route reviews by risk and retain corrections
    27:38 ↗
  • Preserve judgment and listen for missing capabilities
    31:05 ↗
  • Architecture and team agreement remain harder than checks
    33:39 ↗
  • Let durable rules follow observed gaps
    40:58 ↗
  • Separate functional proof from visual acceptance
    46:01 ↗
  • Hide startup complexity behind a dependable interface
    50:42 ↗
  • Hand off the intended interaction, not an accidental architecture
    53:05 ↗
  • Plan synchronously, execute asynchronously
    58:13 ↗
  • Keep the factory understandable to people and agents
    1:02:37 ↗
  • Let system events initiate maintenance
    1:08:19 ↗
  • Run the harness on infrastructure you control
    1:11:20 ↗
  • Coordinate ownership without exposing the org chart
    1:15:53 ↗
  • Detect activity that is making no progress
    1:21:00 ↗

References