Okay, now I'm going to press the open button. You can also get to this by going file, I go into
projects, I go into pre-legal, I say open, and now we have our new open VS Code project. We say yes,
I trust the authors. Here we go, we are in here, this is the beginning of our new project.
Okay, so I'm going to bring up a terminal again with command and then the backslash and now,
sorry, the backslash, the backtick, and now we're going to install another MCP server and this time
it's for GitHub. We want to connect to GitHub using GitHub's famous remote MCP server using
the token that we just created and that you're taking great care to preserve exactly as is.
Now you may wonder why are we using MCP servers directly like this when I just told you
that the best place to start is with plugins and the reason is because first of all these are two
very famous MCP servers, Jira and GitHub, that are very well known and very powerful and highly
used in the community and secondly because they have these very particular authorization techniques
and to do it, to go through that proper process, it is best to go directly through the MCP server
and that's why we're doing it that way. Okay, so let's now connect to the GitHub MCP server
using our key. Okay, so I've pasted in here the command which is in the course resources. I'm
going to close that so you can see it all in one line. It's, hang on, let me just delete that,
that's not necessary right there. Here we go. This is the line that will be in the course resources
Claude MCP add. It's another remote MCP server, an HTTP MCP server just like the Jira one was,
the Atlassian one. It's at api.githubcopilot.com.mcp and we're passing in a header and in that header
we're putting the GitHub personal access token but you can see what I've got there is some text and
that's not going to work. I'm going to have to replace this right here with the exact key that
I carefully copied with taking great care from GitHub from that screen we were on just a few
moments ago. So I'm now off camera going to put in my private key in there that we took from there
with these fine-grain permissions, put it in there and install this MCP server by running that just
like this and you should do the same. Okay, I've run that command and now we're going to start
Claude and see what happens. Do we trust this? Yes, we do. Number one, here we go. We're in
pre-legal and we are going to do slash context to see what kinds of tools it has access to.
Let's take a look and you can see it's got access to a whole bunch of GitHub related tools.
Excellent. Okay, let's give this a whirl. Okay, we're going to say please write an issue to GitHub
that the README needs to be updated. Let's see how it does.
It's hopefully going to use the tools. It's first of all just running a local and now it is indeed
trying to use the create or update issue. Let's say yes. We're not going to give it full approval
to do everything. It's doing that. Created issue. All right, let's go and have a look.
Well, here we are in a browser window. I'm going to go to GitHub to the pre-legal and here we are
looking at the repository. It looks very similar to me but wait, there's an issue. Under issues,
it says one. Let's go and check this out. Update README. Let's look at it. The README needs to be
updated to reflect the current state of the project. There we go. Very nice. We've just
used Claude code to connect to GitHub and raise an issue. Okay, well, let's just take it one step
further. Please update the README to reflect that the project is in progress and will be completed
in one week. Then raise a PR for this to be merged. I don't know if we have enough permissions for
this. Let's see what happens. Let's see what happens. Give it a try. We can get into some
problem solving if it doesn't work. It's reading a file. It wants to make a change to the README.
That sounds fine. Go for it. I press number two. It should have updated that and now it's going to
check out and make a commit. That's all great. I'm fine with that. This is not using tools yet.
This is just running Git commands. We'll accept that. It's just running that locally to make the
commit. Now it wants to do a push. Let's say yes. Okay. Now it is looking to open a new pull
request. Open a new pull request. This is using the tool. Tool use. Yes. Let's see if it's working.
Done. Created PR number two. There it is. Okay. Let's go check this out. All right. I'm going to
click on this link right here to a pull request on this repo. Click. Up it comes. And here we go.
We do indeed have a pull request. I don't know why it's called number two, but experts will
probably tell me why it's not number one. Here we go. It's got the summary. Add status section
to README. Generated with code. It's put in here, which is really nice that it adds in that
attribution. And then if we go to commits, we'll see that this PR includes the single commit to
update README with project status. There it is. And it's here so that we could check this out.
And should we wish, we could press merge pull request, which will have the effect of updating
this. So hang on. If I go and look into the code right now, you should see that this is the
code that we've got. We now go into pull request. This is just standard GitHub stuff.
We go into this pull request. We press merge pull request. Confirm the merge. This has now been
merged. We go back to the code again. And now you can see the status is updated. That's cool.
Now, if some of that Git stuff went over your head, then honestly, it doesn't matter. It's
standard sort of Git stuff. I'll try and put some good resources for you or let me know if you'd
like more about it. If you're a seasoned Git, GitHub person, then you knew what was going on
and you understand that's part of the typical workflow with a larger team. And it's something
that Cloud Code can do for you. There's one little bit of housekeeping that we have to do now,
and then we can push on. If you bring up a terminal and you do a Git status, you'll see that we are
in a branch, origin slash update readme. And I'm just going to say, Git checkout main. And that
just switches us back to the main branch. We were on a special branch for our PR. We're now back to
main. Again, if you don't know about this kind of Git workflow stuff, then I'll put extra resources
for you. But that's where we are right now. We've got Git status. Here we are. We are now on origin
main. And we have our directory set up with our license and our readme ready for the next step.
Okay, so we're back in Cloud Code again. I'll tap Cloud to bring it up. We have so far installed
two MCP servers, a Atlassian Jira one and a GitHub one. And we've done them by going to the
MCP server configuration directly. We are now going to install a plugin. So do slash plugin
to bring up the plugins and have a look at them. And you can see there is in fact a GitHub
official plugin that you could also use. It's a slightly different auth approach where you have
to put it as an environment variable, but otherwise it would work in much the same way.
That's not what we're going to install. We are going to install a plugin called FeatureDev.
FeatureDev is an official plugin from Anthropic to guide Cloud Code through a disciplined seven
stage process to build a new feature for your product. In some ways, I think of this as like
the polar opposite of Ralph loops. Ralph loops are all about chaos and just total autonomy and just
go for it 10 times, see what happens. The FeatureDev is a rigorous disciplined, keep you on
rails, take you through a process. That's what FeatureDev is all about. That's what we're going
to use. It's something which Anthropic themselves use internally for their own software development.
So it must be good. It sounds like I was saying that as a joke. It's like, so it must be good,
but no, it really must be good if Anthropic uses it themselves. So we select it and then press
enter to look at it. Comprehensive FeatureDev workflow with specialized agents for code base
exploration, architecture design, and quality review. I know we haven't yet talked about
having specialized agents, but I think you probably guess what it's all about. And now,
if you look down below, we can choose to install just for you, have the scope just for this user.
For all collaborators on this repo, have project scope. And that is what we want. We want project
scope. And so we select this and I press enter. And now it has been installed and you can see it
just created a .clawd file right there. We have everything here. We are ready to be using a
disciplined development process. But just before we get started, just some final housekeeping.
We've now created this .clawd folder that got created for us, which has turned on this plugin
for all people in this repo. So we've got something to check in and we might as well
take this opportunity to create some other useful or another useful file for our repo,
which would be a .gitignore file, which is an important one to have. So we'll get
Claude to do all that for us. I'm going to say, please create a boilerplate .gitignore
for this new project for a typical Python fast API next JS web app development
and then commit and push to GitHub. All of that. All of that. We'll let it do its thing. It
shouldn't need to use any plugins for that. This is just about doing some files. There we go. We
can see it's made a .gitignore file. We will let it make its edits and do more edits. And
hopefully it is now going to run. It is doing a .gitstatus. It's committing.
And it's doing a .gitpush. And it's doing a .gitpull because we merged the PR that needs to be done.
It's doing all that for us. It's handling all the .git stuff for us. And it's all been done. Okay,
that sounds exciting. Let's see if this actually worked. We'll go over to GitHub now.
And we can see here we are in GitHub. Sure enough, we've got ourselves set up with the full, the new
readme that says we're going to complete it in a week. Well, let's hope we do it in a day.
And we've got a .gitignore. And that .gitignore, if we click into it, it looks like it's got all
sorts of sensible things, including a .env. You should check that your version has that .env.
And very standard stuff for a JavaScript and Python project that has been successfully created.
It's obviously on our local disk. It's also now been committed to GitHub as well. And so we are
ready for primetime. We are ready to build a feature using a proper disciplined workflow,
taking advantage of our integrations with both Atlassian JIRA for issues, for work, for tasks,
and also GitHub for managing PRs.