Blitzy's Brian Elliott: Cursor And Claude Code Are Looking At Your Enterprise Code ‘Through A Straw’

**Brian Elliott** (0:00)
For eons, we have been limited by how much a human context can hold in their brain and push changes. Right now, we say we can actually offload that context load to this system, meaning we can do changes at a size and scale that were previously impossible, meaning that we can now say, what were we gonna do in five years that we can now do in one year?

**Alex Konrad** (0:21)
It feels like AI has taken over every industry, but in big business, their projects and code bases, too difficult and expensive to really take advantage.
Blitzy is a startup that uses thousands of agents to help those enterprises modernize their code and really put it to work. Our guest today is the co-founder and CEO of Blitzy, Brian Elliott. He says his company could be the corporate antidote to runaway AI spend or token maxing.

**Brian Elliott** (0:48)
Any other approach is adding incremental tech debt inside of the organization, which is what's happening in that incredible clip for folks that are simply just launching iterative-based AI coding inside of their system versus taking a, I'm going to use Blitzy to understand the large scale code base. I'm going to have Blitzy build everything that it can, and then I'm going to bring in Claude Code. I'm going to bring in Cursor to do the final last mile in development with the human developer for anything that our system couldn't do.

**Alex Konrad** (1:13)
Today on the podcast, we're going to talk about why context is king in large scale software development, how Brian built Boston's newest unicorn in a crowded AI field, and what he learned chasing high impact in the US. Army Rangers.
I'm Alex Konrad, founder and editor of Upstarts Media. And this is The Upstarts Podcast, our weekly show about startup founders who punch above their weight to take on the status quo. Brian, welcome to the show.

**Brian Elliott** (1:38)
Alex, welcome to Blitzy HQ.

**Alex Konrad** (1:40)
This episode is brought to you by Rippling AI, the only AI built to give you full visibility into your startup and the ability to take action across every department. Technically, I guess I'm coming on your show because we're in the office in Cambridge today in Massachusetts, right? That's right.

**Brian Elliott** (1:54)
Yeah, welcome.

**Alex Konrad** (1:54)
What exactly does Blitzy do? What are all these people in this building actually doing day to day?

**Brian Elliott** (1:59)
Yeah. So we're autonomous enterprise software development platform. So we first are the most inference compute intensive code generation platform on the planet by orders of magnitude. So we'll understand large scale code bases, think 50, 100 million lines of code, and then we will do large amounts of software development completely autonomously. You can think things as simple as a Java upgrade and as complex as even add 50 feature stories to this large interline code base. So we are an orchestration layer of all the state-of-the-art LLMs, allowing enterprises to move five times faster in their software development life cycle than just using the iterative assist tools that they use today.

**Alex Konrad** (2:34)
So you're taking in these state-of-the-art models from an OpenAI or another-

**Brian Elliott** (2:39)
Gemini or really all of them.

**Alex Konrad** (2:41)
All of them. Okay. Better together. You're bringing those models in. Yep. Then you guys are running, I believe, thousands of agents, 3,000 agents, right?

**Brian Elliott** (2:49)
It's actually dynamic. It could be tens of thousands, right?

**Alex Konrad** (2:52)
Okay.

**Brian Elliott** (2:53)
It's based on the complexity of the underlying code base. But let's say you give us a 50 million line trading market execution system, like these are the common types of projects that people will bring on to Blitzy. We've invented a language agnostic approach to understanding all programming languages. So we have a deep knowledge graph. So this phase one is reverse engineering. Right. So we'll reverse engineer the code base. That'll take a few days of continuous hardening compute. And then we will show the client, the customer exactly what that means with the spec.

**Alex Konrad** (3:21)
Why is that such a big deal? Reverse engineering the code base, being able to ingest up to 100 million lines of code and understand what it says. Why is that so different from maybe the status quo?

**Brian Elliott** (3:31)
The old way of doing this was to go to Deloitte or Accenture and give them 24 months and $200 million and say, we have this really old system.
There's no one here that understands this anymore. We need to get this into a modern state to be able to do anything on top of it at AI or just not have end of life. And so the first thing you have to do when you're modernizing an old system is understand it. It's impossible, even if you have the people that were building this over the last 20 years, to understand 30, 50, 100 million lines of code. It's just too big for a human to grow. So we used to do this piece by piece by piece by piece, slowly over months to years. So we've compressed the ability to do that completely with compute to allow the enterprise to first understand everything they have inside of their core records, core systems, to then transform them.