TRASCRIZIONE 🔗
Jason Hiner: Alright, Kyle, welcome to The Deep View Conversations podcast. Thank you for being here. For those who don't know, why don't you talk about what you do at GitHub?
Kyle Daigle: Yeah, so I'm GitHub's COO, so I'm really responsible for making sure what we're doing for developers. Like, if we can get it in their hands, they can use it. So, I was a developer myself when I joined 13 years ago at GitHub. Yeah, and so I've been on quite the journey and also helped produce GitHub Universe every year.
Jason Hiner: Exciting. We're here on Fort Mason at GitHub Universe. There's a lot that you announced today. So, maybe you could sum up for us what you announced, but also kind of where you're going, where GitHub is going, and the big picture.
Kyle Daigle: Yeah, absolutely. I mean, you know, in the last year, developers and agents have absolutely arrived. I mean, we have so many more pushes, code commits, you know, GitHub Actions runs than we've ever had. And so, we're first, we're really deeply investing in our underlying infrastructure. So, adding, you know, 4 million CPUs to get those Actions runs running, really changing how we store all the Git data so we can separate the compute from the storage. It gives us a lot, a lot more scale. And then I think, you know, that empowers us to deliver a new way of building software. We're building an agentic software delivery system. The idea that, you know, you're no longer probably obviously writing code by hand, but even if we made that a lot faster, that's not enough. You have to write the code with agents, then we have to verify that it's correct. We have to secure it. We have to do that in a loop with a set of automations. And so, if you start with something like the GitHub Copilot app, you know, it makes it very easy to get going. But then, you can also verify what the agent built. You can do, let the agent merge the code for you, for example. And do that sort of end to end across security, code review and everything. Using the thing I'm most excited about, which is, you know, GitHub Copilot Fusion, our new Fusion, our Fusion model that orchestrates across a multitude of models to give you like really great performance, but at a much lower cost.
Jason Hiner: Yeah, we're going to talk more about GitHub Fusion in a second, because it's huge and it solves one of what I see is like the biggest problem that I hear about time and time again from a lot of folks. But first, I want to talk about, at the keynote, just all these charts were so hockey-sticked up and to the right with all of the data, right? People making more apps, you know, doing more commits, maybe they're editing and revising their apps faster, more constantly. And then you have more people doing it too. I have people that I run into in the regular world now that have nothing to do, they don't have anything to do with tech. And they're like, they're telling me that they have a GitHub account. And I'm just amazed by that. Like 2026 has been such a turning point in more people creating software. I never imagined, a year ago even, that as many people would be creating their own apps. Like I said, not only just people in tech who aren't developers, but people who aren't even in tech that are doing it now. What are you all seeing in that? And how has that changed how GitHub thinks of itself?
Kyle Daigle: Yeah, I mean, GitHub has always taken this really broad view of developers, because obviously there's the folks that are doing this professionally, are doing it at work, but the reality is, if you own a house, you're probably going to go change a light switch, but you may not go change the breaker box on your own, like you call an electrician. So my goal is just to get as many people around the world to feel comfortable calling themselves a dev. And that could be writing a small app just for you or your family or friends, it could be improving something that already exists in the world. And we kind of do that by making Git open and available for free, using open source or private repos for individuals. We want to give the best tools to all those folks. So everything I talked about securing, you can go use yourself right now. Because there's nothing quite like having an idea and then using that idea and closing that loop as much as is possible. We'd love to have a world where there's a billion developers, we're at 225 million and growing very quickly right now. But that requires everyone to feel like they can be a part of the team. They can join the home for all developers with their ideas.
Jason Hiner: How does 225 million compare to where you were last year?
Kyle Daigle: I think the last time we talked about it was only, I think, two-ish, three-ish months ago. We were at around 160 million developers. So we're adding a developer more than once a second right now for the second straight year in a row. And so we're continuously seeing more and more people. And then it's hard to quantify the number of agents, but all those charts can show you that there's also a lot of agents showing up for every one dev.
Jason Hiner: Absolutely. This is going through the roof. So coming back from the like, anybody now wants to be a developer, you also have people that are in tech or in business that now they're building stuff themselves. You certainly are seeing that too. Project managers now, they're just like, well, instead I can just build the whole prototype myself and do it. How is that also changing? So that's the professional side of what you do. So many more of those folks are creating, you know, accounts and being part of the ecosystem. And that's really how you all see yourselves as a community, as an ecosystem. Tell me how that has evolved in this year as well.
Kyle Daigle: Yeah. So, I mean, we use GitHub to build GitHub. All my teams, I've kind of got the traditionally more technical teams, all the developer advocates, all those folks. And then I have just kind of pure marketing
Load full transcript
teams that probably wouldn't consider themselves developers in most cases. At the same time, to have those teams be able to build like they were using a brand new social media asset generator, you know, built by GitHub Copilot from a marketing person. One of our brand studio folks, really, really great at animation, has built multiple custom applications to do the visualization. So the visualization that we have in the keynote of all the Actions minutes coming in, that's actually a web app that was built by one of these folks who don't know how to like write code in the traditional sense, but now have learned how to write code in GitHub Copilot. I think the goal is how can we give tools to everybody to go from like, like I said, having an idea or maybe hearing a problem from a customer and being able to validate that they're right. Usually it takes so much time, we build all these plans and then we go to a dev and we go, can you build this? And the answer probably was weeks or months in the old days, but now even if it's fast, you're so detached from the solution that you're aiming for, I'd rather you go try to build something and then I'll go use it and go, oh, this seems like right, this solves the problem, then they can continue to scale or we can go with our engineering teams and have them help us build it out. It's giving everyone that capability of kind of proving that the solution is the correct one.
Jason Hiner: So you're doing it yourself?
Kyle Daigle: Absolutely.
Jason Hiner: With your own team. Yeah, very cool. All right, let's talk about GitHub Copilot Fusion because you have your own harness. Harness has become a word that, again, [unclear] throughout this year, but you have your own agent then, a coding agent, which is GitHub Copilot. You know, throughout this year, these coding agents have gotten a lot of buzz, especially Claude Code and Codex and Cursor. Yours hasn't necessarily been in that tier, [unclear] of exposure. But is this your way of saying, we have something unique we could offer, which is being kind of a model agnostic and not only that, but we can help solve what is the biggest problem out there right now, which is sort of the token economics of coding agents.
Kyle Daigle: Yeah, 100%. I mean, you know, we have tens of millions of people using GitHub Copilot. I think the unique thing for us is we've been so committed to like developer choice from day one of GitHub that we're a multi-model from the get go. So you could choose every single model that you want versus only being able to choose one of the models that are available to you in any of these other tools. I think that's like a big part of it. But the reality is like customers have been asking us, and honestly, I don't know that even I can fully keep up with like every single model launch and all the nuances of which, when I should use each model. And so they've been asking, like, okay, I need to have— be able to observe my spending. I need to be able to know
sort of if I'm getting ROI on that spending. And we wanted to come up with a way to productize that like how do we make it so that way every business doesn't need to enable all of their developers on what every model does and how they should use it. And so we came out with Copilot Fusion. We've been testing it in technical preview for a bit internally and externally. But the main idea of it is normally when you talk about like any type of model routing, it's only one to one. I look at a task, I consider how difficult it is, and I'll choose the best model to do that task. What Copilot Fusion does, which is unique, is that it can do that usually with simple tasks. But for most complex tasks, it can use two other policy modes like kind of like under the hood. The first is something called Cascade, which is like it'll start with a lower tier model. It'll build a plan and start implementation and then look at it. And if it feels like it's not meeting the objective, it will upgrade a model. And it could do that multiple times. But by doing so little work before deciding whether it should continue or not, you still get an enormous amount of kind of savings, you know, and not having to start with a model.
Jason Hiner: Burn a bunch of tokens by wasting it.
Kyle Daigle: 100%. And then we also have this model called Critique, which basically says I'm going to start doing work, and then I'm going to use a separate model, usually from a separate model family, to check that work. And it kind of does it in a loop. So Critique tends to be on the like sort of top tier frontier of, you know, intelligence. But with something like Cascade or even single model, we can now give you basically frontier intelligence. Like, we have the Artificial Analysis benchmarks on this to say we're like two points from Opus 5.5 Max, but 77% lower cost. And I think most interesting to me is 40% faster, because that those policies allow for the agent to do less turns, do less work, and then ultimately give me a result faster, less expensive, and then, you know, on the Pareto frontier of what these models can do. So we're really excited about it because it kind of resolves some of the question of, do I really need this frontier intelligence? And the answer is no, not all the time. So you can choose Fusion Max when you really, really need it. We offer Fusion High, which is kind of like when you know you don't need the absolute frontier, but you need something very capable. And then Standard, which is kind of like, okay, we'll optimize the best we can to save you on your dollars, but usually sit in that tier of like, you know, Haiku or Terra or Luna, you know, area.
Jason Hiner: So does the model do this, like, per task or per workflow? Can it say, okay, we're going to use different models for different parts of subtasks and that too?
Kyle Daigle: Absolutely. So instead of only going with one model, like kind of chooses something, or it kind of does some work and then chooses a single
model, it will inherently choose different models as it's working to give you the best result.
Jason Hiner: And now it's time for a word from our sponsor, Atlassian. If you're managing software development teams right now, you've probably noticed the speed gap. AI is making individual coding faster, but organizational friction, such as meetings and context switching remains unchanged. Atlassian's 2026 State of Developer Experience Report surveyed over 1,500 professionals, and the numbers confirm this. Eighty-seven percent of developers say they're writing code and shipping faster, but only 28% actually feel less organizational friction. And there's more. 65% are spending time correcting AI-generated work that missed intent, while 49% are spending over four hours a week managing AI tools and reviewing code. Only 26% are saving 10 hours or more per week. The research shows that as AI writes more code, the developer's role is shifting to architecture, systems thinking and validation. To unlock full productivity, your team needs an AI-native SDLC, software development lifecycle to resolve the friction. Join Atlassian leaders and key industry thinkers on November 9th for a webinar focused on helping you develop a clear AI strategy that fixes the friction and builds workflows that actually work. Click the link in the show notes to reserve your spot today, or you can go directly to fandf.co slash webinar. That's fandf.co slash webinar. And our thanks to Atlassian for sponsoring this episode. And now back to the show. So it's pretty sophisticated.
Kyle Daigle: Absolutely.
Jason Hiner: Yeah, yeah, yeah. Okay. So I know our audience understands this, but this is the biggest problem this is trying to solve is that people, you know, developers, especially they have work, they want it done. And so they'll pick a big model and, you know, a big expensive model because they know it can do all of the things. And that can cost a lot, right? Like those big models get really expensive. But now there's open source models, smaller models. We also are seeing like literal SLMs, small language models, domain specific models. Are you also accessing some of those models as well?
Kyle Daigle: Yes. So we didn't talk about it in the keynote today, but a couple weeks ago, we talked about, you know, we're also bringing Copilot Fusion the ability to drop down to local models. So if you have a local model running on your device, and right now we're looking at the multi-billion-parameter models, not true SLMs, you know,
Jason Hiner: But like a four-billion-parameter model.
Kyle Daigle: A four-billion-parameter model, exactly. Instead of going to a third party model where you're going to pay tokens, it can just actually drop down onto your device and use your device to generate. And then again, go back up to a top tier model to do the orchestration, for example. And so yeah, we're going to give you from the absolute top tier and kind of the most expensive model all the way down to just making tokens based on your laptop or your, you know, computer, and everything in between.
Jason Hiner: For free or next to free.
Kyle Daigle: Yeah. Yeah. But if you're using that local model on your computer, that's your computer. Great. You're good to go.
Jason Hiner: Yeah. But you are also doing SLMs and domain-specific models too in some of the routes?
Kyle Daigle: Yeah. So some of the—we use SLMs, some on device, like there's some explorations with, like, the Microsoft kind of like Ion model sets and so on and so forth. And then we do some of it in like the task intent. So we have to very, very quickly understand how difficult is this task and then kind of doing the online evals of how frequently are we correct to do that first step incredibly well. I think that we spent a lot of time there for the sort of either, you know, domain specific models. We find that our customers are bringing those, you know, like with bring your own key or because if you're in a certain field, you likely have the right context, you know, for
Jason Hiner: Law or healthcare,
Kyle Daigle: Automotive, pharmaceutical, etc. But you can also bring those into GitHub Copilot and use them as well.
Jason Hiner: Oh, very cool. Okay. No, appreciate the extra detail on that. I'm sure the audience will too, because all the enterprises that we talked to, like the token economics, we had a dinner last night with a bunch of IT leaders and the token economics part was like a big part of the talk, right? Totally. Because so much they know that they're spending a lot and they know they're getting some benefits from it, but they have to bring those numbers together, you know, in a more purposeful way because right now it's a big challenge. They're spending a lot on AI. So are you all using it internally? Yeah. And how much is it saving your teams by using it?
Kyle Daigle: Yeah. So we're using it internally. I've been using Copilot Fusion as we've been testing it out. I would say like in the last month or so, I couldn't, one, I can't tell the difference. I think it's an important detail because when we're talking about teams, you know, optimizing their spend, we're really talking about a human problem. You know, we got to get devs to understand and have them be incentivized to make the change, which is, as a dev myself, can be quite difficult. But we've been hearing from both internal and our other customers that like on average, when you're doing the most complex work, we're getting probably about like between 50 and 60% lower costs, simply because it's automatically using these less expensive models. And I don't notice. In the early days of—we call it Hydrofusion—in the early days of Hydrofusion, I noticed, you know, and then you kind of like lose trust, and you're like, I'm not so sure. But now that 50 or 60% is internal, external with like large, some of our larger enterprise customers. And then obviously like depending on the exact workload, we think we can go
even more higher performance, you know, lower cost. But we'll, you know, excited to get it in the people's hands.
Jason Hiner: Because you quoted it as up to 77%. Yeah, yeah, yeah. Is that customers that are seeing up to 77?
Kyle Daigle: So that's customers and evals. The problem is, it's a question of how difficult is your task. And so everyone has a very different answer to that. And so we try to focus on the reality, which, like, for us, tends to be around 50 or 60%. But for some workloads, it could be up to 77% less expensive.
Jason Hiner: And somewhere between 50 to 77%, not noticing any drop off in the performance.
Kyle Daigle: It still feels like an Opus 5.5 experience or a Sol 6.1 experience for me.
Jason Hiner: Nice. And then 40 to 50% faster too, at the same time. So win-win there. Okay. How about for the other stuff that you all announced, you know, here at GitHub Universe, what are the other things you think are worth highlighting and that you should make sure, you know, we [unclear] overlook?
Kyle Daigle: Yeah, yeah. So really fast. I mean, like, if you haven't heard of, like, you know, GitHub Copilot Projects, definitely go check out Projects. For me personally, when I'm working with an agent, I find it really annoying to have to decide if I'm going to steer an agent, interrupt an agent, you know, to give it some more information. And so effectively, what Copilot Projects does is it lets me take a bunch of different repositories or files or other assets, put them together and say, hey, I want to work on this. And then I'm interacting directly with an orchestration loop. So I can interrupt it and talk to it and just keep moving. And it will do all that and spin out agents to go do that work either locally or in a cloud sandbox. It's how I'm kind of building bug fixes on the weekends for GitHub. When I see feedback on Twitter, you know, I can go in and make some fixes with Projects. Definitely take a look at that. And then I think, you know, on the security front, because that's like such a big topic, especially when we're creating more code, we should check out, you know, the AI code scanning features and the AI secret protection features. If you're not using GitHub Advanced Security, which is our sort of big security suite, you can still go and use these features, just sort of pay as you use them. So you don't even have to have the full set of protection, but kind of everyone can benefit from don't put secrets, passwords, tokens in your code base, you know, and then using the AI models and deterministic code scanning to find vulnerabilities. So by putting them together, we can give you a better result across way more languages. And again, you can just go try this today by just paying for what you use and not having to commit to a full license for the entire product just quite yet.
Jason Hiner: Very cool. I'm glad you brought up cybersecurity. That was the other thing that all the IT leaders wanted to talk about, with safety and security too. So, Kyle, thank you so much. Appreciate your time.
Kyle Daigle: Thanks. Great to meet you.