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.
Key Moments from the Interview
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.
Full Interview: Matan Grinberg on Agents, Engineering, and the End of IDEs
In His Own Words: What Matan Grinberg Revealed
Intro (00:00)
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.
“Some problems are too big for all the engineers on Earth to solve. But now, one engineer can deploy a thousand droids.”
Why Factory Exists (01:50)
From string theory to code generation: why Matan built Factory to redefine how software is written.
“After ten years in physics, I wanted to work on something fundamental. And software is foundational to everything in AI.”
From Faster Horses to Cars (04:45)
You can’t build the future by retrofitting the past. Factory skips the IDE and builds for zero-percent code authoring.
“You don’t iterate from a horse to a car. You build the car from scratch.”
Parallelization and Agent-Orchestration (06:05)
AI's biggest superpower? Parallelization. Matan recalls his first “wow” moment running multiple agents simultaneously.
“The speedups you get from parallel agents are fundamentally different. That’s what makes it magic.”
Systems Thinking > Coding (10:58)
The best engineers aren't the fastest coders. They’re the best at decomposing problems for agents.
“Systems thinking is the real skill. It’s always been the real skill.”
Should You Still Learn to Code? (12:18)
Even in an agent-driven future, the fundamentals still matter.
“You may never write machine code—but knowing how it works makes you a better architect.”
The New Economics of Software (17:25)
Agent-native development makes it cost-effective to solve problems for a market of one.
“Software used to be too expensive for niche problems. Now, every individual could have their own engineering team.”
Agent-Native UX and Design (21:32)
Factory’s interface is designed like a product from the future—not an homage to the past.
“Our lead designer never used an IDE. That was intentional.”
How Factory Understands Codebases (30:44)
Why Factory works so well: deep integrations, org-level memory, and actual code execution.
“We precompute relationships between design docs, PRs, Sentry errors, and Slack threads—just like human engineers would.”
Vertical SaaS in a Zero-Cost World (37:20)
The bar for great software is rising fast. Internal tooling is having a moment.
“You don’t need to buy bloated vertical SaaS anymore. You can build exactly what you need—in hours.”
What’s Next for Factory (40:58)
Matan shares what to expect in the next six months: better agents, simpler interactions, and widespread adoption.
“Even if you don’t care about agents, Factory will blow your mind in one minute.”
Full Transcript
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:
First-party integrations: We hook into GitHub, Slack, Jira, Sentry, Datadog, and more. That gives us rich, precomputed context—so the agent doesn’t have to discover relationships on the fly.
Memory: We learn across org, team, and individual levels. If you always forget to write tests, Factory remembers. If your team has a unique PR style, we adapt to it.
Execution environment: We can run agents locally or in the cloud, and verify that generated code compiles, passes tests, and behaves as expected. It’s not just code generation—it’s real engineering.
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.
🔑 Key Takeaways
Factory is building an agent-native stack from scratch, not retrofitting IDEs.
Systems thinking is more important than syntax in the age of agents.
The cost of building software is dropping to zero.
Every engineer will soon command a small army of AI-powered droids.
Factory is designed for both elite engineering teams and non-technical orgs.
Enjoyed this conversation?
For more in-depth interviews with the people shaping AI, follow us on X and subscribe to our YouTube channel.
