About this talk
This talk features Simon discussing the effective utilization of coding agents, particularly focusing on Claude. He delves into several key features of this AI tool, such as running bash commands, customizing commands, and managing permissions. Simon highlights the significance of context and planning in code development, emphasizing that agents like Claude can assist in structuring projects and maintaining context without overwhelming the user. He also introduces Tessle, a package manager designed for skills within coding environments, which allows users to evaluate, version, and utilize skills effectively. Finally, Simon discusses the importance of managing context efficiently and the potential of using sub-agents for better organization in coding tasks.
Full transcript
I want to present our first speaker today. Uh it's Simon. I know Simon since maybe 201 I don't know 13 or 12. Uh when he was the leader of the virtual and creator of the virtual Java user group. It was back in the days when everybody met like this and there were no online conferences. Uh and it was the first uh basically the first organization that organized
online events uh throughout the year. Uh and yeah, I also joined that and we had a lot of fun with with the guys. >> Yeah, it was it is the biggest Java user group by the way. >> Yeah, it has no >> but now he >> he's going to speak about another thing. Uh he joined a couple of years ago a startup called not Tesla. It's not
Tesla, it's Tesla. But the but but the AI at DevOps uh used to transliterate it to Tesla. Every >> Tesla there I said Tesla >> and if you ever type Tesla whatever you use will auto correct to Tesla. So we know when we get to a certain stage in size when we've made it it will stop autocorrecting. That's that's our goal. >> Yeah. So Simon the stage
is yours. Thank you. >> Thank you. I appreciate it. Thank you very much. Thank you. I don't Well, actually, first of all, did everyone understand everything that was just said? I can repeat anything you'd like. >> You'd like me to repeat? Okay. Typescript, JavaScript, AI, uh, uh, TypeScript. No, uh, Quarkus versus Spring. And then someone brought a gorilla out. I don't know what was happening there. Um,
but not important. Not important. It happens every time. I'm I've come to I've come to the wonderful Sophia on the weekend and she won't believe me that I'm actually working. But this is this isn't work. This is good fun. Um >> it's Yeah, she'll tell me it's generated. Yeah, for sure. Um awesome. So, uh a little bit about No, let's just jump in. You don't need to
know about me. Um I've actually been to Bulgaria a couple of times. uh actually wants to speak at J Prime and and another one for a for a little meetup. Um I really enjoyed my time at J Prime. I'd love to come back. So So hopefully hopefully I'll I'll I'll if if everyone you know uses Tesla then I'm sure I'll come back and my company will say,
"Oh yeah, you can go." But there we go. Um so I work at Tesla. We'll talk a little bit about Tessle very briefly in in a bit. But today I'm going to be talking about how you can use the most out of your coding agents. Um I'm actually going to focus I saw the second talk is going to be around orchestrating with Claude. I'm gonna also focus
with Claude. Um, but I'll every now and then I'll mention others like like cursor and things like that where where we have similar uh similar features. But I feel claud has the many has many many features that we can really make most use of to be more productive. Uh, who's using an agent today for coding or or anything like that? Cool. An awesome number. Who's using claude?
Okay. The vast majority I think others cursor I I suspect is okay. Um, Codeex, uh, Gemini, a fair number. What have I missed? Windsurf and Windsurf. Anything else? Say again. >> Oh, Bob. IBM's son. My wife works at IBM. So, yeah, I should say Bob. Um, she's not allowed to use many other things, so she loves Bob. Um, okay. So, we're going to This is what we're
going to cover today. I'm going to I I was originally going to do all live coding and then I thought I was writing down everything that I wanted to cover and I thought there's no way I'm going to remember all of this. So I've created some slides and I'll do some demos with the slides and then I'll share the slides so you can have everything as as
reference as well. But we're going to cover some basic usage tips uh go into a little bit about context and memories how you can make customizations uh within claude code itself and then how you can use it for autonomy. I was going to talk a little bit about as uh like being able to use claude in an asynchronous way parallelizing it. I saw the second talk is
also very much uh focused on that. So I won't talk about that too much but I'll I'll briefly mention it. Okay. So some general tips first of all um I thought these kind of like didn't fit during the presentation but I thought I'll probably use them as I go. Um but here are some you know fancy tips that is just like just useful if you're just if
you're just playing around with it. So using bang to run a bash command. You don't need to go to a terminal. You just hit bang and then anything you type will automatically be rooted to the terminal. You don't actually Claude won't have anything to do with it. It will just go straight to the terminal. If I was just to type ls at the ter in Claude, Claude
will know what I want to do and it will it will actually run bash under the covers. Run ls and then format it and it's it's slow and not very nice. So bang ls will and any any other command will do that. Um couple of other things changing the theme. Uh you can go light mode, dark mode, whatever you fancy. You can fork your conversation. So you
can have if you think, oh, I've got the context, and I'll talk about context and all these terms in a bit later. But if you think you've got your conversation to a good point and you want to take it in two different ways, you can fork your conversation and then potentially say, well, let me do this over here, this over here, and see how they each see
how they each work from that same context starting point. Um, other things like permissions you can change and and also copy. There's a whole ton of stuff that we can do. Uh, I'm going to run Claude in this directory. Um and and actually just running just hitting uh uh command um question mark will give you a few example commands as well. Hitting slash there is a ton
of different commands that you can run from here. I've just picked a few out. Um but I'll I'll I'll do a couple. So yeah, if I was to do, you know, bang ls, that just runs any bash command. So in this case, ls at the command line. If I was going to run theme, I can choose dark mode, light mode. I don't know why I I'm not
crazy enough to run light mode, but uh you can run dark mode or or colorblind friendly ants and see colors. You can do like, you know, nice things. You can probably actually build your own themes as well. I haven't looked into that. Um permissions is a very interesting one. Um permissions provides you, you know, Claude will ask you, by the way, I speak very fast. I'm sorry.
If I need to slow down, put your hand up, throw something at me, tell me to shut up. I will not be offended. Um permissions. Claude will very often ask permission to do certain things. Certain things it is allowed to do. Certain things it cannot do without asking for permission. Certain things even if it asks for permission it just wouldn't be able to do. So we have
a deny. We have an allow. We have the ask. So anything here it will always ask me can I do this? Can I do this thing? And you have workspace. Now workspace is the set of files it should have access to. If I want to add additional files at this point, I can kind of add whatever directory I wish and it can use this as files that
it will it will go ahead and read. So, there's a ton of of different commands. Um, yeah, have a have a play with some of those. When we first got LLMs and agents as well, whenever we asked the agent to do something, it would just go ahead and bang, it will try and it will try and provide me with an answer as quick as it can that
will satisfy what I'm asking for. But when we build and write code, that's not what we do. We will stand at a whiteboard for a while thinking about how to design something. We will talk to people and build a plan or a thought in our mind. Claude can do this, but it doesn't always do this. So don't assume it will always create a plan if if you
don't ask it. So what we want to do is think about think think about it not just ourselves but discuss with Claude get Claude to ask you some questions about how what you are trying to implement. And this can be done in two ways. You can either use the command slashplan or you can use shift tab uh to to enter enter plan mode. Uh let's actually demo
that right now. So you can see at the bottom here it says question mark for shortcuts. Okay. If I was to press shift tab, I get accept edits on. Accept edits on means uh any Claude can just start updating files without needing to do anything without needing my confirmation or asking me. it will go ahead and edit files. This is for more of a rapid application development.
If you're doing something prototyping, I don't want it to ask every single time if it can do this, update this, write this. It just goes ahead and does it. If I hit shift tab again, now you can see plan mode on. Is is the font big enough at the back. We're good. Yeah. Um, this is plan mode. If I was to ask Claude something now, like if
I was to say, I want I want to build a CLI uh game. If I asked something now, perhaps if I didn't have plan, it would go ahead and go, okay, let me build, let me do this in Typescript and build this out or whatever else. What it's now going to do is it's okay, it tries to understand my my vision for a CLI game. It looks
at my project and it kind of says, okay, let's try and understand what we're what we're doing. It's going to ask me about the game type, the tech stack, the location, and so forth. And it asks me a ton of questions. The planning is a really cool way because it'll take all of this and it'll actually start adding it into into its project files so we can
reference this later as well. This is a really good way of putting our architecture, our thoughts into context. Okay, let's uh let's skip that. Now, once we've planned, we could use YOLO mode. Who's heard of yellow mode? It's called YOLO mode, but that's not kind of like what it does. Y All right. YOLO mode is Let's go into The good is Claude is kind of like how
you want your kids to behave. I have a 9-year-old and I have a I have a 14year-old, 10-year-old almost, and a 14-year-old. My My 14-year-old's very very responsible. He's he's very sensible. He will come up and ask for things and and and if he thinks something's a little bit bad, he'll go, "Oh, should I do this? Dad, can I do this? Can I do He asks for
things. He asks permission. Quite responsible." My my 10-year-old was very much like me as a child. Um he never asks for things. He just does bad. He makes bad decisions. Um so the good news is Claude is kind of like that responsible kid, right? It will do things if I allow it to do things. The bad thing is kids ask a [ __ ] ton of questions. Can I
do this, daddy? Can I do that? Daddy, daddy, why? Why? Why? Enough. Just sometimes you just want, you know, I I do it and I'll suffer the qu consequences. In Claude, if you put dash dangerously skip permissions, that's yolo mode. Okay, you have to say yes, I agree. I am dangerously skipping permissions. This means whatever the [ __ ] it wants to do, it will do. What? Now, the
ugly, we've done the good and the bad. The ugly is Claude can do whatever it wants. I would never do dangerously skip permissions for my 9y year for my 10-year-old. Now claw can do whatever it wants. Make sure you use version control, right? You need to undo what it what it's doing. Make sure you're running a container or a sandbox because you've got to trust what it's
doing and would you trust that on your laptop? And also make sure you scope tasks carefully cuz you want if you're if you're letting it go yolo mode, you want it to be able you want to be able to precisely say what you want it to do. The plan is really good for this because you structure something and then allow it to go ahead and and and
build that. We'll talk about uh Ralph Wigum a little bit later. And if you don't know what I'm talking about, that probably sounded very weird. Um okay. Uh we'll jump into context. Uh who's heard of context? I'm sure pretty much everyone in the room's heard of context. Yeah. Yeah. You don't need to put your hands up. Okay. So, context and context windows. The context window is the
space that contains the knowledge which an agent can use to better um to better uh produce a response or an outcome that is most valid for the user. Context and prompt and everything else can kind of like it all kind of like sits in as one massive piece of data that the LLM will use. But typically context is not something you constantly need to provide the the
agent or the LLM like a prompt. My prompt is something that I ask. It's a task I give the agent or LLM. My context is something that exists and the agent can read it. It can pull things in and out of context to to do a better job of that task. And it can be a number of things. It could be skills and memory files or project
files and other things. Now there's this thing which I call a Goldilock what I call the Goldilock zone of useful content. People have probably heard of Goldilock zone in in like astrology no astronomy uh where the they say the earth is within the Goldilock zone uh in terms of the distance away from the sun. The Goldilock zone is the is the is the distance from the sun
with which life could occur. If it was further out it's too cold. Uh nothing will grow. If it's too close No, sorry. It's too close. Yeah, too close it will be too hot. Bacteria, etc. won't be able to grow and evolve and and and and flourish. If it's too far away, too cold. The Goldilock zone is that space where planets like Earth can could could happen with
life. Now, context is exactly the same. Too little context, it will do something. It will produce something, but it it most likely won't produce it in the way in which you want it. Whether that's styling, whether that's uh you know specific example of the task that you wanted. if it's too much context. Um, studies have shown that the more context you add, the the the perform not
the performance, but the the effectiveness of the LLM decreases because the specific areas of context that it should get are just it's it's a it's in a sea of context that it can't pick it out. So when you get your context just right and it understands how it should do something the parameters with which it should work in your project that's when you start thinking oh wow
this agent is really good and it's it's doing exact it's yoloing my request on my on my command and it's very often because you're providing the right context and the right amount of context. Um you can see your current context. This is clawed code specifically. I don't think there's many other um there's many other uh agents that do this, but SL context is really useful within your
agent. I'll show you a demo of that in just a sec. Um but I'll talk about compaction first. So the more the longer we go on and talk about agents, the greater or talking with agents, the greater our context window grows. And it gets to the stage where we need to start removing things from context in order for us not to overwhelm with huge amounts of context.
So we need to do something called compaction. And this is essentially freeing up many of the tokens within our context window that we just no longer need. Now compaction can happen automatically when when you when your context window fills up all of a sudden. Typically when you're very very busy or when you're very low on time, you'll get compacting and you wait there for a minute while
it it eliminates the context window. Um it can also happen manually. Um, and there are a few commands that you can use. Clear will entirely remove all context from the context space. That's good if you want an empty context or want to start again, that kind of thing. It's not good if you want to continue working in the same project, continuing to build. Because what compaction does
is it it when you when you do a /compact uh or it automatic manually or it automatically compacts it it takes everything out of the context window and it replaces it with a summary of what was in the context window. So, so um when you say I want you to do these five things and it does a compaction sometimes you have to go oh don't you remember
that thing I asked you to do it's lost from the context there will be times when you have to continually repeat and it gets very very frustrating uh a really smart way of doing this is /compact instructions so you type /compact and the instructions is a description of the is is a description of the summary you want left so you might say I want to do these
five things next. And when it compacts, it'll provide a summary of the information that you want left in your uh in your context window that will allow it to do those things really well. So, if you're doing manual compaction, passing instructions after a slash compact is very, very important. Um, okay, let me show you what actually I'm not sure how much there will be in here, but
let me show you /context. Okay, slashcontext. This is my this is my context window. Um you can see things like my my model and stuff like that but you can also see uh what exists in this in this uh in this context. So this is all my system prompt my system tools. Tools are essentially built in to the agent whereby if I want to do a certain
thing like if I want to there's a there's a a read and a and a write tool there's a bash tool uh those types of things. If I want to do something like, hey, let me, you know, can you uh uh I want to I want to be able to do, you know, run ls maybe or something like that, but I'm not doing it at the terminal.
I'm just saying, can you run ls for me in five different directories, it will run the bash tool to to do that, get the output back, and then present that to the user. Uh we also have MCP tools, which we'll talk about. Um skills is a is an important one. Uh messages is my back and forth uh with the with the with the agent. So this kind
of like shows me what is taking up all my all my context. Um code as context. So now when we are um when we're building when we're writing code and we're using our an open source library or something like that um maybe we're using a very specific library. Um what we essentially want to do is make sure that the agent knows about that specific library that we're
using because if we was to you know hire a new person we would tell them about everything that we're doing. We'll tell them about our stack. We'll tell them about the the the libraries that we're using etc. We want to on board an agent in exactly the same way. So what our studies have shown by passing in context about every single one of your or let's just
take one library by passing in context about a library which includes information about your API about best usage practices when to run certain things when not to run certain things you tend to get a 35% uh improvement not just in it using the right APIs but using them properly. Um, very often people mistake a hallucination uh for actually just an API version mismatch. So if I was
to say I want to use this library over here and it's trying to hit uh a method that doesn't exist. Actually maybe it does exist but it exists in a completely different version. This is you know LLMs don't work in the way whereby they think oh this is the this is the library I want at this version. Let me try and let me try and hit that.
It's it's statistical outputs right? So it if it thinks, oh, I want to use this, it uses it because there's a ton of examples for proprietary code as well, there are obviously things in the training data for of an agent or an LLM rather for open- source libraries, but your proprietary data, your proprietary libraries, there is no training data because they're proprietary. It's closed source. Um, so
how do you get an LLM or an agent to to use though your own libraries, your proprietary code? Um, context is a great way being able to turn your code into context um will allow the LLM or the the agent to know these things exist and know when to use them. We have this uh within Tesla we have this thing that we call abstraction adherence. Yeah, abstraction
adherence. LLMs like doing everything by themselves. Very often they will be encouraged to use libraries APIs. This is the abstraction and abstraction adherence is about how many times they actually do correctly go to a third party library versus trying to build it all itself. And uh we run a whole bunch of tests using context and without using context. And when we have context to say these are
the libraries the abstraction adherence is far higher in terms of using the right libraries for the right things. So context around code is is very very important. And the final thing, we'll get into this in a little bit, but how you actually validate your context cuz you know it's important that we reduce our context to the minimal that we can, but how do we know we're not
producing bad context or context that the LLM actually doesn't need? Um tests and evaluations are are really key Um, okay. As the great Liam Niss said, um, who who's heard of skills within agents? Few people. Okay. So, so skills are, um, fairly well, they're not that new, but pe people like cursor, I think, maybe first came out with it with something called cursor rules. Um, many others
have kind of like built similar things. Claude has Claude skills. Um they're essentially uh they're I don't trying trying not to say rules or skills here. They're essentially uh guidance to the agent to be able to perform uh tasks a certain way. So if I have a particular preference, let's say I love TDD. If I love TDD, do I say in every prompt or make sure every
piece of context has the fact that I want to do something in TDD? I could do the actual better way to do this is to have a skill and that skill says when you are trying to do a certain thing try to do it in this way try you know use this behavior. So I might have a TDD skill that explains how I want TDD to be
done what my project structure should look like what happens under certain conditions and the agent will load that skill when it feels and use that skill when it feels it needs to. So if there is a task to create code, it might say let me write some tests first. >> Question or rules, unless they >> You more check your rules first. >> Yeah. Yeah. Just like just
like people, right? Yeah. Yeah. >> Yes. Sure. You don't copy paste a lot of rules, but you >> so so so this is called activation. So activation is essentially if I ask task and there is a way of doing it and I need a rule to be activated or context to be activated will it actually activate will it use that sometimes it will do it out the
box when you just say I want to build this and it just does it sometimes I have to say can you use this skill sometimes you use a command so with claude for example there's a slash command for a skill and I will slash skill skill name build this one so I might say slash tdd build this but the problem is what if I want to run
15 skills or you know, it gets a little bit harder. So, sometimes you have to encourage it. Sometimes I have skills that tell me how to write skills. to use skills. And it it's like it gets a little bit complicated. But this is where almost like context engineering is is is really building in. Now, one thing I will say is LLMs LLM almost sometimes need to need
to keep up a little bit with agents in the sense, you know, skills are fairly new. Do how well do the LLMs know that they should use skills? Well, it kind of like needs to be baked into the agent that uses the LLM to decide that. But there there is an amount that needs to be done on activation. And I think there is work here on both
the agent side and the LLM side for that. But yeah, >> have you as also not remember how many skills you have, you encourage the agent? Yeah, the question was if you have too many skills, it it essentially gets confusing because you know you as a human forget but also what it does is it actually confuses the LLM as well because the LLM has then if if
the LM has 30 skills which ones should it use over which and actually do you get contradictions in the descriptions like oh I need to do this but then should I do that or this and so the more you get the more chance there is for for overlap and and trouble. So it's actually a little bit similar to tools as well and also the context window grows
because you the more skills you actually load in uh the context window grows tools as well. If you look at the difference between Claude, um, yeah, like I think it was Sonet actually we had a look at and and Open AAI. I think Open AI I think has seven or eight tools. I think maybe it's even less. Maybe it's like five. I think Anthropic has 17 or
something like this. And you can you can see like agents will agents and LMS will do things differently like for example Claude has a tool that is um that is read and write whereas OpenAI they use bash to do read and write. So it will cat files and it it will do those types of things. So there's differences between the LLMs as well but all of this
adds complication. So I think by just randomly throwing as much as many skills as we can and things like that we need to we need to be able to manage it actually. >> Absolutely. Yeah. I I think you know if you're in a large organization I think there's a platform team role here that kind of like look at your skills and an AI engineering team that should
look and say you know we're going to provide you with a set of skills that we feel is most uh productive for your team or organization. I think actually using the LLM to well actually there's two things evaluating skills is very very important. Um so being able to say does this skill even work how how good is it? I might say this is my way of working,
but actually if you didn't have that, it might do that anyway. So, you're just adding things into context for no reason. Um, you might be actually improve your skill as well. So, that that helps with activation. I'll actually hold on to that just for a second cuz I'm going to I'm going to do a couple of slides on that. Um, so yeah, in fact, I think I've
I think I've kind of like covered a fair bit of that already. One thing I will say though is anthropic just recently I think only a couple of months ago uh released something called um uh uh agent skills. Agent skills is a standard because obviously cursor rules and claude have different formats. So you have a claude/skills directory and a dot uh cursor/ruules directory with different formats. Do
I now need a repository with 30 different dot folders depending on which user wants to use my uh my my repo? So the idea is we have a standard agent skills that every single agent can hopefully support that then when you have an agent skill they'll pull it in probably into their native way of working. So they'll probably take an agent skill and turn it into maybe
a cursor rules or or um a clawed skill and so forth. So that's an interesting area but as in fact exactly on this discussion we need more from context and actually um >> packages should be applied for example inository >> this agent or any other also support this because usually you don't use W right you you you ask you use WCO maybe >> augment maybe whatever >>
what is the best way make sure you have a single source of rules and they will be picked up is it to be in packages and is it to use agent empty files or use >> let me show let me show you hold on to I thought I'll give you a demo and I'll show you. Okay, so context what we need to do because context is something
that needs to actually be more like a software component. It needs to be maintained and run alongside our our source code because it actually provides a way in which we can then use our our package. Um, and there are, as I mentioned, an a number of different um a number of different types of context, but essentially, you know, they're likely going to need versions because as we
update our our open source, our proprietary libraries with different versions, we want to be able to say, okay, this is the right version of context for this version of the third party library, etc. Maybe even skills, we need versions. We need to be able to test them. Uh, we need to be able to discover uh and distribute them. Um, we need project manifests. Okay? We can't just
say I need these 30 skills and I'll install them manually and I can't if I wanted to distribute them I'd say oh these are the these are the list you want. We need to actually be able to package it properly. Um and yeah what we essentially need is like a maven on our npm like a package json or a pomxl that describes this is the context you
need to work for agents to work well with this with this project and it describes the ways we want to work uh and the context needed in order to build. Um, this is my very brief plug for Tessle. Um, that's exactly what Tesla is. Tesla's a package manager for your skills. So, you know, you can do things like install, discover. Um, in this case, this is a
a version skill in my private repository that I want to that I want to download and use. Um, I might install a skill from GitHub. And also, I can review skills. And there are a number of different evals that we can do to to describe them. Um, a couple of examples here. Uh, you might not be able to see this very well, but I I I'll show
you a very very brief demo. Um, but essentially, if you think of like a Maven Central or or an MPM or something like that, you know, you essentially have version skills that have, you know, some some reviews or evals and overview all the context here. You have things like uh you have workspaces as well. So, I can have a global workspace or a private workspace. I can
add people to that workspace whether it's an organization or whether I just want to make everything you know completely public. Um I can choose how I want to how I want to work. So uh let me uh quickly show you what this looks like. So um this is this is the tessle registry and in here I have a you know a fairly large number of uh of
tiles. I think there are about 10,000 tiles. A tile is essentially a package of context. I can have skills in there. I can have documentation. I can have rules and other things. So, in here, if I was to, I don't know, let's grab uh something like uh where's my search search? Let's grab spring something like this. Uh spring boot actuator. I get uh I get a review
score. Uh this is this is actually for my this is actually for my skill. Um this is a skill MD. I get a review which tells me how good my skill is. uh where I can where I can improve it and other things. I also want to show you um one that I created for um an open source project that Cisco did called uh code guard which
is a security a set of security uh uh results. So here for example they they want to apply certain rules to avoid things like hard-coded credentials and a whole bunch of other stuff. If I go uh if I go over to the um to the rules, you'll see there's a huge number of different rules that can that can each be added into context as needed. So, they're
not fully in context. The agent loads it when it needs to. Um I have a review in this case which tells me, let's go through it. It tells me first of all, you know, is it a valid skill MD? Are there things I need to update in this to actually make it work? Um, this is all based on Anthropic's best practices by the way. Anthropic released best
practices of what they feel a skill should be and should look like. And it includes a whole bunch of stuff like is it concise? Is the workflow clear? And it also provides, you know, information about what it lacks if there is if there is uh issues. Now activation, this is the important one. Activation is essentially what is the agent, what am I missing in my skill that
will actually affect my activation. So for example, um things like the trigger term quality. The trigger is essentially when you know part of your description when should my agent use this skill? When should when's my agent trigger for this skill? If the if the quality of that trigger isn't good, the agent will not activate it when I need to do that. Um specific specificity, completeness, those types
of things. Again, you know, you're more than welcome to to run this on the command line or or just view view each of these. But this is useful cuz like there are a ton of skills out there as well. And if we want to pull in a skill that we know is going to be good, we should be able to run these types of eval. We're running
another skill. Uh this isn't actually public yet, but I'll show you the results. So there's no evaluation data here. This is the result of something that we call a task eval. And this is basically what we do is we take the skill and we say what are you trying what is this skill for? So in this case this is a security skill and it's about building secure
code. So we ran this eval and this will be this will be something which we'll upload shortly. But what this is saying is let me run these scenarios with and without the skill installed. Um what is the and we provide things that we expect criteria that we expect the output to look like. So in this case um I mean let's have a look uh Kubernetes hardening or
or restrictions uh on on your IA network. There will be a list of things whereby if you do these things in your in your output, I will give you these points. And you can see the baseline is just clawed code with the skill is clawed code plus the description of how the skill wants you to do things. And then you know the the the lift is essentially
how much how much the skill has improved what you want based on the on the output of that skill. So this is actually really useful to say because like exactly as we were just just chatting here, you might have a hundred skills, but actually 30 of them aren't doing anything. The the the the agent will do that naturally anyway. Also, you might have context and this is
important here. If we was to take something like uh like this one, the session management here, you probably can't see the baseline is 7%, it goes up to 92. This is super important. There could be other areas. Here you go. 75 to 100, it's actually doing a pretty good job already. And there are probably specific scenarios that actually context is needed. But for the vast majority of
these, maybe context isn't needed. So I can almost delete a large amount of context because the agent is capable of doing this already. It gives us that insight into reducing context and getting the same same kind of result. So emails are like >> Sure. uh skills. The question was actually me and Ivan were chatting about this over a beer yesterday. Um the question was is there a
difference between resemblance between tools and skills? Yes. Yes, there is. Uh a tool is something whereby an agent will invoke a tool something will happen. The tool will give them back an output and the agent will then use that output. A skill is where this is where the agent does everything with guidance from the skill. So let me give you uh an example. A tool might be
let's say a tool is a security review. If I have a tool that that reviews my security of my code, I might have my agent call that skill call that tool. I get results back. The agent does nothing. I get results back from that tool which is here's here's your security information. um and it acts on that with the skill the agent will be get guidance of
how to run how to identify if there are security issues. So the agent has to do it all. That's that's the big difference. Uh oh I see. Uh in in order to as in as in tovoke it it like to invoke the tool or invoke the skill. You mean Yeah. Whereas a tool doesn't have that. A tool just has a description of what the tool is and
the agent can invoke that tool if it wants and then the tool gives it back whatever output the tool will and the agent then continues. So it's it's a case of whether it offboards the work to the tool or whether it does it itself with guidance from the skill. It's essentially saying, you know, if it was, if we compare it to a human, I might say, okay,
I if it's a skill, I will do the work, but I will follow these practices. With a tool, it's like me sending that like to an offshore place and saying, can you just quickly run all this or a contractor and say like a consultancy saying, can you just build this for me? And then I get the output back. So that's the difference whether I do it inhouse
in my agent or whether I use a tool to actually run it for me. okay. So, a couple of things I wanted to uh run. Let's let's uh let's actually do this uh at the command line. There we go. So, here I have here I have a uh project uh I'm running out of time. I have a project uh whereby um Tesla isn't installed or Tessle isn't
initiate initialized. I have Tessle on the command line. So I would just run mpm uh mpm uh install minus global uh at tessle/ cli that installs tessle uh then I just run a tessle in it. Now what this is doing is uh it's installing 24 pieces of packages of content essentially and if I was to cat my Tesla JSON now it has recognized that there is a
huge amount of open source that is being used in this project. As a result it is pulling down context for every single dependency that I am using. Now, if my if I said to my agent, I want you to make this change and it is now trying to do something uh against, you know, one of these or trying to use one of these uh libraries, it could
decide to go to the context. Again, based on activation, it could decide to go to the context and say, "Okay, uh if I'm I have no idea what some of these are. I'm not a JavaScript person, but uh body body paraser, I'm going to do this thing. I need to use body paraser, I think. let me go read that context quickly and then I'll I'll perform that
task. So it gets that context. The the this isn't like ways of working. This is I need to know absolutely how how I use this library or this package. What I could also do in fact let's install. So I'm going to do a Tesla install and I'm going to install the Cisco software uh what was it? Software security I think it was called. So I'm I'm installing
the software security skill. Okay. What that's done is it's added that skill into my.claude/skills directory. So now if I was to run if I can run Claude, there we go. If I run Claude, I now have that software security skill there. And so in fact, let me show you. Let me show you that direct activation. Oops. No, don't do Oh [ __ ] Right. I'm going to run software
security. Oh, [ __ ] security. And then I'm going to say something like uh perform a full code review of this skill of this uh project and it will go ahead and perform that code review using that skill. In fact, it's going to ask me because I'm not using YOLO. Uh oh, actually, it's trying to use Tesla actually. So, I'll say no. Uh just use and it will go
ahead and actually um it'll actually use that skill. So, it'll do that. It's exploring everything and it will go ahead. I'm going to leave that just for now just because uh I'm conscious of time. okay briefly dip into memory. Um so with with uh memory you can stick a bunch of stuff in claude MD and actually this is something that as you create information as you as
you build your project and have information good context that you want to store which is which should always be followed it should go into your claude MD or your agent MD. This could include things like your project structure or you know testing and things like that. Sometimes you don't want to fill this up too too much. Anything you put in here will always be read. This is
always going into your context. So this should be just the absolute you know you absolutely need to know this all the time. But then you can add skills and things like that on top of this. Um, so it's about what's mandatory read by the by the agent and what is optionally read by the agent when it needs. Uh, a really cool thing, this is this is super
cool if you've if you've not done this before, um, is resuming past session. So when you leave the agent, all your messages, all your context is goes away with it. However, you can actually run resume in a couple of different ways. Uh, let me show you this working. Uh, okay. So here for example is just show you this is the security rules using my using my skill
and you can see it's telling me where my violations are on my code guard on my code guard rules. So this is using that that skill and it provides me with that guidance. Now if I was to say okay let's uh let's come out of this and I think oh [ __ ] I actually wanted all of that context back. What I can do is I can run claude
d-res and it will say well which session do you want to resume? So I'll say well let's run this one and you see my you can see my history again. I can also now say if I do a context you'll see I all my messages all my context from my previous session. If I can also do that I think in here right resume. Yeah I can run
resume and I can say let's go to let's go to this one instead. That's weird because uh I obviously ran. Let me go to something I haven't run. There we go. I can go to a previous one. This is one of the ones where I was struggling to actually invoke the plug invoke the skill. Right. Um but but you you know it's it's very easy to be
able to resume previous sessions. Um okay, a couple of things on customization. I'm going to cover uh commands and some hooks as well. So when when you see me running slash followed by a command all of these pretty much are either inbuilt or things which I have added like a skill um what I can also do if I run if I tend to run something again and
again and again I might say let me turn this into a command so I don't have to constantly write the whole prompt. So what you do is you create in your uh claude folder a /comands followed by a name of whatever markdown file. The name of the markdown file will be the thing will be the actual I think will be the will be the um the actual
command itself. So commit push pr I would have as a slash command once I restart that and then I can say this is what I want you to do. This is effectively just copy pasting rather than you know saving me typing. this is what I want you to do every single time. And yeah, there's there's the usage. You might have things like, you know, fix issue followed
by a number or um you know, a sec like slash security check or something like that. Very very easy to very very easy to create. On the other hand, a hook is something which uh occurs on a trigger. So every single time the agent does a specific thing, I want you to do something else. That might be a command, it might be a bash command, it could
be a prompt that runs, but essentially uh it's again very very straightforward. Uh there's an event and there's something else. This could be command prompt and I think there's some other things as well. Um but this will actually be run as a bash as a bash command. Um other useful hooks maybe I'm auto linting or a slack notification or whatever. Um the actually one of my one
of my colleagues Alan Pope he has his own voice whenever Claude finishes and requires human input he has his own voice asking himself for his own input which is very very creepy in an open plan office but um yeah to to show you this working I I would literally just write/hooks uh I would provide the the you know where I would want this hook to be so
maybe it's uh not tool use what shall I do actually. Yeah, maybe maybe user prompt. When I when I submit a user prompt, I want something to happen. This is where I actually run that. And every time I submit a user prompt, this will run every single time. There's no activation. Every single time this would run. awesome. MCP. Yeah, we don't really need to talk too much
about MCP. MCP. Yes, there are security issues with MCP and I know Anthropic have even slated MCP, but there's a few things that are kind of useful. GitHub MCP actually, particularly if you're using if you're using something that isn't GitHub as well because the agent loves the majority rule and will always want to try and use GitHub if it can. But if you're using something which isn't
um standard, things like the these types of skills and MCPs are very very useful. Um we've actually done this very recently with -0 the second one which is uh yeah autonomous debugging. Um someone just yesterday in our engineering team enabled the -0 MCP and just said can you diagnose this problem? It went over looked at our logs and debugged and found what the problem was and provided
that straight to us. This is actually so [ __ ] smart. But obviously security issue if you don't want to pass your sensitive logs to an MCP server. Um but yeah for nonsecure for for nonsensitive stuff really really valuable. Okay I'll briefly talk actually a lot of this I can kind of skip through because actually the next session I believe is going to be talking a little bit about
orchestration. Um but yeah you know you can run there are a couple of ways in which you can run uh claude in parallel. Uh sub aents are actually very very useful. Um but also you can use something called git work tree which essentially adds work trees uh on various uh different directories which you can then just say okay I'm going to claw it in each of these
git work trees and you can run things either in parallel you can run it sequentially whereby I want one thing to happen and then I want to take that output or maybe the I I ask claude for some output as a hand over to the next claude and then you can run things in like sequentially with with follow-on uh feedback there as Sub agents are actually super
cool because I can create agents with their own personas almost. I can create a documentation agent or I can create a testing agent and I and one of the super cool things about agents is they have their sub agents is they have their own context window. Right? That's really important. If I say go and do some research and give me back information about this thing, I'm not
bloating my existing context window. is happening into the in the sub agent and the sub aent sends me just what I care about. We actually did this for a little while. This is one of the ways which we started going through open- source context was uh was using a sub agent. It worked pretty well. We kind of like leaned more into the MCP after that. But but
sub agents are are super cool. Um and yeah, like I say, you can have different personas. So you might have one which is a sec looking at things from a security review, another one from a quality, another one from a performance and so Um, and yeah, these can run in parallel as well. Ah, my last slide off Wiggum. There's this there's this cool um snark tank repo
called Ralph and essentially it is a an automation whereby if you have something which needs to continually loop and f and and continually iterate until something is complete. Maybe it's a refactoring, maybe it's just something which you know something's never going to get done first time and it needs to continually iterate. There's a there's this there's this cool Ralph Wigum kind of like plug-in thing that allows
you you kick it off and you come back hours later and it will have iterated so many times in loop but somehow it actually does a pretty good job of of of this. So even if you don't want to use it at work, try it cuz it's actually quite astonishing watching it flick through in the loops and actually provide something that afterwards you think, "Wow, this is
actually far better than an agent just kind of like doing a a usual yolo or anything like that." So check out that that Snark Tank Ralph Wigum plugin. Uh because that's that's super super fun just to use if not uh if not in production. Um and that's everything I have. I'm sorry I'm a touch late but um yeah I really appreciate coming here and and and talking
with you all. Um I have time for questions or >> is that going >> we'll take them offline and I'll catch you afterwards. Um but yeah uh please use Tesla.
