I've been running the GSD,
get shit done framework on my last two projects.
And honestly,
the results have been unreal.
I'm shipping in about half the time it usually takes me instead of just messing around with Claude or ChatGPT
in a endless vacuum.
One of the things I really want to start exploring
is how can we two x the two x. GSD really enables us to work faster.
But I noticed when I first started going on with GSD, I was going in cold,
and I was letting GSD
essentially just guide me through the project.
But I discovered
if I prime GSD with really good research information,
my projects were going a lot faster in the long run. So I think it's really, really important to shift our mindset from completely relying on AI tools
and making ourselves more the architects and really thinking about how our project structure should be going forward.
So today, I'm gonna show you how to prep a pre context file
that turns your workspace into an execution machine and that really primes the get shit done methodology
to enable you to just work even faster.
So this is the
get shit done GSD
git repository.
And I would highly recommend,
if you don't know about this repository,
you go in and you just take a look at and understand
everything
that's going on in this repository
because it's really interesting how it's all put together.
But in order to get started, there's there's a few really high level things that you need to know.
Um, the first of all is, uh, part of the GSD framework is you need to run claw dangerously
and skip permissions.
This seems really, really scary at first, but I promise you it's not once you get in and you start using it. If you've done AI projects before, you know how much Claude code needs to get permissions.
And for a lot of those permissions,
if Claude code crashes for any reason, then what happens is when you reload into Claude code, you have to give it that the all those permissions again. So it can it can be really annoying. So just starting Claude code by skipping these permissions is totally part of this.
There are alternative if you do want to monitor that a little bit more effectively, but I would recommend that's the big thing. And then always,
whenever you're starting GSD and the for the purposes of this video, uh, GSD new project is how you just get started, and it does a really good job of guiding you through
how to
execute on that project.
So let's go into what actually GSD
is doing on a high level. So
this is what your typical a new project looks like. Right? So you're you're like, okay. I have a client requirement,
and you know what? I gotta start my new project. So first thing I'm gonna do is I'm gonna dive right into GSD.
I'm gonna do slash GSD new project.
And what I'm saying is you actually don't wanna do this. And then for those who don't know,
essentially what GSD is when you start a new project, it'll ask you a bunch of questions and it's gonna create two main documents at least. The first the first big document it's going to create is
the project road map or like a a PRD.
And essentially in this project road map, what it does is it lists out all the phases,
just very high level of what needs to be accomplished.
And then the other thing it's going to do is get a technical state of the types of tech you want to do. So when you start a new project to ask you, okay, what do you wanna accomplish?
What do you want your back end to be? Um, how do you wanna develop your front end? Like, it's going to ask you a bunch of those questions.
And essentially what it's starting to prep is your context window primer
so when you start to execute in these phases okay I need to set up the front end for my client like I need to get a new website set up and maybe I want like an AI chat bot or something. It's going to break that up into phases or it's gonna break that up to milestones and then inside those milestones it's gonna break it up into phases.
And then what you do is you say execute phase one
and what it will do is it'll shoot all of this information into the context window, and it'll shoot the technical state into the context window,
and then the instructions on how to execute phase one. Like, really, really high level. That's essentially what GSD does in a nutshell.
But the problem that
not really a problem, but where I've really noticed we can get a lot more efficient
is starting to prep
GSD
before
we actually engage into project. So what does that look like? So if you look at any AI project or any project you wanna complete in general,
there's a few high level things that we need to dig into. First of all, who are the stakeholders in the project?
What are we trying to accomplish?
What are our timelines? Like, project scope is is a really big
is a really big topic. And then secondly, what are the discussions that we've had around this project?
And so what I found is if we can essentially
mark up and summarize
all of this information into a single document and then use this document
to feed GSD
when we initially create our project, it's two x ing your two x. So what does that look like when we actually create a new project? Well, firstly,
all of us are using notetakers nowadays.
So having access to an API or having access to webhooks on our notetakers where we can download the transcripts
and add them into our project folders is a hidden superpower. Secondly, we've if we're doing client work, we've created a lot of documents
explaining what we're doing. We've created a project scope document
that should be getting fed into your context, your pre context window. So this should actually be like a pre context window. And then secondly, the stakeholders,
like, that's really important. Like, are we working with a project manager? Are we working with the CEO? Are we working with a VP?
What do they have the power to do in this project? Are they like a decision maker or are they like an operator of it? We need to know that information because as we pushed our project forward,
we wanna achieve success. So let's dig in now to how we can actually get these three things and create this pre context file.
Okay. So this is Claude code,
and I have it installed on WSL,
which is a Linux image on my Windows machine, and I'm inside a cursor right now. I've done a little bit of prep to expedite this process.
And, essentially, I've come in and I've run a slash init since I'm starting a new Claude project in Claude code. I've also logged in to Claude. Additionally, there's two more things that we need to focus on here, which is I have installed two MCP servers,
which MCP
essentially just allows us to
have our Claude code agent communicate
with their technology or we can communicate with their services.
So
my notetaker is TLDV.
And then what's also going to be very important is API phi or Apify. There's so many different things you can call this. But essentially, this is just like a scraper. It's a scraper mechanism for us that we can essentially use to get this information.
So now that I have my project initially set up, the slash in it creates the Claude MD file for me. And then from there, we installed the MCPs
and away we go. So in order to prep this on the original
document that we had, there's three main folders.
So I'm going to add these folders into my into my project. We can call it like client research or project research.
Project
research.
And then we have three subfolders in here
that we want to add which is going to be project scope.
There's going to be
discussions.
So first things first is
like
for discussions, there's a couple of ways to do this. You can just go in and create markdown files yourself and paste the transcriptions in there depending on if you just have a few meetings or if you wanna be really if you wanna do it the cool way, which I'm doing it, you can do it through API or MCP servers.
So if you wanna do that, you can just copy the transcript and you can just say, like, hey Claude create a md file of this discussion
and then you can paste the transcript in there.
The other thing you can do is if you're used to using MCP servers is you can essentially
if you're used to using APIs or MCP servers, you can essentially just grab
like a you can give the agent context on the meetings. Like, you can say, I want you to grab all the transcripts
with client x y z and move them into the discussions folder.
Um, and I can show you exactly how this works after I've installed the TLDV MCP.
I can say use the TLDV
MCP
and then I just use TLDV as my notetaker. There's so many other notetakers that have API access and MCP access.
So, um, you can install those. And if you're interested in learning more about installing MCP servers, I can show more on this. But use that TLDV MCP
to grab
to grab my discussion
from yesterday
from yesterday named
Traverse Weekly Call which is one of my one of my businesses
and create a MD file
in the discussions
folder
with the transcript.
And since I have the TLDV
MCP
installed
and
since I have the TLDV
MCP installed and the skills installed and clogged code, you can see right here, it's essentially just connecting directly to TLDV,
and it's going to create that transcript for me. So you can start to see the power of context
at work here. And this is the coolest thing ever because now if we go into my discussions tab, obviously, Claude is still doing its thing.
Once this is finished, I'm going to have my transcript in the discussions tab.
While that's going now, let's talk about stakeholders and project scope. So project scope
is good to move all of your project
details into this folder. So if you've created any sort of documents when you've done your sale for AI consulting or your AI agency,
move those into the project scope folder. If you've done any sort of proposal
for the client, move that into the project scope folder. And then lastly here,
we have the stakeholders folder.
The stakeholders folder is essentially what I would really recommend you do is you essentially
scrape your
clients'
LinkedIn profiles
and do a little bit of a write up on each stakeholder.
Additionally,
another really good thing I do with the a the API fi MCP
is
I love to do competitor research.
Um, I do a lot of high level AI consulting projects, and competitor research is really necessary.
So we can use the APIify
MCP
to scrape LinkedIn profiles,
and then we can also use it to scrape the websites and scrape the profiles
of our of their competitors and add it into this project research folder. It's super powerful. So we'll do a little bit of that once this finishes. So I'm gonna let this finish now.
Okay. So now we can see the TLDV
MCP
did its it connected to my TLDV account, grabbed that transcript,
and it created a discussion markdown file that you can see right here,
um, above
that, um, is in our discussion. So you can obviously take this now and you can apply this to multiple discussions.
Um, you can even search by email or name inside of the TLDV MCP or if your notetaker has a particular MCP or API, you can do that as well. All these notetakers are the same nowadays anyways and they all have the same kind of accessibility
into them. Or again, you can just move the transcripts in. So next we wanna move on to project. We wanna move particularly
into
the, um, discussions tab and you can see here Claude just made another discussions folder. So I'll just move that in there and then I'll I will just, uh, delete that because I don't need that anymore.
Um,
you can see we have project scope and we have stakeholders right now. And really what I just wanna show off very quickly is
how can we use the MCP servers to build this context. So first of all, I've connected APIify
into
I've connected into the APIify MCP server.
And so I have all of the if if we if you don't know what APIify is, it's essentially a
scraping service that has a variety of different scrapers where you can scrape LinkedIn, you can scrape websites,
you name it. And it's MCP is extremely powerful. As an example, what I will do now is I will run
I will grab my own LinkedIn profile
and I will say let's say I'm one of the stakeholders for this project. I can say,
please use the a API
five MCP server to
research a
LinkedIn
profile public profile scraper
and scrape
our client's
profile
which
is my LinkedIn profile.
So API Fi is going to now provide is going to do its thing and it's going to scrape that profile and I'm just gonna say add the
scraped
MD file
into the stakeholders
folder.
K. And it's a you can always you can always just add a command into Cloud Code as you go on, um, and it'll take that additional context and it'll go. So you can see it's found an API scraper and now it's added it into the stakeholders.
It looks like it's created another folder. That's okay.
And it it'll add that at in a markdown into that folder.
Additionally, what we can do with APIify
is we can also scrape websites.
We can scrape our client's website,
and we can also scrape competitors' website. If you're a AI consultant or an AI agency, you should be doing this as part of setting up all your project. You know? And then we can say, like,
we'll wait for this to finish, but we'll run a scrape of our website and we'll add that into the markup
folder. And while this is running,
we also have the project scope tab on the right here. And essentially what the project scope tab on the right is is what we should add in is any project folders
that we've come up with up until this point. So I'm talking about if you've created any proposal documents for your clients, if you've done any pitch decks as part of signing the business, or if you have a project scope document.
All of that should be added into the project scope regardless of what format they're in PDF or anything like that because what we're going to do is when we collect all of this information,
you'll see that we now have we now have
enough information to make that pre context.
We're able to prime the primer essentially.
So here you can see Claude code made a little bit of a mistake, not a big deal though. But you can see my LinkedIn profile here. Um, it's completely scraped and it's it's in the context of our project folder now. And then lastly, what we'll do is we will create a in the stakeholders tab,
um, we will copy
the path
and then
we can ask Claude code,
hey, can you scrape
our client's website for context
and add it to this
location in a md file.
Okay. And now you can see that our our website scrape has been
added into
our project folder, our project research folder.
So once we've
identified
and we've added in all our project research into the scope,
we want to now prime our GSD.
So very easily we can say
we can say, Claude,
please look over my project research folder
and create
a comprehensive
markdown folder
that summarizes
all the information
we have between
project scope,
oops,
project scope,
the discussions,
and the stakeholders.
Um, Additionally, if you've done another great thing you can do with the API Fi MCP
is you can
you can do competitor research in there
and create a
and stakeholders
to create a
pre context
MD file
that we will use to get our GSD
project
launched
with maximum
efficiency.
Then what I would just recommend you do is, like, I'm just trying to do this very quickly right now. But once we create that initial folder,
you do wanna go in into this markdown
file and you want to
really, really dial in on it. That's the best way to really, really get the most out of this.
Um, and then what's gonna happen after all of this takes place
is we're then going to finally
initiate GSD.
So really exciting.
Claude has collected all the context for a pre context folder.
It's gonna be spitting that out any second now.
And then from there,
we're going to be able to engage GSD and get our project started.
At which point, we would go slash GSD
new
project.
And then once it starts
inquiring
about us or once it starts inquiring about the project,
what we wanna do is we wanna reference this pre context folder
and answer its questions so you'll just have a solid context for your for your new project and you have been set up in the best way possible
like a professional AI consultant.
So what we explored today
was we got an understanding for how we wanna start setting up our AI projects.
We wanna use frameworks like GSD,
but what's really important is how we set those frameworks up. We utilized MCP servers
to make the process of gathering all of our project context in the most efficient way,
but we also understand there's manual backups if we're not that advanced yet or
we don't have MCP
or API
access into the project context that we need.
And we understand now
how to make a pre
project context file
so when we start engaging our project frameworks like GSD,
we can do so in the most efficient way possible,
which in the long run will end up saving us a lot of time.
So if you have any questions, leave a comment below. I'd be more than happy to answer. Please like and subscribe if you'd like to see more of this content.
I'll catch you guys around.