[00:00] (0.16s)
Vibe coding. It's the new trend where
[00:02] (2.16s)
people code without really looking at
[00:04] (4.00s)
the code at all. These days, almost
[00:06] (6.00s)
anyone who speaks English can do it. But
[00:08] (8.16s)
Vibe coding comes with a dangerous side
[00:10] (10.32s)
effect, and that's vibe debugging. When
[00:12] (12.40s)
you're building stuff using these new AI
[00:14] (14.48s)
tools like cursor or clawed code, your
[00:16] (16.88s)
app might seem like it's running without
[00:18] (18.72s)
any issues. And I say might because in
[00:21] (21.04s)
reality, that's rarely the case. You
[00:22] (22.96s)
often run into bugs. And that's usually
[00:24] (24.88s)
because the AI doesn't fully understand
[00:27] (27.04s)
what it's writing or it forgets what it
[00:29] (29.12s)
already wrote due to context window
[00:31] (31.12s)
limitations. So now you're stuck with
[00:32] (32.96s)
code that you didn't write, don't
[00:34] (34.64s)
understand, and don't know how to debug.
[00:36] (36.56s)
Now, how do you debug code you didn't
[00:38] (38.32s)
write? That's exactly where Sentry comes
[00:40] (40.16s)
in. Sentry can help vibe coders and
[00:42] (42.48s)
professional devs debug their code
[00:44] (44.24s)
efficiently, even when they didn't write
[00:46] (46.00s)
it themselves. It's a platform many real
[00:48] (48.24s)
developers already use every day, but
[00:50] (50.16s)
they've now made it even more powerful
[00:51] (51.92s)
by releasing their new feature. So, what
[00:54] (54.88s)
exactly is Sentry? For those of you who
[00:56] (56.80s)
haven't used it before, Sentry is a
[00:58] (58.64s)
platform that automatically tracks and
[01:00] (60.64s)
reports errors in your app. And if we
[01:02] (62.48s)
combine the traditional programming
[01:04] (64.16s)
workflow with these new AI workflows,
[01:06] (66.40s)
that's how you're actually going to
[01:07] (67.68s)
build reliable software that doesn't
[01:09] (69.44s)
break. Now, you might think you could
[01:11] (71.12s)
just log these errors in a MD file or
[01:14] (74.00s)
maybe run some bug bots that catch those
[01:16] (76.40s)
errors, but that isn't the optimal
[01:18] (78.08s)
solution. And you might think, what
[01:19] (79.76s)
makes Sentry different? It's actually a
[01:21] (81.76s)
proper system for catching all those
[01:23] (83.60s)
repeated errors in your app. They've got
[01:25] (85.52s)
built-in support for different
[01:26] (86.96s)
frameworks like Nex.js or Python or
[01:29] (89.68s)
whatever you're using. Sentry tracks how
[01:31] (91.68s)
often an error has happened, when it
[01:33] (93.60s)
happened, where it came from, and keeps
[01:35] (95.44s)
a full history of it, all organized in a
[01:37] (97.84s)
clean dashboard. Now imagine this. If
[01:39] (99.76s)
your AI agent had access to all that
[01:42] (102.16s)
context, every stack trace, every
[01:44] (104.32s)
repetition, every log, solving the
[01:46] (106.48s)
problem becomes way easier. It could
[01:48] (108.48s)
easily go ahead and fix that issue with
[01:50] (110.56s)
all that extra context. So, what have
[01:53] (113.12s)
they released? It's their new MCP
[01:55] (115.04s)
server, and this thing is amazing. Sure,
[01:57] (117.12s)
it eliminates the debugging headache,
[01:58] (118.88s)
but there's something even more
[02:00] (120.32s)
impressive that caught me off guard.
[02:02] (122.08s)
Normally, if you were working with
[02:03] (123.68s)
Sentry in your project, what you do is
[02:05] (125.76s)
go to the website, create a project
[02:07] (127.60s)
there, then come back and install the
[02:09] (129.52s)
SDK for the specific framework you're
[02:11] (131.76s)
using. For example, if you're using
[02:13] (133.52s)
Nex.js or Python, you'd install their
[02:15] (135.84s)
respective SDKs. After installing the
[02:18] (138.24s)
SDK, you'd need to initialize Sentry in
[02:20] (140.80s)
your actual code so that when your app
[02:22] (142.72s)
encounters errors, Sentry can catch and
[02:25] (145.04s)
log them in your dashboard. Now, what's
[02:27] (147.12s)
the added perk of this Sentry MCP? Let
[02:29] (149.60s)
me show you. You can see that the Sentry
[02:31] (151.52s)
MCP is already added in cursor. I'll
[02:33] (153.92s)
give you details on what the tools are
[02:35] (155.60s)
and how to install the actual MCP server
[02:37] (157.92s)
because there's a bit of authentication
[02:39] (159.52s)
involved. But for now, just focus over
[02:41] (161.60s)
here. First, I asked if it had access to
[02:43] (163.92s)
the Sentry MCP server. It replied yes.
[02:46] (166.64s)
Then it called the tool who am I to
[02:48] (168.56s)
check my user details because as I
[02:50] (170.64s)
mentioned, we've already authenticated
[02:52] (172.48s)
with Sentry for this MCP to work. It
[02:54] (174.72s)
returned who I was, what my organization
[02:56] (176.96s)
name was. Then it ran the tool called
[02:58] (178.96s)
find organization and it identified that
[03:01] (181.28s)
my organization was automata. After that
[03:03] (183.76s)
I asked if it could access all of my
[03:06] (186.00s)
projects. Remember we usually have to
[03:08] (188.08s)
manually create a project in Sentry but
[03:10] (190.32s)
at this point I hadn't made any project.
[03:12] (192.48s)
So it ran the tool called find projects
[03:14] (194.64s)
and saw that there weren't any projects
[03:16] (196.56s)
set up in my Sentry organization yet.
[03:18] (198.80s)
And this is what actually surprised me.
[03:20] (200.56s)
It said it could create the new Sentry
[03:22] (202.48s)
project for me and automatically set up
[03:24] (204.56s)
the error monitoring for my application.
[03:26] (206.80s)
Now this this is just on another level.
[03:28] (208.96s)
You don't have to go through the UI or
[03:30] (210.96s)
do anything manually again. This is how
[03:33] (213.12s)
AI agents, AI based applications and
[03:35] (215.68s)
these amazing MCP servers are changing
[03:38] (218.00s)
everything. So it said it had helped me
[03:40] (220.16s)
and set up the Sentry project for me. It
[03:42] (222.56s)
checked if I had any teams then
[03:44] (224.40s)
proceeded to create the project for my
[03:46] (226.32s)
notes application and of course it knew
[03:48] (228.48s)
the command to install the Sentry SDK.
[03:51] (231.04s)
In my case it installed the SDK for
[03:53] (233.44s)
Nex.js. Then as expected there were
[03:56] (236.16s)
configuration files. It set those up as
[03:58] (238.48s)
well. After that it modified my code
[04:00] (240.72s)
because like I mentioned earlier you've
[04:02] (242.56s)
got to update the code so that errors
[04:04] (244.64s)
can be logged in the Sentry dashboard.
[04:06] (246.48s)
And another thing as I already said the
[04:08] (248.72s)
manual processes are completely gone
[04:11] (251.12s)
after integrating the code. You
[04:12] (252.96s)
typically need to get your DSN from
[04:15] (255.04s)
Sentry which is kind of like an API key
[04:17] (257.60s)
used to send error logs to Sentry in the
[04:20] (260.00s)
cloud. Normally you'd get this manually
[04:22] (262.24s)
but here's what happened. Since it was
[04:24] (264.00s)
handling everything, it fetched my
[04:25] (265.76s)
Sentry DSN, automatically added it to my
[04:28] (268.40s)
configuration, and even gave it back to
[04:30] (270.48s)
me in case I needed it elsewhere. Again,
[04:32] (272.64s)
this is what I'm trying to tell you. It
[04:34] (274.40s)
handled all of that automatically.
[04:36] (276.40s)
Basically, the MCP gives us these tools
[04:38] (278.96s)
that automate the entire Sentry setup
[04:41] (281.20s)
process. Then, it actually asked if I
[04:43] (283.12s)
wanted to test whether error logging was
[04:45] (285.20s)
working, and I said yes, go ahead. So,
[04:47] (287.20s)
in the app I used, it added three
[04:49] (289.20s)
buttons that would trigger errors. These
[04:51] (291.20s)
are the three error buttons you see.
[04:53] (293.04s)
Actually, let me just open up the app so
[04:55] (295.04s)
you can see how it added those buttons.
[04:57] (297.28s)
So, this is the app and these are the
[04:59] (299.36s)
buttons it added to test if the Sentry
[05:01] (301.60s)
connection was working. If we go into my
[05:03] (303.60s)
dashboard and check the issues, you can
[05:05] (305.44s)
see the different ones that have come up
[05:07] (307.04s)
during testing. So, yeah, the issues are
[05:09] (309.20s)
showing up correctly and Sentry has been
[05:11] (311.36s)
properly initialized. Now, how do you
[05:13] (313.52s)
install the MCP server? It's actually
[05:15] (315.60s)
quite easy. before you go on and
[05:17] (317.44s)
actually install the Sentry MCP server,
[05:19] (319.84s)
you need to make sure you've got a
[05:21] (321.04s)
Sentry account. Just open it up. And if
[05:23] (323.20s)
you don't have an account, like right
[05:24] (324.72s)
now I do, then just go ahead and sign
[05:26] (326.64s)
up. You don't need to create a project
[05:28] (328.16s)
or anything. Now, after you've signed
[05:30] (330.08s)
up, you're going to get this command
[05:31] (331.52s)
from the docs. And don't worry, I'll
[05:33] (333.36s)
leave those docs in the description
[05:34] (334.88s)
below. Just copy this JSON
[05:36] (336.72s)
configuration. And if you scroll down,
[05:38] (338.80s)
they've actually mentioned the verified
[05:40] (340.56s)
clients, which means Claude desktop,
[05:42] (342.56s)
Claude AI, which just means Claude Code,
[05:45] (345.20s)
Windsurf, Cursor, and also VS Code, and
[05:48] (348.16s)
GitHub Copilot. So yeah, it's verified
[05:50] (350.56s)
for all of these. They've listed some
[05:52] (352.32s)
install instructions, but it's pretty
[05:54] (354.00s)
much the same for all of them. Just go
[05:55] (355.76s)
ahead. Like for example, in my case, my
[05:58] (358.08s)
MCP.json is empty right now. So I'm just
[06:00] (360.80s)
going to copy this whole thing. And now
[06:02] (362.48s)
you're going to see that the MCP server,
[06:04] (364.48s)
the Sentry MCP, has been added. After
[06:06] (366.80s)
you add it, it's going to run. At first,
[06:08] (368.80s)
it'll appear red, but once it runs the
[06:10] (370.88s)
command, it'll automatically open up in
[06:13] (373.04s)
your terminal like this. And you'll get
[06:14] (374.72s)
this message saying the MCP CLI is
[06:17] (377.04s)
requesting access. You just need to
[06:18] (378.80s)
approve it. Once that's done, if you go
[06:20] (380.88s)
back and it still hasn't turned on, just
[06:23] (383.04s)
toggle it off and on. And now you'll see
[06:25] (385.12s)
that the tools have been enabled. And
[06:26] (386.96s)
we've got all of our tools right in
[06:28] (388.72s)
front of us. So, I did already show you
[06:31] (391.20s)
that it can automatically initialize a
[06:33] (393.44s)
project for you. But what else can it
[06:35] (395.12s)
do? They've provided some example calls
[06:37] (397.28s)
that give you a pretty good idea.
[06:38] (398.96s)
Obviously, you can ask it to list all
[06:40] (400.80s)
the issues in your project. You can also
[06:42] (402.64s)
ask Sentry about a particular file to
[06:44] (404.80s)
check if there are issues in it and then
[06:46] (406.64s)
go ahead and fix them. There's also
[06:48] (408.16s)
Sentry's own AI powered SEIR which can
[06:50] (410.80s)
analyze your issue and provide a
[06:52] (412.64s)
solution. Now, this is part of the paid
[06:54] (414.48s)
features. So, that's up to you. But even
[06:56] (416.64s)
without Seir, Sentry still gives you
[06:58] (418.72s)
enough data about a specific issue that
[07:00] (420.96s)
cursor or claude code, whichever you're
[07:03] (423.20s)
using, can automatically fix it. I just
[07:05] (425.44s)
wanted to show you some of the tools the
[07:07] (427.20s)
Sentry MCP offers. You can see that many
[07:09] (429.76s)
of the tools are related to using Sentry
[07:12] (432.08s)
as a platform like Who am I, find
[07:14] (434.40s)
organizations, find projects, create DSN
[07:17] (437.84s)
or create projects, which help you
[07:19] (439.84s)
manage the Sentry platform through MCP
[07:22] (442.24s)
like I showed you earlier. You don't
[07:23] (443.92s)
have to do any of it manually. Then
[07:25] (445.68s)
there are other tools like get issue
[07:27] (447.44s)
details, find errors or even begin seir
[07:30] (450.24s)
issue fix which help you get detailed
[07:32] (452.08s)
insights into the issues or actually fix
[07:34] (454.40s)
them. In order for you to purposely see
[07:36] (456.64s)
it in action, I purposely put an error
[07:38] (458.88s)
in my application. One that completely
[07:41] (461.04s)
broke the app and wouldn't let me use
[07:42] (462.72s)
it. If we go into my dashboard, you can
[07:44] (464.96s)
see that the issue shows up here. If I
[07:47] (467.12s)
click on it, you can see that the issues
[07:48] (468.96s)
listed and we get all the details about
[07:50] (470.88s)
it, including the trace. Using all this
[07:53] (473.12s)
information, the LLM can actually
[07:54] (474.88s)
understand where the error came from,
[07:56] (476.80s)
track it, and get accurate insights on
[07:58] (478.88s)
how to fix it. So, first I just
[08:00] (480.64s)
blatantly tried using SEIR to fix it.
[08:02] (482.96s)
That's when it told me I had to enable
[08:04] (484.64s)
it and that it's a paid feature. Then I
[08:06] (486.72s)
went ahead and told it to get the
[08:08] (488.08s)
details of the issue and propose a fix
[08:10] (490.00s)
for me. It called the get issue details
[08:12] (492.24s)
tool. You can see we've got the issue
[08:14] (494.08s)
ID, our organization, and then as a
[08:16] (496.72s)
result, it gave us the issue summary,
[08:18] (498.88s)
some context about its occurrences, and
[08:21] (501.04s)
even as we scroll down, a trace, which
[08:23] (503.36s)
is pretty helpful. It also gave some
[08:25] (505.20s)
additional context, which didn't really
[08:26] (506.88s)
matter much in this case, but
[08:28] (508.56s)
essentially, we gave it the issue
[08:30] (510.16s)
details and as you can see, it
[08:32] (512.24s)
recognized the type of error. It was a
[08:34] (514.32s)
type error. Something was not a
[08:36] (516.00s)
function. It proposed that the error
[08:37] (517.92s)
should be removed and also suggested an
[08:40] (520.16s)
additional check to make sure it doesn't
[08:42] (522.00s)
happen again. Then it just went ahead
[08:44] (524.00s)
and started fixing the issue. And once I
[08:46] (526.00s)
accepted the fix, the application
[08:47] (527.68s)
started working again. But how do you
[08:50] (530.00s)
fully take advantage from this? If you
[08:52] (532.16s)
want to have this full setup with Sentry
[08:54] (534.48s)
monitoring your errors and then logging
[08:56] (536.40s)
them and tracing them, which will
[08:57] (537.92s)
essentially help the agent debug your
[08:59] (539.84s)
code better, then you need to make sure
[09:01] (541.60s)
that you use it properly and use it from
[09:03] (543.76s)
the start. So even if you are building
[09:05] (545.60s)
stuff with AI, the agent knows that you
[09:07] (547.76s)
are using it and make sure that it sets
[09:09] (549.68s)
it up in your project correctly and
[09:11] (551.60s)
Sentry is properly utilized. That brings
[09:14] (554.08s)
us to the end of this video. If you'd
[09:15] (555.76s)
like to support the channel and help us
[09:17] (557.52s)
keep making tutorials like this, you can
[09:19] (559.52s)
do so by using the super thanks button
[09:21] (561.52s)
below. As always, thank you for watching
[09:23] (563.36s)
and I'll see you in the next one.