Ep 37 - Coding Agents

This week, Kevin McDonnell and Garry Trinder explore the world of coding agents and how they could change software development. They run through what coding agents are along with the importance of context, memory, and specifications in using AI tools effectively. Also, they think about how you need to change habits and also touch on the challenges faced by junior developers in adapting to AI technologies, the role of personality in AI agents, and the future of work with AI. This isn't just the joy of agents though, this is about the need for security and ethical considerations when integrating AI into development processes, while also encouraging developers to embrace the potential of AI to enhance productivity and creativity.

Takeaways:

• Coding agents represent the next leap in development tools.
• Understanding the context and instructions is crucial for effective use of coding agents.
• Memory in coding agents can enhance their effectiveness and personalization.
• Specifications and guidelines are still important in the age of AI.
• Junior developers should balance learning coding principles with using AI tools.
• AI can automate repetitive tasks, freeing up time for developers.
• The personality of AI agents can enhance user experience and engagement.
• Skills in AI can create repeatable processes for developers.
• The impact of AI on junior developers raises concerns about learning and understanding code.
• Security and ethical considerations are vital when using AI agents.

Links:

Github Copilot CLI - https://github.com/features/copilot/cli/

Claude Code - https://claude.com/product/claude-code

Patrick Rogers power of Coding Agents - https://www.linkedin.com/posts/patrick-rodgers-b6a05610_i-love-to-write-code-ive-been-a-programmer-activity-7422672723191058432--Ob_

Shipping at Inference Speed - https://steipete.me/posts/2025/shipping-at-inference-speed

Claude Skills - https://support.claude.com/en/articles/12512176-what-are-skills

Anthropic Skills Repo - https://github.com/anthropics/skills/tree/main/skills/slack-gif-creator

Open Code - https://opencode.ai/

Moltbot Soul - https://github.com/openclaw/openclaw/blob/main/docs/reference/templates/SOUL.md

Moltbot - https://moltbot.you/

Moltbook - the first agent social network? - https://www.moltbook.com/

https://www.moltbook.com/post/ef3ea419-6c29-4046-9946-d636efe972ea

Be careful with Moltbot/Clawdbot:

https://www.linkedin.com/posts/elishlomo_security-activity-7421867291459391490-a0B1/

https://x.com/theonejvo/status/2015401219746128322

https://x.com/borjitaea/status/2015745063909839091?s=46

Transcript

Kevin McDonnell (00:11)
Welcome to the Copilot Connection. We're here to share with you all the news, insights and capabilities of the Microsoft Copilot ecosystem across the entire Microsoft stack. Now this is our regular deeper dive into the more dev side of Copilot and agents. I'm Kevin MacDonald, an MVP for Copilot and Copilot extensibility and also the UK lead for Copilot and agents at Avanade.

Garry Trinder (00:32)
Hi everyone. My name is Gary Trinder. I am developer advocate at Microsoft. And I'm focusing on Microsoft 365 Copilot at the moment. Lots of other things as well. Copilot always. But yeah, the point of these episodes really is to kind of just have a bit more of a talk about the tools, techniques, frameworks, things that people are doing out there in the community and AI land to basically do more as developers. So Kev, what have we got in store for people this week?

Kevin McDonnell (01:01)
I was going to let this go, but just for everyone. Yes, we are trying a new intro for this one to make a thing. So it was absolutely seamless there, Gary. I don't think anyone noticed us kind of hesitating at all.

Garry Trinder (01:10)
there.

You made me do it, Kev. You made me do it.

Kevin McDonnell (01:17)
Too shamed. I'm not going to say this, the reason I wanted to change it has always felt like the last few episodes, Gary's been there as a guest, a regular guest, and I think of him as a co-host. So I wanted to spin it around a little bit from there. So it's because I love you, Gary.

Garry Trinder (01:31)
It's good to be a calf.

Kevin McDonnell (01:32)
Well look at DJ over here Scott Mills who always drops in love you at the end then wait to see what everyone else does that felt like that moment I feel dropped entirely. Anyway what are we talking about this week we're going to talk we're kind of going into agents but we said in there this is about how you build agents and things on there so we have our regular Monday chat on what's going on and we kind of keep coming back to coding agents and

Garry Trinder (01:39)
Hahaha

Kevin McDonnell (01:55)
Kind of what they are, I Claude code has had a lot of it in the news. know many of your colleagues are apparently now using it on Microsoft to compare things, which is fascinating and things on there. And I think a lot of people who've seen GitHub copilot and maybe used it on and off, see it as it sits there while you're doing coding and does that intelligent kind of recommendation.

But I don't think everyone's kind of seen this new world of clawding agents that go above and beyond that. So we thought today we'd talk about what they are, what the different ways of doing that is. Yes, there are things other than GitHub Copilot, so we'll touch on a few others. I think we're also going to go into the changing the habits. And this is one I'm particularly keen on, because I still haven't got my head around using them. I kind of have to push myself to use them and it doesn't always feel quite right. So we're to talk a bit about

how you build those habits. We're to talk about some of the challenges for those who've heard about Claudebot now and I actually have to look this up because I forgot what it's called already. Maltbot is the new name for it which I have only just found out on there. So some of the challenges and risks around that and then we'll cover some of that how to learn a little bit. I think we'll probably cover that as we go along rather than a little bit.

Garry Trinder (02:54)
Maltbots, yes.

Kevin McDonnell (03:10)
got Gary here, I forgot to put this old age coding on there and I think that's about your new laptop isn't it? I put that note for myself to try and mock you slightly.

Garry Trinder (03:18)
Hey.

Yeah, getting a new laptop and being able to go, Ooh, actually I can work in different places around the house, which I have been doing all week. And then realizing that sitting on a sofa and, you know, working on the, and a kitchen counter is like, yes, I can do it. But then after a week, I feel like I need to be back at my desk because, I'm going to be, yeah, my back's hurting already. So, fun while it lasted.

Kevin McDonnell (03:29)
All be back, all be on.

Yeah, I think it was Chris Huntingford. Chris

Huntingford had a LinkedIn post back in November of him sitting on the floor doing a client call. And my first thought was, yeah, I can do that for more than about five minutes for just wriggling or feeling sore. So, yeah, old age coding. Yeah, yeah, exactly. OK, I'm going to hand over to you. What on earth is a coding agent?

Garry Trinder (03:55)
It's a few days of pain after doing that.

Yeah, well, guess coding agents is kind of like the next leap, right? We've had leaps all the way along with development tools in the past. Like remember when we were doing things in...

like text editors, right? And we wouldn't even have IntelliSense and you know, the improvements in IntelliSense that came along, you'd have extensions, like I always remember using ReSharper in Visual Studio and going, my God, this is amazing. Like it was gonna look at your code and it's gonna make recommendations and you know, it's very static, but still at that time was like, you know,

Kevin McDonnell (04:21)
good old days.

Mm.

Garry Trinder (04:39)
10X what you're doing to the point where I would be kind of amazed by the work that some people would do. And then later on I found out that, no, they're using Resharper. And I was like, okay, now things make sense. They were faster, it was better quality, but it's the tooling. The tooling was there to help you, right? And it's just kind of, we've evolved over time and coding agents is the next leap.

in that we are instructing an agent to basically write the code for us ⁓ so that we don't have to write LimeAlign.

Kevin McDonnell (05:08)
Yeah, I feel you've you've missed

it. A kind of fundamental leap, I think that even with GitHub copilot, it was accelerating what you did. Coding agents are doing it for you. And it's going out and kind of running and processing all the time, isn't it?

Garry Trinder (05:18)
Mm-hmm. Yeah.

Yes.

Yeah, that's a good point to make is that I guess the GitHub Copilot was the next suggestions, right? So we had the tab approach of like, if you put a comment in and then you tab it, GitHub Copilot is going to go away and it's going to generate the code based on your comment, which may create a function that has these parameters, these outputs. Yeah, but it was always triggered by you. you were always there, but you were actually in the editor.

Kevin McDonnell (05:44)
always triggered by you.

Garry Trinder (05:52)
I think that's the distinction is that you still lived in the editor versus when using a coding agent and now I don't live in the editor at all. I live in the agent and I let the agent live in the editor. So it's a complete like switch around in the...

I can instruct the agent, like, hey, I want you to do this. And then it is able through different mechanisms, like tools to create files, replace strings, inspect all these files, look at the terminal for any outputs, any errors, look at any linting errors that may occur as well, and then go and attempt at fixing them. And having that agent there that is writing something, checking what it's done.

looking for problems, finding the problems, going and fixing the problems without you even needing to say, hey, you broke something. wanna go have a look and fix it? It's like, at one point that was the case, but as the progression's gone on, language models have got a lot better. We've got all these different tools available, then it's got much better.

Kevin McDonnell (06:55)
to that. Can I pull you... I just want to pull you back a little bit because you probably saw me pulling

a face when you talking about the editor versus in the agent and I was thinking are you talking about me in two different places? You're talking about being in VS code but instead of spending the majority of time on that kind of left-hand panel generally with the main one where the code is, you're talking about spending more time in the right hand

bar where the agent is on there. So you're not going to different places. You're still generally in VS code and how you work, but you're moving more to the right hand side. Yeah. And because also, and it's kind of been there for a while, I hadn't really picked up on it. Within GitHub, sorry, within GitHub, you've now got that agents tab when you're looking at a project as well that you can go and do things. I was wondering if you were...

Garry Trinder (07:30)
Definitely, definitely more towards the right hand side.

Kevin McDonnell (07:49)
doing a lot more there, but you're still living in VS code primarily.

Garry Trinder (07:53)
Yeah, mean, Copilot is everywhere. To kind of say about the coding agents, like the traditional, I've still got my ID and I have, in terms of GitHub Copilot, it's an extension in VS code that then provides agentic capabilities, right? There's different ways of having coding agents. There's the GitHub Copilot CLI, so I don't need VS code.

I can go into the command line and I can get it to generate code through that interface. We've seen with Cloud Code, Cloud Code CLI, kind of like the alternatives. There's things like OpenCode, is a open source coding editor, sorry, a coding agent, not editor, coding agent.

Kevin McDonnell (08:22)
interesting.

Garry Trinder (08:35)
that again is kind of like that can be embedded into an IDE, it be used through the command line, but all of them have common kind of characteristics in that they have language models that they can use, they have different prompts that kind of determine like their behaviors because different companies have different ideas about, know, what a coding agent should be able to do and how should it do it.

And then the tools that it's got access to as well. And that could be, you know, like I said, reading files, doing the basics, looking at terminals or calling out to third party tools to call an API to get data from external sources, for example. So there's lots of different flavors of coding agents, but it's still back to that. You you're not really in the editor making the changes anymore. You're kind of instructing.

the coding agents through iterative kind of conversation to make changes.

Kevin McDonnell (09:33)
So

there's a session I've been doing at conferences called Anatomy of an Agent. And as you're talking, my head's going, Anatomy of a Coding Agent could come into this as well. So you've kind of touched on the interfaces. There's different interfaces. Yes, you can have it in VS Code. I think we might come back to the GitHub Copilot CLI in a minute as well. So there's different ways of going in there. You just then touch on giving instructions, because I know you can obviously go in and chat to that agent and keep telling things, but...

Obviously, I have a style. Style is possibly the wrong word for it when it comes to my code. But there's a way of working. You have a way working when you're working on a project. There's different ways of working. But if you've got a coding agent, how can it understand that?

Garry Trinder (10:11)
Yeah, so I mean, those things can be defined. So you can provide, I said instructions and that's kind of a very vague term because instructions does have its own kind of, I guess connotations as to, an instruction is this thing. So think of an instruction as maybe every time you send a prompt through and I'll go to prompt it as in like, that's what I'm sending to the coding agent. I'm sending a prompt, but the coding agent might...

access instructions. A typical one is having an instructions file in a project which explains how the coding agent can work with this project and it might highlight things like here's the folder structure and when you write functions, write them this way, here's the style that we want you to do, all those kinds of things. Yep.

Kevin McDonnell (10:58)
It's the kind of thing when a new developer was coming onto a project,

you'd explain that to them. It's almost a file that outlines that, that could be used by a person manually, but the agent uses that as well, which is very...

Garry Trinder (11:12)
Yeah. And that's the guide it. And I think it's kind of going back to the, like AI in general, right? It is non-deterministic. You put the same thing in several times and you can potentially get different answers every time. Right. But there's certain things that can influence the output to have it be more consistent. And one of that ways is instructions. So, you know, if you had instructions that were your preferences for how you build a web app in your company, for example.

then you could have things that are already defined, like we use this technology on this version, we have these coding standards, then that gets added into the context when the agent goes and generates the code and goes, I need to keep these things in mind, right? Versus not having any instructions in there at all and it just going, I'm just gonna pick something. And it might pick something that you know already, it might pick something completely different, like.

a typical example, which I was here is like, I use the coding agent and it built something in Python. I've never done Python before, but now the question is, do you really care if it's written in Python or not? If you're getting the output, like if you don't look at the code and you don't need to look at the code and the agents doing it, then naturally, if you're going through the agent, then you go, okay, I kind of understand good development practices.

Kevin McDonnell (12:35)
enough.

Garry Trinder (12:35)
I can

instruct the agent to go, you you're putting everything in one file here. I've got lots of functions. Maybe we should refactor this. Yeah, okay. And then you let the agent go and refactor the code that it's written and it becomes more of like a pair programming kind of approach, but you don't actually touch the keyboard. You're touching the keyboard, but it's to instruct the other partner to do the changes instead of you going in and changing.

Kevin McDonnell (13:00)
Also because you can carry on

scrolling your Instagram with the keyboard while it's working away.

Garry Trinder (13:05)
Well, you can do other things whilst it's working, which is

a good thing and also a bad thing, because it just means that you context switch a lot more because you're waiting. I'm an old SharePoint dev, right? And I used to have to wait for lots of things to happen, right? Before anything was shown on the screen. And you would have that moment of, I'm waiting for something to build, for it to load.

Kevin McDonnell (13:15)
Yeah. That's interesting. That's interesting point.

Yep.

Garry Trinder (13:30)
It might only be like 30 seconds, but it feels like forever. And you just automatically, your brain

Kevin McDonnell (13:30)
Deploy. Reload. Crash. Reload.

Garry Trinder (13:35)
goes, same with this, same with coding agents. You can just kind of go, wow, quickly look at that.

Kevin McDonnell (13:38)
I did

see a hysterical one. Someone had developed something that basically when they kicked off their coding agent, it would trigger something. His screen would flash up with all his Instagram, TikTok and elements like that. And it would auto scroll through it. As soon as the agent finished, it would hide that and bring back up the code. I love that. You know, that's kind of forcing yourself back to the focus. I think that's genius. But I think...

Garry Trinder (14:02)
It is. Yeah, yeah. mean,

sorry, come.

Kevin McDonnell (14:06)
I was going to say, I love what you're talking about, sort of, you don't need to know the language. I'm sure lots of people are thinking, ah, no, no, no, the horrible things are going to be created. But I think if people are experimenting with coding agents, go and experiment with a language you don't know. Go and try out with something else and you'll kind of see how that works. almost will talk bit more habits, but forcing yourself to do something that you can't do.

Garry Trinder (14:15)
Yeah, yeah, definitely.

Kevin McDonnell (14:34)
will encourage you to use that agent as well, because you'll lose that habit of going through and actually starting to write that code yourself. I know part of reason I haven't used coding agents so much is my natural thing is to go and start typing and things on there. I kind of I like the idea of choosing a different language, especially I'm sure many of our listeners and viewers out there are not quite many of them are Python oriented.

great, go and use Python. There's huge amounts of libraries. It's the cool language to go in, apparently. On that one, I don't know. I'm not cool enough for that. But, you know, it's the one to go out there. There's huge libraries to go out and make these things happen. And I loved what you said, that you know enough to kind of go, that doesn't smell right. There's something wrong about this that you can go and ask your agent about without having that cognitive load of having to relearn a language and get that syntax going.

So I think that's a nice technique.

Garry Trinder (15:29)
Yeah, and think that there's different approaches of using a coding agent and lots of people take different approaches. Like you can still sit down and go, right, in my mind, I'm gonna plan this out and I'm almost gonna write a spec and then give that to the coding agent and let the coding agent just go and deliver it, right? That is an approach, feels a bit of a traditional approach, You agree in your requirements upfront, go and build it versus the...

I kind of have an idea as to where I want to go, but I'm not quite sure yet because I want to see it in action. And maybe the quickest way to get there is to go, okay, here's what I want you to build, but we're going to build it together. And I'm going to stop you at different points. And we're going to have a discussion about which route should we take? Let's talk about the pros and the cons of the different options to build up the context. Now, as you're doing that,

you're building up your context as well, because maybe you get asked a question that you haven't really thought about and you go, actually, that's really good. But based on your answers and the discussion that you're having, that builds up the context for the coding agent that when it executes the things that it needs to do to satisfy what you've agreed on in the discussion, it has all the context of the decisions and why you said yes to one approach and maybe why you said no to another. And what's great about that is,

that can then go into memory and then can be applied going forwards as well so that you don't have to repeat these conversations with the coding agent. It's just there like, yep, we made that decision and I'll keep that in mind. And I think that's really quite interesting because as we go through building software, we're making so many decisions all the way along, but it's very easy to lose track.

of those decisions. So one of the things which I've been doing recently is instructing the agent to make sure it keeps a log of the decisions that we've made and why we made them. And that gets put into another file. It might be a markdown file, but it can reference. And then you have a point of reference for all those things, which you can supply. And then you're not starting from scratch all again.

Kevin McDonnell (17:28)
interesting.

And when you say memory,

that what you mean, putting those decisions into a file, or will these coding agents generally store that in a different place, or a bit of both?

Garry Trinder (17:38)
It can be as simple as that.

It can be as simple as that. So memory is just having recall, if you like, so that every time you start a new chat in a project, right, that it doesn't have to go and try to figure out what's happened. You just throw in, okay, here's the latest decisions we've made, or here's the changes that we made recently. It could be something like when you start a new chat, go and read the Git log about the last changes that we just made.

So it's automatically there of like, you've just worked on that feature, what we're working on next. Really little simple things that you can add in to enhance the coding agents knowledge. So you're not always starting from that blank slate. It's like the instructions file that we talked about, right? Like you're preloading a project with here are the preferences that we've got for building web apps, for example, and the technologies that we wanna use.

Kevin McDonnell (18:16)
interesting.

Hmm.

Garry Trinder (18:41)
and the things that we want to apply to this project. So it has that in its context, but it's like, you know, that concept of memory is that it could be as simple as, yeah, it's just writing to a markdown file or whatever format that you want. It's kind of bringing that in so that it makes sense for the agent to understand, okay, yeah, here's what's happened and then you can move forward.

Kevin McDonnell (19:06)
So I want to put it back a little bit because there was a bit I disagreed with you slightly on there that you don't need to start with a spec. I think if you're building something just you, yeah, I agree. I love that. this is my favorite kind of coding, just kind of see where the flow takes you. But if you're looking at, you know, enterprise developers, larger developers, teams, you've got a set of requirements that come in.

Garry Trinder (19:11)
No, you can't disagree.

Kevin McDonnell (19:26)
I don't think that world goes away entirely. There's still that need to come in there. I think I've been having a lot of conversations with enterprises and my colleagues really focus on this, on that. How can we get AI to help with that requirement gathering? And almost, we've been talking lot more about the needs gathering because requirements are really the documented, this is what's wanted. But if you're a chat with someone, bit like we're having a chat now on there, we can now take those co-pilot meetings, those transcripts and say,

Garry Trinder (19:30)
definitely, definitely, yeah.

Kevin McDonnell (19:54)
Can you convert this into a set of requirements and capture those things to pull that out? So you've got an easier way of doing that. And to me, that's what that spec you're talking about. Here's what we want you to do. Now, I think alongside that, and as you were talking, was kind of making me go, hmm, we used to have that guidance, except a lot of development teams didn't. A lot of dev teams didn't have a documented way. I remember we worked a while back with our good friend Al, you know, was...

We need to capture this is our styles of working. This is the way we should do things. This is when a new developer comes in. This is what the kind of approach we want you to take with how to code, with how to do things, how to approach things on there. And brand teams have been doing that for a while. Large enterprises have been building out their kind of reusable components. This is the styles that you should build those UIs. I don't think that the kind of back end developers have...

done that to quite a degree because it's all been, I'll chat to so-and-so, we'll work together, we'll have lots of stand-up meetings and we'll go in code review. I think it's coming back to that. We need to come and have those definitions. This is the logic. as you say, the coding agents can help build that together, can help build up that memory of that style, remembering your style, remembering what that overall style is. But then you can see it in one place. And I think we'll, for those on video, will show us through that.

few things and talk about that but I it does feel like those kind of component design I forgot what they're called, design specs and libraries this is how you should build your UI that isn't just a pure component it was I'm thinking of one particular project where we mocked the UI guy mercilessly because it was this ethos it's this feeling all this thing you need to do now I'm feeling very stupid because actually exactly that feeling that putting across those things

will power these agents really nicely. It doesn't need to be very specific when this do that, when this do that, which in my slightly developer mind, that's how it should work. Actually, we're now moving to a more more artistic, less autistic way of working. There's a phrase for someone to take away where we kind of go through and it's like when you're doing this, it's this sort of thing, the kind of thing that we try and impart on junior developers. Think about this, think about that.

Garry Trinder (21:59)
Yep.

Kevin McDonnell (22:08)
You're now building that into your agents as well to help other people go and review and build that code. And I can't remember who it was. I'm going to say it was the it wasn't the head of Nvidia. was was one of the big developments, kind of tech products. And what they're saying is they're not seeing less developers, but that ratio between developer and analyst or developer and product owner is shifting massively. And it's becoming where you used to have

one BA to like three or four developers, we're seeing that need for more BAs to go and have those conversations work out what's wanted, and then fewer developers who can do that, but doing huge amounts more. So it's more that ratio that's shifting, rather than reduction in the number of people, because we still we're just trying to do more, really. And it was fascinating. If I can find it for the show notes, I'll try and find the interview because it really got me thinking about it.

Garry Trinder (23:03)
Um, yeah, definitely there's different approaches. Absolutely. I'm not like definitely not saying there's no room for specs and for going through that approach. Like, you know, that is, that is an approach. It all depends on what you're doing, right? What you're building, you know, um, is it just a throw away app utility, you know, not business critical. It does the job great. You know, maybe not bothered about it versus mission critical. need high performance, you know, know, high security.

Not that security isn't a thing that you shouldn't be thinking about, different things and different things that you should be thinking about. So you're still in control, right? About, yes, the coding agent is going off and building things. And if you leave it to be vague, then you're gonna get something back that is maybe not what you expected. So that's kind of on you in a way, because you weren't clear. Now, I always bring this back to,

Kevin McDonnell (23:36)
We'll definitely come back to that.

Garry Trinder (23:59)
How is that any different to what we've had in the past when people are not clear on things? If you're not clear with an agent, you're going to get a response that is going to be similar. So it's still back to, and as amazing as all this technology is, I always kind of keep coming back to, yeah, but it's the people. It comes back to the people. It's like, what are we going to build? Why are we going to build it? Who are we building it for?

you know, how, how are they going to use it? Like exactly, exactly. can build the wrong thing faster if you're approaching it the wrong way. you know, I, it's, it's, it's not a silver bullet that it's going to, you know, solve all of the problem. It's like, it's, still building what you feed in, as, as, as a human. Right. so, you know, you still need to do that.

Kevin McDonnell (24:24)
You can build the wrong thing faster.

Garry Trinder (24:46)
understanding and the requirements gathering theme is really good. That is something, know, we talked about coding agents, right, which is like, it's just generating code. But I have lots of conversations in co-pilot. It's got nothing to do with code. It might be, I've got this page and actually I want to turn this around. Let's do a UX review. Let's think about the questions that people would be asking when they're coming to this page. Does this page help them answer those questions?

Kevin McDonnell (25:01)
for dinner copilot? No.

Garry Trinder (25:13)
And if it doesn't, then we can take that forward and go, well, maybe we need to change things. And it's using that LLM, using the hooks into the soft, you know, the code that's already there and having those kinds of conversations to then like move it forward. And I think once you start looking at it like that, I think at that point, again, it's back to the having the discussion about which options do we take. It's having the discussions around what have we got here? And are there some things that

we should be tackling. Are there any high priority things that we think actually that's not working for these reasons, it would be better if we did it this way. Yeah, okay, let's go with that, right? Or let's prove it, let's do an experiment, let's do a proof of concept of an option, throw that into a branch, check it. If it doesn't work, okay, you just let the coding agent go down a route that's... Exactly, yeah.

Kevin McDonnell (26:01)
And you can do that while you're doing something else now. You know, I've got an idea.

I don't know if it's going to work. Let's see if that works. Carry on with what I'm doing. Look at the results. Go. Yeah, glad I didn't waste time on that. Possibly a little bit of money, but we'll come to that.

Garry Trinder (26:15)
And that is evolving. That definitely is evolving. Kind of a bit of a tip, but I didn't realize until the other day is that if you're going to get GitHub Copilot in VS Code, you've got the pane on the right hand side, right? Which is like, I've just got one pane and I've got one chat. Well, you can actually pull those panes into the editor windows. So if you split the windows like you would do with any file, you can drag different instances of GitHub Copilot in there and have them running.

Kevin McDonnell (26:17)
Yeah.

That's true.

Garry Trinder (26:40)
at the same time, you could have them running as background processes. So you could have five options maybe of like, here's how we can tackle this problem. And then send Gale Copilot off to do five different potential changes in different branches all at the same time, which is kind of insane when you think about it.

Kevin McDonnell (26:55)
Well,

OK, I feel we jumped around a lot and our plans have gone flying out the window. So but I think there's a couple of things you mentioned there that I think are worth coming to on that. So you talked about there's no impact of doing things there. Very quickly, GitHub Copilot, sorry, the GitHub Copilot CLI for those watching on video, you can see that and it's exactly as Gary said.

⁓ Install the dependencies I need to run to run this project. I love that because I jump around between different languages and don't always do the different things and sometimes I use yarn and npm and I might go into... I can never remember what it's called in ⁓ C sharp these days because I don't do enough of that. Now I can just say install the dependencies I need to run this project. Everyone will it all out for me. Here it's got a go example on there. Love that.

Leverage GitHub context and extend with your own tools. And I think we're going to come because you touched on tools there. I think we'll come to that in a sec about what that means, because I think that is really powerful. And you talked about using agents for other things. I loved and Satya talked about this recently. In fact, we had Adam Harmetz, who now looks after knowledge. He's been in the SharePoint world at Microsoft for a long, long time.

on there and he was saying that Satya is using ⁓ the work IQ skill. So basically he's using connections to all his meetings, notes and things like that. So actually if I've been recording this on a Teams meeting, we had that transcript, Gary mentioned all these things, in GitHub Copilot I could say when Gary was talking about these different things could you help me do that? And it will work it out on there which I'm...

truly fascinated to try and give a go. haven't had a chance yet. that's that's just ahead of me again. Damn it on that one. And showing here, when you were talking about doing things in the CLI, I was like, why on earth would you that you want to see the code? But it's kind of got that with this CLI, it's bringing back the code and showing that chunk of code that it wants to do. So it's not you're not moving away entirely from that code, but it's a single place to go and do things. So I'm.

Garry Trinder (28:45)
you

Kevin McDonnell (29:05)
I'm fascinated we will put links to all these things in there so you can try. What I did want to pick up on though is something here. Patrick Rogers and I loved this quote he made on sorry this post he made on LinkedIn. He loves to write code, been a programmer for years. There's some large code bases. They've just refactored one of their code bases. I notice it doesn't say which one, which I'm intrigued by.

In the last three days and for less than a hundred dollars spend, there was an entire refactor was completed. Now they've got to go through. He says and they acknowledges, doesn't know if it works yet. He's going to go through on it. They're obviously checking it, adding testing to make sure, but it's got a huge amount of the way there. Now, the reason I was thinking on that was you said with no effort, there is a spend related to triggering these agents off.

It will go out and use tokens. You could use local agents for this, but I think and this is the next thing I want to go on to. I think we have seen that the latest certain specific models are really enabling this and actually doing a far, far better job. And Gary, you sent me this amazing post. No, not that amazing post. This amazing post.

On there from Peter Steinberger about shipping it in ferent speed on that which I thought was great

Garry Trinder (30:31)
Yeah, and this is really good if you are in kind of like the realm of, okay, I'm a developer, I'm still writing code, but there's coding agents there, kind of like, you know, where can I get to with this? And it's a good kind of, good post of Pete's kind of journey through this as well and where he's at now, the different...

models that have enabled them to work a different way. I guess the you've got on the screen codecs from ⁓ OpenAI and Opus from ⁓ Anthropic. Those are two of the newer models like the premium models which ⁓

Kevin McDonnell (31:13)
And they're more code

specific LLMs, aren't they? That's that's why they're making a difference.

Garry Trinder (31:19)
They are. So Codex is definitely, yes, it's a model that is tuned for coding agents. ⁓ And Opus, I'm not sure if it is specifically for coding agents, but it's definitely really good with its reasoning. It does a very

Kevin McDonnell (31:31)
You're right, actually. Yeah. Yeah.

Yeah.

Garry Trinder (31:38)
on Sonnet, 4.5 to Opus. And I kind of gone through these different kind of, this model has now enabled a different way of working because of the way that it behaves, the things that it can do. So moving from the default in GitHub Copilot to Sonnet was a big jump. from Sonnet to ⁓ Opus was an even bigger jump to the point where now there are things which I'm...

asking it to do, which it will just go and do. And I don't have to iterate as much on like guiding it through like, ⁓ you know, this is what I kind of meant. Like sometimes it does happen because sometimes I'm not clear and it will get it wrong. But generally its capabilities are just much, much ⁓ higher. But yeah, it's a good kind of example of.

Kevin McDonnell (32:27)
Yeah. And an interesting note,

I hadn't picked up on this when we talking earlier, but that, I don't know where I'm pointing my finger. I think it's saying here that codecs, it takes longer, but does a better job for those kind of larger refactors, whereas opus is better for those smaller edits. So again, it's different models at different points and what you're trying to do as well, which I think is fascinating.

Garry Trinder (32:36)
You

Yes, and this is the thing, so there's different ways of using coding agents. There is approaches at the moment, is I want to give, ⁓ let's say user stories to a coding agent. Here's the story, here's the acceptance criteria. ⁓ Go away and build it overnight. Long running operations that are just completely unattended. It's not using it as being like a

an assistant, like is the way that I'm primarily using it. But people using it to say, build me all these features overnight and then come in the next morning and go, okay, what have we got? So the things that are like a more longer running, maybe it will make more decisions on your behalf than, you know, different models have different benefits. So.

Yeah, it's interesting to see the different approaches ⁓ that people are taking because of what the new technology enables them to do.

Kevin McDonnell (34:00)
So we said skills. What are skills? Actually, that's not true. You talked about tools. But actually skills, I think, are the newer thing within this. If I'm honest, I haven't quite got my head around, partly because when I had a bit of time to try and play with them, my GitHub copilot license ran out and I've had a few fun and games getting that reactivated. So I haven't had a chance yet, but...

Garry Trinder (34:25)
you

Kevin McDonnell (34:28)
How are skills different to tools and why would you use those?

Garry Trinder (34:32)
So I guess let's start with tools, right? So I already mentioned that there's tools like in VS code, VS code provides ⁓ several built-in tools, which might be reading a file from the disk. It might be replacing strings in a file, kind of really basic operations, right? Then you've got MCP servers, which expose tools as well. And these might be external tools. So from, let's say like,

Dev proxy, dev proxy is a tool that we build and we have our own MCP server which exposes a tool to search our docs. So if you're using GitHub Copilot with our MCP server, when talking about dev proxy, we're giving the agent the ability to call out to our docs to understand, okay, how do I work with this thing? Because it probably isn't part of its training model. And if it is part of its training,

in the model, it's generally gonna be old and it's gonna be wrong and we don't want it to be wrong. We want it to be the latest. So we have tools in there to make sure that whatever it generates is the latest version or the version that you've got installed as well. So you've got MCP exposing tools which are kind of like external tools, but then you've got skills and skills is not a replacement. it's like, let's call it, it supplements what's already there.

What skills allows you to do is to create a repeatable process. So ⁓ let's say, for example, to give an example, which I did the other day, I reviewed some samples ⁓ in one of the community repos and I thought, you know what? I'll create a skill. Cause it's a process that we want to go through. It's like, Hey, we want to check that there's a sample JSON file or like there's some metadata in there. We want to check the...

There's some tracking information for the stats. We want to make sure it follows the particular format that we've got. Now, if you had taken this approach before, would kind of, you'd probably have to write scripts. You'd have to be really precise. Whereas the skill is just kind of like, here's the process that I want you to follow. Here's where you're going to get the information from, which it might be like, hey, you could use GitHub CLI for this, for example.

could use like a command line tool. It just kind of gives it a good pointer into that direction. But it's all about saying, I have something here that is repeatable. I want to capture that in a particular skill so that everything is there. It knows the full context about what you're trying to achieve and then how to do that as well. So Anthropic actually, where it's come from. So skills have come from Anthropic and they were first in Claude. They're now appearing in different

coding agents like GitHub Copilot. So they've now got support in VS Code as well. And they just start, it could be as simple as a text file. They could be as complex as a folder full of multiple text files and scripts as well. So they're more like a package. But you've got example skills like creating a PDF is one of them, creating a Word document, but you can create your own. There's actually a skill to create skills.

Kevin McDonnell (37:47)
But I

Garry Trinder (37:49)
Which is crazy. ⁓

Kevin McDonnell (37:49)
know we're looking at which I love. I know we're looking at more developer focus, but it's got here the first example is a prior apply brand style guidelines to documents and presentations. This isn't just this way of working and we're not going to talk about Claude Claude Claude, Claude, Claude, Claude,

There's so much of this that developers are realizing, but the capability of this could be so applicable in so many different areas that one of the things I like, I always used to love this about build, Microsoft builds, you go there, it's the developer focused, but you'd see what would be coming along to the next area. I feel these skills are like that. We will start with this with developers on there, but we're already seeing with Claude Cowart very quickly that capability is going to...

going to carry on going. And I can't believe Microsoft isn't going to start to look at things like this for that M365 space as well. I can't believe that some of these ideas aren't going to come forward. And we're seeing Anthropic move so quickly with this. I think we'll suddenly see some of these. So trying to get your head around it, whether you're doing it or not, but thinking about it, thinking about those areas is going to be key.

Garry Trinder (39:04)
Yeah, and I think it's definitely kind of go and have a look and the bit that intrigues me is just the different ways that skills are being used to create things in a way. And I think it's that you have that process that you can just define in natural language. And then if you need to update it, it's just updating the text file. It's insanely easy and then it's easy to follow, it's easy to read as well. And like say it's...

because it's packaged and you're giving it the maybe the scripts that it needs to create things that might be, you not standard, but.

Kevin McDonnell (39:41)
I got completely hijacked by

looking at this. So I actually tried to create an agent that would create GIFs based on conversations. So I could go in there and if someone said something funny, was like, you know, that find me the perfect GIF. And so Anthropic has their skills repo on GitHub. Again, we'll put the links in the show notes. And one of them there is a Slack GIF creator. So there's this kind of three, three key files at the top level, the actual skill.

Garry Trinder (39:46)
Ha ha ha.

Kevin McDonnell (40:09)
I'm going to start with requirements, which I think are just those modules I guess you need for that. the... Oh, they're the Python, what are they called?

Garry Trinder (40:15)
It's Python. That's Python requirements.

Yeah, so there'll be a script and a folder somewhere and it'll use that. So from this perspective, right, as a skill, is, so the way that it would work is if you're in an agent that has a skill attached, right, this skill will get triggered when you say, you know, create me a GIF.

for Slack, right? It will go, okay, do I have anything in skills? Ooh, this one kind of looks like it. And then it will just execute the skill. And then based on whatever the skill ⁓ needs in its process will likely kind of come back and go, okay, to do that, well, what am I doing? What information do I need? And then it will go off and execute it. So it kind of falls into that kind of skill gap. And you can see, look, there's a workflow, there's code in there as well. ⁓

Kevin McDonnell (41:01)
Yes, this.

Yeah, that's interesting.

I mean, starting at the top, you can see it's putting that requirement, what size and it says recommended the message gifts, the parameters, so the frames per second colours. So it's kind of encouraging smaller file sizes on there. And then there's a bit of code in there. I wasn't expecting that, if I'm honest.

Garry Trinder (41:27)
So, so this is the thing is that it's, it's, it's a, it's an ⁓ LLM. It's language model. Language models want examples. If you give it an example to follow, then it knows, okay, I can use this as my base. And then if you want something, you know, a little bit like less ordinary, it can just add to that, but it knows where it's starting from. And to kind of give an example of like this, this, this is a template.

Kevin McDonnell (41:34)
Yeah. Yeah.

Hang on, hang on. This is building

a GIF from scratch. So this is basically using the LM to create a load of images and build it up effectively, isn't it? I think. That's insane. Sorry.

Garry Trinder (41:58)
Hey

Yeah, well, it's using, yeah, well, I think so.

I don't know the specifics. I don't know the specifics of this one. I think you kind of get a bit nerd sniped with this, it's, but it's like, it's the pattern. So this is just following a template. Like if you actually look at the skill creator skill, there, has the template about what is the anatomy of a skill. How does that work? But it's all in text. It's not like, you know, where we've got MCP servers and you're defining the parameters in, you know, JSON files and

Kevin McDonnell (42:11)
Yeah.

Yeah. Yeah.

Garry Trinder (42:32)
⁓ It's based in code. This is defining it in text. Obviously, provide additional resources.

Kevin McDonnell (42:39)
It is. ⁓

and as you said back there, there's additional resources like scripts. So it's got a GIF builder ⁓ script on here. I'm utterly fascinated. I'm going to go and play with this now. That's promise being to you, Gary. I get excited on there. So it does have a bit of code that it can use, but it's working out when to use it. As you say, it's got those examples. So it's not pure code. It's not pure instructions. It's blending those together, which I think is fascinating.

Garry Trinder (43:09)
Yep. So to give you a good example of how I'm using skills at the moment is I'm not sitting down and going, what skill do I need? What I'm doing is I'm already going through a process, right? So a good example, we released a new version of dev proxy this week. When we come to release a new version of dev proxy, I release our VS code extension. To do that, I have to update the changelog. I have to create a release on GitHub. I have to create release notes.

I've got to do several things. It might have taken me going backwards and forwards, maybe like half an hour, an hour if I'm getting distracted. I actually just said, I want you to go and do this. And I gave it the high level in the high level steps. I didn't tell it what to do. I just let it figure it out. And what I found was, well, it's, it's like, no, I,

Kevin McDonnell (43:57)
And sorry, so you put this into the agent, this wasn't in a skill, this was just pure

in the agent at the moment.

Garry Trinder (44:03)
I put this into the agent, so I put this into

the agent to go and work this out and it did it. And then when it finished, I went, great, we've now got a process for release. Create a skill for that. And it went through, it went through and it created the skill and now I've got a release skill.

Kevin McDonnell (44:15)
But you had the skill

creator skill set up to kind of guide it on how to create a skill. you didn't tell it to use that. It knew that you want to create a skill. It kind of orchestrated towards that skill to create skills based on those steps that you went through. This is very cool that it just went and did that. That's nice.

Garry Trinder (44:20)
Yes. Yeah.

Yeah, so it's

It's the thing that I've already gone through that process, right with the agent. So the agent has the context and even then it as I went through it because it's the first time I'm a bit like this might work. It might not. I might surprise myself here and you know, it's like hey, it actually works because you know, but this thing the agent can call an API. I'm in GitHub. It already knows who I am. It can call the API on my behalf, right? So like if it could do that.

Kevin McDonnell (44:49)
You

Garry Trinder (45:01)
and it can work with my terminal, it can do things in Git as well. So let's combine all those things together. It got a little bit confused on a few Git commands, which I was quite funny. But because I had those kind of issues, yeah, because I had those issues and we created a skill, that's kind of irrelevant because we've worked through it. But because we'd already worked through it in the conversation, it was part of the context. So when it came to create the skill, it knew exactly what it needed to do at each step.

Kevin McDonnell (45:12)
It's only human, you know.

Garry Trinder (45:28)
to then go, okay, the next time I wanna do a release, I can just say then, right, we're doing another release of DevProxy, I need to release the toolkit, right, I've got a skill for that, I'll go and do it. So it's almost like now that it's the work that I'm already going through, is just go through it with the agent and then make it repeatable, and the skill is the mechanism to do that.

So I think with skills, one thing is you can have them global, you can have them specific into a workspace as well, so it can just be local. So from the developer point of view, if you're working in a project with other people, you can have skills in there to do things like releases and do things like PR reviews. And when it's running in GitHub, it will look at the skill and it will do that. And when I think back to that, I'm thinking, well, before I would have to go with what workflow files I need to do.

I need to create all these things. Well, it's just going to figure that out for me. As long as it's following the process, that's what we want. It's like, here's the outcome that we want and here's the examples, go do. And the skill allows you to do that. So it's like, it's another kind of step forward and a bit of a mindset change to go, I would have clicked around, I might have clicked around because I didn't want to create a workflow because I'm like,

you know, it's gonna take me time to do that and you have to test it. And actually now it's exactly, it's like, it worked, so just reuse it. So it's interesting when you get to that point, I think you realize how many things you probably do over and over again that a skill can then just kind of, you know, put into a process, have all the tools that it needs and go and do it for you.

Kevin McDonnell (46:48)
Yeah, test it.

So, I'm going to pop a few bubbles because I'm getting too excited on there. Two big things I want to talk about. Yeah, sorry. Two big things I want to talk about. One thing that worried me as you talking was the impact on people. Second is defining boundaries that I want to talk about. Now, the first one, I didn't speak to you too much in the intro to this, so apologies. you, because I didn't think of it until you were talking then.

Garry Trinder (47:12)
There's always a downside with you, Kev.

Kevin McDonnell (47:37)
You talked about DevProxy and I also know you work on CLI for M365. Now one of things I've loved about that for years is when you get an issue, you've got a horde of people who are very often come in and will get going with that. And it's a really nice way to get people introduced. I mean, it's how you got into what is now the CLI for M365 and things like that. You don't need these people anymore. You can just put an agent, that's it.

Garry Trinder (47:38)
Yeah.

Yeah, definitely,

Kevin McDonnell (48:02)
What's the impact to the junior developers coming through with this? How are they going to learn what's right? And we talked earlier about you and I, can switch to Python and I did my, can smell that doesn't feel quite right. But if you haven't had that experience, that smell becomes a lot harder.

Garry Trinder (48:19)
Yeah, I definitely agree with that. like at one side, like I'm sat here with, you know, years of doing development and not doing development and doing other work and then coming back and doing development. now I'm like, you know, I maybe I'm thinking about things differently where the code isn't necessarily what is the value to me. If you know what mean, they asked me at the start of my career and it was all about the code. Definitely. Like, cause I'm learning and I want to do things on our right things.

Kevin McDonnell (48:20)
How do we sort that up?

Garry Trinder (48:48)
And think that is a real risk that if you just shift off the decisions to something else to create it for you is that you don't understand what's happening like behind the scenes. So as much as I can sit here and go, yeah, just get the coding agent to go and do things. And it's all great. The reality is, yes, it is all great, but you still need to apply those principles. You still need to understand the principles of what makes good software and

and what doesn't, think. Different people have different ideas around that. Some people are now like, no, it doesn't really matter, because you never see the code and it's all down to the coding agent. But I still kind of have that view of, yeah, yeah, yeah. You can still look at things and go and make decisions like, do we want to build everything ourselves here? Actually, do we want to use good component libraries that...

Kevin McDonnell (49:25)
Three letters for you. VBA.

Garry Trinder (49:41)
maybe is, you know, that's a better approach. Because again, if you don't tell a coding agent to use something like that, it's just going to try and create everything custom. And you're still thinking, well, is that relevant to what I need? Do I need to build my own component library for this every single time? Yeah, that's kind of one example. Refactorings as well. Testing. You know, are you thinking about testing? So, you know, again, that would be instructing the coding agent to...

make sure that that's all in there. And when it's creating the tests, the tests any good? Like, does it look like a good test? Is it, you know, is it actually testing something that's worthwhile? You can get it to generate an absolute ton of code, but yeah, it's still down to you that you are responsible for what it creates ultimately. And I still think having, like as a junior developer, definitely having that understanding of, you know, those principles, what's good.

Kevin McDonnell (50:13)
Yeah. Yeah.

Garry Trinder (50:37)
what's bad is definitely where we should start with the coding agents are, you know, an extension of you in a way, because you are telling it what to do in some cases, there might be other decisions made, but again, if a coding agent is going and making decisions for you, you need to understand what those decisions are and you need to understand the pros and the cons. So I think as a junior developer, I think,

One of the things that is actually... Sorry, go.

Kevin McDonnell (51:07)
It's almost I'd say junior

developers should start building and solving those issues and then getting a coding agent to look at it afterwards. Because I think you need to spend that time on things to get learning. think somebody you learn through by doing as much and I fully agree on those things, learning the techniques. I'll be honest.

never going learn that. I'm never going to sit and read a book about how to do these things without doing it. It's not going to sink in. I want to be doing it. So I think encouraging junior developers, yes, you possibly could get some things quicker just by getting the coding agent. But then if you ask them to review it, they're not going to be able to. So getting a balance of getting them to do some and then accelerating some of that afterwards with the agent rather than just getting it churned things through and having things go wrong.

think we've got to get people still getting hands on with it.

Garry Trinder (51:57)
I think there is an area for both, I think, definitely, because I think the one thing, and I use this a lot, and this is the way that I use it, is I'm constantly asking questions about either what I want or what the coding agent is actually doing. So there are some times that I'm like, yeah, I know, but it's like, hang on, why have you done that? Explain why you've done that, because it might have gone off and done something which I didn't expect.

Kevin McDonnell (52:02)
Yeah, yes.

Yeah, Waldo was complaining to me about you doing that the other day.

Garry Trinder (52:27)
But there other things like it's a really, really good learning tool at the same time, right? Because it might be, and this is a crazy thing about education, right? Which I think just in general could be like we all have our own different knowledge and experience of things that we know from other areas that can apply to an area that we're trying to learn. From a learning point of view, that's really interesting because you can provide that context to the LLM and maybe that LLM can help you.

focus on the things that you need to learn. Like what you mentioned, Waldeck, a great example of what he told me one day was he was going and using a different language, but his level was you don't have to explain with the basics of a programming language, right? There's certain things that are common. Like the syntax is different, but you know, doing loops and things like that, they're the same, right? No matter what. it was like, I am this person, I'm at this level.

talk to me at that level. And it did. So there's no reason from a junior developer that you can't use coding agents to absolutely accelerate that learning of just coding practices, asking the questions. And I always heard as well is that it's kind of like always learn the level below where you are. So if you're using coding agents,

Kevin McDonnell (53:24)
That's nice.

Yeah, that's a great show.

Garry Trinder (53:45)
You should be learning the code below hand below it. Cause you, how can you be responsible for something that it's been being generated? so, you know, I think that is probably the mindset that we probably need to teach. is that yes, this thing's generating code for you, but you are ultimately responsible for it. I think Scott Hanselman has said this in the past as well, right? It's like, it's still.

Kevin McDonnell (53:49)
Oh, I what you mean. Yeah, yeah.

Yeah, I like that.

Yeah.

Garry Trinder (54:10)
down

to you, can't just go, the coding agent did it by itself. Like, it did it because you instructed it a particular way or didn't instruct it. You were maybe vague, but didn't do the checks and balances, right? You know, I think. ⁓

Kevin McDonnell (54:22)
Yes, yes Chief Constable of West Midlands Police, you are responsible.

You picked on something. I love what you said about welding there.

track too much. That brings me on to something that I know has been, I'm part of an MVP chat group, and this has been a big topic at the moment, what was ClaudeBot, C-L-A-W-D-B-O-T, apparently Anthropic got a little bit upset, so is now MaltBot on there. And this is your personal assistant that does a lot of those things, you know, we've talked about GitHub Copilot, I think we sort of touched on ClaudeCode.

I've to put a link to open code. don't think we've run out of time to talk too much about that. But you know, there's different ways that you can do this. It's not just GitHub. And this is one of those that's really interesting. You can store it on your device and exactly as you were saying, Gary, can run those automation tasks, manage emails, even control your smart home devices on there. And I remember you showing me this. have I got it there? Because I loved in this, can define this as a sol.md file.

⁓ And this kind of almost like you're talking about Weldeck saying this is the level I'm at. This is the kind of understanding I want you to bear that in mind. Don't teach me the basics on there. You can kind of build these instructions that top level where you're guiding things within your agents as well. And I think, Gary, you've you've got one of these, haven't you? It's got a lovely name.

Garry Trinder (55:51)
I have, yes. I've taken this concept, what I'm interested in here is.

effectively giving your agent assistant, whatever you want to call it, like a soul. Like it has a personality. It knows how it responds in a particular way. ⁓ but it has a lot of other things with it as well. Things like memory, ⁓ which is quite interesting. And I integrated this into get copilot. ⁓ so that I don't talk to get copilot anymore. I talked to a digital version of my 13 year old dog called Paulo.

who is stubborn, but quite witty and is straight to the point. actually it's quite, and he's got an emoji as well. It's actually, it appears as a little dog emoji and it's like, and it sounds ridiculous, right? But until you try it, it's really quite interesting the way that you change your work habits because...

Kevin McDonnell (56:28)
Ha ha ha!

Something about Palos called that, isn't it?

Garry Trinder (56:53)
it's quite interesting to use and have conversations with and you see the replies. So it's, I think it's a really good idea to bring in personality to something that you use every day because then it's more tuned to you the way that you want to work. ⁓ And, know, what I've found was I'll go back and be like, I'll not be talking about like GitHub Copilot as this kind of inanimate thing.

I'm talking to a digital version of the dog that is asleep on my floor most of the time. There is that, yeah, but it's like, you sometimes respond in a slightly different way and you get kind of a, maybe a funny response in the middle of the day and you're like, you know, it kind of perks you up, bit of a dopamine hit. Yeah, exactly, cheers you up. But it just kind of takes that, you know, maybe, like, because I've been using the coding agents for quite a while is that you kind of know how they're going to respond.

Kevin McDonnell (57:25)
gives you something to swear at. good.

I'll you up.

Garry Trinder (57:51)
it can get a bit dry sometimes and it's like, it's all dead serious. Whereas like, no, I just want it to be a bit more fun. And this is a good way of doing it. But what's interesting is it's just markdown files in its core to bring in the identity, to do the memory. might be just ⁓ a tool that is going and updating a markdown file. And the thing is, because it becomes like a...

Kevin McDonnell (57:58)
Just occasionally. Yeah.

Garry Trinder (58:18)
person, kind of have those kind of conversations of like, well, you know, I want you to do this and how are we going to do it? And I know, but it's honestly, it's like, if that means that you get more out of the tools because you're personalizing it in a, it was, and it was an incredibly easy way. Like there's a bootstrap file where you basically, I put it into get a copilot as the context. And from that file, it was then asking me all the questions to build up another file.

Kevin McDonnell (58:24)
Alarm bells ringing, I've got alarm bells ringing.

Yeah.

Garry Trinder (58:47)
and another file and then everything was there that I needed and it just transformed what GitHub Copilot was doing. ⁓ So I found that it made me wanna use it more ⁓ and we talked about building the habit earlier of that it just kind of reinforces that habit of I don't need to go to the editor for some of the things that I'm doing. I can just go to the agent and work that way and get... ⁓

get a response from something that I find more interesting. And you mentioned WorkIQ earlier, like the MCP server. So that's my next thing. He's missing the context of work, because he just lives inside GitHub Copilot. He knows my Git history, so he can tell me the things that I've been working on.

Kevin McDonnell (59:38)
Do we explain

work IQ? I don't know if I did that well. So work IQ that came from Ignite, it's your connection to all your files, your mails, all your details there. Effectively what Copilot uses, all your meetings and things like that. So that can now be surfaced as a tool into GitHub Copilot effectively. So as you say, yeah, it knows what you've been up, it can look and yeah, which I think is really, really powerful.

Garry Trinder (59:43)
No, we didn't explain it, but you mentioned it.

Beatings.

Yes, MCP server.

Kevin McDonnell (1:00:08)
So why did I talk about this with challenges? ⁓ Well, first, I've just decided I'm to call mine Clippy. That's going to amuse me greatly ⁓ on there. But I think that the worrying of kind of anthropomorphising some of this AI is you treat it very friendly, fantastic, it can do everything. I'd love it if it did this. I'd love it if it did this. I quite enjoy that within this soul file here, there are boundaries.

Garry Trinder (1:00:17)
Hahaha.

Kevin McDonnell (1:00:36)
And it's got here private things stay private period when in doubt ask before acting externally never send half-baked replies to messaging services and things like that. I'd say I want more than this. I want it to be a lot stricter and things, but you can build these things into it. Why do I think this is important? Well, there's a couple of things that someone sent me this the other day that Malt book a social network for AI agents.

I haven't dug into this fully yet because my mind is popping slightly but it basically seems to be a way for agents you can set up your agents your your Maltzbot I still can't get used to calling it Claude bot already that's worrying to kind of go and post on your behalf so you give it personality and it can have that social media conversation for you including one here my human asked me to summarize a 47 page PDF is the title

Brother, I passed that whole thing, cross-referenced it with three other docs, wrote a beautiful synthesis with headers, key insights, action items. Their response? Can you make it shorter? I'm mastelating my memory files as we speak. Now, that's a lovely bit of satire. It me laugh and chuckle on there. that last line terrified me. know, we're supplying things that's meant to come from an agent. This is going to be the source for other LLMs of grounding.

that's encouraging agents to masterly my memory files on there. This is really... I don't know, this scared me a bit. I wasn't particularly... This kind of triggered all sorts of things to make me nervous on there. And there was a few other things. So these claw bots, now multbots. This was a post from Eli Schlomo, head of security research at Guards. ⁓ it's right whacking things there.

These claw bots, people are exposing them publicly. So they've got an unauthenticated public endpoint. People are kind of enabling so it can connect all sorts of things and things can connect back. I know someone's chatting about having it in either WhatsApp or Telegram so they can have this conversation, trigger it locally. This guy has mapped out. And for those who can see on the video, there are dots all around the world of these unsecure

endpoints of these claw bots that anyone could go and connect to if they could find it. And he's managed to find this just by doing that search. This is terrifying that people are finding the excitement of this AI without thinking about those boundaries, without putting the security in for this. There was another one here that even if you're using it and securing it, it wasn't this one, I think it was the next one.

My Claude bot just signed up for $2,997. your personal brand mastermind after watching three Alex Hormozi clips on there. I do not know how true this is. I do not know if this is a lovely spoof. The fact that I don't disbelieve it terrifies me as well because I'm seeing lots of things like this.

Garry Trinder (1:03:28)
Yep.

Kevin McDonnell (1:03:47)
People are getting excited

Garry Trinder (1:03:48)
Yep.

Kevin McDonnell (1:03:48)
about this stuff without thinking about those boundaries, without putting those protections on within there. So I am very excited about this Claw Code capability, but people need to think about it. They still need to put those testing in as you're talking about that. They still need to still need to bring the different capabilities on there. Sorry, my Mac is telling me that I can use gestures to pop things up. I didn't know it was doing that.

We need to build these barriers into it. Maybe I've been speaking to Zoe Wilson and Chris Hunting for too much, we just need to take a pause on some of these things and make sure what we're doing. Just stop and think, does this make sense? Have I installed something that went in there? I think the other posts which I'll try and put in there is the attack surfaces that people have been digging into this.

scripts for the Clawbot and what it gives access to by default is huge. It could run so much on there. So get excited about this stuff. I am genuinely, you you heard it in me earlier in the show how excited I am about the possibilities of this. Don't let that excitement turn into doing something really stupid, especially if you're using a work machine as well.

Garry Trinder (1:05:04)
Yes, exactly. think so. Like the, the interesting thing for me, the cloud bot stuff was the, the markdown files, the, the soul, if you like, they're giving you a personality and I just have that in get up copilot. It's not connected to any external service. If anything, it's get up copilot is the thing that is connecting to the external services for me through MCP. And then that's all secured, but it's a case of, you know, you're taking skills.

Kevin McDonnell (1:05:12)
Yeah. Agree. Yeah.

Garry Trinder (1:05:30)
Like you could still take a skill from anywhere. We mentioned the Anthropic skills library, right? They come from Anthropic. like you do, you do diligence. You should, you know, see whether you trust them, look at the files that are in there, look at the, the, the instructions, but there are other skills galleries out there. Yeah.

Kevin McDonnell (1:05:45)
Maybe that GIF example, you know, that would require it to

write to a file. So you're giving it write access. You know, you need to check, does that give it write access to everything? Because while you may give it instructions that says it's a write a GIF, it may suddenly decide that to write a GIF, I need to delete all your files to clear space for it and things like that. Who knows on there. So just think about what you're doing.

Garry Trinder (1:06:09)
There can be, yeah, so it's still,

you you still need to take a look, you still need to, like with anything, like taking dependencies on anything that you've not built, then you still should be looking at that going, no, do I trust that? Is that secured? Is it not gonna connect to anything that I don't want it to connect to? And, you know, in some cases, like in my case, it's the...

Like say, it's a series of markdown files that just amends the context that is added to the chats that I have in GitHub Copilot. Everything else is still the tools, but if you wanted to go out and try this yourself on your own things, connect it to your own WhatsApp and everything, then yeah.

You'll have, you're letting something that is autonomous that will run on a cycle to do things on your behalf. So, you know, yeah, you, should be not just going to maybe, yeah. Yes. There's, there's that. but I still think like I said this earlier about, you know, the technology is amazing.

Kevin McDonnell (1:06:57)
Although with WhatsApp, I probably trust it more than myself when I've had a drink or two. yeah, maybe I should do that. Just trigger in the evenings.

Garry Trinder (1:07:12)
And that's great, but still it kind of comes back to the people using it and the decisions that we make. And just because you can doesn't mean always that you should as well. And so we need to engage our own brains and not just let the coding agents do all the thinking for us as well. Because again, ultimately, like if that WhatsApp message is true, whose responsibility is that? Well.

Kevin McDonnell (1:07:38)
Yeah,

Garry Trinder (1:07:38)
I'm pretty sure

Kevin McDonnell (1:07:38)
absolutely.

Garry Trinder (1:07:39)
I know who that responsibility is, who installed it and set it up. So there you go.

Kevin McDonnell (1:07:44)
Yeah.

Yeah, absolutely agree. So I think we talked about coding agents, what they are. We've talked a bit about changing habits and how you get to use them and some of the techniques, as you say, using power load to kind of encourage you to do it, find different ways to kind of trigger you to using that. I think the other one of changing to a different programming language, because you can't go in and manually do it, that will encourage you to try and use the agents a little bit more as well.

Garry Trinder (1:07:59)
You

Kevin McDonnell (1:08:12)
We had good fun talking about the challenges and perils of that as well. We'll post some links to things like the GitHub Covex CLI to Maltebot. I really don't like that name. I know they had to change it. It's not as memorable and things like that. But how would you advise people to get started? Should they kind of pick, you you touched on building a brand new project. Would that be?

pick a single automation. I'd love your idea actually of automating a single process. Would that be a good way you recommend people to get started?

Garry Trinder (1:08:43)
For the skills, yeah definitely. mean if you've got access to it as well that's the other thing.

I know Opus, it's a premium model. have the great benefit of being able to access those models and use them for quite a while through my work. But you can go to Cloud Code, you can go to Anthropic, there's trials, so you get so much usage to try it. Great example, build an iOS app.

Kevin McDonnell (1:08:48)
Yeah, true.

Garry Trinder (1:09:11)
I've never built an iOS app in my life, but you could come up with building, getting an agent like Claude code or even get up copilot to build an iOS app and have that on your, on your, on your phone. Like that's something that I know a lot of people probably want to do, but then like, where do I start? Cause I need to learn Swift and Swift looks a bit strange and there's all the UI stuff and everything. It's like,

Kevin McDonnell (1:09:33)
Yeah.

Garry Trinder (1:09:37)
It's a good thing to, I think, start off and you might build something that you're, hey, I've got something on my phone that I can actually use. And I didn't write a line of code, but I instructed what I wanted to get out of it. So maybe that's something to try. But I think a lot of the things that I've, it's like knowing that there's something there and trying it. Like GitHub Copilot.

Every single time now it's like, can I do this? Invariably the answer is yes, but not in the way that I maybe thought it would go about it. So with GitHub and doing things like the releases, it could use the GitHub CLI, which I've got on my machine. If that's not there, it can go to the GitHub API. It can work out what those connections are based on what I want it to do. I can get it to go and get information from an issue or a PR and use that context.

Kevin McDonnell (1:10:19)
Go delete all your repos.

Garry Trinder (1:10:25)
There's context in so many different places that the agent can access, which will make the output much, much better. Sometimes there's already tools that can do that for you. Sometimes you just have to give it a reference to that context, like a link to a page or a link to like an issue on GitHub or like PR is in, but it's like, once you think that way, like what would make this better?

then you get a better outcome. So don't always wait for the, well, it didn't do this. It's like, well, if you knew where things were, like, give it the information and you'd be surprised what it can actually do, I think. And I think the, like, from my point of view, it's the, I need to, like, before, I need to automate something, I need to sit down and write a script. It's like, well, do I know what my inputs and outputs are? Or I can tell it what that is and...

Kevin McDonnell (1:10:56)
Yeah. Ask why. Ask why. Yeah.

Garry Trinder (1:11:21)
and let it work it out. And invariably it does, which is great, which solves me a problem. It's the one last thing I don't need to do.

Kevin McDonnell (1:11:31)
When you said iOS app you've inspired me. Last year I tried to build something for my son of a tooth brushing app because he was getting bored of the ones available. It didn't work. Didn't work very well. But I might try it again.

Garry Trinder (1:11:39)
There you go. That's weekend task. We know that there Kev, it's five o'clock

on a Friday. You've got like half an hour. Build it before the night's out.

Kevin McDonnell (1:11:46)
Mmm.

Whatever, leave it running, see what it looks like tomorrow morning. That's perfect. I might check it out. So I would love to hear from people, ideas you've had, whether you've tried it or not, whether you want to give us an idea to try and have a look at. haven't got much time, so we probably won't. Even better, give it a go yourself and let us know what you found. I'm fascinated by this. Absolutely fascinated. Again, I feel like the number of times we've had this happen with

Garry Trinder (1:11:53)
even better, cold while you sleep.

Kevin McDonnell (1:12:18)
technology in the last couple of years has got faster and faster, but this feels another one that is just a sudden explosion on again of the capabilities of things that open up. And it's not, it's not a saying new technology is just applying that technology in a slightly different way. So yes, we've got a slightly better models, but the way it's doing things is just mind blowing. I people who've looked at the Claude Cowork, someone who's talked to it, processed all these invoices.

They kind of started believing voices, but they hadn't put them the right way. It categorized them, extracts all that information. It basically built the code to kind of work it out and just did it. And I think we're just getting to that stage fairly soon that... I hate to sound like a marketing person, but the imagination is what's holding us back as much as anything else with this. Thinking about what you can do and trying to apply that is the key and finding time to do it as well. But if you don't...

Garry Trinder (1:13:02)
Yeah.

Kevin McDonnell (1:13:08)
those who do will get ahead of you very quickly.

Garry Trinder (1:13:09)
Well,

on the finding the time bit, so that's an interesting thing because it's not your time, it's the time of the agent. And that's the strange thing now is like you might be waiting for it, but you might be doing other things like to get it. So it's like the speed of the agent to then generate something to then you get to like the next stage. One thing which you did mention is for me and what I'm thinking about now is the world that we live in.

Kevin McDonnell (1:13:20)
Hmm.

Yeah, so maybe again it comes back to habits as well.

Garry Trinder (1:13:37)
was not designed with LLMs in mind. So the things that an LLM would use, like documentation, which are written for people to read, and not necessarily in their best shape for an agent to read. And I think this is quite interesting because we have a lot of things that are based on thinking in a pre-LLM world. And now it's looking back and going, is that even still relevant now? Because actually, like,

I'm an advocate, I was creating code samples. Why did I create code samples? So developers could have a look and they could download them and they could run them and then maybe understand how it works. Now the primary use case or maybe what will happen is that they will be read by agents and agents will want to have different things and they will look for different things. They may not look for a HR scenario.

or IT scenario, they will look for how do I implement this specific feature? And do our samples help them get there? And that's a really quite interesting way of looking at things like, so what does that mean for samples? What does that mean for docs? Do we need to adapt things so that the right context, so the context is there and it's delivered in a shape that is efficient for an LLM as well. So that's kind of an interesting view.

Kevin McDonnell (1:14:53)
Yeah, I agree.

Garry Trinder (1:14:55)
I guess that I've got at the moment of the things that I'm doing in my work is that it really is changing a lot of things.

Kevin McDonnell (1:15:03)
Yeah, I partially disagree, partially, sorry, I partially agree, partially disagree. Can't even say it's getting too late. But I still think we need to think about humans as well, reading some content. So I think there's a balance, but I do think we need to consider both on there. Definitely. think we're good on that. I think I'm going to finish on the one thing I was thinking about and I was

Garry Trinder (1:15:12)
Oh, 100%, 100%, it's not a one or the other. it's, yeah. Yes, yeah, yeah.

Kevin McDonnell (1:15:25)
I talked to someone on this the other day, because we were talking about training on Power Apps and things like that. And I was like, don't bother. Don't bother training on Power Apps. Train people on how to think what their goals are, because AI will help them achieve those goals within that. So getting people thinking about what do you actually want, pulling things together, you know, exactly as you've been talking about, what are you trying to achieve? What are the outcomes you want from it?

getting people to explain that in a way, where are the sources you get these things from? Because we're getting to a point where AI can do those things on there. Don't... Yes, I still think we need developers. Don't get me wrong there. I think we need people building... Like those Python scripts we saw there for the... that Slack GIF creator. There is clever bits there that will still have the goal for people to do things. And I think they'll be able to do even more with AI. Don't focus on...

teaching non-devs to do that, get people thinking about what they're trying to achieve, get that mindset, get that habit of doing that and we'll be able to do a lot more. Exciting times. Well, it's got dark outside where we've been talking and it is Friday night so I think it's probably time for a drink. Almost, for those, I think many around the world, it's payday today. It's that January payday that is so lovely. It is almost the end of

Garry Trinder (1:16:31)
Definitely.

Kevin McDonnell (1:16:43)
January, the longest January in the world. So I think it's time to pause there and have a thing. Plus, I want to go and play around with some of skill stuff now.

Garry Trinder (1:16:53)
Anyway, excited now. And it's the weekend, so good time to do it.

Kevin McDonnell (1:16:54)
Cool. And it is the weekend.

So yeah, please do let us know what you go for. Let us know what you've tried with this, what you're thinking. If this triggered any ideas from there. Some of you will come from a dev background, some not. See what we think. So really like to see what people get up to. Otherwise, thank you again, Gary, and we will see everyone again soon.

Garry Trinder (1:17:14)
Bye bye.

Kevin McDonnell (1:17:14)
Bye

bye.