Latest / Coffee with Developers / Validating Real-World Usefulness of AI Models - Julia Kasper

Transcript

Validating Real-World Usefulness of AI Models - Julia Kasper · Coffee with Developers

• 0:01
  SPEAKER_00: Welcome to another coffee with developers.
• 0:03
  SPEAKER_00: We hear live at the GitHub offices in San Francisco.
• 0:06
  SPEAKER_00: Well, in the library of it, not everybody works with a place like that, I guess.
• 0:10
  SPEAKER_01: I wish.
• 0:12
  SPEAKER_00: So Judia, you and what are you doing here?
• 0:14
  SPEAKER_01: Thanks for having me.
• 0:14
  SPEAKER_01: My name is Julia.
• 0:16
  SPEAKER_01: I'm a product manager on the VS Code team.
• 0:18
  SPEAKER_01: In particular, I support all of the model launches in VS Code and in GitHub Copilot in VS Code and our chat extension.
• 0:28
  SPEAKER_01: So yeah, it's been a fun journey.
• 0:30
  SPEAKER_01: I joined the team last year in August.
• 0:33
  SPEAKER_01: So it's now been roughly over half a year.
• 0:36
  SPEAKER_01: Lots of learnings, lots of growth, and been super exciting so far.
• 0:40
  SPEAKER_00: So you're part of Microsoft and working with GitHub rather than GitHub?
• 0:46
  SPEAKER_01: It's you know, we all consider ourselves very close friends.
• 0:50
  SPEAKER_01: Um so we are in this very lucky position that we work very closely with GitHub, but also with the Microsoft team.
• 0:57
  SPEAKER_01: Um so if you look at my old chart, yes, I like direct in Microsoft, but we have day-to-day conversations, we work very close with the GitHub folks, so it really goes hand in hand.
• 1:09
  SPEAKER_00: So when people talk about VS Code or old school people like me, we're always like, oh, cool new editing feature, cool new code folding, whatever, and these kind of things.
• 1:18
  SPEAKER_00: But with the integration of uh of Copilot, it becomes much more than that.
• 1:22
  SPEAKER_00: It feels like more like an integrated IDE writer now than a text editor.
• 1:27
  SPEAKER_00: How are the numbers of people actually jumping into the fully like chat integrated thing in Visual Studio Code, or is it more like coders that use it like me, command I when I need it?
• 1:37
  SPEAKER_01: I think we are getting a lot of different use.
• 1:41
  SPEAKER_01: Like we have the ones that grew up with VS Code as the pure IDE code editor, who are not that often yet using our chat extension.
• 1:52
  SPEAKER_01: But then we also get the new developers that have a very AI-first mindset who go in and purely want to use the Copilot chat extension, who immediately go in with the intention of I want to use the AI features, the AI functionalities in here.
• 2:07
  SPEAKER_01: Um the numbers are I can't share too many details, but um they are constantly growing, and we see more and more users, also from the more old school, how you kind of called it, and maybe they are more and more using these AI integration more natively.
• 2:23
  SPEAKER_01: Um and we truly see a shift on how developers are working with AI these days now.
• 2:29
  SPEAKER_00: Now, your dedicated role is to talk about the model integration into the V into VS Code.
• 2:35
  SPEAKER_00: And uh I mean it was interesting because at first it started with a few models and then Microsoft announced like we allow any of them in there.
• 2:42
  SPEAKER_00: So, how many are in uh available out of the box right now?
• 2:47
  SPEAKER_00: And how fast do you how long do you get time to actually get acquainted with them before new ones come out?
• 2:52
  SPEAKER_01: Yeah, good question.
• 2:53
  SPEAKER_01: Um so GitHub Copilep has different SKUs.
• 2:56
  SPEAKER_01: So we have enterprise skew, we have an individual screw.
• 2:59
  SPEAKER_01: So it does depend on which is the subscription, which is the license.
• 3:02
  SPEAKER_01: First of all, you've subscribed to, and then depending on this, what are the models that you're allowed to do?
• 3:07
  SPEAKER_01: As an enterprise, um, certain enterprises have certain policies, so it might be that your admin is restricting what are some of the models that you're allowed to see because of their security or ceiler requirements.
• 3:18
  SPEAKER_01: Um in theory, um, we support all of the three big model providers from Google, Anthropic to OpenAI.
• 3:25
  SPEAKER_01: And we also work very closely with them before these model launches to make sure that it really works end-to-end for all of our developers who immediately from day one want to use these new models to make sure it works in VS Code and with our chat extension.
• 3:41
  SPEAKER_01: Um typically it really depends.
• 3:43
  SPEAKER_01: I thought, so I joined the team and I thought, oh, we must have such good processes and like it works very smoothly.
• 3:51
  SPEAKER_01: The reality is that these model providers sometimes get a checkpoint, a model checkpoint that is very promising, and they're like, oh, we have a very exciting new checkpoint.
• 4:02
  SPEAKER_01: Can can you please go and test this and give us some results back and make sure and let us know how this new model checkpoint is doing within your harness.
• 4:12
  SPEAKER_01: So it's very ad hoc sometimes.
• 4:14
  SPEAKER_01: Um typically I would say we probably get like two-ish weeks in advance where we know oh, there might be a new model, um, uh yeah, a new model release coming in, and that's when our engineering team, our offline eval team started to get to work with these new models.
• 4:33
  SPEAKER_00: Now you talked about e bills, what are they and what do people what why are they important?
• 4:40
  SPEAKER_01: Yeah.
• 4:40
  SPEAKER_01: Um so there are different kinds of evals.
• 4:42
  SPEAKER_01: Usually when I talk about evaluations, um we talk about online and offline.
• 4:47
  SPEAKER_01: Um so one of the very interesting things, AI is non-deterministic.
• 4:52
  SPEAKER_01: So you might have experienced this yourself.
• 4:54
  SPEAKER_01: You go in, you open the chat, and you ask one question, oh, um scaffold me a new web API.
• 5:01
  SPEAKER_01: And every time you do this, you're gonna get a different result, which makes it so hard if we think for us to test before a new model gets released, how do we test and how do we evaluate how these new models perform, especially because of their non-deterministic nature?
• 5:19
  SPEAKER_01: So, how it works is we very similar back then we had um tests, we had test scripts.
• 5:29
  SPEAKER_01: We still do this in the evaluation or offline eval space.
• 5:34
  SPEAKER_01: These are called assertions.
• 5:35
  SPEAKER_01: So we write a test case which is scaffolding a web API, and then we have certain deterministic assertions to say, oh, a web API should have, for this specific task, it should have five endpoints or things like that.
• 5:53
  SPEAKER_01: So we write up these assertions, so then we have a way to test if this non-deterministic model is able to achieve all of our assertions, only maybe a certain amount of these, and how many do we need to make sure that it actually works end-to-end.
• 6:08
  SPEAKER_00: So it feels like a good prompt, actually.
• 6:11
  SPEAKER_00: Like instead of just giving it an open-ended question, you're already limited to the things that you want, and then you get better quality results back.
• 6:18
  SPEAKER_01: Well, yeah, I mean, if everyone is, would be as efficient as prompting, but we all know, including myself, sometimes I go in, I ramble, I don't really know what I want the model to do.
• 6:28
  SPEAKER_01: I have a fair amount of an idea what I want it to do, and but not every prompt is always as um straightforward as it probably should be.
• 6:38
  SPEAKER_00: One uh one thing you said was that companies might limit it down to only using a few models or different ones.
• 6:44
  SPEAKER_00: Now, the big thing right now is that everybody has got worried about is like token pricing and like uh our engineers burning through like lots and lots of money for different things.
• 6:53
  SPEAKER_00: Now, different models are differently efficient at different tasks.
• 6:56
  SPEAKER_00: There's lots of third-party software that I see that actually allows you to see your cloud status, for example, in the taskbar.
• 7:03
  SPEAKER_00: Is there an idea to do that inside VS Code to say, like, okay, here's the limit how many tokens you can use, here's which model is the most efficient one for the tasks that you need to do?
• 7:12
  SPEAKER_00: Is there a way to get a token saving mechanism inside VS Code?
• 7:17
  SPEAKER_01: Yeah, that's a very spicy question.
• 7:19
  SPEAKER_01: I'm not allowed to answer all of them just yet.
• 7:22
  SPEAKER_01: Um one of the things, um, so one of the benefits of GitHub Copilot is that we don't just want to limit you to one model provider.
• 7:32
  SPEAKER_01: It truly is you can pick across different model providers whatever model you think works best for your task.
• 7:40
  SPEAKER_01: Um we are, or we do want to be more transparent in sharing some of our own internal benchmarks across these different model providers to give our end users a little bit of a better, roughly fair estimate.
• 7:52
  SPEAKER_01: Hey, maybe for this task, uh it would be super cool to use this model or another one.
• 7:57
  SPEAKER_01: At the end of the day, something including myself, you get to know models and they all have their own certain personalities in a way.
• 8:07
  SPEAKER_01: So you're getting used to a certain style, a certain way, maybe for a certain task.
• 8:12
  SPEAKER_01: And I see people picking models based on tasks that they are more familiar with, the personality or the style that they like.
• 8:21
  SPEAKER_01: So on a lot of use cases, I see, for example, um claude models being used for more web dev, um backend development being more used with the GPT models.
• 8:33
  SPEAKER_01: Um so yeah, it's uh it is a tough question.
• 8:37
  SPEAKER_00: There's also political decisions sometimes.
• 8:39
  SPEAKER_00: I mean, there's lots of models that are from countries you might not want to send your data to, uh, and uh but that seemed to be very, very powerful.
• 8:47
  SPEAKER_00: But it's it's such an overwhelming market.
• 8:51
  SPEAKER_00: I mean, I look at at Hugging Face and I looked, I used to look up like a specialized model for different tasks, and I'm like, cool that I could run locally and things.
• 8:59
  SPEAKER_00: I kind of gave up because there's a new model every two days.
• 9:01
  SPEAKER_00: How do you keep up with the demand?
• 9:04
  SPEAKER_01: Yeah, so now it's part of my job, so I basically have to keep up with the demand.
• 9:08
  SPEAKER_01: Um it is very interesting for me personally, because now that I that we work so closely with the model providers, we can really see the shift every time a new model has, and what are some of the improvements, also so some of what are some of the personality, even like kind of like personality traits for these new models.
• 9:30
  SPEAKER_01: So we now watch more carefully.
• 9:32
  SPEAKER_01: Um but yeah, that it feels almost like we've also reached a saturation of how good is there even going to be a next big jump?
• 9:43
  SPEAKER_01: Um, because right now it feels like GPD 5.5 and the Opus 4.7 one, they're very close in um quality at this point, so I can see why users are also like the quality is really good.
• 9:56
  SPEAKER_01: Do we need a new model?
• 9:58
  SPEAKER_01: Um we do see a lot of improvements every time.
• 10:01
  SPEAKER_00: Do you see that there's a performance improvement or decrease from model to model?
• 10:06
  SPEAKER_00: It feels like, of course, they can do more, but also are they more efficient than they used to be before?
• 10:11
  SPEAKER_01: So so so far, um looking at our internal benchmarks, we've always seen a jump every time we've released a new model.
• 10:19
  SPEAKER_01: Um, some might be smaller, um, for example, 4.6 and 4.7, there was an increase, it was just a little bit smaller than what we've seen with 4.5, 2.4.6.
• 10:30
  SPEAKER_01: But every time there is um uh somewhat of an improvement.
• 10:34
  SPEAKER_01: Um token efficiency is a different um different story.
• 10:39
  SPEAKER_01: We do see uh all kinds of degrees every time a new model is being um released.
• 10:45
  SPEAKER_00: Is there a way to connect a local model that I have already running on my machine with something like Olama?
• 10:50
  SPEAKER_01: So we have in VS Code bring your own model, um, bring your own key, so you can um bring in, you can connect through your own API key to these models, so you can bring any kind of model that you would want.
• 11:03
  SPEAKER_01: Um the nice thing for built-in models like GBD 5.5, if you don't bring your own model, and we do optimize our coding hardness for these models.
• 11:12
  SPEAKER_01: That's why we put, especially before launch, so much time into making sure the system prompt is updated.
• 11:18
  SPEAKER_01: The system prompt works um great with these new models because we have a little bit of time before the launch to make sure it really works end-to-end in hours.
• 11:26
  SPEAKER_01: So that's one of the advantages of using the built-in ones.
• 11:29
  SPEAKER_01: But we you can always bring whatever model you want as well.
• 11:34
  SPEAKER_00: Can you say something about numbers?
• 11:36
  SPEAKER_00: How many people do that, or am I a freak for doing that?
• 11:39
  SPEAKER_01: I actually I actually don't no no no.
• 11:40
  SPEAKER_01: I think there are.
• 11:41
  SPEAKER_01: I actually don't know the correct number, just to be very transparent.
• 11:45
  SPEAKER_01: But we talk a lot and I see this coming up and a lot of times where people are asking, oh no, I want this specific model because for yeah, whatever reason.
• 11:55
  SPEAKER_01: Um and that's a very fair point.
• 11:57
  SPEAKER_01: I just don't know the number, unfortunately.
• 11:58
  SPEAKER_01: So so you're not a freak.
• 12:00
  SPEAKER_01: We are getting the question more and more, and I see a lot of also um issues in now we as code um repo where people are asking constantly about hey, we would like support for these kind of um models or edge cases.
• 12:13
  SPEAKER_01: So yeah.
• 12:14
  SPEAKER_00: As an engineer yourself, how does that how does that that challenge feel?
• 12:19
  SPEAKER_00: Like you seem to be, it seems like you're you're you're beholden to a third-party provider who does the models, and oftentimes models get like, oh, we might release it, we might release it, we might release it, and then like the newest model is the best thing ever.
• 12:33
  SPEAKER_00: And how much time do you get from like as a as an integrator?
• 12:37
  SPEAKER_00: Do you get preview time or do you also get it when it's when it's finally out there?
• 12:42
  SPEAKER_01: Um so we typically get like the two weeks-ish weeks before a model launch.
• 12:48
  SPEAKER_01: And usually what we do during this time of the two weeks is one very important thing, we are optimizing our coding harness for it.
• 12:55
  SPEAKER_01: So, most importantly, we are looking at our system prompt and make sure that it works with the new nuances, how the new model works.
• 13:03
  SPEAKER_01: Um we do this by running offline evolts.
• 13:06
  SPEAKER_01: We constantly, like in this two weeks, we run so many offline evolts, we are tweaking certain system prompts, we are tweaking certain things in our coding harness to make sure the quality keeps going up, the resolution rate of how many of our test cases are being solved just goes up, so we are providing the best quality overall.
• 13:24
  SPEAKER_01: At the same time, or in parallel, we're still doing a lot of internal dog fooding and testing, and which is interesting because these are the two types of feedback the model providers are really looking to us as the integrators.
• 13:36
  SPEAKER_01: They're always asking about um eval numbers and they are also asking about what we kind of call vibe checks.
• 13:44
  SPEAKER_01: Um so they are they love some quotes that we are getting from our internal dog fooders.
• 13:48
  SPEAKER_01: So before model launch, I go in, I have a fun project that I'm currently working on, and I just test the new model and I'm like, do this.
• 13:57
  SPEAKER_01: Sometimes we get some recommendations from the model providers.
• 14:01
  SPEAKER_01: For example, GBD 5.5, they've done a lot of work into more front-end dev work.
• 14:06
  SPEAKER_01: So they said, hey, our research team focused a lot on more front-end stuff.
• 14:10
  SPEAKER_01: So I test a lot a lot of different tasks about front-end web development to see if whatever they claim to be better at, it truly holds off.
• 14:20
  SPEAKER_01: And then we are sharing this kind of feedback with them as well.
• 14:23
  SPEAKER_01: So they get a we're all hoping the model in providers including that the quality holds and um it truly reaches the promises what they are saying.
• 14:34
  SPEAKER_00: Can you do a direct A B test in VS Code that you say, like, okay, I got this task, run both of the models, and then I will take the better result?
• 14:45
  SPEAKER_01: Um so that's where sessions come in in VS Code.
• 14:49
  SPEAKER_01: So um there we have different types of agents.
• 14:52
  SPEAKER_01: We have local agents or um remote agents.
• 14:56
  SPEAKER_01: Remote agents use um GitHub Copilot CLI, so you can just send it off, it does its work, and it comes back, or your local agent, you're in your editor, you see these local changes also being um applied at the same time.
• 15:10
  SPEAKER_01: So typically what I do is I spin off different local sessions and I ask the same prompt across different models, across different um yeah, across different models, and see what they come up with, and then I let faith or whatever I feel like in that moment kind of decide.
• 15:31
  SPEAKER_01: So I kind of do my own A-B testing as well.
• 15:35
  SPEAKER_00: Is there anything I can do as an outside contributor to help with like integrating the new things?
• 15:40
  SPEAKER_00: Is there a different integration in uh in Canary, for example, in VS Code Canary, or is it just that's more about UX of the system itself?
• 15:50
  SPEAKER_01: Um so all of our system prompts for VS Code, because we are open source, they are public.
• 15:55
  SPEAKER_01: Um, and every model provider gets their own system prompt because how these models behave, um so anybody can look at the system prompt, especially once we release a new model, everyone can immediately see what the new model prompt looks like, and you can kind of also tell and see what are some of the changes that has been applied that the model provider has shared, and we are always open for community suggestions.
• 16:19
  SPEAKER_01: So if you have done your local testing and you feel like, hey, with maybe we want to make some or tweaks to the system prompt based on yours, we are always open for these kind of suggestions as well.
• 16:31
  SPEAKER_01: Um so yeah, that's usually what I recommend people to look into and also to familiarize themselves a little bit more with these different models as well.
• 16:42
  SPEAKER_00: What is a request you always get that you think like people this should be something that should be obvious?
• 16:48
  SPEAKER_00: What is a stumbling block that people have that that comes in as a as a question to you?
• 16:52
  SPEAKER_01: Usually the the very first one I get is what's the best model?
• 16:57
  SPEAKER_01: Um and I wish I had this here is the best model, but you already touched on a point where different models are good for different certain tasks, like dev front-end versus back-end dev.
• 17:12
  SPEAKER_01: Um so I typically, including myself or looking at the VS Code engineering team, I always recommend switching models from time to time.
• 17:21
  SPEAKER_01: And also always please use the latest, just because they are better better, and we do see a lot of enterprises still using some of the older models as well, which um it makes sense maybe sometimes for them because of CELA requirements or enterprise requirements, but I always recommend um go ideally to the latest, just because we do know it holds the best of all quality.
• 17:45
  SPEAKER_01: Um so yeah, usually it's the question well which which is the best model I should be using.
• 17:51
  SPEAKER_00: And um, how does it feel that?
• 17:55
  SPEAKER_00: I mean, that might be a spicy question again, but it always cracks me up that there's so many editors out there from different companies that are just a fork of Visual Studio Code with security turned off, or like uh or like special features.
• 18:08
  SPEAKER_00: Like I love that Monaco and the environment that Visual Studio Code is has become the blueprint for all of them.
• 18:15
  SPEAKER_00: But it does feel weird to say, like, oh, you gotta have start with this editor to be a good developer or with this editor.
• 18:23
  SPEAKER_00: Like, how does it feel to be like in the OG of the of the development environment and other people like, yeah, I'm using that one, not touching yours anymore?
• 18:30
  SPEAKER_01: Of course, I'm not gonna lie, of course, it hurts sometimes where you're like, ah, you know, it is a fork of MPS code.
• 18:37
  SPEAKER_01: Um the re but also the reality is we've always been open source.
• 18:41
  SPEAKER_01: The team has always been open source.
• 18:43
  SPEAKER_01: So open source has always been a core part of the team culture of how we think of the product.
• 18:48
  SPEAKER_01: So we always knew there could have been the opportunity, like the possibility of somebody forking our repo and making their own.
• 18:56
  SPEAKER_01: So as much as it does hurt from time to time, we still value the open source community and we also benefit a lot.
• 19:03
  SPEAKER_01: Like we get PRs from the community themselves.
• 19:06
  SPEAKER_01: So there's always a like pros and cons towards being um open source with yeah, people taking that also for their own advantages.
• 19:17
  SPEAKER_01: But overall, we just value the open source community mindset, and I think nothing has changed towards that mindset, and we're still very proud that we we love that open transparency, um and we don't want to give up on it, so there's never been any talks in the team that to making it um close to anything.
• 19:37
  SPEAKER_00: It feels weird when one of the forks get becomes closed source.
• 19:40
  SPEAKER_00: That's really the weird thing about it.
• 19:42
  SPEAKER_00: And I I want to call that out because I worked on VS Code and Edge and Edge inside VS Code.
• 19:48
  SPEAKER_00: There was an extension that we did, and a lot of people feel like they can't contribute from the outside.
• 19:54
  SPEAKER_00: They're either not they feel they're not good enough because Microsoft has thousands of board developers sitting around that will do it anyways, or they feel like, why should I do it for a company like Microsoft or or why should I support that they have enough money?
• 20:07
  SPEAKER_00: It's a great way to learn, I think.
• 20:09
  SPEAKER_00: Contributing to an open source project, especially a big one like that, is a great way to learn as a developer, and it's also every contribution I found, at least in my team back then, was very much appreciated, and there is no dumb contribution that feels simple enough.
• 20:25
  SPEAKER_01: No, totally agree.
• 20:26
  SPEAKER_01: Um, and I think even especially with AI nowadays, um, I mean I joined the team half a year ago, and I feel like I I feel very empowered with AI because the first thing I did is I um phoned via Scode Repo and I asked, explain this to me, and in this way I was able to narrow down how certain things first of all work.
• 20:50
  SPEAKER_01: Um so it's so much easier to grasp a big GitHub repo to better understand how it works, but then also to make these small contributions and start small, pick one issue that is open that the team has somebody assigned to, but we always love these contributions and we are a small team overall.
• 21:09
  SPEAKER_01: Um so it is really seen and it is um appreciated.
• 21:13
  SPEAKER_01: We call out these PRs even in our stand-up from time to time, where we are like, hey, somebody contributed it.
• 21:21
  SPEAKER_01: This is one of the reasons why we are open source.
• 21:23
  SPEAKER_01: Um so I always recommend use now that we have AI, use the power of AI to understand how it works and then make a small first contribution.
• 21:33
  SPEAKER_01: It is seen definitely across the team.
• 21:35
  SPEAKER_00: Cool.
• 21:36
  SPEAKER_00: Well, thanks very much.
• 21:37
  SPEAKER_00: This was insightful, this was good.
• 21:39
  SPEAKER_00: Um are you coming to our event in September?
• 21:41
  SPEAKER_01: I mean I hope so.
• 21:43
  SPEAKER_01: Um so yeah, we haven't finalized times yet, but I would love to be there for sure.
• 21:47
  SPEAKER_00: Yeah, and if people have any questions about models inside uh like AI models inside VS Code, that's the right person to talk to.
• 21:56
  SPEAKER_00: Thanks very much.
• 21:57
  SPEAKER_01: Thank you.