Factory AI founder Matan Grinberg joins Matthew Berman to discuss the rise of agent-native software development, the decline of traditional IDEs, and why systems thinking—not syntax—is the most valuable skill of the AI era.

At a time when AI is reshaping the craft of coding, Matan Grinberg is designing the tools to match it.

In this wide-ranging conversation, Matan shares how Factory reimagines the role of the software engineer, why agents are better parallel workers than humans, and how every engineer will soon be backed by an army of intelligent droids.

00:00 – Intro
From theoretical physics to AI: the journey behind Factory.

01:50 – Why Factory Exists
The IDE is dead. Coding with agents requires a new paradigm.

04:45 – From Faster Horses to Cars
Why you can’t iterate your way to the future.

06:05 – Parallelization and Agent-Orchestration
The wow moment: when multiple agents run simultaneously.

10:58 – Systems Thinking > Coding
Why systems design is the most critical engineering skill.

12:18 – Should You Still Learn to Code?
Why abstraction and fundamentals still matter in the agentic era.

17:25 – The New Economics of Software
How AI expands the total addressable market for engineering problems.

21:32 – Agent-Native UX and Design
Factory’s product design is built from first principles, not nostalgia.

30:44 – How Factory Understands Codebases
First-party integrations, memory, and local execution.

37:20 – Vertical SaaS in a Zero-Cost World
Why internal tooling will outcompete off-the-shelf SaaS.

40:58 – What’s Next for Factory
Reliable agents, lower effort, and mass adoption.

The core idea behind Factory: a future where software engineers work with agents—not IDEs—and where teams of 10 can achieve what once took 1,000.

From string theory to code generation: why Matan built Factory to redefine how software is written.

You can’t build the future by retrofitting the past. Factory skips the IDE and builds for zero-percent code authoring.

AI's biggest superpower? Parallelization. Matan recalls his first “wow” moment running multiple agents simultaneously.

The best engineers aren't the fastest coders. They’re the best at decomposing problems for agents.

Even in an agent-driven future, the fundamentals still matter.

Agent-native development makes it cost-effective to solve problems for a market of one.

Factory’s interface is designed like a product from the future—not an homage to the past.

Why Factory works so well: deep integrations, org-level memory, and actual code execution.

The bar for great software is rising fast. Internal tooling is having a moment.

Matan shares what to expect in the next six months: better agents, simpler interactions, and widespread adoption.

Matthew Berman: What does five years from now look like for software engineering?

Matan Grinberg: I think we’ll see a much more efficient journey from idea to solution. A task that used to take 1,000 engineers might only need 10. At the same time, software problems are growing in complexity—some will be so massive that even all the engineers on Earth wouldn’t be enough. But with an “army” of virtual engineers, individuals will be able to solve those problems.

We’re used to thinking linearly, but technology progresses exponentially.

Matthew: Let’s zoom in on Factory. It’s not a traditional IDE, and that reflects your view of where software engineering is heading. Why did you build Factory?

Matan: Before Factory, I spent 10 years in theoretical physics, working on string theory. It was a stubborn pursuit—not because it was the perfect fit, but because it was hard. I came to Berkeley for my PhD, took some AI courses, and got “nerd sniped” by what was then called program synthesis. Today we just call it code generation.

Matthew: What year was that?

Matan: Early 2022.

Matan: What drew me in was how central code generation is to AI. There’s a strong correlation between a model’s ability to write code and its performance across a wide range of tasks—writing poetry, answering research questions, etc. It’s a foundational capability. That’s why so many mathematicians and physicists are drawn to the field.

As for moving away from the IDE—it’s like the Henry Ford quote: “If I had asked people what they wanted, they would have said faster horses.” IDEs have been around for 20+ years, but they weren’t designed for a world where developers write 0% of their code.

Rather than iterating from that world, we decided to start fresh—build the car from scratch, so to speak. That’s what we call “agent-native” software development.

Matthew: How does that mindset change the developer’s role?

Matan: In the old paradigm, you ask, “How do I do this faster?” With agents, the question becomes, “How do I break this large task into discrete, verifiable steps that I can delegate in parallel?” That shift—from serial to parallel execution—is what unlocks real acceleration.

Matthew: The first time I saw that was using multiple agents in ChatGPT or with an OpenAI operator—running long-horizon tasks in parallel was a total “wow” moment. You also said something earlier that stuck with me: code generation is upstream of other AI capabilities. Did you read that recent Apple paper about the “illusion of reasoning”?

Matan: I read the abstract. The timing of that paper was interesting, given where Apple is in the AI race. But it raised a deeper question—what is intelligence?

Anytime LLMs do something, we try to explain it away: “It’s just memorization” or “It’s just interpolating from training data.” But even humans generalize from experience. Models writing code to solve problems? That sure seems like intelligence to me.

Matthew: Sarah Guo said people conflate AGI with consciousness. Do you agree?

Matan: Absolutely. That confusion is everywhere. But if solving novel programming challenges counts as intelligence, then these models are intelligent—even if that intelligence is bounded by training data.

Matthew: Let’s go back to parallelization. Human engineering teams have always worked around merge conflicts and coordination issues. How do agents work together differently?

Matan: Good question. First, parallelizing clearly distinct tasks (like Feature A and Feature B) is easy. But the real unlock comes when humans use systems thinking to decompose a task into clean sub-problems.

That’s where human engineers shine. Systems thinking—understanding constraints, dependencies, abstraction layers—has always separated great engineers from average ones. It’s just that now, instead of implementing every step yourself, you’re packaging up the work and delegating it to agents.

Matthew: I often get asked, “Should my kids still learn to code?” I used to say yes—it's how I brought ideas to life. But now I think the real value might be in systems thinking. What do you think?

Matan: I totally agree. And I’d take it further. Whether your background is in physics, math, biology—anything where the problem space is dense and historical—you learn how to navigate ambiguity and prioritize. That’s the real skill. You don’t need to know every detail, but you need to know how to figure out what matters and what can be abstracted away.

Same goes for software. You probably won’t write machine code—but understanding how the stack works matters. That foundational knowledge helps you orchestrate agents and validate their output effectively.

Matthew: Let’s bring it back to Factory. The UX is so different—clearly not an IDE. What’s the thinking behind the design?

Matan: Huge credit to our designer Kyle—my older brother, actually. His background is in industrial design, not software, which gives him a fresh perspective. Most IDEs are designed by developers for developers. Kyle brings a very intentional focus on experience and abstraction. That’s especially important when we’re rethinking how humans interact with software creation altogether.

Matthew: What allows Factory’s agents—your “droids”—to understand a codebase so well?

Matan: Three things:

Matthew: That’s huge. So where does this leave vertical SaaS companies? If building software becomes near-zero cost, how should they respond?

Matan: Even if software isn’t your core product, you still rely on it heavily. Take Bayer, one of our customers. They’re a pharma company—not a software company—but they still benefit massively from using agents to build internal tools, replace expensive legacy systems, and ship faster with smaller teams.

Matthew: So Factory helps non-technical enterprises level up too?

Matan: Absolutely. Especially if they don’t have armies of engineers, Factory gives leverage to the engineers they do have. You can do more with less, without compromising quality.

Matthew: Let’s play this out. If every company 10x’s their engineering output thanks to agents, doesn’t that lead to layoffs?

Matan: Only if you ignore competition. If you downsize and your competitor doesn’t, you lose. The bar for great software will keep rising—just like how the bar for websites rose with Webflow and Squarespace. What used to be “great” is now baseline.

Matthew: So what’s next for Factory?

Matan: In the next 6 months, agents will become far more reliable and require less guidance. Even if you're not into AI, even if you’re stuck in Emacs, we want you to try Factory for a minute and say: "Wow." It’s about giving every developer more leverage and letting them focus on what really matters—solving problems.

For more in-depth interviews with the people shaping AI, follow us on X and subscribe to our YouTube channel.