The full power of Git, without the friction: A conversation with Netlify CTO Dana Lawson

Netlify has embarked on an ambitious effort that brings version control in-house as a core part of the platform. Netlify Source is new, native Git infrastructure designed to give every project the protections and capabilities of version control, without requiring a separate repository or GitHub account.

There are some big questions in front of the technical community around Git and version control.

Is Git still the right foundation for software development in an age when agents can generate extraordinary volumes of code? Should conversations, prompts, context, and agent traces live alongside the code itself? As more people begin building software without traditional development backgrounds, how much of the underlying machinery should they need to understand?

Dana Lawson is especially well positioned to weigh in.

Before becoming CTO at Netlify, Dana worked at GitHub. Today, she sits at the intersection of version control, deployment, AI-assisted development, and the infrastructure required to make all of those systems work together.

That intersection has become particularly relevant as Netlify undertakes something ambitious: bringing Git infrastructure directly into the Netlify platform.

With Netlify Source, projects created through Agent Runners can have source control built in from the beginning. Builders do not need to create a GitHub account, connect a repository, learn Git commands, or manage the mechanics of commits and branches before they can begin creating. The source is safely stored and versioned behind the scenes, while remaining available whenever it is needed.

Even for experienced developers, this removes steps and allows faster experimentation. For a new generation of builders, it makes the protections and capabilities of version control available without requiring them to first become Git experts.

Note: Connecting Netlify to an external Git provider remains a core feature. Netlify Source adds a foundation for simpler ways to bring version control into projects.

We sat down with Dana to talk about why Netlify brought Git in-house, whether Git is ready for the age of agents, and what source control means when the most important artifact may no longer be the code alone.

First, tell us a little about yourself and your role at Netlify.

Dana Lawson: I’m Dana Lawson, the CTO here at Netlify. Currently, the entire R&D organization rolls up to me. Everything you interact with, touch, see, feel, change, and love at Netlify is something my organization is responsible for making real.

It’s pretty awesome, pretty exciting, and pretty overwhelming all at once. But we love what we’re doing.

Netlify Source is intentionally not very visible to customers. What is it doing behind the scenes?

Dana: Netlify Source shouldn’t create more work for you. You shouldn’t have to deal with the friction that has historically come with pulling, pushing, and creating a codebase.

We want to make it as easy as possible for builders everywhere to safely change what they need to change without worrying about the mechanics. That is something Netlify has always done: simplify the coding process for everyone.

Bringing Git infrastructure onto the Netlify platform was an ambitious step. What motivated the team to take it on?

Dana: We’ve seen Netlify’s user base expand significantly.

Historically, we served traditional developers who often came from computer science backgrounds. Now, we’re seeing an emerging type of builder who still needs the same practices as a traditional software developer but isn’t necessarily an expert in software development. They’re experts in the experiences they want to create.

We wanted to bring those software practices and principles to this new group of builders.

A code repository has always been part of the system, alongside builds, content delivery, and the rest of the platform. But many of these new builders aren’t accustomed to the traditional path. GitHub may be completely foreign to them. Even the concept of Git may be foreign.

The workflows Git enables, however, are something they absolutely need.

As we introduced a more complete, end-to-end experience on Netlify, we knew people needed a simple way to create full-stack applications. Traditionally, you might come to Netlify with a separate frontend, a content management system behind it, and a Git repository connecting everything. Content might be changed through the repository or through another interface.

With Netlify and Agent Runners, you don’t necessarily have to go into a content management system. You don’t have to go directly into a database. We make it seamless to create full-stack, end-to-end experiences.

Those experiences still require platform primitives and mechanical operations underneath them. But we don’t want to turn everyone into an expert in those mechanics. We want to enable people to bring their expertise into the world.

One of Netlify’s core principles has always been simplification. Netlify Source is another part of that journey: taking something as difficult and abstract as code repositories and Git systems and making it simple.

It is already integrated and embedded. When you create an application, your source can be safely stored. Much of that is invisible. You don’t need to know it’s there—but when you need it, it is there.

Whether you’re an experienced developer who wants less friction or a new builder learning how to maintain the applications you create, we knew we had to make it easy. So we did.

There has been a lot of discussion about whether Git can keep up with AI development: higher commit volumes, agent traces, conversations, and more context surrounding every change. Are you still bullish on Git?

Dana: I think the original concept of Git is amazing. It is still a widely used and maintained open source project. Many startups and businesses—including GitHub, where I previously worked—have been built on the technology.

But whenever technology becomes more accessible, you have to ask whether it has been commoditized. That isn’t a dirty word. It simply means the technology is generally available for all of us to use because the friction is disappearing.

That is what we’re seeing in the evolution of Git.

Previously, Git was something you had to operate manually or build workflows around. Now, version control is simply expected.

At the same time, what we consider part of the source is expanding. It includes skills, intent, output, and context. In many cases, what you are trying to preserve is more context than code.

Models always introduce some degree of uncertainty. That is why we create guardrails around them. When we think about the future of source and the way we use Git systems, we want to preserve enough context to ensure that an agent can execute against the same information again and produce something repeatable.

It is similar to the thinking behind site reliability engineering practices for humans. We are now extending those practices to agents. The underlying principles haven’t changed. What has changed is what—or who—is following the instructions.

Does that mean source control will need to preserve more than files and code?

Dana: Yes. Think about some of the things that made Git so powerful in the first place.

You could put Markdown files and other human-readable information alongside the code so that people could understand what was moving through the system. Now, skills, recipes, prompts, and related artifacts are becoming equally important.

At Netlify, we’re thinking about all of it. How do we serve memory? How do we bring in context? How do we produce the right signals while abstracting the mechanics so that the customer can focus on the output?

That does not mean we are dumbing anything down. I want to be explicitly clear about that. We are removing friction.

When I was at GitHub, we used to joke about carrying sticky notes because you had to remember all the Git commands. Ain’t nobody got time for Git commands. Nobody.

That distinction is interesting. Usually, we assume that getting the full power of a technical tool requires more direct access to it.

With Agent Runners, I’ve actually developed a greater appreciation for the power of Git because I can use it through natural language. I can say, “Take the best ideas from this branch and this other branch and bring them together”—something I would not have been confident doing manually.

So this isn’t a reduced version of Git. It is the full capability made more approachable.

Dana: That’s right. The full power of Git in a very accessible way. That’s what we’re trying to do.

What was the most surprising part of establishing Git infrastructure in-house?

Dana: That it wasn’t that difficult.

We had already been consumers and producers within the ecosystem, and the great documentation created by the open source community made it very accessible for us to implement.

One reason we wanted to bring Netlify Source in-house was precisely because Git has become so accessible. We knew it should be something that simply happens.

We were also trying to simplify all the places you have to reach into and out of to produce a full-scale application. The fewer unnecessary API calls, the better.

I’m not suggesting that we need one system to rule them all. With technology advancing as quickly as it is, you have to be ready to be composable. There are places where you absolutely want to extend your offering or digital experience.

But I don’t think the inner plumbing should be one of the complicated parts.

We should keep that plumbing simple, easy, and intuitive so that complexity can be reserved for the places where it creates genuine innovation.

Could Netlify eventually contribute what it learns back to the Git project?

Dana: We’d love to. We have a principle here: pay it forward.

As we continue to learn and mature Netlify Source, we definitely want to give what we learn back to the community.

That is one of the great things about the future of software building. Previously, this team sport was played by only a few people. As more of us participate and learn from one another, we make it easier and easier for others to join.

I’m a hardcore, longtime nerd who has practiced this profession for a long time. When I see new people come in and do it better, there can be a moment of, “Wait, what?”

But it was never about the doing. It was always about the getting: helping people create the thing they imagined. I hope these new builders create and give us something better than I could ever have imagined. I have to remember that’s what we’re here for.

We want to share what we learn and make it accessible because that was the premise from the beginning. More power to the new companies, projects, and platforms that may be created from those contributions.

I’m here for it.

Source control for everyone who builds

Git has spent decades evolving from a specialized tool into a nearly universal foundation for software development. AI does not necessarily diminish its importance. It expands the range of things we may ask source control to preserve.

Code still matters. But so do the prompts, instructions, skills, context, decisions, and intent that led to it.

Netlify Source brings that foundation into the Netlify platform, making version control available as an integrated capability rather than another system builders must configure and operate themselves.

Experienced developers retain the safety and power they expect. New builders receive those same protections without facing an immediate lesson in repositories, remotes, branches, and Git commands.

The infrastructure is still there. The friction doesn’t have to be.

Related resources

• Get started with Agent Runners — Create, update, and ship projects with AI agents directly from the Netlify dashboard.
• Create a new project with an AI agent — Follow the complete workflow from an initial prompt to a deployed application.
• Explore Git workflows on Netlify — Learn how Netlify works with repositories, branches, builds, and continuous deployment.
• Learn about Deploy Previews — Review and collaborate on changes in an isolated preview before publishing them to production.
• Read Dana Lawson on the future of the Agent Web — Explore how Netlify is thinking about infrastructure and interfaces designed for AI agents.