Video summary
The presentation welcomes attendees to the Microsoft campus, highlighting direct access to the engineers behind key products like Visual Studio, .NET, Azure, and SQL. It addresses the rapid evolution of AI adoption, acknowledging that while concepts such as prompt engineering and autonomous agents have emerged quickly, many professionals feel anxious about falling behind or losing their passion for coding. The core message is that AI should serve to augment human developers rather than replace them, particularly those who view code as a long-term asset requiring high standards of quality, security, privacy, and governance. By leveraging AI agents to handle less desirable tasks like routine coding or data gathering, developers can shift their focus toward the most critical aspects of development: defining the problem space and business goals, designing the solution architecture, and implementing the final code.
Visual Studio demonstrates its commitment to this augmented workflow through live demos showing how Copilot can analyze performance profiles, identify bottlenecks such as floating-point math operations, and automatically optimize code while validating changes against unit tests. The platform is set to evolve with several strategic enhancements, including a unified SDK that provides a consistent Copilot experience across Visual Studio, VS Code, and the CLI, as well as the ability for users to host local large language models on-premises without signing into GitHub to address privacy concerns. Further improvements include full support for Git worktrees and submodules, a new auto-merge button to resolve conflicts automatically, and specialized agent skills where teams like WinForms and Azure maintain knowledge repositories for expert guidance on niche technologies.
To ensure an efficient human-agent loop, Microsoft is investing heavily in testing guardrails, diagnostics, and build speeds, while confirming that Visual Studio will continue to receive monthly updates regardless of a user's current AI maturity level. This ongoing evolution ensures that professional developers are never left behind as the industry advances. The session concludes by reinforcing that Visual Studio remains an essential tool for professionals, with dedicated teams available throughout the week to engage with users, share stories, and gather feedback to continuously improve the platform.
Read the full video transcript
Well, thank you so much. And uh you
know, welcome to the Microsoft campus.
Uh I've been lucky enough to to be here
on the campus for uh close to 16 years.
And I'm really happy to uh to have you
all come here and join us. And you know,
from the Visual Studio and .NET and SQL
and C++ teams and Azure and whatnot, we
got a bunch of speakers, we got a bunch
of engineers, people actually build the
products. They're all here in this
building, they're in the booth, they're
like hanging around. And they all really
want to talk to you. This is the
conference where this happens. It
doesn't really happen anywhere else
where we have that concentration of
uh engineers, people who make the
products that we all use every day. Uh
and they really, really, really want to
talk to you. So, please don't be shy. Go
tap people on the shoulder.
Uh you know, like Brian was saying,
"Tell us what's wrong." And we'll try to
help you out, right? Or tell us how we
can improve because that's that's kind
of why we're here.
And uh so, please take advantage of
that. We will do that, too. We might be
poke, you know, uh coming up to you and
ask you a few questions out of the blue.
So, be prepared.
So, um
yeah,
Visual Studio and AI,
that's what we're going to talk about
here today. And uh
you know,
it seems like every session is about
that this this time around, right? It's
been It's been coming. It's like
everything is about AI, and everything
is moving so quickly. And it wasn't that
long ago where Visual Studio AI kind of
felt like it was tagged on, right? And
now it seems much more integrated. And
things have moved pretty quickly, not
just on Visual Studio, but everywhere in
this space. And it could be kind of
overwhelming. Like things are moving.
Things you thought was the new best big
thing that you learned very recently is
like no longer being talked about.
And it it it it's overwhelming. Um the
the pace of this kind of is is
staggering, and it's faster than
anything else that at least in my time
uh I remember in the industry happening.
So,
um
Like an example, do you remember uh
prompt engineering?
This used to be the thing like you could
be a prompt engineer. This is like a
year ago.
You could now be a prompt engineer.
You'd see people hiring a prompt
engineer.
When was the last time you heard even
the term prompt engineering? Like it
came, it was the biggest thing, and it
went away.
Um
>> [clears throat]
>> Oh.
Here we go.
We also hear this a lot. Like if you're
on social media, Twitter, at
conferences,
when when when was the last time you
wrote code? I don't write code anymore.
The agent does that for me.
I have multiple agents. In fact, I have
agents that run agents, so I don't have
to write or look at code.
It's like, "Oh, that seems that seems a
little extreme, maybe, but you know,
makes me also feel like a little anxious
maybe that I'm not doing that. Does that
mean I'm falling behind? What did I not
learn that maybe I should have learned?"
It's like, "Ugh."
I don't know. Is it a good thing? Maybe.
It's also kind of doesn't feel good.
Um
And the future is now. It's agentic.
I think we all know this.
We know that AI is kind of disrupting
and taking over parts of our jobs and
parts of our responsibilities as ours
then shift to do other things and manage
all the agents and stuff. But it's all
like not necessarily clear how that's
going to work out. There's a bunch of
people that have very strong opinions
about it, but it seems everyone is a
little bit
uh spread out on the spectrum of a
little bit of AI and like
I have a Mac mini that orders me lunch
every day without me even knowing that I
like chicken on Tuesdays, right?
Something like that.
And so, we all fall in the spectrum of
somewhere in between.
And this This kind of what we see on
social media. This world of
just, you know, Minority Report, like
managing all these agents, I'm in
control, and all these things are
happening around me and sub agents, and
all these skills, and
all this thing. And and um
like, "Oh, yeah.
Maybe not. Maybe not the job I used to
have. Like, maybe I like programming.
Maybe I don't like
being the Minority Report person."
But, what about this?
Uh this I can get behind.
What if What if having uh the agentic
workflow being more like something that
frees you up?
So, yeah, you're managing agents and
stuff, but maybe you have time for a
little uh
just sit on the beach while you do it.
So,
this is kind of the ideas that you see a
lot of floating around about all this,
and it's
I don't know. It doesn't feel like
reality, which looks a lot more like
this.
Like, this is what my reality looks
like. Probably what yours look like. We
can't just sit.
We have Visual Studio open. We probably
have a terminal. We probably have some
other tools as well.
And we code, and we have a good time
doing that. That's why we're in this
business. We love coding. We love that
technical thing, whatever it is, if it's
coding, or you know, database solutions,
or whatever it is that that made us
interested and passionate,
and come to conferences like this about
this stuff, right?
What?
Is the microphone not on?
It's on.
Oh, it's it's simply just too far.
Oh.
Here, let's do something else.
I'm not demoing, so I have a hand free
here.
All right.
So, um
this is kind of um
the reality, right? We're still sitting
in front of our screens and doing kind
of this work
the our environment is similar, but it's
still different.
Because AI allows us to shift how we're
working, how we're prioritizing, and
what we can get done.
But, you know, there's some blockers for
some people.
Uh it's gotten pretty expensive.
All right, so
when you're out of tokens, like maybe
you can't afford running agents after
that, and you have to wait till your
token budget resets every month and
whatever, right? It's It's simply
getting a little bit too expensive.
Maybe you don't get the budget that you
hope to get from your organization.
It could also be that you're limited in
how you use AI because of privacy
concerns from your
company. This is absolutely very real.
We hear this all the time.
And
so maybe you can use AI for some things,
but maybe you can't use it for coding
purposes, but you can use it for like
saying writing documents and and
planning and other things. And so you
use whatever you can.
Uh wherever it makes sense.
But at the end of the day, things are
moving so fast that you might not have
time to just keep up with all the
things.
Like not that long ago, open club came
out and was this big thing. You can run
your LLM. You get a Mac Mini, and it
does everything. It can reply to your
emails. It can organize your entire life
and is your own personal assistant.
And
that seemed like really interesting and
fascinating, but just imagine the amount
of time it would take for you to set
something like that up.
We're professionals. We don't have time
for that stuff.
Right? Or that's true for a lot of
people at least. So
um it's hard. And and often we are
seeing these workflows, and we're
hearing about workflows, but are we
really taking advantage of all the
things that are available inside Visual
Studio or whatever tool we're using?
Are we getting the workflow that we kind
of hope for to really up our
productivity to make us all rockstars as
promised?
Um
there's some learning, and there's a
bunch of uh that goes into that for how
it will work in your organization and on
your team.
And you haven't had time to look at that
yet. And that's totally okay.
Maybe you just don't want to organize
um eight or orchestrate agents. Maybe
you are not you don't want to be that
Minority Report person.
You just love coding.
That's why you're here. That's why
you're doing what you're doing.
And um
I think a lot of people, especially
people that have been in the industry
for many years,
they're like, "Hey, please don't take my
passion away."
You know?
So,
good news is that
if you feel like that,
you're the 99%. This is very common,
right? So,
one or more of the things I've been
talking about probably applies to all of
you.
Um this is very common. It's very few
people in the real world, people who
write actually the real software running
on in real companies and all that type
of stuff, not just people on Twitter
that, you know, vibe codes uh iOS apps
that no one uses.
Um but the people who build the the real
software, the people in this room.
All right.
So,
with Visual Studio, we understand this.
And we understand that we come from
different
starting points.
And um
whether you're just dipping your toes
in the AI
pond,
or you're kind of more diving in and
already swimming and
whatever it is that you're doing, how
you're using it, you're again on the
spectrum, it's all very, very different.
Uh
but
um with Visual Studio, we want to make
sure that no one is
falling behind or feeling like they're
falling behind. I don't think anyone is
actually falling behind. It's more of
that feeling of anxiety and all that.
But it's also about productivity. Are we
actually taking full advantage of
something that's in front of us?
And uh we want to make sure that
everyone that can take advantage of it
will take advantage of it to gain that
extra productivity.
And it's clear that in doing so
your skills now matter more than
probably ever before.
Because if you're now starting to work
with agents
you're now the senior
in the room.
And you have all these junior agents
that can never know the same amount of
stuff that you do about your company,
the way you want the code to be written,
the way you want architecture, the thing
that you decided in that meeting with
these stakeholders yesterday about the
future of something something something.
There's no way AI that knows that.
You know that.
And you have to now steer and be the
senior in the room. Whether you're
senior or not, you're the senior.
All right? And so having skills and know
fundamentals about computer science,
knowing have technical depth in the
things you're building is really really
important to do this optimally.
And um typically when we build software
we do it in like three categories or
there's three tasks if you will. So one
is the why.
Uh this is the you know, the customer
goal, the business goal. What is the
problem space that we're trying to solve
for? Let's say we want to build a new
feature. Well, what what is the problem
we're trying to solve?
So we might do customer interviews, we
might do surveys. Uh we might have uh
you know, customer feedback channels
that let us know what matters to users
and customers.
And then the what is okay, then how do
we What is the thing that we're doing to
solve it? This is the solution space.
Like what's the architecture? What's the
design? So here you have the
architecture, you have the designers.
You might have uh senior engineers and
such.
Um this is kind of the solution space.
And then finally we have the how. So
this is the implementation.
Actual coding.
Getting stuff done. Getting the CI/CD
pipeline up and running. Right? Um
So usually we see these type of
disciplines and we have different
uh people in each of them.
So the the um
the problem space is typically like a
product manager. Then you have an
architect on the on the solution space
and then you might have a engineer on
the um coding and the CI/CD pipeline and
that stuff that stuff.
Um And of course sometimes we can hold
more than one role, which is very common
too.
It might be that
with the emergence of AI, you're going
to see your matrix here and your
priorities shift a little bit.
It might be that where you were you
know, could do a little bit of
everything before, maybe you say, "Hey,
I'm actually most passionate about the
solution space.
That's where I want to spend my time."
So I might want to spin up agents to
help me out with some of the other
things, the why and the how.
So I can spend the time that I love.
Maybe it's more like coding. This is a
lot of this is passion to people, right?
Actually writing code. So if that's what
you want to do,
do it.
And maybe have help with some of the
other things from the agents.
So I'm a product manager. So I usually
live in the why.
Um I also like kind of
making prototypes and stuff to figure
out what could be a solution.
But and and anyone on the Visual Studio
team will tell you that you definitely
don't want me to write any code in the
Visual Studio repo.
So we'll keep that very very tiny.
But the cool thing is that AI helps me
do that. It helps me get rid of the
things that I'm either not good at or
not or want to spend time on.
Um so I can really double down
on the why in this case.
So, um,
it might look a little bit different
uh, in the new world where AI can help
us out.
I think this uh,
the problem space is pretty similar.
Like, what does the business want to
achieve and what issues do the customers
have?
The problem space doesn't really change
just because we have a new tool in our
tool belt called AI.
But, what really changes is the
what because
we can now as architect, we can come in
and we can do uh,
a lot more and a lot faster. So, the way
we define write specs and all this type
stuff
uh, can really be elevated. Can we can
really take advantage of AI that can go
out and
synthesize all this data that otherwise
would have been pretty difficult to come
up with like clear evidence of why we
want to solve a problem in a certain
way.
We can also look at uh, scope beyond
what we're just normally doing.
Like, how does your product fit into the
larger ecosystem of your company's other
products?
Does product A contribute to product B
and the other way around?
Sometimes it's like, let's just focus on
our thing, right?
And then if you know, something may come
up later where we can do some sort of
collaboration, but
the thing is that with AI, we are now
elevating ourselves. We can we can move
ourselves up to a higher ground.
Take the helicopter up and look at a
much larger picture all of a sudden
because we can like use agents to help
us get all the data and align all the
different things and so we can think
bigger.
Which is absolutely phenomenal.
Um, and the same thing goes for how.
Um,
if we don't want to write so much code
because we have help doing that
we're going to now stress the reviewing
and the verification
of everything we're doing. We're going
to relatively spend more time building
our solutions,
running them, debugging them,
verifying that it works according to the
problem we wanted to solve and the spec
on how to do it.
Right?
So, having those skills and those tools
being super
fine-tuned for that is now more
important than ever.
And Visual Studio is here
for all of this.
Because for all of these different
tasks,
we need to understand
our, you know, basically our files, our
projects, our solutions, how our
dependencies work.
We need an interface to talk to the
agents.
We need our chat window, right? And
other types of integration that really
can elevate
uh our productivity.
And Test Explorer becomes more important
than ever
because
uh
when you have agents writing your code,
how do you know that that code doesn't
break something?
Uh
guardrails in forms of tests,
integration tests, unit tests are like
crucial.
And finally, code. Because you want to
code, you want to review code.
Like read code, write code, you still
want to do those things either because
it's a really good idea or because you
were like really passionate about it.
Either way,
those tools that we know and love,
IntelliSense and so on in Visual Studio,
a strong debugger,
is not going anywhere.
Right? Visual Studio is here
for the same reason today as it was here
20 years ago, 29 years ago,
when Visual Studio was first
uh came to the market.
And one thing that we're very clear
about when it comes to Visual Studio is
who's it for?
Because you have colleagues, they prefer
VS Code, some prefer, you know, cloud
code or codex or
the CLI experience or whatever it is.
And
how do we make sense of all these
different tools and what to choose?
Well, from Visual Studio's point of
view,
we're very, very clear on who our target
audience is.
It's you.
The professional C# and C++ developers.
That's it, okay?
Professional developers.
And there's a reason for that. And that
is because they share something that
we don't really see it a lot of other
cohorts
uh care so much about, and that's
quality gates and tenants.
We care deeply about security, privacy,
accessibility, governance, and so on.
And so having the tools that allow full
uh administration for like big companies
to roll out a fleet of Visual Studio
license um machines, right? And
uh have the tools in Visual Studio to
handle all these different things remain
a super focus for Visual Studio. You
don't really find tools like this
anywhere else.
Um and at the end of the day,
Visual Studio is for developers who care
about code as an asset,
not an artifact.
Like if you were to just to do a
prototype of something, you don't really
need to look at the code, right? You can
just ask the agent to build you a
prototype of of whatever it might be,
and you can throw it away. That's fine.
So for projects like that,
you know, use whatever floats your boat.
But for the projects where
the code is an asset, like you have to
maintain this thing, not just you, but
your colleagues and your future you,
your own worst critic, right?
Uh you want to make sure that it's uh as
high quality as possible
for now and years to come.
And the priorities from Visual Studio's
perspective does not change just because
AI gets in the mix. If anything, we're
doubling down.
Because where we see some other products
are kind of trying to find their path,
we know our path.
Professional developers.
And so, I want to show you a little demo
of a thing that
shows how in Visual Studio the tools
that we have and that that we rely on
works great for humans, like we can use
these tools. But when we sprinkle AI in
the right places and we really implement
AI around the depths and the roots of
these features as they intersect,
we come out with an experience
that's quite unique and is uh leaning
into the power of a full-blown IDE that
Visual Studio is.
So, let's check this out.
>> Hey folks, today I'm super excited to
share some of the new features we've
been working on in Visual Studio. Uh
specifically a feature around helping
you improve the performance of your
code.
And so, to do that, I want to show you
this feature working on some real code
that I grabbed from nuget.org. So,
searching through some of the packages
there, trying to see if I could find one
that would be kind of cool for a demo,
and I found this QR coder library. Uh it
seems to be a pretty popular library. It
has almost 60 million downloads,
uh and it basically helps you render QR
codes in your .NET applications.
And so, I went ahead and I cloned it in
Visual Studio, and you can see I've got
my project, I've got some benchmarks, a
console test app, um bunch of different
things.
Uh and I want to go ahead and I want to
see if I can make a improvement to their
code.
And so, I could run this under the
profiler, um kind of doing existing
profiling workflows,
uh but I don't really have time for that
in this demo today. And so, I want to
click the easy button. And so, for that,
we've gone ahead and we've added some
new entry points into the profiler and
the test explorer. And so now, on newer
versions of Visual Studio, all SKUs can
profile different unit tests. So, if you
have like an integration test, this is a
great way to get into the profiler, get
actual
performance data out of it, make
changes, and kind of see the impact of
those changes that you're making.
But what's even cooler is we now have
this profile with Copilot button.
And what this does is this tells Copilot
to go ahead and run the test under the
profiler,
try and make changes to the code that
it's testing, and then try and implement
some optimizations and measure the
impact of that. And so, you can see it
says it's identifying the scope. It went
ahead and it ran the profiler to
establish a baseline. And then it can
start digging into um
that trace that I captured. And so, you
can see it said it sees the key
findings.
"Should match approved image." This is
test framework code, making sure that it
actually kind of asserts and matches
what it should be expected.
It says, "Can't be optimized here cuz it
tries to ignore any test framework
code." But then, almost half the time is
spent on the QR code
generation, which is good. We That's
something that'll be a good target for
optimizations.
And then it says a moderate contributor
is the draw scan lines
for the actual image rendering.
And so, you can see it says it's the
generate QR code is definitely the thing
to try and implement.
It's going to go ahead and implement an
optimization. So, it found specifically
where it should try and implement. It
found some of the functions that it
should be looking at. It's digging up
and down the stack trace that's in the
um trace that it captured.
And it can see
um where things are actually being
called and uh
what is happening. And so now it says
now it has a comprehensive view of the
hot path. What are the key optimization
opportunities? There is this mass code
module placer.
Uh it calls these um things multiple
times uh because of the fact that it
used an instrumentation profiler in this
case, uh it gets actual call counts. And
so it can see like if you've called
things multiple times and it can
optimize that by um just making the call
once and hanging on to the result.
Uh it found a point where we use
floating point math, which is slower, uh
and it thinks it can use integer
division.
Uh and then it found another spot where
it looks like we're doing some indexing
into a module
uh
a 2D array uh matrix and then it can now
cache the row reference.
And so it's reading the code, it's going
ahead and it's doing the optimizations.
Uh it went ahead and it actually uh it's
kind of getting ahead of us a little
bit. Uh it is going ahead and it's done
the optimizations. You can see it made
changes, it tried to do the build, and
it looks like it was doing method input
options, uh aggressive inlining. My
guess is it was trying to inline a
function call,
uh and then it's seeing that the
namespace isn't there, so it's going
ahead and it's going to uh correct that.
And then
uh with any luck, the build will now
pass, and then it is going to go ahead
and it'll rerun that unit test, and then
it'll see the impact of the change that
I made.
So our build is successful, which is
awesome.
Uh it's now running the test to verify
correctness. Uh that's one of the
benefits of using tests to go ahead and
profile is it knows that the test will
actually test for for functional
correctness and so as it makes changes
it can make sure that the
um
it's not breaking the functionality of
it and then it can make sure that it is
actually faster and so it said there was
a failure on .NET Framework only and
that's regarding um source information
uh but it works on .NET 5 and so it's
gone ahead and it re-profiled it uh and
made the changes and you can see it then
list off all the different changes it
made
uh it looks like
the create QR code is faster uh place
modules which previously was in our top
functions is no longer listed that makes
sense if it was probably inlining it um
and then it was making some additional
changes and then that pattern five where
it switched from uh float arithmetic
with a floor down to integer math
uh it should have improved that there
and so now the self percent dropped by
approximately 63% reflecting you know
um that it has in fact improved the code
uh and so I can go ahead and I can look
at the code and I can see like oh you
know it went from uh obviously floating
point math uh down to integer math
maybe that's faster maybe I don't know
why and the nice part is is when Copilot
is doing these optimizations I can
follow it up with my own questions and I
can say
why is the integer math faster than the
floating
point math
and then not only will Copilot go and
try and optimize my code it'll actually
teach me along the way like hey this is
why um this is faster and so talks about
uh
floating point unit versus ALU pipeline.
Um it says that math.floor does far more
work than just, you know, right shifting
by one,
uh and then
the floor is redundant, and then the
cost of this is compounded. And so it
looks like it's doing it in for every
cell of the QR code. Uh so it's a 29 by
29 grid. Uh so there's over 6,000 calls
to it. So even a little bit of
optimization where you're optimizing,
you know, very small amounts of floating
point to integer
can actually have a pretty big impact.
And with that, we can, you know, we
could continue to click on buttons here
and
uh continue to follow up on more and
more things and have Copilot optimize
stuff for us. Uh but it really goes to
show like, you know, couple of minutes
here I've been clicking on some buttons
that launched into a performance
investigation. Copilot helped me find
and identify things that we could change
that actually have a positive impact on
the code. Uh and then it made those
changes, validated them for me, and then
taught me something along the way.
And so with that, thank you everyone,
and I hope you enjoy your time at the
conference.
>> All right. Thank you Nick, who couldn't
be here today, but Nick, he's uh he
works on the Visual Studio team. He's on
the diagnostics team, and and his team
is the the team that built the profiler.
And so what this illustrates is, I
think, very
uh clearly how we're looking at how
Visual Studio fits into this picture
both now and going forward. Like you
have tasks that you do today. You
probably rely on the debugger
because it might be the best debugger in
the industry. Is that that's what you
tell us at least.
Um so and and we believe you.
Uh the profiler is one of those things
that
helps us instrument our code to learn
how we can optimize it. And that's what
he did here, and he did it from the test
explorer. So, there's an integration
here that otherwise would have been kind
of maybe difficult to to do any of the
the profiling um without it. But, what's
really nice is that you can write any
test, you can do integration test. As
long as you can start the profiler from
that test, you can have the AI help you
out.
And I don't know if you know the
difference between floating point math
and
integer math.
Yeah.
Maybe.
I for sure don't. Right? And that's the
beauty of this. Like, I can run that
profiler. I would have probably been
able to squeeze some performance out of
uh whatever I was profiling, but I would
never in a million years have thought I
could just
you know, maybe I didn't even know that
was something called floating point
math, to be quite honest with you. That
would had a different performance
characteristic than any other type of
math.
How can there be multiple times of types
of math to begin with?
Right?
And that's the beauty. You don't have to
be low-level, know how, you know, the
bits and bytes of the compiler is
running on the metal.
But, the agent knows.
And so, it can help you learn how to do
this going forward. It can help you
learn why it might not be a good idea to
accept an I list in a as a parameter,
but maybe you should have a more
specific type that has better
performance characteristics for the
specific thing your method is using it
for.
It's those things that you probably
don't even think about.
And this can help you find them.
And the good thing about performance
profiling is that I don't think anyone
has ever
been fired for optimizing code without
asking permission first.
So, it's something anyone you can just
go home and try it.
Um some of the people from the profiler
team, they actually when they go for
lunch, they start the profiler agent to
"Hey, while I'm gone for half an hour,
go see if you can find parts of the code
to optimize.
And sometimes it doesn't really find
anything useful and you just leave it
alone. And sometimes you get a perfect
benefit and you spend a little bit of
time and you check it in.
And now your stuff is faster.
It's really, really significant and
we've used the Visual Studio profiler to
make Visual Studio itself faster.
And other
um
products as well like Bing, like .NET.
Um
all over the map. Uh you can really use
this for anything, whether it's UI apps
or web APIs or whatever it might be,
WinForms. Uh Brian's WinForms apps, she
will work for those, too.
>> [clears throat]
>> So, but it's a capability that we've had
already and we're adding value through
AI to something that's important.
So, we didn't talk about debugger, but
you can go through the debugger agent as
well through the unit tests or through
test explorer, rather.
So, we're talking about this thing about
workflow.
Well, how do you start taking advantage
of all these things? Because one thing
is that we have this in Visual Studio,
but what could be a good workflow?
Um
I'm going to just do a little bit of uh
uh
prescription here, but if you really
want to see a full workflow, come to
Sebastian's talk about how we use
Copilot internally on the Visual Studio
team and what our workflow is.
It's a really quite uh interesting.
But the first thing we need to make sure
we do and I alluded to this was that we
have to add sufficient tests. This is
kind of the pre-requisite.
We can't really take full advantage of
AI until we have guardrails in place.
Some constraints for the uh agents to
work within. Otherwise, we're just
setting ourselves up for like having to
run all, you know, all this stuff
manually. We have to verify a lot more
manual stuff than we otherwise would
have.
So,
Hello, Brian.
Also, get your backlog in order. So,
this goes for both
your product backlog, like your user
stories, but also your any technical
data or bugs that you might have.
The
getting a backlog in order doesn't just
mean prioritize, it means
that you have clear titles and
descriptions.
Because if you're going to let an agent
loose on your backlog,
you want to make sure it does kind of
what you expect it to do.
And so, having those clear descriptions,
if you have links to
uh user feedback or anything like that,
make sure you get it in there.
The good news is that the agent will
help you with this. So, I do this all
the time. And uh if you give it links to
certain things, it will start creating a
very, very detailed description of
existing
GitHub issues or ADO tickets or whatever
it is. So, uh or Jira, what whatever
you're using today.
And so, that's a really good place to
start.
So, once you have the tests
and you have a backlog of things that
you're comfortable having the
agent run,
you can start
assigning work to the agent.
And so, you know, whatever floats your
boat. If you want to use Visual Studio,
if you want to use the CLI, whatever you
want to use,
assign the agent to the work. Maybe you
want to use github.com, you can actually
spin agents up directly from the website
if you want to.
Uh which makes sense if you have
something it it can run and you, you
know, maybe you don't have to verify it
that
um
specifically like you do from within
Visual Studio, where we have this very
specific thing that is actually
fantastic. When we have our code, you
click F5,
you run it, you verify things are
working, and you debug it if it doesn't.
That is an immensely powerful
inner loop, is what we call it. You
might have heard us talk about the inner
loop. But that whole idea of like
coding, verifying, testing, debugging,
coding, you know, we're talking about a
loop.
We can now add profiling into that as
well. Because it's gotten so simple and
so fast because we pointed the profiler
at the profiler.
And so, this becomes a very, very
powerful thing uh for any developer,
professionals in particular because we
really value those debugging sessions
and those logs and all those things when
we do run our apps.
So, this is a typical kind of very
high-level
uh getting started workflow. Now, for
the specifics, go to Sebastian's session
uh later in this conference.
So, Visual Studio going forward,
we're going to double down on some
things. We're going to add some
investments around certain key areas
that are important
with or without AI, but certainly with
AI.
Okay? One is about testing.
Those guardrails are important, and so
the experience you have adding tests has
to be as smooth and delightful as
possible.
Like we have an agent the test agent
that makes it really easy to add unit
tests. So, if you haven't uh played
around with that,
and maybe you don't feel that you have
enough unit tests, give that a go and
you'll see uh some true magic happen to
your code coverage.
Uh but it has to be a very, very
pleasant uh
experience, and so we're going to invest
more on testing. Same goes with
diagnostics.
Debugging, profiling,
all that stuff. Um
we are maybe the best. We want to it to
stay that way.
And we want to give you all the tools
both for humans and for agents so that
you can decide when and where you want
to use agents and when and where you
want to be driving the whole thing or
anywhere in between.
Uh build and run.
We're going to do this is now
relatively to coding than we have ever
before.
Because we're now being We're going to
be a little bit of a QA person sometime.
We have agents doing work on our behalf.
We need to verify things. So, how do we
speed up builds? How do we make that
experience better?
Uh running of your app and all that type
stuff.
Uh integrations.
If you're building something on Azure,
you're using Azure services,
could something light up in Visual
Studio that makes that even easier?
Um
we already have some We're shipping some
in preview right now that will help with
that. What if maybe Brian's WinForms um
applications here? What if he could have
expert help with writing WinForms?
Maybe Wouldn't it be cool if you could
have a
uh
like you could basically have a a member
of the WinForms team sitting next to you
while you're building WinForms apps to
kind of help you along the way.
Seems like that would be pretty amazing,
wouldn't it?
Um
I'm not saying we're going to ship
members to your companies.
>> [clears throat]
>> And then review. Like you're going to
review a lot more code than usual.
And so, how do we make sure pull
requests and both like reading a pull
request, but also if you wanted to send
a pull request somewhere? Uh again, it
doesn't have to be an agent. It's
humans. Like we we want to review code.
We want to have a great experience
uh as much as we possibly can. So,
um maybe
I want to get a
code review of my code before I send it
into my colleagues. Especially like And
we know this because um a lot of people
tell us this that there's certain
anxiety associated with sending pull
requests because you're now inviting
other people that might be your seniors
to look at your code that you may not
feel is as good as they would have
written it.
So, it would be nice to have like an
impartial person or agent or whatever to
review your code to catch common things
first, right?
So, that would be nice.
And then it comes time to commit.
And uh
the mouse hovers over the commit button
and what you're feeling?
Please don't result in a merge conflict,
right?
Anyone here loves merge conflicts?
No.
Uh
So, we want to make that a thing of the
past.
Um
So, again, whether you're human, whether
you're an agent.
And um all of this is
how professional developers
use the product, the thing they rely on.
And then we want to make sure we add the
meaningful AI to where it makes sense.
It doesn't mean we're going to bolt on
AI for the sake of
AI. It has to mean that it changes
something that you're doing for the
better. You're going to do this anyway
or
you wish you could do it, but you don't
know how.
So, we want to make sure we get that in
there. The AI word makes sense and where
AI is the
best solution.
Okay?
The problem space is the same,
but we have another tool in the toolbox,
just like you do.
And so, from Visual Studio's
perspective, we can now use AI to solve
problems.
All right.
So, what got we What have we got here
coming for you? Let's take a look.
So, we heard from uh Dalia this morning.
Visual Studio
has used its own implementation of
Copilot for quite a while, and that's
now changing.
So, it's changing to use the Copilot CLI
SDK. So, all the GitHub Copilots,
whether it's in VS Code, the CLI, Visual
Studio, or elsewhere, it's going to use
the same
foundational component, the same SDK.
So, you're going to have the same
experience across all these and they
We're looking at how we can share
sessions, so you might be able to start
in the CLI, move that into Visual
Studio, and so on.
But, right now in preview,
we do have the new SDK. You can choose
the agent in the agent drop-down, you
can choose the preview agent, which will
run
um Copilot on the CLI SDK.
So, no longer will you see all those uh
developer command prompts show up and
steal focus in the IDE. It'll all run uh
the way you may be expected to. So,
that's really, really nice. I've been
using it for several months and it's
fantastic. Look forward to that.
Bring your own key.
So, we talked about privacy and how that
stops some people from deploying it in
their enterprises, their companies
because of, you know, the privacy
concerns.
But, what if you could run
any model of your choosing
on any hardware, on any URL, whether
it's on prem, it's local, it's on your
Mac Mini,
or it's any cloud provider out there.
It's Azure Foundry, wherever it might
be.
We're going to open up for that so that
you can now host
your own LLM and get that to light up
within the Copilot experience without
doing anything else.
Okay?
So, that's a big change coming here.
You don't have to sign in with GitHub
for this to work.
Git worktree?
So, that
Ooh.
Yes, let's hear it.
So, Git worktree is a fantastic tool. Uh
a lot of agents use it. Um
and it's a really good way of
parallelizing your work and have
multiple agents work on different
worktrees of your uh of your repo and
and uh and make that all kind of more
seamless. So, that's fantastic. Another
Git feature is Git submodules. So, full
support for that. Um it's now in
preview. It's going to go into stable
here pretty soon.
I talked about the merge conflicts
of which there were no fans among you.
Um
we're going to have a button. In case
there is a merge conflict, there's one,
we're going to add a button that says
fix it. You know, it's not it's not
being called fix it. It's What's it
called?
Andy, what's it called? What do we call
the button? Uh auto merge, maybe?
Um no, but what it does is that it will
as best as it possibly can, just like
you or I, it will look at the diff, the
deltas and all that, and try to do it
the way you would do it to uh
solve the conflict.
And so,
this is absolutely a game changer
because it removes that whole anxiety,
it removes all that time wasted in
figuring out and resolving merge
conflicts.
So, we're very excited about that one.
It's coming in preview here pretty soon.
And then we talked about this notion of
having,
you know, the WinForms team sitting next
to you.
Or the Azure App Service team sitting
next to you when you're working on some
Azure service that you're using, right?
We do it through agent skills.
So, the thing about agent skills is that
it's a great way to add knowledge to
the agent.
Uh knowledge that it wouldn't otherwise
know, like specific things. Very
specific things, either to your company
or to specific technologies like a
specific Azure service, for instance.
The problem is, how do you discover
them? How do you find these skills?
They're just markdown files.
And they exist, people have written
them, they're on repos around the world,
you know.
How do you find them?
And which ones are good?
So, we're taking that on and saying,
well,
what if the WinForms team wrote a bunch
of skills and maintained that in a repo?
What if the Azure App Service team and
the Azure Fabric team and
all sorts of different teams, they write
the skills and they maintain them
themselves? These are people who build
the product.
And so now when you're using the agent
to write some of your code,
they gain that knowledge from the team.
Which is absolutely fantastic and we can
apply it automatically. So you no longer
have to go look for it. Visual Studio
will simply say, "Oh,
you're using some Azure stuff.
Let me get you the uh let me apply the
Azure skills that's relevant right now."
Um and same with WinForms.
And so on and so forth.
So that is starting to roll out. The
WinForms was the first, we just did some
Azure.
Um and uh and this is absolutely a
game-changer for the AI because we take
it removes that discoverability issue.
So
things are moving fast and so is Visual
Studio.
So we've already shipped quite a few
updates. Every one of those uh orange
dots or golden dots
are the monthly updates we have done to
Visual Studio 2026.
So we used to ship quarterly, but we now
ship
monthly because the world is moving fast
and we have to move fast with it. So
make sure you update Visual Studio.
Uh there's always new features
available, there's always new fixes,
there's always new performance gains as
well.
And we have um
a good history. I'm just showing you a
few kind of highlights, some of the
things we've been talking about that
we've been shipping and that we are
shipping.
Um and that moves us into November where
we're going to see Visual Studio 2027.
And what we talked about now
applies not just for now,
but also through next year and as long
as we know, okay?
We are here for the professional
developers
and the AI is not to take over, it's to
be meaningful
where it matters.
Um
and so Visual Studio will be here.
It's with you, no matter where you are
on your
AI journey.
If you say, "Hey, I'm just going to
I'm okay waiting and just whenever
Visual Studio is adopting certain
features, that's when I'm going to join
in."
We got your back.
If you want to say, "I want to be on the
cutting edge and I want to use cloud
and, you know, CLI tools and all this
type of stuff, but I also want to use
the Visual Studio debugger and so on."
We got your back, okay? Integration and
all that type of stuff.
So, Visual Studio is here to stay.
Visual Studio is here for you, the
professional developer.
Uh and that won't change.
So, as I mentioned earlier,
we are here. Everyone who People who
build Visual Studio and all the
underlying technologies, .NET, C++,
Azure, and so on.
SQL.
We are here throughout the week.
Please come talk to us.
We really want to hear your story, want
to hear what you have to say,
learn how we can improve.
And with that, thank you very much and
enjoy the rest of your conference.