YT YouTube2Text

YouTube2Text → Transcripts → What Claude Code Can Do That You Haven't Tried - Gui Ferreira - NDC Oslo 2026

What Claude Code Can Do That You Haven't Tried - Gui Ferreira - NDC Oslo 2026 — Transcript

by NDC Conferences · 9,451 words · 1,465 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:11Hello.
0:12So, based on the number of people in
0:14this room, I think it's safe to say that
0:17Cloud Code is quite popular.
0:20But also, it's safe to say that things
0:22keep changing too fast and it's hard to
0:24keep up.
0:26And that's the point of this talk.
0:28So,
0:30if I ask how many features do you think
0:32Cloud has,
0:34I'll get many different numbers for
0:35sure, big numbers. And I couldn't get
0:38the number, but I could get the number
0:40for the number of slash commands, those
0:42that you start with a slash and you
0:44write something, that are available on
0:46Cloud Code by default.
0:48And on Friday, they were 104
0:52slash commands.
0:54Since then, I didn't check X or whatever
0:58we want to call it. So, maybe they're
1:00already 105 or 106 because it's really
1:04hard to keep up with these things, okay?
1:06And in the past few months, I've been
1:09teaching this thing about Cloud, and
1:12I've noticed one common thing.
1:14You pick Cloud for the first time, you
1:16start Cloud, you ask to build something,
1:19and in a couple of minutes, you are so
1:21much more productive than you used to
1:22be. Okay? It's doing a ton of things for
1:24you. It's writing tests. It's doing
1:26reviews. It's finding bugs. And you just
1:29learn 10 to 20% of it.
1:32Personally, I believe that if you learn
1:34all the types of things, you might find
1:36some important details that improve your
1:38workflow, your quality of life. And
1:40that's the point of this talk. So, what
1:43I want to share with you, and this comes
1:45from someone that is not affiliated to
1:47Anthropic at all, is just someone that
1:49uses the tool every day and that feels
1:52that the tool is helping him a lot. So,
1:55every single thing that I will share
1:56today are actually things that I use in
1:59my day-to-day, okay? And I will organize
2:01those in four different buckets.
2:04Stuff that you can do once and take
2:06advantage of it forever, okay? You
2:08configure it, you take advantage of it,
2:10either you and your team or you alone.
2:13Also, we'll talk about daily workflow
2:15things. So, stuff that you can use in
2:18your day-to-day in certain scenarios.
2:20They can be quite useful. And during the
2:22process, we'll talk about also things
2:25that you can customize, you can extend
2:27Clojure during your day-to-day. But, I
2:29want to focus not on the things that are
2:31available, but because those became
2:33quite popular if you have ever used
2:35Clojure. I want to talk about some
2:38scenarios that we tend to ignore. And
2:40finally, I want to leave this room by
2:42sharing with you a couple of other
2:44scenarios where you can use Clojure
2:46code, okay? Things that don't involve
2:48code at all, okay? That's the goal for
2:51this session.
2:52Warning.
2:53This is a session for those that once
2:56run Clojure. Okay? So, that's the idea.
2:59And uh I will not be doing uh demos like
3:02intro demos, that's not the point. This
3:05is a rapid-fire style of talk. So,
3:07during the next hour, we'll go through
3:09roughly 40 different things that I want
3:11to share with you. So, we are going
3:13fast, okay? So, bear with me and watch
3:16the recording afterwards if needed. My
3:19point here is the following, and that's
3:21my mission for today, and I want to do
3:24that today. If you leave this room and
3:27you have the feeling that on Monday you
3:29need to open Clojure and run two or
3:32three of those things that I will share
3:34with you, for me is a huge success.
3:36Because some of the things that I will
3:38share with you, you might be familiar
3:39with them, they are old things but good
3:42ones, others are new things uh and great
3:45ones as well. So, to start, we need to
3:48first talk about where we run Clojure.
3:52You can run Clojure inside of your
3:53terminal, you can run Clojure inside of
3:55uh your editor as an extension. You can
3:58run Clojure as a desktop application.
4:00Personally, I like to use the terminal.
4:03I feel that it's faster. Also, usually
4:06the experimental features come there
4:08first. That's the reason why I use it.
4:10So, I will be sharing print screens from
4:12the terminal, but most of the things
4:14that I will share with you work wherever
4:15is the environment that you prefer.
4:18Just uh to share that with you.
4:21So, let's start. First pillar, um set up
4:24type of stuff.
4:25So, let's say that in the past few
4:27months you used Claude in the past and
4:30you changed to something like Codex or
4:32Cursor.
4:33And after this session you are too
4:34excited to go back to Claude. What you
4:37can do, slash import and the name of the
4:40product where you want to get your
4:42stuff. Basically, this will pick your
4:45MCP servers, configuration files, uh sub
4:48agents, all of that and bring it to
4:51Claude. So, you don't need to do that
4:52manually. Why does this happen?
4:55For a simple reason. Unfortunately, the
4:58standards that we have with coding
5:00agents are not that great standards. So,
5:03everyone is doing things differently. At
5:05least they are putting the files inside
5:06of different folders.
5:08But the worst of them is actually the
5:10Claude.md.
5:12That is one of the most important files
5:13that you have in your project. But if
5:15you work with other thing, you will be
5:17naming that thing as agents.md.
5:21And this file is so important, um
5:23but I believe that we have created some
5:25misconceptions in the industry.
5:27Also, if I would come here to be honest
5:30last year and I talked about the
5:32Claude.md, I would be saying,
5:35"Put there every single thing that you
5:37can think about that can be helpful."
5:39Write it a document as
5:41most complete that you that you can. You
5:43can have every single thing there.
5:46That's actually wrong, okay? Finally, we
5:48have studies that prove that that's not
5:50the way of doing it. ETH Zurich ran the
5:53a study
5:55and proved that we have some problems.
5:56So, we need to have some techniques. And
5:59one of them is this problem of the
6:00typical duplication.
6:02So, it's quite common that you'll see
6:04things moving around between your
6:06projects and eventually you have
6:08information in the readme and another
6:10and the same information in your
6:11cloud.md. Eventually, your agent is
6:14absorbing all of that those files and
6:16becomes confused. So, tries one way,
6:20doesn't work, it needs to go through
6:21another one.
6:23Actually, cloud supports this import
6:25type of thing. So, you do the at and the
6:27path to the file and you can bring that
6:29file with the cloud.md. So, if you have
6:31something like team rules or a given
6:33schema that is super important for that
6:35API and you want to have it as part of
6:38your
6:39cloud.md, you can do it. Whatever is the
6:41extension that you want. So, avoid the
6:44duplication that can lead to some
6:45problems. As I was saying, ETH Zurich
6:48proved that the performance when you
6:51have a long and descriptive cloud.md, it
6:54tends to drop in 3% and your costs will
6:59increase in 20%.
7:01And they run the study based on
7:03cloud.md, agents.md. So, cloud, codex
7:07and so on. And they did the the study
7:10with groups that were handcrafting the
7:13cloud.md, groups that were generating
7:15the cloud.md and groups that had no
7:19cloud.md at all. And they proved that
7:22a good cloud.md, one that is efficient,
7:24is actually one that is lean enough.
7:27Okay? So, that you throw away things
7:28that are useless. So, I usually ask
7:31three questions to clean my cloud.md and
7:34I challenge you to do the same.
7:36So, I go for each instruction that I
7:39have there and I will ask the following.
7:41The first one is
7:43do I need this thing for every single
7:45task? Okay? If I imagine every type of
7:48iteration that I have with cloud, is
7:49this actually useful? So, if it might be
7:52useful,
7:53let's keep it there.
7:55If it's something so specific that I
7:57only do that once in a while, like
7:59running my performance tests,
8:02maybe let's move that to something like
8:04a skill. Or if it's something like the
8:06rule for your team for JavaScript or for
8:09C# or for whatever, you can create rule
8:12files inside of Cloud.
8:14.cloud/rules
8:16and you can create files there that are
8:17specific to languages or specific to uh
8:20file extensions. And finally, I'd like
8:23to ask if um the agent could figure out
8:26this thing alone.
8:28I used to add to my cloud.md things like
8:30the folder structure, like here we are
8:33using vertical slices and you will find
8:36the controllers here, the endpoints
8:38here, the models there.
8:40That information, your agent can't find
8:41it alone. And if you write it once,
8:44eventually it will drift from the
8:46reality, so it can lead to problems.
8:50The good news is that is that you are
8:51the lucky ones and quite recently uh
8:54Anthropic decided to add to the slash
8:56doctor exactly these type of things, so
8:59this cleanup. The slash doctor can uh uh
9:03check the state of your current
9:05installation of Cloud, if you have
9:07something that is misconfigured, but
9:09also when run inside of a given project,
9:12it will go through your cloud.md and
9:14apply those three questions to the
9:17duplicate stuff, to move things to
9:19skills, okay? It can do that for you.
9:21So, at least do that one.
9:25And remember that cloud.md is a file
9:28that is so much more than that file that
9:30you usually create in the context of a
9:32project.
9:33Because otherwise, what will happen is
9:35that you'll have your own preferences,
9:36things that you want Cloud to do that
9:38way. For example, for a long time I was
9:40doing test-driven development, but I
9:42don't want to force other people to do
9:43it. So, what's my option here? You can
9:46actually create a cloud.local.md,
9:49Git ignore that file, and have your own
9:52stuff there, okay? It doesn't impact
9:53anyone else.
9:55The things that are shared with your
9:56team go to the traditional cloud.md,
9:59but there's one more that we tend to
10:01ignore.
10:02There's a user profile folder named
10:04.cloud where you can find the cloud.md
10:08and where you can find things like your
10:09settings.
10:11But, they are things that apply to every
10:13single session.
10:14So, if you have something like I want
10:17you to talk with me, let's say I'm
10:18Portuguese. So, let's say that I would
10:20prefer Claude to talk with me in
10:22Portuguese. I could go to my user
10:24profile, so I know that every single
10:26session that I start with Claude Code
10:28will follow that instruction. I don't
10:30need to keep copying it to the many
10:32different projects that I work with.
10:35This is the things about Claude Code,
10:36but there's another important file
10:38inside of your project under dot Claude
10:40that is the settings.
10:42And there,
10:44um, please promise me that you'll do the
10:45following.
10:47And for that, let's use an example.
10:49Imagine that you are trying to fix a
10:51database connection issue that happens
10:53only once in a while.
10:56And you ask Claude to do it, and what
10:57Claude will do is that it will say,
10:59"Yeah, you are right. That's really an
11:01important issue. Let's address it." And
11:03will try his best to find the solution.
11:06And will try and try and try, and to
11:08finally be able to help you, will read
11:10things like your secrets, your settings,
11:14your environment variables.
11:17And it will do that unless you deny it.
11:21You might say, "Okay, but no one puts
11:24production keys on the
11:26the settings files.
11:28You are lying.
11:30Uh, if it's not you, because we are all
11:32perfect, someone in your team will do it
11:34one day when it's actually needed. And
11:37in that moment, your keys are going over
11:39the wire to Anthropic.
11:42So, this is a small thing that you can
11:43do. Go to the settings.json, permissions
11:46deny is a collection of extensions that
11:50you want to exclude or bash commands
11:52that you don't want to run.
11:54That way, you guarantee that those files
11:56or those commands are not never executed
11:58or seen by Claude Code. It's a small
12:00thing to do that is quite important.
12:04But now, let's talk about the things
12:05that you said to help that we actually
12:07like. So, we are developers, we are
12:09super proud of the setup that we have on
12:11VS or Visual Studio, right? So, one
12:15thing that has been missing for a long
12:16time was themes. And we all like to pick
12:19a different theme or create our own
12:21theme. Now you can do it, okay? You will
12:23pick the theme. Obviously, if you are in
12:25the context of the terminal,
12:27you you will need to deal with the theme
12:29of the terminal plus the theme of uh
12:31Claude code. But for the things like the
12:33font, the way that you see the source
12:35code, you can actually do it. It's quite
12:37simple and you can do it once.
12:40And the other thing that is even more
12:41important than theme, and this one you
12:44should do it, is to create your own
12:46status line.
12:48I like to see the status line as a
12:50dashboard that I have over uh my current
12:53session. Why? When I'm working, I need
12:56to know where I'm working, what's the
12:58project. I need to know, for example, I
13:00like to know the branch. I like to know
13:02the current model that I'm using. I like
13:04to know things like the percentage of
13:06the context window that I'm using. That
13:08type of information is useful after a
13:11few minutes, I promise. And it's quite
13:14simple to create your own status line,
13:15something like that. You just need to
13:17chat with Claude code using the {slash}
13:20status line and Claude can tell you what
13:22is available. And then, that will create
13:24a script for you that will be uh running
13:27on your behalf and you uh have always
13:30visibility on the things that are
13:31happening.
13:33So, do those things once and you'll take
13:35advantage of them forever.
13:37Now let's go to the uh uh
13:40most extensive part of the talk. So, the
13:42daily minor things that you want to do
13:45in your day-to-day.
13:46And I've learned during the World Cup
13:48that is important to have an hydration
13:50break. So, sorry for this.
13:58Thank you.
13:59So, you have been using Claude code and
14:01one of the things that you
14:03you might came
14:04uh
14:05to to the conclusion is that it is a
14:07good idea to first plan the changes that
14:09you are about to do instead of doing
14:11them right away. That's why we have the
14:13plan mode. You can do the shift uh tab
14:16and you navigate through the different
14:18modes and eventually you get to the plan
14:20mode. What will happen is that Claude
14:21will
14:22do a research to understand the best way
14:24to implement something.
14:26Sometimes it comes back to you with a a
14:29description of how you going to do the
14:31thing that you want.
14:33But you
14:34there's something that is wrong.
14:35What I used to do is that I would have a
14:37conversation. I would keep going like,
14:39"Okay, but I don't want implementation
14:41this way. I want that way. Please change
14:43that thing, okay?"
14:45But eventually we were just discussing
14:47details.
14:48Just one line that was wrong or
14:50something that I could write myself. And
14:53it's not that productive to keep
14:55chatting and having Claude refining that
14:57plan. You can actually do something
14:59different. Once you see the plan, you
15:02can do control G and that will open your
15:04plan as a markdown file in your editor.
15:07You do your changes, you save it, and
15:10Claude recognizes all of those things
15:12and keep going. Okay? Looks like magic.
15:15It's like a shared Google Doc with
15:17Claude, okay? You are collaborating with
15:19Claude and Claude is using that file.
15:22So, it's
15:23a pretty cool and pretty useful tool.
15:26Another thing that happens with
15:29plans
15:30is that
15:32I came to love this idea of having
15:34Claude interviewing me.
15:36Because quite often you ask for a plan,
15:38but by the end the plan has a ton of
15:39assumptions that you don't think about
15:41them.
15:42We have been building software for a
15:43long time and we have learned that
15:46usually the understanding of the problem
15:48will come weeks later when we are
15:51writing a line of code and finally we
15:53have to write that if statement that
15:54reveals that no one discussed the given
15:57topic.
15:58And Claude can assume a ton of things
16:00for you because it wants to be
16:01productive. And if you have a prompt
16:04that is not descriptive enough, a ton of
16:06a ton of assumptions will be there.
16:08So, what you can do is that you can take
16:10advantage of those questions that
16:12usually pop up from Claude saying, "Do
16:14you prefer option A or option B?"
16:16But you can force Claude to do that.
16:18There's this thing inside of Claude
16:20named the ask user question tool. So,
16:22you can simply say, "Hey Claude,
16:24interview me and don't stop until we
16:26clarify every single thing." Okay? And
16:28we'll keep going, keep going, keep
16:30going, and improving the plan. That way,
16:32you will realize that things were not as
16:35clear as you thought in the first place.
16:37And you can be involved in the decisions
16:40instead of only finding only finding
16:42them once the thing is implemented.
16:45Okay?
16:45Do that uh is super useful as well.
16:50During this process, when you are
16:52planning, sometimes you might realize
16:54that Claude comes back to you with
16:56questions like, "Hey,
16:58um I know we need to build this API, but
17:01do you prefer to use something like MVC
17:03pattern or something like uh minimal
17:06APIs?" And you think about it, you might
17:09ask, "What do you recommend?" And Claude
17:10says, "Okay, I recommend MVC pattern."
17:13You say, "Okay, let's do it."
17:15And now you we start implementing, and
17:17eventually, you start looking into the
17:19code, and you don't like it. You think,
17:21"That was too much for this problem. I
17:23want to go back to the other thing."
17:25So, what do you usually do? You prompt
17:28again, and you ask Claude, "Okay, let's
17:30refactor this thing, and let's move away
17:32from MVC and go to minimal APIs."
17:36By doing that, you are basically taking
17:38steps forward
17:40towards the thing that you want.
17:42However, by doing that,
17:45there's a problem.
17:46All the past directions, all the past
17:48code that was generated will stay in the
17:50context window.
17:51By staying there, once your context
17:53window is big enough, it might have a
17:55negative impact in the future
17:57iterations. So, what can you do instead?
18:00You can take advantage of an amazing
18:01feature that feels like time traveling.
18:04That is the rewind.
18:06If at a a given point, you want to go
18:08one step back, you can do double escape
18:11or {slash} rewind, and then you can take
18:14the direction that you want. It's like
18:15taking one step back to then take two
18:18steps forward. Okay? That's the idea.
18:21Looks like uh reverting something with
18:24Git,
18:25but Claude is doing that for you, okay?
18:27And you can always navigate to the
18:28proper message, the proper prompt, and
18:31adjust that prompt during the process.
18:35Talking about
18:36uh plans and implementing those plans,
18:39there's a common recommendation that is
18:40you need them a powerful model to uh
18:43plan and a cheaper model to execute.
18:48That's a a common saying in the
18:49industry. So, one thing that you can do
18:52is in the middle of a conversation run
18:54{slash} model and pick the model that
18:55you want. So, once you do this, you will
18:58want to have that status line, so you
19:00know which model you are using.
19:03But, what most ignore is that this is
19:05not only about Sonnet, Opus, Fable,
19:09Haiku.
19:11Inside of each model, you have different
19:13levels of efforts, different different
19:15levels of reasoning. They will cost more
19:18or fewer
19:19um
19:20tokens. So, you can actually change for
19:23that thread
19:24the effort level. You can say, "I want
19:26to use to the to the planning Opus, and
19:30to implement, I also want to use Opus,
19:33but with a a small level of effort, for
19:37example, okay?" And you can change that
19:39for the whole thread.
19:40One of the problems of changing that for
19:42the whole conversation is that
19:43eventually you will forget it, okay? At
19:45least I do.
19:46So, sometimes you are fixing a bug and
19:49you want to run the
19:51a prompt and you say, "Okay, let's fix
19:52this thing."
19:54But, it is a hard thing to fix. So, you
19:56don't want to change the effort level.
19:57What you can do is to take advantage of
19:59ultra think. So, you just write ultra
20:02think, and what is happening is that
20:04Claude is running that specific prompt
20:07in max effort level for you, and then
20:11going back to the past one.
20:12But, if you don't use this for this
20:14reason, use it just to see the rainbow
20:16that they will uh do. It's a nice
20:18animation, okay?
20:22Talking about um
20:24this type of thing. So, you let's say
20:25that I'm now implementing my feature
20:28with uh X high level. So, it might end
20:31hopeless or fable, and it will take some
20:32time.
20:34While it takes that time, what do I do?
20:36Do I stare at the computer?
20:39Many of us start writing the next
20:41prompt. Okay, so we think, okay, what's
20:43the next step once this one is finished?
20:45So, I used to start writing that one, uh
20:47but eventually sometimes Claude will
20:49stop during the process saying,
20:51"Hey, on this problem, what should we
20:53do?" So, I would need to copy that
20:55prompt to a notepad, and then get it
20:58back there, uh and that was a mess.
21:01But actually, it's as simple as doing
21:02control S. That will stash the current
21:06prompt. So, it's like putting that uh
21:08current prompt on another place, like
21:10another file, for a moment, and once you
21:13click it again, you will get back to the
21:15conversation. So, let's say that you are
21:16writing a long prompt, you do control S,
21:19it goes there, you answer Claude, you
21:21bring the the other one back, and you
21:23keep going. You don't need to be using
21:24notepad and so on uh for that. So,
21:28this one uh saves a a ton of time.
21:31If
21:32what you actually have is a question, is
21:34not the next prompt, is something that
21:36you want answered uh right away, you can
21:39use the by the way.
21:41Why?
21:42If you write your next prompt, it will
21:44wait until the previous one finished to
21:47answer you back.
21:49But let's say that I'm working on the
21:50key feature, is implementing the
21:52feature, and in the middle, I think,
21:53okay, did we discuss this aspect? Uh how
21:56are we going to do this thing? Is with
21:58this pattern or with that pattern? So,
22:00what I can do is that I run the slash
22:02BTW, that is by the way, and it will run
22:05that as kind of like a a side
22:07type of thing, doesn't pollute the
22:08context window, and will get back to me
22:10while it's working on the main
22:12execution. So, you don't need to keep
22:14waiting on that.
22:17Let's talk about the most important
22:19aspect of being a developer nowadays.
22:21That is
22:22money.
22:23Uh in the past, we were super concerned
22:26about uh cost when we got the decisions
22:29in terms of infrastructure.
22:30What's the database that I'm using? Am I
22:32using a cloud platform for for
22:34something? What's the idea that we have
22:37here? Or maybe I have a routine that is
22:39too inefficient for my data set.
22:42Nowadays, we need to think about the
22:44tokens that we consume to write a small
22:46endpoint that just does CRUD with a
22:48database.
22:49So, it's important to have an idea of
22:51how much each session is costing us. I
22:54like I like to bring that information to
22:57my status line.
22:58But also, you can do that through the
23:00terminal as well.
23:01If you run status, you can find not only
23:04your most used model, but also for by
23:08the end of a session, you can see all
23:10the models that were involved because
23:11sometimes Claude will start models that
23:13you don't expect. Why? It starts using
23:16sub-agents with different types of
23:18models, so you can have a clear picture
23:20on much does it cost to implement a
23:21given feature if you were paying each
23:24token. Okay? That can be quite useful,
23:26and besides that, by the end of the
23:28year, it makes a great print for X.
23:30Okay? So, that's the idea.
23:34Cost,
23:35we are talking about context. You can
23:37check the context window by running
23:39{slash} context. But the idea is not
23:41that. Why I'm talking about this?
23:44This one is super useful when you are in
23:47an empty session.
23:49So, you start Claude,
23:50it's empty, and you run {slash} context.
23:52Why?
23:54Because this way, you can actually
23:55diagnose what is happening.
23:58You can see what types of things go to
24:00your context window without you asking
24:02for it.
24:03You can see the types of things that you
24:05have configured in your project that
24:07might be there and you don't need it.
24:09Because it's quite cool nowadays, you go
24:11to LinkedIn and you see uh someone
24:14posting uh my top 10 agent skills. So,
24:17let me download them all and put them in
24:19my project.
24:20But each skill has a small footprint.
24:23So, you need to do your own maintenance.
24:25So, running the {slash} context when the
24:27session is empty, and if you see that
24:29it's taking 8% for example,
24:32do something. Go and try to understand
24:34what is there, okay? Because each
24:37token that you are consuming will have
24:39an impact in the future.
24:40That relates to a concept that is is
24:43based on opinions, okay? By the way,
24:45it's based on opinions of many different
24:47people. I'm not aware of any study that
24:50proves this, but there's this idea that
24:52once you get to the 40% of the context
24:54window, you get into the danger zone.
24:57What does it mean? It means that once
24:59you reach that limit, your um
25:03quality, the quality that you get out of
25:04each token is not as good. So, each
25:07dollar that you invest in a token
25:09doesn't return the same amount of money
25:11to your pocket, okay? That's the idea.
25:14So, what can you do?
25:15First, you avoid that you bring to bring
25:17things to the context window that that
25:19you don't need, but also, you can do uh
25:22another important thing. That is
25:25taking care of the compaction.
25:26Compaction will run automatically when
25:29you are reaching the 100%. So, Claude
25:31will go, summarize your history, replace
25:34that history with a summary, and you can
25:37keep going.
25:38Why not doing it yourself?
25:40So, when you start seeing that Claude is
25:42always doing trial and error, so you are
25:45trying to fix something and it's trying,
25:47okay, doesn't work, and you are
25:49basically asking, "Are you stupid? Why
25:51you don't you get this?" Okay? Try
25:53again. This time try harder. When you're
25:56doing that, it is
25:57it means something. It means that you
25:59need to clear something from your
26:01context window usually. In that moment,
26:04be proactive and run the slash compact
26:07yourself.
26:08Personally, when I'm working on a
26:09feature, I split implementation in
26:12multiple parts. Let's say that first I
26:14do the data model, then I will do the
26:16the domain model, then I will do the UI.
26:18Let's say that was something like this.
26:20So, by the end of each one of these
26:22sections, what I like to do, instead of
26:24starting a new conversation, if I know
26:26that the context of this one might be
26:28useful, I compact and I keep going.
26:30Because that information
26:32took some time to build it and the agent
26:35will appreciate it. So, it will be
26:37useful.
26:38Inside of your contacts, you will see
26:40many different things popping out.
26:42And one of them is quite curious.
26:47Because sometimes you don't ask for it.
26:51There's this concept named memories.
26:53And memories became auto loaders in many
26:57applications.
26:59One of the interesting most interest
27:01interesting stories of my
27:04utilization of ChatGPT has been the day
27:06where I realized that ChatGPT was always
27:09calling me Emily.
27:10But that didn't make sense to me because
27:13I never asked to be called Emily. So, I
27:15went to the memories folder and I
27:18realized that back in the days I asked
27:22Claude to parse a given blog post to
27:24summarize and Claude no, ChatGPT. And
27:28ChatGPT he concluded that
27:30since the blog post had a sentence like
27:32my name is Emily, that I would be Emily.
27:35So, it will capture things that you
27:36don't imagine sometimes. So, you need to
27:38be proactive maintaining those things.
27:41But it's not only about throwing away
27:43things that are useless. It's because
27:45sometimes Claude will spot your
27:46preferences and you don't notice it. So,
27:49it might understand from a simple prompt
27:51that you prefer things being done this
27:53way and never this way. So, we'll create
27:56a memory inside of the memory
27:58file. So, what you want to do is to run
28:00{slash} memory, go to your folder of the
28:03memories and there audit them. And some
28:06of them you will want to promote them to
28:09your Claude.md. Because they are
28:11actually rules that are useful to have a
28:13better outcome. So, if you do that as a
28:16diagnosing tool, you will by the end
28:18enrich your Claude.md and improve the
28:20experience for every single person
28:22in your team.
28:24There's another thing
28:26that I like to do to avoid polluting the
28:28context, that is the following. I think
28:30we all have done this, that is we get to
28:33the end the implementation of something
28:35and we need to do a commit. We all know
28:37how to do a commit, so get commit
28:39{slash} m write a message, right? But we
28:42say, "Hey Claude, commit this for me."
28:45I personally do that because the usually
28:47the message is so much better than the
28:49one that I would write, okay? I would
28:50say, "Fixed."
28:52or something like that.
28:53And Claude does a better job on that
28:55one. What you don't need is to have
28:57Claude reasoning about this step. What
29:01you can do in certain types of commands,
29:03those that are quite simple and you know
29:06how to do it, is to use the exclamation
29:08mark.
29:10Once you type the exclamation mark,
29:11every single thing that comes after will
29:13be treated as a bash command.
29:16So, if I want to do an LS or a dot net
29:18test, npm test, npm run, something like
29:21that, I don't need to have Claude
29:23thinking about the process. What is this
29:25thing? How do I run this that thing?
29:27You just write it.
29:29But keep in mind that result will go
29:31back to the context window. So, if you
29:33run something that
29:35brings sensitive information in,
29:38don't do it.
29:39Talking about Git,
29:41um recently they released one feature
29:43that I've been using a lot because I
29:45used to do this in another terminal,
29:47that is a slash diff. So, if during the
29:50process you want to see what Claude is
29:52changing, the files, the different
29:54changes in each line, you can actually
29:57open a pane that will contain that
29:59information, okay? On the side see all
30:01the files being changed and you can
30:04click there and see what changed, okay?
30:06It's a new feature uh that I really
30:08like.
30:09So, these type of things are things that
30:10come to help us with many of the things
30:13that we used to use for a long time.
30:15But the ones that I like the most are
30:16the ones that change the way that I
30:18work.
30:19The ones that change my lifestyle, I
30:22would say.
30:23And the one that impact me the most was
30:25the remote control.
30:27If you've never tried remote control,
30:29you should.
30:30Remote control is something uh quite
30:32cool. Then let me uh share with you a an
30:34example. So, a few months ago
30:37I was working on
30:39um
30:40something that I had to deliver on the
30:42the next day and I was running late and
30:45my father called me asking if I could go
30:47pick him at the hospital tell because he
30:49had an appointment. Um so, I was
30:52thinking, "Okay, uh I'm screwed. I have
30:54to deliver this thing. I want to stay,
30:56but I won't say no to my father."
30:58So, what I've done is that I start
31:00remote control.
31:02I asked Claude to implement a complex
31:04stuff um that will take a couple of
31:07minutes. Then, I pick my phone, my
31:09pocket.
31:11I go to the hospital.
31:13Uh and while I was waiting for my uh
31:15father I used the Claude code
31:17application
31:18to keep working.
31:21Okay, let's discuss uh work-life
31:23balance.
31:25>> [laughter]
31:27>> On the other side, there's another
31:28scenario where this is quite helpful.
31:31Sometimes I'm working the plan at my
31:33desk for a for a long time. I'm refining
31:35the plan. I know what I want to do and I
31:37know that the plan will take a couple of
31:38hours to be um executed. So, what I like
31:42to do is that I start remote control. I
31:44send Claude on that journey of
31:45implementing that thing and I go for a
31:47walk because I know that during that
31:49time I might receive a uh a pop-up
31:53notification message, a push
31:54notification saying, "Okay, you need to
31:56prove this thing or I need feedback on
31:58this thing." And I also know once it's
32:00finished.
32:01So, while on one hand we have a problem
32:04because now we can keep spending our
32:07tokens wherever we are
32:10on the other hand, it uh creates this
32:12opportunity to work in a different way.
32:15If you don't like this one, try the next
32:17one.
32:17Next one is voice and I know that many
32:19of you won't agree with me uh but I
32:22really like this one. So, before the
32:25pandemic uh we would go to the office 5
32:28days a week and you would sit in your
32:31computer and eventually you'll find a
32:33problem. You would spend 4, 6, 7 hours
32:36looking online trying to find that
32:38thing. There was nothing on Stack
32:40Overflow. There was no AI agent to fix
32:42it. So, we would go to your colleague in
32:45the other side of the office and you
32:46would start explaining the thing that
32:48you were facing.
32:49And eventually, in the middle of a
32:51sentence, he would say,
32:53"Ignore it. I know what it is." And you
32:55would go back to your computer and you
32:56would fix it in just a couple of
32:58minutes.
32:59Why? You were explaining it out loud.
33:02And for some reason, when you speak,
33:04your brain works in a different way. At
33:05least with me, it happens. So,
33:08I came to the conclusion that when I'm
33:10using voice,
33:12I start understanding better the things
33:13that I'm building. Okay? I know it's not
33:15for everyone. I don't advise anyone to
33:18be doing this in an open office. It
33:19might feel strange.
33:21But, if you want to try it at home,
33:24run {slash} voice to enable voice mode
33:27and from that point on, just press your
33:29space key without leaving it and start
33:32talking and it will write the prompt for
33:34you. Okay?
33:35That's the big idea.
33:37If you like this idea of working with
33:39different types of mediums, we call this
33:41multimodal.
33:42So, text,
33:44voice, and you also have image.
33:47If any of you is a front-end developer
33:49or works with the web,
33:52using images and print screens is
33:54awesome. Screenshots. So, often I'm
33:57building something and I'll
33:59shopping for inspiration online. So, I
34:01find a website that I like or I'll go to
34:04Figma and I see something that I like. I
34:07take a screenshot. I paste it on my
34:09terminal and I explain what I want on my
34:12own website. And Claude will use not
34:14only the text, but also the image as a
34:17visual representation.
34:19The cool thing is that you can actually
34:20do this in the terminal. You You can
34:22paste it or drag and drop images to your
34:24terminal and Claude will recognize it.
34:26If you use a Mac, it's actually control
34:29V as well. The command V doesn't work.
34:33Oh.
34:35One of the big problems of the being a
34:37developer in 2026
34:42is the fact that we are sitting waiting
34:45for our
34:46code to be written and we need to do
34:49other thing, right?
34:51So, you start working in things in
34:52parallel.
34:53And sometimes it might be things inside
34:55of the same project. So, how do you do
34:57it? Because you are working on that
34:58branch, how do I fix something on on a
35:02place where I'm actually working on the
35:04feature? Do I need to wait? Do I need to
35:06commit and move around?
35:08Nowadays we use this thing named work
35:10trees that
35:11is older than Claude code, okay? It
35:14stayed in
35:16Git Git for a long time, but we are now
35:18taking advantage of this. It's like
35:21a virtual folder that you have inside of
35:24your
35:25repo in your computer and you can keep
35:27working things in parallel. That means
35:29that I can be
35:31building a new feature,
35:33doing a code review,
35:35and fixing a bug on the same project at
35:37the same time, no problem.
35:39Actually, there's a problem. How do I
35:41know where I'm doing each of those
35:43things? Because it's hard to maintain
35:45that
35:46context when you are always shifting
35:48around between tabs or
35:50different
35:51windows. So, one thing that I like to do
35:53is to use the slash color and the slash
35:55rename. For example, I can apply red to
35:59a bug fix, orange to
36:01refactor, blue to a new feature. And
36:04also, I can rename the the conversation
36:08so I know that that is the issue 123
36:11from GitHub.
36:13And this way, when I'm moving around, I
36:15always have a reference, a visual
36:16reference where I'm looking at, okay?
36:19That can be quite helpful.
36:21Since you are waiting for Claude,
36:24you actually want to wait for a long
36:25time. You don't want to babysit Claude.
36:28How do you do it? One of my favorite
36:30features, slash goal.
36:32Instead of writing a prompt, write a
36:35goal.
36:36A goal is like a journey that Claude
36:38should go, the thing that needs to be
36:40built, but also a way to verify that we
36:43achieve the goal.
36:45How do we stop? When the test pass? When
36:48I have a specific type of test that will
36:50go through? When I go to the browser and
36:52click this button and something goes to
36:54the database?
36:56So, if you define that, Claude can
36:58iterate as a loop until finally it can
37:01verify that the thing that you are
37:02asking for is there.
37:04Example, you want to build an invoice
37:06generator, an API for that. You explain
37:09that and you say, "Okay, to verify this
37:11thing, create a test that should pass
37:14and that test will call the API and by
37:17the end you should call another API that
37:19will give you a PDF and the PDF should
37:21look like this one." Okay? If you do
37:23something like this, Claude will take
37:25his time, but eventually he'll get back
37:26to to you saying, "Okay, it's done. Give
37:29me feedback." It's better than staying
37:31there just babysitting in every single
37:34step. Okay?
37:36One thing that happens is that you send
37:37it on that journey and you are doing
37:40this for five, six, seven, eight, nine
37:43projects in parallel eventually. Okay?
37:46It's natural that it will happen.
37:48Um
37:50and when you are always jumping around
37:52between different tasks, seeing all of
37:54those logs from Claude is not that
37:56useful
37:57because many of those things are just
37:59details while he's implementing. It's
38:01like
38:02when you come for the first time to to a
38:04stage and you start doing demos or doing
38:08live coding, one thing that they teach
38:10you is that you shouldn't uh be quiet at
38:12any moment. And that's the thing that
38:14Claude is doing. But if you are not
38:16there looking at what is happening, why
38:18bothering? So, the thing that I like to
38:20use is {slash} focus.
38:23{slash} focus
38:25uh will basically say to Claude, "From
38:27this point on, I don't care about those
38:29intermediary messages. I just want to
38:32see my initial prompt
38:34and the final result." So, when I go to
38:36that conversation, I always see, "Okay,
38:38this was what I asked. This is what
38:41Claude is is telling me." Just that.
38:43It simplifies the whole process.
38:46Working with different agents, uh many
38:48different agents, is hard because you
38:50need to keep up with many different
38:51things.
38:52What do I recommend? You either use the
38:55Claude desktop application that is a bit
38:57easier to do that. Or if you are like me
39:00and you really like the terminal, you
39:02can actually start Claude with Claude
39:04space agents instead of doing doing only
39:07Claude. And basically what will happen
39:09is that you have access to the agents
39:11view. The agents view gives you access
39:14to
39:15a quick overview of who is running,
39:18okay? Who needs my attention? Who's the
39:21the next thing that I should do? Who has
39:23finished? And I can quickly navigate and
39:26jump between each agent and control it
39:28that way. Okay? It's one way of doing
39:31it.
39:33Let's now go to our second iteration
39:35break and talk about platform layer.
39:41What do I mean with this?
39:43We all have heard about skills or sub
39:46agents and things like that.
39:49But the thing is that sometimes we don't
39:51take advantage of those techniques in
39:54certain scenarios.
39:55And one of them that I like to use a lot
39:58is hooks.
40:00I used to do a ton of test driven
40:03development and one thing that
40:06changed me during the process of doing
40:08test driven development is that I like
40:10to have my feedback as soon as possible.
40:12Okay? When something is wrong, I want to
40:15know it.
40:16And Claude wants to know it as well. So
40:19why not
40:20building a hook that once Claude thinks
40:24that okay, this thing is done,
40:25runs your tests and uses that tests
40:28those tests as information to correct
40:31the path.
40:32You can do that. The benefit of doing
40:34such a thing is that now you are also
40:36saving
40:37tokens.
40:38Why? Because running this instruction,
40:42this bash command, yourself doesn't cost
40:44anything in terms of tokens.
40:47But if you decide to go to your Claude
40:49MD and write things like always run the
40:52tests by the end or
40:55respect this naming convention, always
40:58name tests this way. If you do things
41:00that way, actually it's Claude that
41:02needs to take the decision, that needs
41:03to reason about that, and sometimes
41:05won't do it.
41:07You are not sure that he's always doing
41:09it. But, if you create a post tool use
41:11hook and you let run your linter, your
41:14tests, and all of that,
41:16Claude will ask to run it. It will run
41:18it, and the feedback goes back into the
41:21conversation. So, if something is wrong,
41:23Claude can fix it before saying, "Okay,
41:25I'm done." Okay? That's one of the big
41:28benefits.
41:30The other one is skills.
41:31Skills is one of our favorites, okay? It
41:34looks like putting a prompt inside of a
41:36file that we call once in a while.
41:38They look like small recipes that we
41:41have.
41:42But, I think we are missing one
41:43important aspect of skills.
41:45Skills are more like packaging small
41:48features, small capabilities inside of a
41:51folder.
41:52Because a skill is so much more than a
41:55skill.md.
41:57The skill.md is just entry point.
42:00You can put there things like scripts,
42:02like a Python script, PowerShell script.
42:05You can bring all of that inside of that
42:07folder. You can bring markdowns
42:09explaining how to use that script.
42:12So, if your team has a Confluence page
42:14with scripts that you run once in a
42:16while to fix a given problem, you can
42:18package those scripts as skills. So,
42:21next time that you need them, you can
42:23just call Claude, and Claude will do it
42:25for you. Okay? It can run all of those
42:27things for you.
42:29Whatever is the language. If it runs on
42:30your machine, Claude can
42:32can do it.
42:34Talking about skills, I see often people
42:37creating their own
42:38code review skill or
42:41skills to
42:43for example do refactorings. A ton of
42:45skills that become quite repetitive, or
42:48we shop around online for them.
42:50But, actually, our friends from
42:52Anthropic exposed some
42:55um skills inside of the product by
42:57default. Skills that they use to build
42:59Cloud Code.
43:01One of them that I really like is the uh
43:03{slash} patch. What does this one does?
43:06Imagine that you want to do a a huge
43:08migration, like a huge refactoring,
43:10renaming a ton of things, you can run a
43:12{slash} patch, and it will parallelize
43:14the work for you. Okay? We'll split that
43:16in multiple
43:17agents and work separate agents and do
43:20the work for you. So, it's quite simple,
43:21you can take advantage. But, my favorite
43:23one is the {slash} simplify. Why it's my
43:26favorite one?
43:27I love simplicity, and the second thing
43:29is that many of [clears throat] us
43:31create this skill on its own, named
43:33something like refactor or something
43:35like that. {slash} simplify will try to
43:38fix things and to avoid duplication, the
43:40common problems that will lead to code
43:43hard to maintain. So, use that one
43:46before creating another one. Try that
43:48one. Play with it and see how it goes.
43:50It's the one that they use to build the
43:52product.
43:54There's also the {slash} loop.
43:56If you ever had the experience of uh
43:59creating a pull request that should be
44:02deployed to somewhere, and then you are
44:04going to, let's say, GitHub actions, and
44:07you are refreshing, waiting for
44:09the thing go green and to know that it's
44:11already on Azure or something like that,
44:14you can actually ask Cloud to do it. You
44:16say {slash} loop, every 5 minutes, go
44:19check if this thing is deployed.
44:21And it'll be doing for that for you.
44:23This is just a skill that they have
44:25built.
44:27As I told you, we also uh often shop
44:29around for um skills, but also we shop
44:33around for things like MCP servers.
44:37When you get to the tool, likely, you go
44:39online and you'll see, "Okay, which MCP
44:41servers exist?"
44:43Okay, in my company, I use this
44:44technology, that technology, and that
44:45technology, so let me install all of
44:47them.
44:48What is happening is that all of those
44:51different MCPs will be installed on your
44:53user profile.
44:54What you actually want to do is to go to
44:56your project, create a .mcp.json,
45:00and describe there all the MCPs that you
45:02use.
45:03Why?
45:04Next time that someone in your team
45:06opens the the project with Claude,
45:08Claude can go and make available those
45:11MCPs, and now you can also audit the
45:14ones that are used in your day-to-day
45:15because you'll be committing this file.
45:18Okay? Do that instead of having an
45:20instruction somewhere saying, "To work
45:22with this project, install these MCPs."
45:24It's one way to help your uh team as
45:27well.
45:30>> [clears throat]
45:31>> Do you know that you don't need to run
45:32Claude and wait for Claude to ask you a
45:34a question?
45:37There's actually an headless mode.
45:39You can use Claude to in this way.
45:42Claude space write the prompt {dash}
45:44{dash} print or {dash} p.
45:47What is happening is that instead of
45:49going to that uh typical user experience
45:52of asking for the first prompt, it'll
45:54run that thing and get back to you and
45:56hence the session.
45:59That means
46:00that you can do things like this.
46:02You can start changing your scripts,
46:05your partial scripts, your shell
46:07scripts, whatever, to have reasoning in
46:10place.
46:11To use Claude as one element of it. You
46:15can do piping, for example, send things
46:17to Claude, Claude analyze them, and then
46:19outputting the result to another place.
46:22You can do all of that with your uh
46:24Claude subscription.
46:27Let's go to the final one. Okay? Um this
46:30one is uh quite important to me
46:34because
46:36I often see people using uh think about
46:38Claude since we say Claude code as just
46:41one thing to write code. But personally,
46:44I have tried to use Claude for other
46:46things as well, and uh actually it's
46:48helping me in my day-to-day uh improving
46:51my life. So, I decided, "Why not sharing
46:54with you?" So, some of those things
46:56might work as inspiration for the types
46:58of things that you can do in your
46:59day-to-day with Cloud.
47:03You might be aware
47:04that Cloud nowadays offers three
47:06different products: Cloud Code,
47:09Cloud Co-work, and cloud.com.
47:12Cloud Co-work is like a hybrid between
47:14um Cloud Code and the Cloud because it
47:17has access to the same things on your
47:19machine, but it tends to be a bit more
47:21friendly. But, we are developers. We
47:23don't need friendly things, right?
47:25Uh
47:26so,
47:28you can use Cloud Code to automate many
47:30different things, and it opens many
47:31different possibilities. One common use
47:34case that I see is when you have those
47:37quarter reviews where you'll be
47:39evaluated, and you need to go to your
47:41manager and say, "You know, this
47:44uh year I have implemented this thing,
47:46that thing, and that thing. I had this
47:48contribution on this project and on that
47:50project." The problem is that doing that
47:52after three, four, or six months is
47:55hard. You need to go back to your uh
47:58email or calendar to understand the
48:00meetings you were involved and all of
48:01those things.
48:03But, if those
48:04objectives were related to were related
48:06to uh code,
48:09ask Cloud.
48:10If you have been building those things
48:12with Cloud, Cloud can tell you what you
48:14have been building. Okay? It can share
48:16with you the things that you have been
48:18doing.
48:20And also, that means that you can go to
48:22your user profile,
48:23create a skill
48:25to do this every quarter whenever your
48:27manager asks for it. So, you don't need
48:29to go back and research your email once
48:31again or calendar. You can actually ask
48:33Cloud to help you during the process.
48:37Let's use another example.
48:39I have a huge problem with my downloads
48:40folder. Anyone can relate?
48:43Okay? I think I'm not alone. Uh every
48:46single thing that goes to my downloads
48:48folder will only disappear from there in
48:50the day that I get that message saying
48:51you don't have enough space on your
48:53disk. Okay?
48:54So, that's the day when I decide to take
48:56actions. I'm always afraid of losing
48:58something that matters, but I know that
49:00there's nothing value inside of that
49:02folder. But, I'm in fear. So, what I've
49:05decided to do is that recently I have
49:081,626
49:11items inside of that folder. I know that
49:14some of those were actually folders, so
49:16they were even more. And what I decided
49:19to do was the following. A cloud, can
49:21you help me with this thing? Organize
49:23those things into uh
49:24uh folders. So, then it becomes easy to
49:27me to take decisions. Because now what
49:30I'm seeing is a couple of folders, and I
49:32know that if it's code, it will be on
49:34GitHub, so I don't care. Let's drop that
49:37one. If it's a screenshot, I don't care.
49:40Let's drop that one. Installers as well.
49:43But for things like documents, okay,
49:44let's take some time and look at it.
49:47It's those small things that you used to
49:49take a ton of time or writing a Python
49:51script that you can use cloud to help in
49:53your day-to-day in just a couple of
49:55minutes instead of wasting your time.
50:00While I'm quite disorganized with my
50:02downloads folder, I'm absolutely
50:04obsessed with productivity.
50:06Uh maybe that's the reason why I'm doing
50:08this talk now that I think about it.
50:10Uh
50:11But one of the things that I really like
50:13is uh note taking. But for a long time I
50:15struggle I struggle to find the tool
50:17that I like, the tool that I would use,
50:19that I would commit to it. So, I tried
50:22OneNote, Evernote, Apple Notes,
50:25whatever you you know Notion, whatever
50:27you know uh I tried it. And I tried one
50:30thing named Obsidian.
50:31Obsidian works with markdowns. Uh it can
50:34create connections between those
50:36markdowns. But the way that I see it is
50:38like a client on top of your a folder
50:41with markdowns that you can use as note
50:42taking.
50:44And eventually I start thinking, okay.
50:46Obsidian loves markdowns.
50:49Cloud code loves markdowns
50:51on my machine.
50:53Why not using both together?
50:55So, nowadays I can use Cloud Code to
50:58help me in my day-to-day type of things.
51:00It can help me to surface things that I
51:02would need to do next month.
51:04It can help me with summarizing a given
51:08meeting. It can help me with things like
51:11understanding when I'm running late,
51:12when I'm not. It can help me to create
51:15connections between different notes that
51:17I'm researching.
51:19And nothing here is code.
51:22It's just text. Text on my machine.
51:25And now I have a folder that I control
51:28and I use the tool that I want. And if
51:29the day that I want to use Code X or
51:31Cursor or whatever, I can do it as well
51:34because I move those technologies to my
51:37own control. Why that is cool? Because
51:40now I can run Claude inside of my
51:42Obsidian and I can have those
51:45cool mesh diagrams over there that they
51:48are pretty cool for a slide. Actually,
51:50they are useless.
51:52Uh
51:53but they are pretty cool. So, these
51:55types of things you can do. Let me share
51:57with you one more example before we get
52:00to the end.
52:01So,
52:03I I have a a chronic disease. So, uh
52:07maybe 10 years ago or more, I was told
52:10that I couldn't run, okay? Um yes,
52:14because of the problems that I have with
52:16that disease. And I accept that fact and
52:18for a long time I didn't want to go for
52:20a run.
52:21Eventually, I was stubborn enough that I
52:23started running. And one thing that I
52:25learned during the process is that the
52:27problem was not the fact that I was
52:29running. Was the fact that I was running
52:31in an unstable way.
52:33I would I might be running today 5 km
52:36and next week I will try 20 km, okay?
52:39And um
52:40that was not structured. I didn't have
52:42anyone advising me.
52:45So, what I decided to do eventually is
52:47that I record my all my runs using
52:50Strava. So, I said, "Okay, let's build a
52:53skill that goes to Strava every single
52:56day, pulls my
52:58runs into my Obsidian vault. So, now all
53:01of my history from every single year
53:04since I've been using Strava is inside
53:06of my Obsidian vault.
53:08Then, I have a second skill that I run
53:10every week that that I uh ask, "Hey,
53:13help me build this um
53:15um
53:16program, so the next week plan, and
53:19guarantee that we don't get to the point
53:21that we were before where I had to stop
53:23because of my disease."
53:25And now, I have every week a stable way
53:28of keep running, and I have been uh more
53:30healthy because of that.
53:33Just using two skills and a set of files
53:35on my own machine.
53:37So, any type of things like those, you
53:40can do it with just a set of files
53:43and Clojure.
53:44I hope you have learned at least one or
53:46two things with me. I told you that was
53:48the goal. But, if you haven't learned
53:50anything with me, promise me one thing.
53:53Next uh week, once you get to your desk
53:56and you start Clojure, type
53:57{slash}insights.
53:59Because if I couldn't tell you anything
54:00new, {slash}insights will tell you a lot
54:03about the way that you use Clojure.
54:05I hope you like this session, and I hope
54:07you enjoy the rest of the conference,
54:08and I will see you around. Thank you.
54:11>> [applause]

About this transcript

This page contains the full transcript of What Claude Code Can Do That You Haven't Tried - Gui Ferreira - NDC Oslo 2026 by NDC Conferences, generated from the public captions YouTube serves with the video. The transcript has 9,451 words across 1,465 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.