[00:20] (20.08s)
All right. So, we're going to go ahead
[00:21] (21.44s)
here and in this video, this is just
[00:24] (24.08s)
going to be raw. We're just going to go
[00:25] (25.36s)
ahead and vibe code um what is known as
[00:28] (28.88s)
Rev ROI. So Rev ROI is actually a pretty
[00:32] (32.64s)
slick little extension uh that Chris
[00:35] (35.36s)
Granton company put together for being
[00:37] (37.76s)
able to find deals, right? And being
[00:41] (41.12s)
able to do it in a way where we're
[00:43] (43.60s)
actually able to see a couple different
[00:45] (45.20s)
things of data, right? So we can see
[00:46] (46.64s)
cashback, gift cards, and settings. So,
[00:48] (48.88s)
we're actually going to go ahead here
[00:50] (50.24s)
and and see if we can put together um a
[00:53] (53.84s)
what is known as an MCP server or model
[00:55] (55.92s)
context protocol. And essentially what
[00:58] (58.56s)
model context protocol is all about is
[01:00] (60.80s)
you can take things like claude here for
[01:04] (64.16s)
example and I can give it different
[01:06] (66.28s)
tools. So those tools just make your AI
[01:09] (69.52s)
editors that much smarter. Uh think of
[01:12] (72.00s)
it kind of like a USB a USB port, right?
[01:14] (74.88s)
A USBC port. It's universal. It allows
[01:17] (77.12s)
you to connect all sorts of different
[01:19] (79.12s)
devices to your MacBook Pro and and be
[01:22] (82.00s)
able to to work more efficiently. Same
[01:24] (84.16s)
kind of thing with MCP servers, right? I
[01:26] (86.80s)
can go ahead and I can have, you know, a
[01:29] (89.20s)
calculator. I can have a fetch server
[01:31] (91.12s)
that goes out to different websites. I
[01:33] (93.28s)
can go ahead and use it for being able
[01:36] (96.40s)
to source profitable inventory. So this
[01:38] (98.64s)
is essentially what we're going to do is
[01:40] (100.32s)
we're going to start the process and
[01:41] (101.76s)
it's going to be very raw of just train
[01:44] (104.08s)
the thought of how do I take Rev ROI
[01:46] (106.64s)
which is a Chrome extension and be able
[01:48] (108.96s)
to convert it into something that we can
[01:50] (110.80s)
use into one of these AI editors to just
[01:53] (113.04s)
to be able to help ourselves out. So
[01:54] (114.96s)
that'll be the scope of this session
[01:56] (116.40s)
that we're going to go
[01:57] (117.80s)
through. All right. So here's what we're
[02:00] (120.08s)
going to go ahead and do. We're going to
[02:01] (121.36s)
go and the first thing we need to do
[02:03] (123.44s)
with Rev ROI is we're going to
[02:06] (126.44s)
need to
[02:08] (128.44s)
grab some data from the extension. So,
[02:11] (131.60s)
when we pull up the extension
[02:14] (134.68s)
itself, we're going to do a right click
[02:16] (136.80s)
on this and we're going to do an
[02:18] (138.76s)
inspect. And what that's going to allow
[02:20] (140.96s)
us to do is we can then type
[02:25] (145.40s)
in any website. Let's just do a search
[02:28] (148.16s)
for Kohl's for example. And if I go to
[02:30] (150.88s)
the network tab, when we do that search,
[02:34] (154.00s)
I should see an action here. Perfect. So
[02:36] (156.96s)
now I have an actual URL that we can
[02:38] (158.88s)
use. So this is actually the
[02:41] (161.88s)
request that it's making a call for
[02:45] (165.44s)
cashback. So I'm going to assume so
[02:47] (167.44s)
we're going to make a note of this,
[02:48] (168.48s)
right? So this is one of our endpoints.
[02:50] (170.00s)
We're going to call this
[02:51] (171.32s)
cashback. Cashback is going to be here.
[02:54] (174.88s)
So we're actually going to go through
[02:56] (176.72s)
and we're going to generalize this a
[02:58] (178.48s)
little bit. We're going to say, let's do
[03:02] (182.52s)
cashback and we're going to give it an
[03:07] (187.48s)
example. And that's going to be what
[03:09] (189.68s)
we're going to put in here. And then
[03:11] (191.92s)
we're also going to give it an
[03:14] (194.36s)
endpoint. So the only thing we're going
[03:16] (196.32s)
to do differently is we're just going to
[03:18] (198.40s)
say instead of host name, we're going to
[03:21] (201.12s)
call this the
[03:22] (202.60s)
retailer. All right. So we'll add that
[03:26] (206.56s)
in. And all I'm doing here is just
[03:27] (207.84s)
taking raw notes. This will make sense
[03:29] (209.36s)
here in a minute. So the beginning part
[03:31] (211.60s)
is just a lot of doing information
[03:34] (214.16s)
gathering. So what I'm putting here is I
[03:36] (216.72s)
have on my editor. My editor is known as
[03:38] (218.96s)
cursor. So it allows us to be able to
[03:42] (222.08s)
run AI make different things and it's
[03:44] (224.32s)
basically like the Swiss army knife of
[03:46] (226.24s)
AI tools for software development. But
[03:48] (228.48s)
you don't have to be a software
[03:49] (229.68s)
developer to take advantage of this,
[03:51] (231.28s)
right? you can be a non-developer and
[03:53] (233.84s)
still be able to interact with these
[03:56] (236.08s)
tools. And this will start to make more
[03:57] (237.52s)
sense as we go through. So, all right.
[04:00] (240.24s)
So, now we have an endpoint that we can
[04:01] (241.92s)
use. Um, and that's going to go ahead
[04:04] (244.16s)
and say, okay, that's we've put the
[04:05] (245.28s)
retail in there and we're going to use
[04:06] (246.68s)
cashback. Um, let's actually look at an
[04:10] (250.08s)
example of if we pull the inspect back
[04:13] (253.16s)
up. If we look at the response body for
[04:16] (256.24s)
this, I should be able to
[04:19] (259.00s)
do grab this. So, this is actually going
[04:22] (262.24s)
to give us all of the relevant details
[04:25] (265.60s)
that I found for the cashback. So, we'll
[04:28] (268.32s)
keep that as a response example. So,
[04:31] (271.20s)
we'll say cashback
[04:34] (274.36s)
request and then we're going to
[04:41] (281.80s)
cashback response.
[04:45] (285.20s)
And this is going to come back in the
[04:47] (287.28s)
form of JSON. JSON's just javascript
[04:50] (290.40s)
object notation. So it's a standardized
[04:52] (292.88s)
format for the web. So think of it like
[04:56] (296.56s)
everyone communicates in different
[04:58] (298.48s)
languages and in speech, but there's
[05:01] (301.68s)
certain hand motions or things that you
[05:03] (303.20s)
do that regardless of the language that
[05:04] (304.80s)
you speak, it's common. It's universal
[05:07] (307.28s)
communication. Think of that as one way
[05:09] (309.20s)
of what JSON kind of serves as. So we're
[05:12] (312.64s)
just going to put an example here. And
[05:14] (314.40s)
all this is is this is the actual data
[05:16] (316.16s)
from the different sites of the
[05:17] (317.36s)
different cashback that I found. So
[05:19] (319.28s)
we're giving information to our AI or
[05:22] (322.00s)
creating building the the information
[05:24] (324.64s)
database. That way we can provide later
[05:27] (327.60s)
which are going to be these files these
[05:29] (329.52s)
PRD or project requirement documents.
[05:32] (332.32s)
We're going to be building a very
[05:33] (333.68s)
thorough document out that when the AI
[05:36] (336.08s)
is prompting it now it's going to be
[05:37] (337.84s)
able to build step by step.
[05:40] (340.80s)
Okay, so we have an example for
[05:42] (342.96s)
cashback. We're going to do an example
[05:44] (344.96s)
for gift cards next. So, we will do the
[05:49] (349.32s)
search, run our inspection, and let's
[05:52] (352.48s)
see if we can I'm going to clear the
[05:55] (355.12s)
clear it out and rerun
[05:57] (357.24s)
it and see if we can find Okay, so
[06:00] (360.56s)
that's the cashback. I want gift
[06:03] (363.40s)
cards. Give me something for gift cards.
[06:09] (369.76s)
Some of this is uh Okay. Yeah. All
[06:12] (372.16s)
right. Perfect. So, gift cards is the
[06:15] (375.16s)
thing. All right. Great. So, what we're
[06:18] (378.00s)
going to do here is now we can rinse and
[06:20] (380.80s)
repeat the same
[06:23] (383.32s)
process. So, that's a cashback. Just for
[06:26] (386.16s)
the sake of being lazy, I'm going to
[06:29] (389.80s)
put gift cards
[06:34] (394.04s)
request. All right. And whoops, that's
[06:36] (396.88s)
the response.
[06:39] (399.68s)
Uh let's do this and do one two three
[06:43] (403.52s)
gift cards
[06:46] (406.60s)
response. This will also be
[06:50] (410.60s)
JSON. And we're just going to post that
[06:52] (412.96s)
in just so we have a response
[06:56] (416.68s)
example. Okay. And let's do our
[07:01] (421.48s)
request. So if we pull this back over,
[07:04] (424.40s)
we can see that it's it's following the
[07:06] (426.08s)
same format on these which is good.
[07:08] (428.32s)
That's very common development pattern.
[07:11] (431.12s)
So we will go ahead and say this is our
[07:15] (435.56s)
example and we will do one more. And
[07:20] (440.00s)
this doesn't have to be perfect, right?
[07:21] (441.28s)
The first iteration of this is notes.
[07:23] (443.12s)
The beauty of this is we can prompt it
[07:25] (445.04s)
to put it into proper formatting after.
[07:27] (447.84s)
So we're just going to call this
[07:29] (449.28s)
retailer here
[07:31] (451.00s)
again. So now we have two of the main
[07:33] (453.84s)
items. just to be thorough. Pull this
[07:36] (456.96s)
back over. We'll clear it out. And let's
[07:39] (459.20s)
do one. Okay, there's the two main ones.
[07:42] (462.00s)
So, we're just going to do cash back and
[07:43] (463.44s)
gift cards. I think that's that's a good
[07:45] (465.28s)
starting point for this. Okay, so now we
[07:48] (468.08s)
have what we need. And basically what
[07:50] (470.64s)
we're doing is we're going to be
[07:51] (471.76s)
reproducing the output that's in the
[07:53] (473.52s)
Chrome extension, but now we're going to
[07:55] (475.12s)
make it so that way it's enabled for
[07:59] (479.00s)
AI. Okay, so we have these two items.
[08:02] (482.48s)
Now, the next piece of setup, right, is
[08:04] (484.56s)
we're going to leverage uh cloud code
[08:07] (487.04s)
for this.
[08:08] (488.84s)
So, I'll show you how I how I set this
[08:11] (491.52s)
up, right? So, cloud code is essentially
[08:14] (494.88s)
the claw
[08:16] (496.76s)
browser, which we have the desktop
[08:19] (499.08s)
browser, but it's in a terminal format.
[08:22] (502.72s)
And a terminal is just a fancy way of
[08:24] (504.96s)
saying we're able to basically get
[08:26] (506.88s)
straight to the roots of how to start
[08:29] (509.20s)
doing some of these builds. And you can
[08:30] (510.64s)
do this a couple different ways, but I'm
[08:32] (512.08s)
going to choose to run cloud code in
[08:34] (514.60s)
here. All right. So, I'm going to go
[08:37] (517.52s)
ahead and anytime there's a new project,
[08:39] (519.28s)
you're going to run in it, which just
[08:41] (521.36s)
installs
[08:42] (522.68s)
the underlying files and systems that
[08:46] (526.08s)
Cloud Code will need. And basically what
[08:48] (528.00s)
this will do is it's going to create a
[08:49] (529.44s)
memory bank. So, it's going to learn
[08:50] (530.96s)
about the project. And as as you get
[08:53] (533.92s)
better at prompting and as you get more
[08:55] (535.92s)
familiar with the these principles,
[08:58] (538.72s)
it'll start to make a lot more sense. So
[09:00] (540.88s)
what we did in this folder for Rev ROI
[09:03] (543.40s)
MCP is we just
[09:05] (545.88s)
created a blank file for what's known as
[09:09] (549.36s)
an open API file. So this is the actual
[09:11] (551.84s)
API calls which we're actually seeing
[09:13] (553.84s)
here. This is the underlying code that's
[09:15] (555.76s)
running that's having that extension to
[09:18] (558.40s)
return the data for it. So we're going
[09:21] (561.04s)
to create a a specification file of
[09:23] (563.84s)
those two endpoints and that's going to
[09:26] (566.16s)
be our main input to generate the MCP
[09:28] (568.64s)
that we use in cloud. Okay. So cloud
[09:31] (571.04s)
code has analyzed our
[09:33] (573.08s)
codebase and it's going to go through
[09:35] (575.36s)
and it's going to learn a little bit
[09:36] (576.32s)
about it. It's going to ask us for
[09:37] (577.44s)
permission to run some listings of the
[09:39] (579.20s)
files to just get a little bit more.
[09:41] (581.04s)
Since it's just a listing, we'll give it
[09:43] (583.04s)
permission to use it for the session.
[09:45] (585.28s)
One reason I really like cloud code is
[09:47] (587.20s)
it will ask for these. So, it's going to
[09:49] (589.12s)
give us a it'll give ask for permission.
[09:51] (591.68s)
Then it stores any of our responses in a
[09:54] (594.16s)
settings file. And those settings files
[09:56] (596.32s)
become incredibly relevant. So, that way
[09:59] (599.04s)
you know, okay, well, what did I give it
[10:00] (600.88s)
permission to? All right. Well, I gave
[10:02] (602.24s)
it permission to run listing commands
[10:04] (604.16s)
within uh the terminal here or bash
[10:06] (606.64s)
terminal and it's going to maintain that
[10:09] (609.64s)
goes. Okay. So, this will continue to do
[10:12] (612.64s)
its thing. Um, what we're going to do
[10:15] (615.36s)
here in the meantime is let's see, let's
[10:19] (619.60s)
go ahead
[10:20] (620.84s)
and take a look at another cloud session
[10:24] (624.00s)
just so we can get familiar with what it
[10:25] (625.84s)
does so we can find uh we're still in
[10:28] (628.88s)
the run running setup stage. So, we'll
[10:30] (630.56s)
wait here for a second. So, we'll do an
[10:33] (633.48s)
exit. Okay, so it wants to create
[10:35] (635.84s)
cloud.md. Yes, I'm going to give it
[10:37] (637.60s)
permission. So, it's just did a full
[10:39] (639.96s)
recap of what it learned about this
[10:43] (643.16s)
project, what the endpoints were that we
[10:45] (645.52s)
just created, and we're going to go
[10:46] (646.88s)
ahead and give it permission.
[10:50] (650.28s)
Yes. All right. This will write it. So
[10:52] (652.64s)
now we will have a new file called cloud
[10:54] (654.48s)
MD, which is think of it as its brain or
[10:56] (656.96s)
its memory
[10:59] (659.00s)
bank. All right. The file will help
[11:01] (661.12s)
claude instance understand the project
[11:02] (662.64s)
and the purpose of the scope. Perfect.
[11:06] (666.04s)
So now what we can do, let me do an exit
[11:09] (669.36s)
here on this
[11:11] (671.08s)
one because I think we can only have one
[11:13] (673.76s)
instance running at a time. So I'm
[11:15] (675.44s)
actually going to do Okay, it's it is
[11:18] (678.24s)
connected. Let's see
[11:20] (680.12s)
here. All right, so we'll run an exit.
[11:22] (682.32s)
We're going to open up a new session.
[11:23] (683.52s)
And anytime you do a new session, okay,
[11:26] (686.00s)
we are connected. Perfect. Um, what's
[11:28] (688.88s)
new? Fixed some items. Okay, great. So
[11:31] (691.20s)
let's do a status just make sure we're
[11:34] (694.72s)
All right.
[11:39] (699.08s)
Excellent. All right. So, now let's go
[11:41] (701.36s)
ahead and get started here. All right.
[11:42] (702.96s)
So, I'm going to go ahead and tell it to
[11:45] (705.44s)
what we want to do. So, this is where we
[11:47] (707.28s)
can build some more sophisticated
[11:49] (709.04s)
prompts. Um, so I'm going to go ahead
[11:51] (711.44s)
here and in our
[11:54] (714.04s)
PRD, I'm going to actually say I'm going
[11:57] (717.20s)
to give it some context. So, I'm going
[11:59] (719.20s)
to give it an overview. And now what
[12:01] (721.28s)
we're going to do, so we're going to do
[12:03] (723.88s)
overview. I'm actually going to use a
[12:06] (726.16s)
software suite here called Whisper Flow.
[12:09] (729.68s)
And it's going to allow me to be able,
[12:12] (732.80s)
let me do it like this. And then
[12:14] (734.72s)
overview. It's going to allow me to be
[12:16] (736.56s)
able to just talk and it'll start
[12:18] (738.84s)
typing.
[12:21] (741.08s)
So I'd like you to be a senior software
[12:24] (744.40s)
engineer and architect. Your primary
[12:26] (746.76s)
responsibility will be assisting a
[12:30] (750.24s)
client to be able to take to build a
[12:34] (754.00s)
open API spec that we will later be able
[12:37] (757.52s)
to convert into an MCP server model
[12:39] (759.60s)
context
[12:42] (762.36s)
protocol. All right. So that's the
[12:44] (764.24s)
objective. Now we're going to give it or
[12:46] (766.16s)
that's the overview. We're going to give
[12:54] (774.36s)
objective. Your first objective will be
[12:56] (776.96s)
to look at this particular file and
[13:00] (780.32s)
convert it into a fully
[13:03] (783.88s)
compliant project requirement document
[13:07] (787.12s)
that will be leveraged with engineering
[13:10] (790.32s)
detail for task level breakdown for
[13:14] (794.00s)
engineering assignment.
[13:16] (796.80s)
Okay, so that's one objective. Second
[13:19] (799.12s)
objective is going to be
[13:21] (801.96s)
um your second objective will be to
[13:24] (804.88s)
construct a fully compliant open API
[13:27] (807.92s)
specification in YAML format.
[13:34] (814.64s)
Your third objective is going to be to
[13:37] (817.20s)
convert the open API specification into
[13:40] (820.32s)
the necessary code in JavaScript and
[13:44] (824.44s)
TypeScript to be able to convert it into
[13:48] (828.00s)
an MCP server.
[13:52] (832.40s)
have an API specification into I'm just
[13:55] (835.04s)
going to say code in
[13:57] (837.96s)
JavaScript to convert it into an MCP
[14:00] (840.92s)
server. Okay. And here we have let's
[14:05] (845.60s)
give this we're actually going to call
[14:09] (849.16s)
context and then we will give it that.
[14:13] (853.36s)
So these will be the context files.
[14:18] (858.24s)
Now, what we could do additionally, I'm
[14:21] (861.04s)
not going to do it for this one, um, is
[14:24] (864.88s)
we could actually do our full prompt.
[14:26] (866.48s)
So, I actually use another tool called
[14:28] (868.72s)
Text Blaze. Allows me to use templates
[14:30] (870.88s)
for any type of, um, prompts I use
[14:34] (874.00s)
regularly. Maybe it doesn't work in
[14:35] (875.92s)
this. It does work in in um um when it's
[14:38] (878.88s)
in in chat GPT. So, it looks like it
[14:40] (880.80s)
doesn't work in the cursor prompt, but I
[14:42] (882.32s)
could put prompt and it would actually
[14:44] (884.40s)
put that in there. Maybe it'll work in
[14:46] (886.00s)
terminal. Let me see. No. Okay. So, it's
[14:48] (888.48s)
not picking that up. All right. But it
[14:50] (890.48s)
does work in browsers for those. Okay.
[14:52] (892.80s)
So, now we have a loose template. We
[14:55] (895.84s)
gave an overview. We gave it an
[14:58] (898.44s)
objective.
[15:00] (900.04s)
Um, let's call this actually
[15:07] (907.80s)
context. All right. And then at the
[15:10] (910.72s)
bottom, we're going to do
[15:13] (913.00s)
our outcomes.
[15:19] (919.68s)
call it objectives and outcomes. We'll
[15:21] (921.28s)
keep this light to start. We'll
[15:26] (926.92s)
say success looks like being able to
[15:30] (930.00s)
take this existing file, converting it
[15:33] (933.80s)
into a markdown file that's fully
[15:36] (936.72s)
rendered into a task level breakdown of
[15:39] (939.44s)
a project requirement
[15:43] (943.16s)
spec. Okay, perfect.
[15:45] (945.76s)
All right. Um, I think that's good
[15:48] (948.08s)
enough to get us started. So, we'll save
[15:51] (951.88s)
file. And what we're going to do is
[15:54] (954.80s)
we're actually going to go ahead. I I
[15:57] (957.12s)
would generally do this through two and
[15:58] (958.80s)
open up uh Google AI Studio and run it
[16:00] (960.96s)
through, in this case, one of the Gemini
[16:03] (963.36s)
2.5 models at time of recording. But
[16:05] (965.92s)
whatever if if you're looking listening
[16:07] (967.60s)
and viewing this in the future, you
[16:09] (969.36s)
could use uh whatever the best model at
[16:11] (971.60s)
the time. Claude's still going to be
[16:13] (973.04s)
great for this. So, we're going to say
[16:14] (974.96s)
I'm going to give
[16:16] (976.20s)
it the PRD
[16:18] (978.92s)
file. So, let's
[16:22] (982.52s)
docs and let's actually we could
[16:25] (985.28s)
probably Yeah. So, we'll do PRD. All
[16:28] (988.24s)
right. Please review the
[16:34] (994.76s)
existing PRD draft
[16:40] (1000.68s)
file. Actually, I could probably type
[16:42] (1002.64s)
this or I could probably just say
[16:44] (1004.52s)
this. Once you have the file in your
[16:47] (1007.36s)
context, please write it as an output
[16:49] (1009.84s)
file in the docs directory called
[16:52] (1012.84s)
prd-final.md, which should be a fully
[16:55] (1015.04s)
compliant project requirement document
[16:57] (1017.84s)
for engineering. Please note, we are not
[17:00] (1020.00s)
doing the engineering. We just want to
[17:01] (1021.68s)
do the planning of this exercise. Please
[17:05] (1025.04s)
ultra think about this and then do your
[17:08] (1028.24s)
output.
[17:11] (1031.04s)
Okay, perfect. So, while this is going,
[17:13] (1033.04s)
a couple things we said in there. So, we
[17:15] (1035.12s)
used the keyword ultrathink. Ultraink is
[17:18] (1038.56s)
super important. Um, the reason that we
[17:21] (1041.44s)
want to use ultrathink is from an
[17:24] (1044.16s)
anthropic perspective, which is the
[17:26] (1046.48s)
parent company of Claude. Um, they
[17:29] (1049.12s)
actually talk about this where they'll
[17:30] (1050.80s)
actually use keywords for hard, ultra
[17:32] (1052.80s)
hard, um, or think hard, think harder,
[17:37] (1057.36s)
and think ultra hard for that. So, um,
[17:40] (1060.40s)
kind of on the spot on this one. Let's
[17:42] (1062.24s)
see. Uh, ultra hard. So, if that comes
[17:46] (1066.08s)
through, I think it's this article here.
[17:48] (1068.08s)
I could actually use OpenAI as well to
[17:49] (1069.92s)
be able to find this, which is what I
[17:51] (1071.28s)
would normally do for that. Um, but
[17:53] (1073.44s)
there should be something in here around
[17:56] (1076.60s)
hard or hard. Okay, kind of going on
[18:00] (1080.64s)
there, but there is an article that we
[18:02] (1082.00s)
could run to be able to grab that. But
[18:03] (1083.84s)
the idea there
[18:05] (1085.32s)
is those keywords matter. Um, so you're
[18:09] (1089.12s)
going to see that this review task is
[18:11] (1091.20s)
going to take um, arguably significantly
[18:14] (1094.16s)
longer because it's going to go through
[18:16] (1096.08s)
and it's going to actually look for some
[18:18] (1098.24s)
of the different um, it's going to go
[18:20] (1100.64s)
through and it's going to take its time
[18:21] (1101.84s)
to be able to do some of this thorough
[18:23] (1103.48s)
research. So, what we can do while we're
[18:25] (1105.92s)
waiting is let's do let's actually build
[18:29] (1109.88s)
out for Google AI Studio.
[18:34] (1114.56s)
We could do a similar one and have it
[18:36] (1116.08s)
compare the results. Be an interesting
[18:38] (1118.40s)
little task here. So, let's see.
[18:41] (1121.80s)
Um, pull this over while we do that. And
[18:45] (1125.60s)
I'm going to give it its own
[18:49] (1129.72s)
role. I'd like you to be a senior
[18:52] (1132.40s)
product manager for a very large SAS
[18:56] (1136.40s)
company. Your primary job is going to be
[19:00] (1140.32s)
the best in the industry at writing
[19:02] (1142.96s)
project requirement documents. The
[19:05] (1145.68s)
documents should be to a level of detail
[19:08] (1148.88s)
with task level
[19:11] (1151.96s)
breakdown. Okay. So then I can then say
[19:15] (1155.20s)
objective.
[19:20] (1160.24s)
Please review the draft PRD file that
[19:24] (1164.24s)
will be pasted below and rewrite it and
[19:27] (1167.84s)
update it using grounding with Google
[19:30] (1170.64s)
search for anything where you are unsure
[19:33] (1173.20s)
of the best practices or way to
[19:34] (1174.88s)
implement this
[19:36] (1176.52s)
solution. Okay. And then we're going to
[19:38] (1178.64s)
put under this we're going to give it
[19:40] (1180.40s)
the PRD draft. Okay. So on the PRD
[19:44] (1184.88s)
draft, we can then go through. We're
[19:47] (1187.92s)
actually going to take the file itself.
[19:49] (1189.68s)
So we have a fully
[19:51] (1191.64s)
baked item here. Uh yes, I want to write
[19:55] (1195.92s)
it and I don't want them to ask me
[19:58] (1198.00s)
again. Just write the file. Okay,
[20:00] (1200.40s)
perfect. So now we have an executive
[20:02] (1202.40s)
summary. So see how as long as we just
[20:05] (1205.04s)
give it the context. Now we can do
[20:06] (1206.56s)
several iterations of this.
[20:10] (1210.08s)
So we have pro provides an a unified API
[20:14] (1214.08s)
experience. Okay,
[20:16] (1216.20s)
great. Um, excellent. The vision, the
[20:20] (1220.00s)
goals, success criteria. Okay, that's
[20:23] (1223.12s)
fine. Functional requirements. Perfect.
[20:25] (1225.44s)
It shows the different formats that we
[20:27] (1227.20s)
have. Um, retailer
[20:29] (1229.72s)
identifiers. Okay. Uh, let's see.
[20:32] (1232.56s)
Response specification. Good deal.
[20:34] (1234.96s)
Business
[20:35] (1235.88s)
logic. All right. This is pretty way
[20:38] (1238.80s)
more thorough than what I originally
[20:40] (1240.32s)
had. Here we go. API standards opa the
[20:43] (1243.04s)
open API
[20:44] (1244.28s)
specification. It grabbed our languages.
[20:47] (1247.16s)
Beautiful. All right. Testing
[20:49] (1249.28s)
frameworks. Excellent. Compliant. All
[20:51] (1251.92s)
right. So, this is pretty good, right?
[20:54] (1254.32s)
So now I can take
[20:57] (1257.24s)
this and at the same time I can drop
[21:01] (1261.32s)
draft over here. And let's just make
[21:03] (1263.92s)
sure we give it
[21:05] (1265.16s)
a output format so it
[21:08] (1268.44s)
knows. Please make sure to create the
[21:11] (1271.44s)
PRD file as markdown. Render it as
[21:15] (1275.44s)
markdown. So I'll have to tweak that a
[21:17] (1277.44s)
little bit.
[21:19] (1279.32s)
Right. I'll just say P file as markdown.
[21:22] (1282.64s)
Right. Okay. Perfect. Actually, I want
[21:25] (1285.60s)
to stop this. I just made a mistake. I
[21:27] (1287.92s)
want to ground it. Oops. So let's do
[21:32] (1292.72s)
grab the whole thing
[21:34] (1294.76s)
again and I'm going to ground it with
[21:37] (1297.68s)
Google search which is going to give it
[21:39] (1299.20s)
the ability
[21:41] (1301.32s)
to leverage that for best practices and
[21:45] (1305.28s)
we'll let that kick off and do its
[21:46] (1306.72s)
thing. So it's going to do a revision of
[21:48] (1308.80s)
it. Um,
[21:51] (1311.80s)
okay. See
[21:56] (1316.44s)
here. All right. So that's going to take
[21:58] (1318.40s)
a little bit of time here. So now we can
[22:00] (1320.08s)
go ahead. Let's just organize our
[22:02] (1322.88s)
project
[22:04] (1324.36s)
here. Um, what can we do in the
[22:06] (1326.72s)
meantime? We can set up a Git
[22:09] (1329.72s)
repository. So,
[22:12] (1332.52s)
GitHub, I'm going to create a new
[22:16] (1336.04s)
repository. We're going to call
[22:21] (1341.08s)
it Rev ROI MCP. Okay. We will make this
[22:26] (1346.08s)
one public and we'll create the repo.
[22:34] (1354.36s)
And couple things we can
[22:38] (1358.68s)
do. All right. So we'll do get a
[22:43] (1363.80s)
net get dot which is going to put
[22:46] (1366.80s)
everything in the directory. Get
[22:48] (1368.44s)
commit-m message commit. So we're
[22:51] (1371.76s)
putting this into version control. So we
[22:54] (1374.44s)
it. We will set the branch details.
[23:03] (1383.48s)
Okay, check the status and we are in
[23:07] (1387.84s)
business. So now there should
[23:10] (1390.12s)
be a repository that is now out
[23:15] (1395.32s)
on GitHub. So we have that. All
[23:21] (1401.96s)
right. All right. So if we pull over AI
[23:24] (1404.56s)
Studio, it's still doing its thing over
[23:26] (1406.16s)
here. Um, so we should have an answer to
[23:28] (1408.80s)
this one very shortly. And the next step
[23:31] (1411.76s)
that we're going to do is let's set
[23:39] (1419.88s)
up let's set up our task breakdowns here
[23:42] (1422.88s)
for each of these. So I don't think we
[23:45] (1425.04s)
need to do the folders because we'll
[23:46] (1426.96s)
just let it set itself up.
[23:57] (1437.68s)
All right, it's almost done. Let's see
[23:59] (1439.52s)
what the prompts look like here.
[24:01] (1441.04s)
Maintenance and support. So, this thing
[24:02] (1442.72s)
is very
[24:08] (1448.04s)
thorough, project requirements, some of
[24:12] (1452.20s)
goals. Okay, excellent. End
[24:17] (1457.80s)
points. See what some of the t See, they
[24:20] (1460.00s)
want me to do a lot more than I want for
[24:21] (1461.36s)
this one.
[24:24] (1464.08s)
This would be really good for a full
[24:27] (1467.04s)
production, but we're not going to need
[24:28] (1468.64s)
this for for this particular use case.
[24:32] (1472.12s)
Okay, so this is pretty good here. So,
[24:35] (1475.12s)
let's do
[24:37] (1477.12s)
um we'll move this
[24:39] (1479.16s)
over. Created it. Perfect. Okay, so now
[24:41] (1481.84s)
we're just going to prompt it. All
[24:43] (1483.44s)
right, perfect.
[24:46] (1486.32s)
Now that we have the full
[24:51] (1491.24s)
[Music]
[24:54] (1494.36s)
inpdfinal, please fully review it and
[25:00] (1500.28s)
start the engineering
[25:03] (1503.72s)
work. Before you do, what tasks are you
[25:08] (1508.32s)
planning to execute? Because what we
[25:11] (1511.12s)
want to do a couple best practices with
[25:13] (1513.28s)
some of these items. You want to
[25:15] (1515.04s)
separate your prompt out to give them
[25:17] (1517.52s)
planning
[25:18] (1518.68s)
tasks and then check it with what's
[25:21] (1521.76s)
known as human in the loop. So you want
[25:23] (1523.12s)
to check the responses that come through
[25:25] (1525.20s)
and then you'll do engineering task by
[25:27] (1527.84s)
then saying okay now you're an engineer
[25:29] (1529.36s)
go ahead and and implement this. So this
[25:31] (1531.52s)
is good right? So we have now to-dos
[25:33] (1533.04s)
it's going to create the specification
[25:34] (1534.40s)
with the structures define gift card
[25:36] (1536.84s)
endpoints define the cashback add error
[25:39] (1539.92s)
response definitions. Okay perfect.
[25:43] (1543.32s)
So it looks like it's already kicking
[25:46] (1546.68s)
off. Docs open. So it's streaming the
[25:49] (1549.12s)
input. Okay. So it's going to start
[25:50] (1550.32s)
doing its thing. I generally like to to
[25:52] (1552.64s)
stop it completely at planning and but
[25:55] (1555.52s)
and have those two distinct steps just
[25:57] (1557.36s)
to make sure. In this case, it was
[25:58] (1558.96s)
pretty much exactly what I wanted to do
[26:00] (1560.88s)
anyway. So I'm just going to let it keep
[26:02] (1562.08s)
doing its thing. Um as you go through
[26:05] (1565.76s)
some of these items, want to keep in
[26:07] (1567.76s)
mind there's different types of plans
[26:09] (1569.36s)
with Claude um that we're using Claude
[26:11] (1571.76s)
code. You can stream it on a per cost
[26:14] (1574.16s)
basis with the API tokens or application
[26:17] (1577.04s)
programming interface or you can use at
[26:19] (1579.12s)
time of recording. Uh you can use the
[26:21] (1581.92s)
max tiers. They come in two different
[26:23] (1583.68s)
ones. There's a $100 a month plan and
[26:27] (1587.12s)
there's a $200 a month plan and it's
[26:29] (1589.04s)
just the amount of consumption that you
[26:30] (1590.64s)
can use. Um basically as much as up to
[26:34] (1594.64s)
the point with what your threshold is.
[26:36] (1596.76s)
The cheat code with that is basically
[26:39] (1599.68s)
once you use it up, it resets every five
[26:41] (1601.68s)
hours. So if you know you're going to be
[26:43] (1603.76s)
away for a period of time, it starts
[26:46] (1606.08s)
from the first time that you use it. So
[26:48] (1608.72s)
you want to make sure your coding
[26:49] (1609.92s)
sessions you're maximizing them and then
[26:51] (1611.68s)
if when you find a nice logical break or
[26:54] (1614.00s)
you want to or you're going to be going
[26:55] (1615.44s)
to do something else or you're going to
[26:56] (1616.80s)
eat or whatever it may be set up your
[26:59] (1619.04s)
your slot so that way you know you can
[27:00] (1620.72s)
maximize the full scope of in this case
[27:03] (1623.44s)
the opus model followed by u the sonnet
[27:06] (1626.72s)
model. It will use opus is a more
[27:09] (1629.12s)
complex model um so those credits will
[27:12] (1632.80s)
use up faster and then sonnet is a
[27:14] (1634.72s)
faster model on those. Now, what you'll
[27:17] (1637.60s)
see on some of these things is it under
[27:19] (1639.68s)
the covers, it's doing a series of
[27:21] (1641.52s)
agents calls or tool calls. So, if u if
[27:25] (1645.76s)
something errors out, it'll go ahead and
[27:27] (1647.68s)
try to retry on the files that they
[27:32] (1652.12s)
were. All right. So, if we do let's see
[27:34] (1654.72s)
if it's done anything yet. Nothing yet
[27:36] (1656.88s)
that has been written to new files.
[27:38] (1658.80s)
Still doing its its thought process here
[27:41] (1661.92s)
for each of them. Now what we'll end up
[27:44] (1664.68s)
using once we have the open API
[27:49] (1669.64s)
specification is there's a
[27:52] (1672.20s)
tool that we can use to
[27:56] (1676.76s)
convert
[27:58] (1678.92s)
a spec file. So, Swagger open API
[28:02] (1682.24s)
specification. We'll end up producing
[28:04] (1684.24s)
this and then it's going to generate us
[28:06] (1686.48s)
the output um which is going to be super
[28:09] (1689.20s)
awesome because it's going to fasttrack
[28:10] (1690.72s)
us to be able to get our our minimal
[28:12] (1692.80s)
viable product of the MCP server um
[28:17] (1697.04s)
coded out so we can take it through for
[28:18] (1698.40s)
an end to end test to test it out. All
[28:21] (1701.04s)
right. So, let's see here. We're still
[28:23] (1703.04s)
waiting on this to to go
[28:28] (1708.68s)
through. Couple other ways that we could
[28:30] (1710.96s)
go about implementing this. We're using
[28:32] (1712.48s)
cloud code right now. I'm going to move
[28:33] (1713.92s)
this over so you kind of see it. But you
[28:36] (1716.16s)
can also subscribe to cursor and uh what
[28:38] (1718.80s)
cursor allow you to do if we pull that
[28:40] (1720.64s)
menu out is it also has different types
[28:43] (1723.44s)
of agent modes you can use, the
[28:45] (1725.28s)
different models um thresholds there.
[28:47] (1727.92s)
And this is just a fantastic editor all
[28:50] (1730.32s)
in all. um being a developer I generally
[28:53] (1733.28s)
like the terminal based experiences but
[28:55] (1735.52s)
using cursor and being able to um have
[28:59] (1739.20s)
this experience there as well is great.
[29:01] (1741.04s)
So one thing you'll notice as you kind
[29:03] (1743.28s)
of go through this journey with these AI
[29:04] (1744.80s)
tools is use the right one for the job
[29:06] (1746.88s)
and in some cases there's multiple that
[29:09] (1749.04s)
could do the job as well.
[29:10] (1750.92s)
So let's see here. All right. So it
[29:14] (1754.08s)
started the basic structure. Um let's
[29:16] (1756.88s)
see what has it done. So it be okay. Did
[29:19] (1759.20s)
it create the spec yet? It did.
[29:21] (1761.60s)
Excellent. So, let's take a peek
[29:23] (1763.96s)
here. So, we got a support page. It's
[29:26] (1766.96s)
giving us a license. I like its version
[29:29] (1769.20s)
it chose. Provides unified API interface
[29:32] (1772.48s)
for discounted gift cards and cash back.
[29:34] (1774.60s)
Excellent. Um, all right. We can see
[29:38] (1778.16s)
which end points are there. That's good.
[29:42] (1782.84s)
offers schema definitions. Okay, cool.
[29:45] (1785.68s)
So, we can view this real quick. So to
[29:48] (1788.96s)
be able to do that, we can use what is
[29:52] (1792.08s)
known as the swagger editor and swagger
[29:56] (1796.32s)
editor allows to quickly see
[30:01] (1801.00s)
that. Okay, let me just grab a file
[30:12] (1812.60s)
here. Okay, I didn't like it at the
[30:15] (1815.44s)
component level. Interesting. Okay,
[30:17] (1817.76s)
which component? But you can
[30:22] (1822.84s)
uh There we go. Did I fix it
[30:27] (1827.32s)
for what is it saying
[30:29] (1829.80s)
here? Duplicate mapping. Why is it
[30:33] (1833.36s)
picking up on
[30:35] (1835.48s)
Keepa? Do we have anything in there for
[30:38] (1838.52s)
Keepa? Is it just a stale
[30:41] (1841.40s)
session? Um let's try it again with an
[30:44] (1844.96s)
incognito window. All
[30:48] (1848.32s)
right. So, let's do swagger
[31:00] (1860.44s)
editor.
[31:06] (1866.28s)
Okay. So, 419. Okay. So, it doesn't
[31:10] (1870.84s)
like duplicate key mapping. All right.
[31:13] (1873.76s)
Well, we're going to take this error
[31:16] (1876.88s)
And let's go back over here and
[31:21] (1881.08s)
say, okay, great, but we got an error on
[31:28] (1888.04s)
the open API. So, you want to give
[31:30] (1890.56s)
context to the files so that way it
[31:32] (1892.56s)
knows what to work
[31:35] (1895.88s)
on. Here's the error that we received.
[31:40] (1900.32s)
And we'll paste it in. So, now it's
[31:42] (1902.56s)
going to go through and it's going to
[31:43] (1903.76s)
start thinking about it, right? So all I
[31:45] (1905.44s)
did there is I used the at symbol and
[31:48] (1908.08s)
that allowed me to be able to see the
[31:49] (1909.76s)
context of the project that we're
[31:52] (1912.56s)
working
[31:53] (1913.80s)
in. So it adds it into its context
[31:56] (1916.40s)
window as notice that hey this is the
[31:57] (1917.92s)
primary f file that's there. All right.
[32:00] (1920.32s)
So it did make a change. Okay, great. So
[32:03] (1923.80s)
let's go through and grab it
[32:06] (1926.44s)
again and let's pull
[32:11] (1931.08s)
up a swagger window.
[32:23] (1943.28s)
Oh, yeah. Yeah. All these goodies. Okay.
[32:25] (1945.44s)
So, let's remove it. Let it think. Drop
[32:28] (1948.48s)
it in. Beautiful. All right. So, now we
[32:32] (1952.28s)
have a fully
[32:35] (1955.72s)
compliant. Uh, let's see here. Let's
[32:38] (1958.24s)
open these up. Uh mostly why does it not
[32:42] (1962.24s)
have endpoints
[32:45] (1965.40s)
for only has a get
[32:50] (1970.52s)
endpoint. So endpoints for different
[32:57] (1977.80s)
see doesn't feel right there. Uh let me
[33:05] (1985.56s)
it do a screenshot actually.
[33:09] (1989.44s)
So if we do a screenshot of this, that's
[33:12] (1992.00s)
a cool feature we can
[33:14] (1994.28s)
try. All right.
[33:18] (1998.92s)
So I noticed there are no end
[33:26] (2006.92s)
points in the open API
[33:30] (2010.44s)
specification for gift cards and cash
[33:37] (2017.52s)
And there is only a default slashend
[33:40] (2020.84s)
point. Please see the
[33:44] (2024.12s)
attached screenshot as an
[33:50] (2030.20s)
example. Oops. Let me stop it. And to
[33:57] (2037.24s)
control. There we go.
[34:07] (2047.80s)
Okay. So, we'll let this do its
[34:22] (2062.44s)
thing.
[34:25] (2065.48s)
Okay. So, it's thinking right now.
[34:35] (2075.68s)
While we're waiting on that, let's see
[34:37] (2077.28s)
if we could try to figure it out
[34:38] (2078.64s)
ourselves while it's doing its thing.
[34:41] (2081.04s)
What did we miss
[34:43] (2083.80s)
there? Those
[34:46] (2086.04s)
are get
[34:53] (2093.80s)
offers. Okay.
[34:58] (2098.16s)
change the different schemas on
[35:02] (2102.44s)
these. Okay, we successfully
[35:04] (2104.72s)
restructured a gift cards. Okay, that's
[35:07] (2107.20s)
more in line. Let's see what this looks
[35:10] (2110.52s)
like. Close it and reopen the file.
[35:13] (2113.04s)
Let's just see status. Okay, we do have
[35:15] (2115.68s)
a change
[35:18] (2118.92s)
there. Let's try closing this
[35:23] (2123.08s)
out. Reopening it.
[35:27] (2127.36s)
Okay. Excellent. That's more in line
[35:30] (2130.72s)
with what we want. Okay. Awesome. All
[35:33] (2133.52s)
right.
[35:34] (2134.52s)
Now, now that we have fully
[35:40] (2140.04s)
compliant, we're going to commit that um
[35:44] (2144.00s)
created open API spec. So, we'll commit
[35:48] (2148.84s)
that. All right. So, we have those files
[35:51] (2151.28s)
there. Um, now let's do I don't
[35:55] (2155.80s)
want guess there technically isn't
[35:58] (2158.08s)
anything crazy in there. Let's do a doc
[36:06] (2166.68s)
ignore just files to to not look
[36:10] (2170.16s)
through. Let's do I don't need that to
[36:12] (2172.88s)
be in there necessarily.
[36:20] (2180.92s)
Okay. So, now we have that. So, here's
[36:23] (2183.36s)
here's where the magic kind of comes
[36:25] (2185.12s)
into play. So, what we can do next is
[36:28] (2188.64s)
I'm actually just going to copy this to
[36:30] (2190.96s)
I'm going to copy
[36:33] (2193.20s)
um just because it's just easier for me
[36:35] (2195.84s)
to to put this in. I'm going to copy the
[36:38] (2198.16s)
open API spec to my downloads folder.
[36:42] (2202.96s)
And then we're going to head over here
[36:46] (2206.08s)
and we're going to do a browse.
[36:51] (2211.84s)
Okay, hit open on that and we are going
[36:54] (2214.88s)
to generate. Great. So
[36:59] (2219.40s)
now we
[37:04] (2224.04s)
have the core code. So can I just make
[37:07] (2227.76s)
this core code
[37:12] (2232.28s)
main.ts? Okay, so a main.ts file. I
[37:15] (2235.04s)
probably have to actually build it.
[37:16] (2236.32s)
Okay, let's do
[37:21] (2241.88s)
Um, okay, great.
[37:25] (2245.40s)
Um, what's next on the
[37:27] (2247.80s)
docket?
[37:29] (2249.40s)
Um, attached below is the
[37:35] (2255.64s)
TypeScript
[37:38] (2258.84s)
output to
[37:41] (2261.32s)
converting the open API the doc. So it
[37:46] (2266.00s)
has context based on what we learn,
[37:48] (2268.44s)
right? Uh docs open API
[37:52] (2272.20s)
spec into a type script file for the
[37:58] (2278.76s)
FCP. Oh Hold on. Um let's paste
[38:02] (2282.64s)
the content in. There we go.
[38:09] (2289.44s)
Now, what I was thinking about doing
[38:10] (2290.96s)
there is I was going to just create
[38:13] (2293.32s)
the actual TypeScript project, but I'm
[38:16] (2296.16s)
going to let staying in line with what
[38:17] (2297.84s)
we want to do here, right? We're moving
[38:19] (2299.52s)
out of the direction of being a
[38:22] (2302.28s)
developer and we're facilitating that
[38:24] (2304.88s)
role of being the technical leader
[38:27] (2307.20s)
that's driving the conversation,
[38:29] (2309.12s)
allowing the AI to do what it needs. So,
[38:31] (2311.84s)
we're going to give it
[38:33] (2313.08s)
permission to create files. So, it's
[38:35] (2315.76s)
going to create the file structure. It's
[38:37] (2317.76s)
going to initialize our text stack which
[38:40] (2320.56s)
will be node and package JSON and any
[38:44] (2324.00s)
required dependencies that it needs. And
[38:46] (2326.96s)
ironically, if we would have looked over
[38:48] (2328.96s)
here, we would
[38:54] (2334.60s)
instructions on how to do this, right?
[38:57] (2337.44s)
So, I could
[38:59] (2339.88s)
actually instruct
[39:02] (2342.20s)
it by giving it this
[39:05] (2345.96s)
context. I'm going to add this so that
[39:08] (2348.00s)
way it has it once it gets done
[39:11] (2351.72s)
here. Let's see. So, it's writing the
[39:16] (2356.44s)
files. All
[39:18] (2358.36s)
right. Implement and generate the
[39:22] (2362.28s)
code. So, source index. So, it's not
[39:25] (2365.04s)
even going to use main, which is
[39:26] (2366.80s)
perfectly
[39:30] (2370.60s)
fine. I'm just going to delete that
[39:32] (2372.80s)
since we'll let it do its thing.
[39:37] (2377.12s)
And I'm going to give it a docs folder.
[39:39] (2379.04s)
And I'm going to call
[39:42] (2382.76s)
this call this spec
[39:49] (2389.96s)
markdown. And we're going to say um I'm
[39:52] (2392.88s)
going to call this
[39:54] (2394.52s)
background information to convert open
[39:58] (2398.88s)
API specification specs to MCP servers.
[40:06] (2406.80s)
Right. And then we're going to call
[40:10] (2410.92s)
this documentation. And I'm sure anybody
[40:14] (2414.00s)
that's really good with this stuff is
[40:15] (2415.84s)
going to say, "Hey, Nick, you could have
[40:18] (2418.32s)
done this a million different ways, but
[40:19] (2419.68s)
this is just going to be how we're going
[40:21] (2421.72s)
do do this on the spot."
[40:25] (2425.68s)
Because what'll happen then is once this
[40:27] (2427.68s)
finishes now I can pass that docs folder
[40:30] (2430.80s)
that specs to MCP just like like we've
[40:33] (2433.12s)
been doing I don't have to write the
[40:34] (2434.64s)
prompt out. I can just drop it in there.
[40:36] (2436.32s)
So anytime you have an opportunity to do
[40:39] (2439.84s)
your planning you're going to spend the
[40:41] (2441.36s)
majority of the time doing your planning
[40:43] (2443.52s)
and the coding effort you're outsourcing
[40:47] (2447.20s)
to your your AI assistant. So and that's
[40:51] (2451.44s)
kind of where this is going, right? I've
[40:53] (2453.28s)
been asked a few times around, hey,
[40:55] (2455.12s)
like, okay, well, you're a developer. Is
[40:57] (2457.36s)
AI is going to come and you're going to
[40:58] (2458.56s)
lose your job? Well, yes, the
[41:01] (2461.12s)
development of writing the actual lines
[41:03] (2463.04s)
of code are going to are going to be
[41:05] (2465.76s)
outsourced um to an AI an AI capability.
[41:10] (2470.00s)
But at the end of the day, the systems
[41:11] (2471.68s)
mindset is the biggest thing for this.
[41:13] (2473.84s)
So now I can apply that systems mindset
[41:16] (2476.96s)
and in this use case, right, we're
[41:18] (2478.56s)
looking for great deals on the internet.
[41:20] (2480.00s)
Like that's ultimately what this is for.
[41:22] (2482.08s)
It's not necessary to write the code.
[41:23] (2483.20s)
It's, hey, how do I find better deals?
[41:25] (2485.28s)
So, this is just a way for to be able to
[41:28] (2488.08s)
make that a more efficient process to
[41:30] (2490.40s)
automate things that normally we would
[41:32] (2492.16s)
be doing
[41:33] (2493.16s)
manually. All right. So, it looks like
[41:34] (2494.96s)
it's doing an update to a readme file
[41:36] (2496.56s)
next. So, create the readme, install the
[41:38] (2498.56s)
required dependencies. Excellent. So,
[41:41] (2501.68s)
we'll see how this how this ends up
[41:46] (2506.44s)
going and we will go from there.
[41:53] (2513.28s)
Ultimately, what we'll do is we'll try
[41:54] (2514.80s)
to build this as a package that we can
[41:56] (2516.32s)
deploy out so you can install it
[42:03] (2523.40s)
yourselves. I'm curious to see what it
[42:05] (2525.60s)
put together here so far. So, we have
[42:08] (2528.92s)
index file, some
[42:13] (2533.24s)
types.
[42:19] (2539.96s)
Sure. Continue
[42:26] (2546.36s)
on. So it read that it already it should
[42:28] (2548.88s)
have already discovered that we already
[42:30] (2550.48s)
had the get ignore. It's updating it.
[42:33] (2553.12s)
Okay, great. So now we have a way better
[42:35] (2555.20s)
file for that.
[42:37] (2557.88s)
Um let's
[42:44] (2564.36s)
do Okay, great. So we'll get the
[42:46] (2566.48s)
dependencies installed.
[42:51] (2571.36s)
And then what I want to do after this is
[42:52] (2572.80s)
just have it review it against the
[42:54] (2574.96s)
specta MCP documentation we had. Another
[42:59] (2579.04s)
way we could have done that too is we
[43:00] (2580.64s)
could have installed use
[43:04] (2584.04s)
um claude MCP which will error out and
[43:08] (2588.08s)
say oh I want to do an add to desktop.
[43:11] (2591.68s)
So I can do
[43:14] (2594.20s)
claude MCP and then it should prompt me
[43:17] (2597.92s)
for which ones I want to
[43:20] (2600.60s)
add. So let's
[43:24] (2604.12s)
do I don't want to do keep on this one.
[43:26] (2606.96s)
I don't want to do
[43:31] (2611.64s)
Um I don't need Taskmaster right now but
[43:35] (2615.68s)
context 7 is great for
[43:37] (2617.72s)
documentation. So we can click on that.
[43:40] (2620.16s)
So now our local configuration will have
[43:42] (2622.08s)
MCP servers configured that
[43:45] (2625.08s)
have type of settings files are here.
[43:49] (2629.48s)
Okay. All right. Perfect. All right. So
[43:51] (2631.92s)
complete the installation. So now it
[43:53] (2633.44s)
gave me an output.
[43:55] (2635.40s)
Right. I successfully
[43:58] (2638.92s)
implemented the work blah blah blah
[44:01] (2641.60s)
created the project set the package
[44:04] (2644.32s)
implemented four tools right. So I can
[44:07] (2647.56s)
get really I care about two of them.
[44:10] (2650.24s)
Getting the gift card rates and getting
[44:12] (2652.16s)
the cash back
[44:14] (2654.20s)
rates data. That's fine. Okay. So I have
[44:18] (2658.40s)
a little bit of work to do here. I need
[44:19] (2659.92s)
to run. Let's see if this works.
[44:22] (2662.04s)
npmi actually before I do that let's
[44:25] (2665.04s)
actually ask it. So before because we
[44:28] (2668.16s)
want a module. So before we do
[44:33] (2673.48s)
the installation
[44:37] (2677.00s)
steps, please review
[44:41] (2681.96s)
the spec
[44:44] (2684.76s)
file and see if there are any other
[44:49] (2689.68s)
changes we should make. Please think
[44:54] (2694.64s)
hard about this. I'm giving it just a
[44:57] (2697.68s)
little bit of extra on there. Um, a
[45:00] (2700.40s)
little extra horsepower with the think
[45:01] (2701.92s)
hard just because ideally I should have
[45:04] (2704.48s)
did that from the beginning, right?
[45:06] (2706.24s)
Hindsight's 2020. I should have followed
[45:07] (2707.92s)
the instruction and did a um npm and nit
[45:11] (2711.28s)
and set set it as a as a module type
[45:15] (2715.04s)
first. So, which is what we're showing
[45:17] (2717.76s)
in this file here. So, I'm going to see
[45:20] (2720.96s)
if Claude's able to pick that up, look
[45:22] (2722.96s)
at the docs, and say, "Oh, by the way,
[45:25] (2725.28s)
all right, you're an idiot. You should
[45:26] (2726.64s)
have did this ahead of time." Yeah. So,
[45:28] (2728.88s)
add tsx dependency for direct. Um, so
[45:32] (2732.96s)
what this is do the TypeScript exec
[45:34] (2734.88s)
executable file. So, this will allow us
[45:36] (2736.56s)
to actually run it as a package. So,
[45:38] (2738.40s)
that way we can actually deploy this
[45:39] (2739.60s)
out. So, you don't need to know all
[45:40] (2740.72s)
this. You just need to install
[45:42] (2742.52s)
it. Um, okay. It's going to create a
[45:45] (2745.12s)
main, which is what I thought. Okay.
[45:49] (2749.60s)
Uh let's see
[45:52] (2752.44s)
here. Create main and root as entry
[45:55] (2755.36s)
point. This will be interesting to see
[45:57] (2757.28s)
how it does
[46:01] (2761.24s)
that. Okay. Just importing
[46:04] (2764.12s)
it. That
[46:10] (2770.92s)
works. All right. While this is doing
[46:12] (2772.96s)
its thing, there's a couple steps we can
[46:14] (2774.48s)
take here. So, we're going to go into
[46:16] (2776.44s)
Claude and we can start prepping for our
[46:19] (2779.92s)
actual setup. The whole reason we did
[46:21] (2781.76s)
this, right? So, in Claude, what you're
[46:23] (2783.44s)
going to do is you're going to
[46:26] (2786.20s)
cla in settings, there's going to be a
[46:28] (2788.32s)
developer panel. We're going to click
[46:30] (2790.16s)
edit config. And this is where we can
[46:31] (2791.92s)
actually load in the various MCP servers
[46:34] (2794.16s)
or the tools, right? We talked about the
[46:36] (2796.24s)
it's the it's the USB port, right? It's
[46:38] (2798.64s)
the way that we connect all of these
[46:40] (2800.08s)
things together. Um, so AI can can make
[46:43] (2803.20s)
it even more useful. So, we'll hit edit
[46:45] (2805.96s)
config and we're going to open it in our
[46:49] (2809.52s)
cursor file
[46:51] (2811.00s)
here. And what we're going to do is I'm
[46:53] (2813.92s)
going to take this off the screen for a
[46:56] (2816.16s)
second. And we're going to
[47:01] (2821.28s)
uh let's do this.
[47:03] (2823.40s)
Take play right and make sure there
[47:05] (2825.44s)
isn't anything in here I need to worry
[47:09] (2829.72s)
about. All
[47:11] (2831.48s)
right. All
[47:28] (2848.88s)
right. So, we pull this back over
[47:33] (2853.16s)
now. All right. So, we're going to add
[47:35] (2855.28s)
our tool in here.
[47:38] (2858.76s)
So, based on the example, we should
[47:42] (2862.08s)
We're gonna call this what? Rev ROI.
[47:46] (2866.76s)
see. Let's call
[47:49] (2869.24s)
this Rev ROI. Rev ROI. And the docs on
[47:53] (2873.44s)
Claude are really good about just
[47:54] (2874.72s)
explain how to do this. So, it's going
[47:56] (2876.24s)
to be an NPX package path full path to
[48:00] (2880.72s)
the repo. So, we are in what?
[48:04] (2884.36s)
PWD projects
[48:06] (2886.44s)
folder. So, by the time you have this,
[48:08] (2888.88s)
we're doing this live, right? We'll
[48:10] (2890.72s)
probably have this on a package manager
[48:12] (2892.64s)
index. So all you'd have to do is
[48:14] (2894.16s)
something like this with some of these
[48:15] (2895.92s)
other ones that have been
[48:17] (2897.56s)
published. And we will save it. And if
[48:20] (2900.72s)
we did it
[48:23] (2903.08s)
right, we should then be able to close
[48:27] (2907.24s)
Claude. And this is the drum roll
[48:29] (2909.60s)
because you have to close it anytime you
[48:30] (2910.88s)
change it. And then we find out did we
[48:32] (2912.64s)
break it or not. Let's find out.
[48:36] (2916.84s)
Okay. ROI server disconnected.
[48:40] (2920.76s)
[Music]
[48:44] (2924.92s)
Interesting.
[48:46] (2926.84s)
Okay. All right. So, we do need to do
[48:49] (2929.52s)
some troubleshooting on this. And then
[48:51] (2931.60s)
if we look at the
[48:59] (2939.56s)
log, let's see. Rev ROI
[49:03] (2943.32s)
log. Look at the log file for this. Why
[49:06] (2946.24s)
did it fail?
[49:09] (2949.28s)
Oh, because we didn't install it yet.
[49:10] (2950.88s)
Okay, so we had we do actually do need
[49:12] (2952.48s)
to do the setup first. All right. Um, so
[49:17] (2957.20s)
that probably be resolved if I just
[49:18] (2958.88s)
read. All right, npm install. npm
[49:22] (2962.72s)
install or
[49:24] (2964.44s)
npmi would have worked. Okay, because in
[49:28] (2968.40s)
here there's probably a whole bunch of
[49:30] (2970.00s)
dependencies that we did not install
[49:39] (2979.12s)
Okay, let's find out if we did it
[49:42] (2982.20s)
right. Let's try doing the same thing.
[49:44] (2984.48s)
So, we're going to close
[49:47] (2987.32s)
Quad. We are going to reopen
[49:51] (2991.88s)
it. Drum
[49:53] (2993.88s)
roll. Still broken. Open MP settings.
[49:58] (2998.24s)
Let's see.
[50:04] (3004.26s)
[Music]
[50:10] (3010.44s)
Okay. What is
[50:14] (3014.28s)
different? Looks like it would try to
[50:25] (3025.00s)
connect. Exiting early. If you're
[50:27] (3027.28s)
developing the server, you can add
[50:29] (3029.36s)
output to standard out. Okay. Well, how
[50:30] (3030.96s)
about we just do this? Why don't we just
[50:32] (3032.48s)
add the log into here? Was there
[50:36] (3036.88s)
anything else I needed to do? Clone CD
[50:39] (3039.68s)
into it. Install
[50:43] (3043.16s)
it. Better user experience. Users can
[50:45] (3045.92s)
now run the server by just
[50:48] (3048.20s)
using Oh, interesting. So, what happens
[50:50] (3050.72s)
if I do
[50:51] (3051.50s)
[Music]
[50:56] (3056.28s)
main? All right. I get the same error.
[51:02] (3062.16s)
So I'm going to do this
[51:06] (3066.76s)
then copy this. I'm going to say getting
[51:10] (3070.64s)
the following error when
[51:15] (3075.00s)
attempting to run the MCP server.
[51:38] (3098.48s)
So, do we need probably miss an install?
[51:41] (3101.56s)
Okay. So, this is the beauty of it. So,
[51:43] (3103.68s)
basically what this is doing, it's doing
[51:44] (3104.88s)
some listings. It's trying to get some
[51:47] (3107.12s)
different information about the project
[51:49] (3109.28s)
and then based off of that uh we got a
[51:51] (3111.92s)
connection. So sometimes when you get
[51:53] (3113.52s)
these connection errors, just say please
[51:55] (3115.40s)
continue. Let it keep doing its
[52:13] (3133.56s)
thing. All right, let's see.
[52:36] (3156.40s)
changing some of the
[52:39] (3159.80s)
code. I don't really know why I did
[52:41] (3161.84s)
that. It's just a different naming
[52:43] (3163.84s)
convention.
[52:52] (3172.40s)
Beauty of this if we weren't streaming
[52:54] (3174.00s)
this is a great time where you get a
[52:55] (3175.44s)
drink get a coffee and go from there.
[52:59] (3179.20s)
All right. Grab server. Sure. You can
[53:01] (3181.60s)
run grab
[53:03] (3183.16s)
commands. I do like to check them as it
[53:05] (3185.84s)
goes. Um I don't like to give it uh
[53:10] (3190.00s)
remove access to files. I still prefer
[53:12] (3192.88s)
to be able to review them. So there's
[53:15] (3195.12s)
certain commands that when they run,
[53:16] (3196.64s)
you're like, I don't know if I want to
[53:17] (3197.92s)
give you god rights to be able to do
[53:20] (3200.08s)
whatever you want to it. But others, you
[53:21] (3201.68s)
know, any of those read files or things
[53:23] (3203.20s)
like that, it doesn't
[53:32] (3212.44s)
matter. Let's see if
[53:34] (3214.84s)
we had
[53:39] (3219.08s)
there error. Couldn't find the module.
[53:46] (3226.48s)
Starting
[53:54] (3234.44s)
server. Yeah, go ahead. So, it's running
[53:56] (3236.72s)
a it's going to run
[54:01] (3241.16s)
it. I'm curious since it fixed it. Did
[54:03] (3243.68s)
it change anything on this side yet?
[54:11] (3251.64s)
theory, it already wrote the code
[54:13] (3253.60s)
changes. We would
[54:15] (3255.64s)
know. Go ahead. Do your thing.
[54:42] (3282.32s)
Yeah, you can do some
[54:45] (3285.24s)
research. Okay, so that's awesome. So,
[54:47] (3287.28s)
it's actually going out and learning all
[54:48] (3288.88s)
about the
[54:56] (3296.60s)
SDK. This is why planning is so
[54:58] (3298.80s)
important. So, if I spent a little bit
[55:00] (3300.00s)
more time on the initial part, we
[55:01] (3301.44s)
probably would have got this right right
[55:02] (3302.64s)
from the first shot.
[55:04] (3304.72s)
But this is a good learning exercise
[55:07] (3307.56s)
of being able to see where the messups
[55:10] (3310.40s)
were. And you do learn by just reading
[55:12] (3312.88s)
some of these logs as you go
[55:15] (3315.96s)
through. So fetch is one of the MCP
[55:21] (3321.36s)
servers that we have access to. So if we
[55:24] (3324.40s)
ran claude down here in the other
[55:26] (3326.76s)
terminal did
[55:29] (3329.56s)
MCP, we should see that we actually have
[55:32] (3332.00s)
the fetch command. So the fetch command
[55:34] (3334.16s)
is is an MCP server in itself and that's
[55:38] (3338.64s)
how it's able to discover what's there.
[55:41] (3341.04s)
So okay using the wrong API. The SCK
[55:43] (3343.84s)
uses a simpler tool method. Okay great.
[55:46] (3346.56s)
So it was able to to go out and learn
[55:49] (3349.60s)
about the
[55:59] (3359.08s)
documentation. NPMTSX full path to the
[56:03] (3363.20s)
main is the main setup, right? It's just
[56:09] (3369.40s)
import. Probably could just take this
[56:11] (3371.84s)
whole file, too, just to make it
[56:14] (3374.72s)
cleaner, but I guess it said it does
[56:16] (3376.32s)
have some of the extra imports. We'll
[56:18] (3378.32s)
leave it alone.
[56:29] (3389.68s)
And what will happen here as you kind of
[56:31] (3391.20s)
get going there's going to be
[56:32] (3392.96s)
compacting. So in claw every every large
[56:36] (3396.72s)
language model has a context window. So
[56:41] (3401.04s)
at time of recording I believe it's
[56:43] (3403.32s)
200,000 tokens is the context window
[56:46] (3406.24s)
where some of the Gemini models by
[56:48] (3408.48s)
Google are a million. So it just kind of
[56:51] (3411.84s)
depends on there. But once it gets to
[56:53] (3413.28s)
its close to its context limit, it's
[56:55] (3415.12s)
going to do an autoco compact. And
[56:56] (3416.56s)
basically what it does is it summarizes
[56:58] (3418.56s)
all the work you did. Um, and it will
[57:02] (3422.00s)
set that as the first system prompt to
[57:04] (3424.00s)
continue on. So it's a clever way to be
[57:06] (3426.08s)
able to maximize the same session.
[57:09] (3429.04s)
Generally, what you do want to do is
[57:10] (3430.64s)
just keep updating your claw.md for the
[57:13] (3433.04s)
case of cloud code because that's the
[57:14] (3434.96s)
that's really the brain of this. And
[57:16] (3436.64s)
then just create a new session. So if
[57:18] (3438.80s)
you have clean sessions as you kind of
[57:20] (3440.40s)
write through each feature that you
[57:21] (3441.76s)
write, um it it allows it to continue
[57:24] (3444.64s)
to, you know, stay as current as
[57:31] (3451.24s)
possible. This over here
[57:56] (3476.16s)
Got a little bit of downtime
[58:04] (3484.44s)
here. Do want to get this working end to
[58:06] (3486.64s)
end. We're very close. So, we're waiting
[58:10] (3490.40s)
on this. Let's look at some of the index
[58:13] (3493.52s)
code. I want to kind of learn a little
[58:14] (3494.96s)
bit like since we did vibe code, I
[58:16] (3496.56s)
didn't do the normal peer reviews that
[58:18] (3498.32s)
we would usually go through. Versioning,
[58:20] (3500.88s)
this is probably where it's
[58:25] (3505.24s)
complaining. So these are the actual
[58:27] (3507.20s)
tools themselves. Get servers is just
[58:29] (3509.12s)
like, hey, is it a local or is it
[58:31] (3511.12s)
production? We probably don't need that.
[58:32] (3512.48s)
I could eventually just remove that one.
[58:35] (3515.20s)
Same with setting the base
[58:37] (3517.40s)
URL. This is this is really the meat of
[58:40] (3520.00s)
it, right? the get gift
[58:41] (3521.80s)
cards required input as the
[58:45] (3525.24s)
retailer and then when we do let's look
[58:50] (3530.60s)
uh get cash back if I do a find on that.
[58:54] (3534.32s)
Yeah, here's the case statement. So,
[58:55] (3535.68s)
it's not even really that crazy, right?
[58:57] (3537.52s)
It just shows the type of call that it's
[59:00] (3540.44s)
making. Retailer not found.
[59:30] (3570.88s)
the parts in the video where you just
[59:32] (3572.32s)
cut it out and go straight to Hey, look,
[59:34] (3574.32s)
it works.
[59:52] (3592.96s)
gives a view of what it's like to be a
[59:54] (3594.56s)
developer here in the new age of coding.
[59:57] (3597.76s)
We're downtime to think about what the
[59:59] (3599.36s)
next plan is or to create new
[60:01] (3601.68s)
specification files for additional
[60:04] (3604.08s)
features is usually what we'll do with
[60:08] (3608.76s)
that because you can run these in
[60:10] (3610.96s)
parallel, right? Up until where you
[60:13] (3613.20s)
where you use all of your
[60:15] (3615.32s)
available subscription amounts.
[60:28] (3628.96s)
didn't even ask it to think extra hard.
[60:30] (3630.88s)
So, I guess it learned a lot
[60:33] (3633.08s)
from the documentation here when it
[60:35] (3635.60s)
fetched
[60:38] (3638.36s)
it. I suspect there's going to be a lot
[60:40] (3640.64s)
of rewrite on that when it gets through.
[61:03] (3663.12s)
I wonder in the time that we do this if
[61:05] (3665.04s)
I could create
[61:07] (3667.32s)
another
[61:10] (3670.12s)
folder and spit it out and test it.
[61:12] (3672.96s)
Let's see.
[61:18] (3678.00s)
That would be something. Okay. So, let's
[61:20] (3680.00s)
do this as a test since we still have
[61:22] (3682.32s)
the original
[61:24] (3684.44s)
um original
[61:30] (3690.04s)
If we go
[61:32] (3692.28s)
back and we do let's do make a
[61:35] (3695.44s)
directory. We'll call it revi mcp
[61:40] (3700.20s)
new cd into into that.
[61:44] (3704.96s)
Um, and let's create a new cursor
[61:47] (3707.36s)
window. So, we'll just keep an eye on
[61:49] (3709.28s)
both of these at the same
[61:50] (3710.92s)
time. If I create
[61:54] (3714.92s)
a new folder, let me call it
[61:58] (3718.20s)
docs. Inside docs, we do open api.l.
[62:08] (3728.44s)
And we could probably just even do let's
[62:12] (3732.24s)
just follow the exact steps, right?
[62:17] (3737.00s)
So, npm in
[62:20] (3740.20s)
it and
[62:25] (3745.72s)
package set type equals
[62:38] (3758.60s)
module. Let's try this
[62:44] (3764.52s)
Um, I'm going to call it Rev ROI MCP
[62:47] (3767.60s)
again version
[62:51] (3771.88s)
one server for the Rev
[62:56] (3776.92s)
ROI. Um, Chrome extension real original
[63:06] (3786.92s)
index want to do
[63:10] (3790.28s)
index.js. I think I want to make it I
[63:12] (3792.32s)
want to call it main.ts.
[63:16] (3796.48s)
No test command, no get repo, no
[63:18] (3798.64s)
keywords, no author, no
[63:23] (3803.64s)
sure. There's our package JSON. And
[63:30] (3810.76s)
let's copy the
[63:32] (3812.40s)
[Music]
[63:38] (3818.28s)
main.ts. Paste it in.
[63:44] (3824.08s)
So if I do
[63:48] (3828.84s)
npmi npm
[63:52] (3832.92s)
install, let's install just
[63:57] (3837.56s)
the and then we could probably go back
[63:59] (3839.68s)
soon and check on our other
[64:09] (3849.08s)
Okay, close that. Close
[64:11] (3851.72s)
that with that. Okay. Now, can I just do
[64:16] (3856.64s)
Let me change my path. Right. See if
[64:19] (3859.28s)
this does anything. This finish still
[64:23] (3863.08s)
crafting. This going to be where a human
[64:25] (3865.20s)
beats the AI. Let's find
[64:29] (3869.00s)
out. So, edit the
[64:34] (3874.76s)
config with cursor. Let's change its
[64:44] (3884.92s)
Oops. I mean, path is just new. Save
[64:53] (3893.48s)
it. Let's go ahead and
[64:56] (3896.57s)
[Music]
[65:00] (3900.28s)
close. Did we do it? I don't see any
[65:04] (3904.00s)
errors. Do we have tools?
[65:08] (3908.16s)
Hey, look at that. We got our tools.
[65:10] (3910.32s)
Okay, let's test it out. So, we beat
[65:12] (3912.64s)
Interesting. So, all of that there.
[65:14] (3914.56s)
Let's see if I'm curious to see if it
[65:16] (3916.08s)
does fix it. But on the
[65:22] (3922.44s)
new, we can go ahead and test this. Um,
[65:25] (3925.28s)
okay. So, I'd like you to use the Rev
[65:30] (3930.88s)
ROI MCP
[65:33] (3933.56s)
server. Please find the cashback
[65:37] (3937.84s)
rates for
[65:49] (3949.72s)
goals. All right. Always
[66:02] (3962.20s)
allowed. Okay. So, it's going to start
[66:04] (3964.32s)
asking us for permission. Just doing a
[66:06] (3966.88s)
get server check which was our
[66:10] (3970.76s)
URLs. Um it's going to set the base URL
[66:13] (3973.60s)
to the main one. That's fine. Could
[66:17] (3977.20s)
probably optimize that a little bit, but
[66:18] (3978.88s)
if it works, it
[66:21] (3981.24s)
works. And now it is doing its thing.
[66:24] (3984.32s)
It's investigating Kohl's review
[66:27] (3987.04s)
carefully, of
[66:28] (3988.84s)
course. All right. So, we set our
[66:30] (3990.88s)
retailer. Remember in the beginning we
[66:32] (3992.96s)
gave it a flag for which argument it
[66:35] (3995.04s)
should use.
[66:47] (4007.88s)
oh. Let's see. Show me what fetch. What
[66:52] (4012.32s)
did it not like? Valid
[66:56] (4016.60s)
JSON page exists but could be simplified
[66:59] (4019.60s)
in from HTML. Okay, so we have a little
[67:02] (4022.00s)
debugging to do.
[67:08] (4028.64s)
Oh, it's
[67:10] (4030.84s)
returning HTML instead of JSON data.
[67:14] (4034.08s)
What did it actually do? I want to see
[67:19] (4039.00s)
output. Will it tell me that detail?
[67:21] (4041.52s)
Here we
[67:24] (4044.12s)
go. Retailer
[67:28] (4048.52s)
Kohl's type text unexpected positioning.
[67:33] (4053.68s)
So, we might have
[67:34] (4054.62s)
[Music]
[67:38] (4058.36s)
to Okay. Well, we have it. Let's
[67:41] (4061.36s)
actually bring this back.
[67:47] (4067.56s)
Right.
[67:51] (4071.80s)
And let's set up a session on this
[68:01] (4081.88s)
one. Yeah, we'll create a new cloud code
[68:04] (4084.64s)
session. Let's init
[68:23] (4103.80s)
it. Now we're waiting on two cloud
[68:26] (4106.00s)
coats. Does this one ever finish? What's
[68:28] (4108.00s)
taking so long on this? It's almost like
[68:30] (4110.24s)
it got stuck there.
[68:32] (4112.40s)
It's not really doing anything. I almost
[68:34] (4114.08s)
want to put I'm going to exit it this
[68:37] (4117.40s)
one and say please
[68:40] (4120.76s)
continue. See if that gives it a little
[68:42] (4122.88s)
bit of a kick in the
[68:46] (4126.76s)
butt because I want to come back over
[68:48] (4128.80s)
here and find
[68:51] (4131.80s)
out. Yeah, you can do that. It's fine.
[68:59] (4139.36s)
want to give it the context of the error
[69:00] (4140.88s)
that we got and see if it can autofix
[69:07] (4147.72s)
itself because we could probably use our
[69:10] (4150.16s)
original draft too. So, original draft
[69:13] (4153.28s)
has those end
[69:14] (4154.84s)
points. Um, let's
[69:23] (4163.48s)
see. I could just take those end points
[69:26] (4166.24s)
there.
[69:35] (4175.72s)
did action gift card and host name? I
[69:46] (4186.28s)
wonder. Let's just take all of them.
[69:59] (4199.28s)
We'll give that as context to the
[70:01] (4201.32s)
window. This is taking a while on that
[70:05] (4205.72s)
side. Yes, you can run ls commands.
[70:14] (4214.64s)
While we're doing that, um,
[70:21] (4221.64s)
okay, I'd like you to
[70:25] (4225.00s)
troubleshoot an
[70:27] (4227.96s)
issue.
[70:29] (4229.88s)
Sure. An issue we are
[70:33] (4233.00s)
facing the
[70:34] (4234.84s)
JSON in the MCP server is getting
[70:40] (4240.92s)
errors.
[70:44] (4244.60s)
Here's the
[70:46] (4246.60s)
errors found in cloud
[70:49] (4249.88s)
code. Yes, you may write it.
[70:53] (4253.88s)
Cloud desktop and the examples of the
[70:59] (4259.20s)
API calls we need to
[71:02] (4262.60s)
make. So I'm going to give the example
[71:06] (4266.52s)
paste and then I'm going to grab
[71:14] (4274.00s)
cloud code
[71:15] (4275.56s)
itself. And we're going to get all of
[71:20] (4280.44s)
detail and we'll paste that
[71:24] (4284.76s)
in. See how it
[71:32] (4292.12s)
does. So, this is a massive prompt.
[71:36] (4296.64s)
Generally wouldn't want to give it that
[71:38] (4298.08s)
much context, but for troubleshooting,
[71:39] (4299.92s)
we'll give it a
[71:45] (4305.80s)
go. Just basically look at these side by
[71:48] (4308.64s)
side. Now, did this get done over
[71:51] (4311.88s)
here? Still attempting to
[71:55] (4315.56s)
write. I almost want to just stop this
[71:58] (4318.16s)
particular
[72:01] (4321.72s)
one. We'll give it some new context.
[72:09] (4329.84s)
Please review the
[72:13] (4333.24s)
codebase and fix
[72:16] (4336.62s)
[Music]
[72:22] (4342.52s)
the issues as identified in cloud MD.
[72:28] (4348.88s)
See if it's able to do anything with
[72:32] (4352.00s)
And this guy's moving right
[72:33] (4353.96s)
here. So, okay. So, it's going to use a
[72:46] (4366.36s)
command. I have a feeling this one's
[72:48] (4368.40s)
going to beat it to the punch. So, MCP
[72:51] (4371.12s)
new might be the one we use.
[73:06] (4386.36s)
Okay. Okay. So, the query parameters are
[73:08] (4388.80s)
different than that. Does that mean Oh,
[73:11] (4391.28s)
we don't have git for this one. All
[73:12] (4392.80s)
right. So, let's pull up claude and
[73:15] (4395.60s)
we'll quit it and we will reinstall or
[73:19] (4399.36s)
reopen it. Not reinstall it. We should
[73:22] (4402.48s)
still Okay.
[73:24] (4404.80s)
Please
[73:25] (4405.72s)
use the Rev ROI MCP server to get the
[73:30] (4410.24s)
cash back rates for
[73:34] (4414.12s)
Kohl's. Now, what we can do if we can
[73:36] (4416.32s)
get this working right, um, not only do
[73:38] (4418.72s)
you get to use that in Cloud Desktop,
[73:40] (4420.96s)
but we can source this into Cloud Code
[73:42] (4422.88s)
and use that for helping with our
[73:45] (4425.52s)
sourcing, too, because you can put all
[73:46] (4426.96s)
of the MCP service in there. So, after
[73:49] (4429.68s)
development, we get this working.
[73:59] (4439.20s)
Perfect. There we go. So, so much
[74:01] (4441.20s)
quicker this time. All right. So, this
[74:03] (4443.68s)
module is actually way better than the
[74:05] (4445.28s)
other one. We We'll be able to stop
[74:06] (4446.72s)
that. It's going through. It's getting
[74:08] (4448.56s)
the cashback portal rates from each of
[74:10] (4450.48s)
the different
[74:11] (4451.72s)
items. Credit card points. So, it's
[74:13] (4453.84s)
actually it went through and did the
[74:15] (4455.04s)
whole thing. Uh, so looks like 4.5 was
[74:17] (4457.36s)
the highest. Let's just double check
[74:19] (4459.84s)
that, right? Like what does Kohl's look
[74:21] (4461.68s)
like right now? Does Kohl's have four
[74:24] (4464.80s)
five or is it better?
[74:28] (4468.68s)
Um yep 45. Perfect. So we are getting
[74:31] (4471.84s)
good data on this. Excellent. So now you
[74:35] (4475.20s)
can see with these types of tools um
[74:38] (4478.00s)
that's just one aspect of this we can
[74:40] (4480.16s)
now use have one for sourcing, one for
[74:42] (4482.80s)
cash back, one for we have the credit
[74:44] (4484.80s)
card and travel points already, right?
[74:46] (4486.40s)
We have that already baked in from Rev
[74:48] (4488.00s)
ROI. Uh, now we could use it for Smart
[74:51] (4491.20s)
Scout. So, Scott, give me a give me a
[74:53] (4493.92s)
send me a DM. We'll write one together.
[74:55] (4495.84s)
We'll make it more um than this live
[74:58] (4498.80s)
session here. Something that we could
[75:00] (4500.16s)
use for that. You only have 10 data,
[75:02] (4502.08s)
etc. You can see wherever you go with
[75:03] (4503.52s)
these things. These are the many tools
[75:06] (4506.08s)
in the toolbox, but now we have a
[75:08] (4508.16s)
working version that is directly in
[75:10] (4510.40s)
cloud code um and available for use. So,
[75:13] (4513.20s)
we'll get a more productionready version
[75:15] (4515.20s)
out there, but this should be pretty
[75:16] (4516.40s)
good for this live stream. So, have a
[75:18] (4518.16s)
good one.