[00:00] (0.08s)
In this video, I want to talk to you
[00:01] (1.20s)
about the workflow that I've been using
[00:02] (2.88s)
with Cloud Code and GitHub to build a
[00:05] (5.68s)
new web app over the last couple weeks.
[00:07] (7.68s)
And I feel like it's sort of unlocked
[00:09] (9.84s)
new superpowers for me. So, first let me
[00:12] (12.08s)
just go through the workflow at a high
[00:13] (13.68s)
level just to give you the taste in case
[00:15] (15.12s)
you don't have much time. And then we're
[00:16] (16.88s)
going to circle back. We're going to
[00:17] (17.84s)
talk about the why you might need a
[00:19] (19.52s)
workflow like this. And then we'll dive
[00:21] (21.44s)
into each of the steps in a little bit
[00:22] (22.96s)
more detail. So, here's how it works. I
[00:25] (25.04s)
create GitHub issues for all the work I
[00:27] (27.28s)
want to have done on the app. In cloud
[00:29] (29.20s)
code, I have a detailed slash command
[00:31] (31.28s)
with instructions on how to process
[00:33] (33.36s)
issues. At a high level, I want it to
[00:36] (36.00s)
first plan its work using scratch pads
[00:38] (38.80s)
to break down the big issue into small
[00:41] (41.44s)
atomic tasks. Then once it's planned its
[00:44] (44.48s)
work, it can create the code. After it's
[00:47] (47.36s)
created the code, it can then test its
[00:49] (49.92s)
work. It can do this in two different
[00:51] (51.36s)
ways. One, running the test suite. And
[00:53] (53.84s)
second, it can use Puppeteer to click in
[00:55] (55.92s)
a browser if it's made any UI changes.
[00:58] (58.96s)
Then once it has tested its work, it
[01:01] (61.28s)
will commit its work to GitHub and open
[01:03] (63.92s)
up a pull request which is then
[01:05] (65.68s)
reviewed. Sometimes I review that PR,
[01:08] (68.96s)
sometimes I have Claude Code review the
[01:11] (71.04s)
PR with a different slash command that
[01:13] (73.20s)
I've written. Also, I have continuous
[01:15] (75.36s)
integration set up on GitHub via GitHub
[01:17] (77.76s)
actions so that anytime a commit is
[01:20] (80.08s)
made, we run the test suite and we run a
[01:22] (82.40s)
llinter and we check to make sure that
[01:24] (84.48s)
it is safe to merge the commits into the
[01:28] (88.24s)
main branch. And then in cloud code, I
[01:31] (91.04s)
use /clear to wipe away the context
[01:34] (94.40s)
window. And then I have it tackle the
[01:36] (96.96s)
next issue and repeat the cycle. Now, I
[01:40] (100.08s)
don't want to pretend like I've created
[01:41] (101.60s)
the wheel here because what I've just
[01:43] (103.36s)
described to you could be summed up as a
[01:46] (106.00s)
cycle of plan, create, test, deploy,
[01:50] (110.24s)
which are generally considered to be the
[01:52] (112.16s)
four phases of the software development
[01:54] (114.48s)
life cycle. So, why do you need a cycle
[01:57] (117.52s)
like this if you have such powerful
[01:59] (119.44s)
software coding agents? Well, the
[02:01] (121.84s)
software industry has known for a long
[02:04] (124.08s)
time that writing code is just one phase
[02:08] (128.32s)
of what's required to ship and maintain
[02:11] (131.36s)
complex software. Turns out that some of
[02:13] (133.76s)
the processes and systems that we built
[02:16] (136.32s)
to manage the creation of software work
[02:19] (139.68s)
really well with these AI coding
[02:22] (142.56s)
assistants and in particular cloud code.
[02:25] (145.20s)
Now to be even more specific, the
[02:26] (146.88s)
workflow I've just described is based
[02:28] (148.48s)
heavily upon GitHub flow, which is a
[02:31] (151.20s)
workflow first published by Scott Shaon,
[02:34] (154.56s)
who is one of the co-founders of GitHub.
[02:36] (156.72s)
Published this about 13 14 years ago
[02:38] (158.88s)
when GitHub was just about 35 employees.
[02:42] (162.08s)
So this is a workflow that's well known
[02:44] (164.16s)
that works really great for small teams.
[02:46] (166.56s)
Say if your team was, I don't know,
[02:48] (168.48s)
approximately the size of one human and
[02:50] (170.40s)
one AI coding assistant. Let's go back
[02:53] (173.04s)
through and talk about each of those
[02:54] (174.24s)
four phases in a little bit more detail.
[02:56] (176.48s)
Plan, create, test, and deploy. Uh,
[02:59] (179.44s)
let's start off with creating the
[03:01] (181.12s)
issues. When I very first started
[03:03] (183.04s)
working on this app, I started that with
[03:04] (184.80s)
a dictation session via Super Whisper.
[03:07] (187.68s)
And then I just worked with Claude to
[03:09] (189.68s)
turn that into a requirements document.
[03:11] (191.52s)
And then once I had those steps, I told
[03:13] (193.52s)
Claude Code to create GitHub issues from
[03:16] (196.08s)
there. Now, you also need a way for
[03:17] (197.44s)
Claude Code to interact with GitHub. And
[03:19] (199.36s)
Enthropic's recommended way of doing so
[03:21] (201.20s)
is to install the GitHub CLI. And this
[03:24] (204.40s)
allows Cloud Code to run GH via Bash to
[03:28] (208.40s)
interact with GitHub. For some reason,
[03:30] (210.32s)
you can't install that CLI. You could
[03:32] (212.88s)
use the MCP server, but the CLI is a
[03:35] (215.28s)
recommended way of doing so. Now, I
[03:37] (217.28s)
would say the first mistake I really
[03:38] (218.80s)
made here was that I had it create those
[03:40] (220.96s)
issues. It's probably about 30 or 40
[03:42] (222.72s)
issues, and then I just had to start
[03:44] (224.72s)
working on them. It was overly
[03:46] (226.08s)
optimistic of me to assume that we could
[03:48] (228.00s)
go straight from the GitHub issues that
[03:49] (229.44s)
it created to writing software. In
[03:51] (231.84s)
reality, my job perhaps got a little bit
[03:54] (234.16s)
less fun because instead of writing code
[03:55] (235.92s)
now, I really needed to go and make sure
[03:58] (238.08s)
that I was being very specific in those
[04:00] (240.00s)
issues and really refining them. And I'd
[04:02] (242.56s)
say the more granular, the more
[04:04] (244.48s)
specific, the more atomic those issues
[04:06] (246.96s)
got, the better results I had. And I had
[04:09] (249.52s)
a couple false starts where I kind of
[04:11] (251.04s)
had to throw the whole project away and
[04:13] (253.20s)
really go back and spend time in GitHub
[04:15] (255.28s)
and say, "Okay, what do we do first?
[04:17] (257.20s)
What do we do second? And how do we
[04:18] (258.72s)
break this down and keep it really
[04:20] (260.32s)
tightly scoped so that we're setting
[04:22] (262.08s)
ourselves up for success?" In fact, it's
[04:23] (263.68s)
kind of funny. I was at Twilio for 9
[04:25] (265.28s)
years. I was a manager for a lot of that
[04:27] (267.12s)
time. And I feel like I got a little
[04:28] (268.80s)
burned out on being a manager and I have
[04:31] (271.12s)
really been enjoying writing code over
[04:33] (273.12s)
the last couple years. And these last
[04:35] (275.04s)
couple weeks, I feel like I had to put
[04:36] (276.32s)
my manager hat back on. I've written
[04:38] (278.88s)
very little code myself and instead I've
[04:41] (281.28s)
spent most of my time writing really
[04:43] (283.36s)
detailed specs, reviewing code that was
[04:46] (286.96s)
written by someone else, leaving
[04:49] (289.20s)
comments and saying things like, "H,
[04:51] (291.12s)
this is not quite good enough. Please
[04:52] (292.64s)
try again." Or, "Actually, I thought I
[04:54] (294.56s)
wanted that, but that now that I see it,
[04:56] (296.08s)
that's not quite what I want." Or,
[04:57] (297.44s)
"Throw away all your work and uh I don't
[04:59] (299.76s)
actually want this at all." Uh and so if
[05:02] (302.00s)
you want to like roleplay as an
[05:03] (303.52s)
engineering manager, uh this process is
[05:06] (306.72s)
actually a pretty good way to do that.
[05:08] (308.64s)
The first couple issues that we worked
[05:10] (310.08s)
on were setting up the test suite and
[05:12] (312.40s)
continuous integration. Most of my work
[05:14] (314.64s)
that I've done over the last 10 years
[05:16] (316.16s)
has been in Python, but anytime I'm
[05:18] (318.32s)
building a more complex web app and need
[05:20] (320.56s)
a users table, I find myself starting to
[05:23] (323.68s)
reach back for Rails. I also think
[05:25] (325.76s)
there's something about the MVC
[05:27] (327.84s)
framework which is not unique to Rails.
[05:29] (329.68s)
Django has this too and lots of
[05:31] (331.36s)
frameworks use the model viewcontroller
[05:33] (333.36s)
framework. But I think there's something
[05:35] (335.20s)
about modularizing your codebase that
[05:38] (338.64s)
makes it easier for coding agents to
[05:40] (340.72s)
work with because they can focus on code
[05:43] (343.28s)
that's related to one idea as opposed to
[05:45] (345.92s)
say a main.py or an index.js that's a
[05:49] (349.68s)
thousand lines long. Rails has really
[05:52] (352.00s)
nicely integrated testing framework and
[05:53] (353.92s)
it was really important to me from the
[05:55] (355.52s)
beginning to get my test suite up and
[05:57] (357.36s)
running so that I could set up GitHub's
[05:59] (359.68s)
continuous integration so that I could
[06:01] (361.76s)
have my tests run automatically every
[06:03] (363.92s)
time Claude Code was pushing commits.
[06:06] (366.72s)
Now along the same lines, I also set up
[06:08] (368.56s)
the Puppeteer local MCP server and
[06:10] (370.88s)
Puppeteer allows Claude Code to use a
[06:13] (373.84s)
web browser to test the local changes to
[06:16] (376.24s)
your app. I've actually found this to be
[06:17] (377.92s)
really useful as I've started in on
[06:20] (380.24s)
redesigning the app. It's also good for
[06:22] (382.48s)
testing to see if buttons work or forms
[06:25] (385.04s)
work. It's actually very surprising and
[06:27] (387.36s)
very satisfying to watch cloud code uh
[06:30] (390.72s)
click around in a browser to test the
[06:32] (392.56s)
work that it's already done. So, I'd say
[06:34] (394.64s)
before you can really get moving with
[06:37] (397.04s)
rapid iterative feature development, you
[06:39] (399.68s)
need some really well- definfined
[06:41] (401.28s)
issues. You need your app set up on a
[06:43] (403.68s)
GitHub repository and you need
[06:45] (405.60s)
continuous integration set up with a
[06:47] (407.76s)
really good test suite and Puppeteer
[06:50] (410.00s)
helps a lot as well. But once you have
[06:51] (411.76s)
that foundation in place, now you're
[06:53] (413.68s)
ready to go. All right, so I have some
[06:55] (415.28s)
issues here. Let me talk through what
[06:56] (416.80s)
happens when I have Claude Code work on
[06:58] (418.40s)
an issue. Most important thing here is
[07:00] (420.64s)
you're going to create a slashcomand.
[07:02] (422.48s)
You can do this in thecloud/comands
[07:06] (426.40s)
directory. A slash command is basically
[07:08] (428.24s)
a prompt template and you can add
[07:11] (431.04s)
command line arguments to that. So the
[07:13] (433.12s)
argument that we're going to be passing
[07:14] (434.32s)
into this one is the issue number. Now
[07:17] (437.36s)
for my /command for processing issues, I
[07:19] (439.52s)
started with the one that came from the
[07:21] (441.92s)
anthropic post on best practices for
[07:24] (444.32s)
agent decoding. That was a post written
[07:26] (446.40s)
by Boris who is the original creator of
[07:28] (448.48s)
cloud code. And I started there and then
[07:30] (450.72s)
I just iterated over time. I added more
[07:32] (452.56s)
to it. And you can see I broken up into
[07:34] (454.48s)
four parts. plan, create code, test, and
[07:37] (457.20s)
deploy. And uh plan is the biggest one.
[07:40] (460.56s)
You know, it's perhaps the most
[07:41] (461.68s)
important. I'm telling Cloud Code to use
[07:44] (464.24s)
the GitHub CLI to view the issue. Uh I
[07:47] (467.20s)
also then ask it to go dig up some prior
[07:49] (469.36s)
art on this. So, uh I do have it use
[07:51] (471.92s)
what's called scratchpad. So, it
[07:53] (473.52s)
basically has a directory in the
[07:54] (474.72s)
codebase where Claude code can plan all
[07:56] (476.72s)
of its work. And I ask it to search
[07:59] (479.12s)
those scratch pads for uh previous work
[08:02] (482.24s)
related to this issue. I ask it to look
[08:04] (484.88s)
through PRs, previous PRs in GitHub to
[08:07] (487.52s)
see if it can find other work that's
[08:09] (489.20s)
been done on this issue so it can figure
[08:10] (490.72s)
out what's been done and why. I use here
[08:13] (493.84s)
the think harder uh prompt to trigger
[08:17] (497.76s)
thinking mode. Uh Anthropic has several
[08:20] (500.16s)
of these. So you can do think hard,
[08:22] (502.24s)
think harder. I think you can do think
[08:23] (503.84s)
hardest and ultraink. I cannot tell you
[08:26] (506.48s)
why I've settled in on think harder. It
[08:28] (508.56s)
seems to be working well. Um maybe I
[08:31] (511.12s)
need to bump this up to ultraink in the
[08:32] (512.88s)
future. I don't know. Uh, but the key
[08:34] (514.64s)
here is that I want it to break the
[08:36] (516.24s)
issue down into small, manageable tasks.
[08:39] (519.20s)
Then I ask it to write that plan on a
[08:41] (521.36s)
new scratchpad and to include a link to
[08:43] (523.52s)
the issue there. Now, Claude Code's
[08:45] (525.36s)
going to write the code and after it's
[08:46] (526.96s)
written some code, it's going to commit
[08:48] (528.72s)
the code. Or is it? I think one of the
[08:51] (531.20s)
biggest questions that's going to come
[08:52] (532.16s)
out of this workflow is, do you have
[08:54] (534.72s)
Claude code write the commit for you or
[08:57] (537.28s)
is it your responsibility to do that? I
[08:59] (539.92s)
have been convicted by Thomas Tacic. He
[09:02] (542.80s)
wrote this post a few weeks ago called
[09:05] (545.20s)
All of My AI skeptic friends are nuts.
[09:07] (547.68s)
It was super popular. It's probably the
[09:09] (549.28s)
best piece of writing that I've read on
[09:11] (551.68s)
AI assisted coding. The link's in the
[09:13] (553.76s)
description here. I encourage you just
[09:15] (555.52s)
to like read it. It's an amazing piece
[09:17] (557.20s)
of writing. Uh and there's a section
[09:19] (559.92s)
he's going through all of the uh
[09:21] (561.60s)
criticisms or objections from his AI
[09:24] (564.40s)
skeptic friends about why you shouldn't
[09:26] (566.08s)
use AI assisted coding. So the objection
[09:28] (568.40s)
here is but you have no idea what the
[09:30] (570.08s)
code is. And Thomas replies, "Are you a
[09:32] (572.40s)
vibe coding YouTuber?" Maybe. Uh, can
[09:35] (575.60s)
you not read code? If so, astute point.
[09:38] (578.32s)
Otherwise, what the is wrong with
[09:39] (579.84s)
you? You've always been responsible for
[09:42] (582.00s)
what you merge domain. You were 5 years
[09:44] (584.00s)
ago and you are tomorrow, whether or not
[09:46] (586.00s)
you use an LLM. If you build something
[09:48] (588.24s)
with an LLM that people will depend on,
[09:50] (590.64s)
read the code. In fact, you'll probably
[09:52] (592.56s)
do more than that. You'll spend 5 to 10
[09:54] (594.48s)
minutes knocking it back into your own
[09:56] (596.00s)
style. And in fact, as I talk to uh
[09:58] (598.80s)
engineer friends who are working at
[10:00] (600.40s)
large companies using claude code there,
[10:02] (602.88s)
they will actually not even let claude
[10:05] (605.52s)
do the commit even though it's really
[10:07] (607.04s)
great at writing commit messages, but
[10:08] (608.96s)
instead they will open up all of its
[10:10] (610.72s)
changes in an IDE such as cursor, review
[10:13] (613.44s)
them all. I've not really been doing
[10:15] (615.52s)
either of those things on this project.
[10:16] (616.88s)
I started I I really did start there and
[10:19] (619.44s)
I was like being very diligent opening
[10:22] (622.24s)
up all the code and cursor. Uh, at some
[10:24] (624.80s)
point I have to admit I started getting
[10:27] (627.04s)
lazy. So maybe I've fallen back into the
[10:29] (629.12s)
vibe coding YouTuber genre, I guess. Uh,
[10:32] (632.96s)
but uh, I have been letting Claude do
[10:36] (636.72s)
all of the commits and then I do try to
[10:39] (639.36s)
read the PRs. Although I will say, and
[10:42] (642.16s)
we'll get to this in a second, sometimes
[10:43] (643.52s)
I just have Claude read the PR. Uh, but
[10:45] (645.92s)
let me tell you what makes me feel a
[10:48] (648.16s)
little bit a little bit better about
[10:50] (650.64s)
having Claude do that, and that's tests.
[10:52] (652.80s)
So when I started this project, I wanted
[10:54] (654.40s)
to be really sure that I had a good test
[10:57] (657.52s)
suite because I do feel like in other
[10:59] (659.68s)
projects such as like the games I built
[11:01] (661.60s)
for my daughters, I often run into issue
[11:03] (663.52s)
where things are working pretty good and
[11:05] (665.36s)
then Claude makes a change. Sometimes a
[11:07] (667.20s)
seemingly simple or benign change and it
[11:09] (669.20s)
breaks all the stuff. I'm not looking
[11:10] (670.96s)
for necessarily 100% code coverage, but
[11:13] (673.52s)
I do want to have high confidence that
[11:15] (675.60s)
Claude can work on one feature without
[11:17] (677.84s)
breaking the stuff it's done before. All
[11:19] (679.84s)
right. Finally, we have planned. We have
[11:21] (681.84s)
created code. We have tested the code.
[11:23] (683.76s)
Now, it is time to deploy. I personally
[11:26] (686.40s)
deploy to render. I like it for a lot of
[11:30] (690.16s)
the stuff I've been building lately,
[11:31] (691.52s)
both in the Python and Rails apps. Uh,
[11:34] (694.48s)
render will look for pushes to your main
[11:37] (697.44s)
branch of GitHub and then automatically
[11:39] (699.84s)
deploy your new app. So in this
[11:41] (701.92s)
workflow, merging a branch into the main
[11:45] (705.12s)
branch in GitHub is the same
[11:47] (707.60s)
approximately as deploying to
[11:49] (709.36s)
production. And so the way that we set
[11:52] (712.16s)
up a branch to merge it into main is by
[11:55] (715.12s)
opening up a pull request. So you as the
[11:58] (718.56s)
human here working with the AI, let's
[12:00] (720.56s)
assume that you have had Claude make the
[12:02] (722.56s)
commits and then let's assume that you
[12:04] (724.40s)
have had Claude open the PR. This is the
[12:07] (727.36s)
place where you really can get in and
[12:09] (729.60s)
review the changes that it's made and
[12:12] (732.00s)
you can leave comments on the changes
[12:14] (734.24s)
that Claude has made and then you can go
[12:16] (736.72s)
back into the console and ask Claude to
[12:19] (739.84s)
view those comments and to make changes
[12:22] (742.08s)
based on them. You can also set up a
[12:25] (745.20s)
separate slash command to ask Claude to
[12:28] (748.96s)
do a uh PR review for you. Now, if you
[12:32] (752.64s)
do have a slash command for doing a PR
[12:34] (754.72s)
review, what I would encourage you to do
[12:36] (756.08s)
is to open up cloud code in a completely
[12:38] (758.88s)
new shell and then to run it fresh and
[12:42] (762.80s)
so that it is not doesn't have the
[12:44] (764.64s)
context pollution of the work that it's
[12:46] (766.40s)
already done. I have a a slash command
[12:49] (769.20s)
for doing PR reviews uh where I ask it
[12:52] (772.16s)
to review it in the style of Sandy Mets.
[12:54] (774.16s)
Sandy Mets is one of my heroes from the
[12:55] (775.84s)
Rails world. She has some great
[12:57] (777.44s)
principles for writing beautiful
[12:59] (779.20s)
maintainable code. When I have Claude
[13:02] (782.24s)
review the code in the style of Sandy
[13:04] (784.08s)
Mets, it reveals places where we can
[13:06] (786.48s)
make things more maintainable or more
[13:08] (788.24s)
readable that I would have missed and
[13:09] (789.68s)
certainly that Claude missed on its
[13:11] (791.28s)
first pass. Now, I I will admit there's
[13:13] (793.76s)
been more than a few times over the last
[13:15] (795.84s)
couple weeks when I've had Claude write
[13:17] (797.76s)
the code. I've had Claude do the PR
[13:20] (800.16s)
review. Uh I've ensured that the test
[13:23] (803.20s)
pass and I'm like, "Looks good to me."
[13:25] (805.60s)
And I click the button to merge the poll
[13:28] (808.08s)
request. So again, this the video is not
[13:31] (811.20s)
intended to be prescriptive about the
[13:33] (813.28s)
workflow, but I think the high-level
[13:35] (815.20s)
bits here make a lot of sense. And then
[13:37] (817.60s)
you got to figure out where in those
[13:39] (819.76s)
individual steps of of the plan, the
[13:42] (822.96s)
create, the test, and deploy are you
[13:45] (825.76s)
going to get hyper involved as the
[13:47] (827.28s)
human? And for me personally, I have
[13:48] (828.96s)
been hyper involved in the planning
[13:50] (830.64s)
phase. And I found it really difficult
[13:52] (832.48s)
to delegate anything other than just
[13:54] (834.80s)
like cleaning up my ideas or my pros to
[13:57] (837.60s)
Claude. I think the planning is where
[13:59] (839.52s)
I've been spending a whole lot of time
[14:01] (841.52s)
and then I personally for this app and
[14:03] (843.44s)
the size of the app and size of the
[14:04] (844.80s)
codebase and all have been able to
[14:06] (846.32s)
delegate a lot of the creating testing
[14:09] (849.12s)
and deploying or the reviewing of the
[14:11] (851.04s)
the coding etc to Claude. All right. So
[14:14] (854.08s)
finally now that I have merged my PR
[14:16] (856.08s)
here's what I do. I go back to claude
[14:17] (857.68s)
and I run /cle.
[14:19] (859.84s)
This completely wipes away the context
[14:22] (862.08s)
window. I am not compacting the window.
[14:24] (864.08s)
I am clearing the window. The idea here
[14:26] (866.56s)
is that each issue should contain all of
[14:29] (869.04s)
the information that Claude needs to
[14:31] (871.44s)
perform that work. It should be able to
[14:33] (873.44s)
work on the issue from a cold start. And
[14:35] (875.60s)
thanks to the scratch pads and thanks to
[14:37] (877.28s)
its ability to review PRs and all the
[14:39] (879.84s)
previous work that's been done on the
[14:41] (881.20s)
codebase, that issue should be
[14:43] (883.12s)
descriptive enough for it to tackle it
[14:45] (885.28s)
with no working memory. And this also
[14:48] (888.32s)
frees up your context window. It will
[14:50] (890.00s)
help you get better results while using
[14:52] (892.16s)
fewer tokens. Now, let me address a
[14:54] (894.80s)
quick question because you probably saw
[14:56] (896.24s)
that Anthropic launched uh Claude via
[14:58] (898.64s)
GitHub actions and this is a really cool
[15:00] (900.56s)
feature that lets you just tag Claude in
[15:04] (904.16s)
your directly from GitHub and have it
[15:06] (906.24s)
work on some stuff. Um, so I have been
[15:09] (909.28s)
playing with that a little bit. The
[15:11] (911.12s)
primary reason why I'm not using that is
[15:13] (913.12s)
because as of today, um, that usage of
[15:17] (917.04s)
the GitHub actions is built with metered
[15:19] (919.76s)
billing against your API. even if you're
[15:22] (922.00s)
on a Claude Max plan. So, I have
[15:24] (924.80s)
upgraded now to the $200 a month Claude
[15:27] (927.60s)
Max plan. I am finding it is totally
[15:30] (930.08s)
worth it to get the Claw 4 Opus use. Um,
[15:34] (934.00s)
I've just been thrilled with the value
[15:35] (935.36s)
I'm getting there, but then I was kind
[15:37] (937.52s)
of bummed to then get a $50 API bill
[15:40] (940.32s)
from Anthropic after I had been using uh
[15:42] (942.80s)
tagging Claude in GitHub. And so, I was
[15:45] (945.68s)
like, man, if I'm already getting
[15:46] (946.96s)
unlimited access, uh, I might as well
[15:48] (948.88s)
just do it in the console. And candidly,
[15:50] (950.32s)
I think I'm getting much better uh
[15:52] (952.96s)
insight and results from using claude
[15:55] (955.36s)
code in the console. And so I actually
[15:56] (956.80s)
talked to a friend Martin who works at
[15:58] (958.80s)
Anthropic and his suggestion was use uh
[16:03] (963.28s)
Claude in the GitHub actions when you're
[16:05] (965.52s)
say doing a PR review and there's a
[16:07] (967.84s)
small change perhaps a copy change or
[16:09] (969.92s)
just like something tiny that needs to
[16:11] (971.60s)
be tweaked but you don't necessarily
[16:12] (972.80s)
want to go into the codebase and do it
[16:14] (974.32s)
yourself. It's really good for those
[16:16] (976.16s)
smaller fixes, but you probably don't
[16:18] (978.56s)
want to be using GitHub actions for
[16:21] (981.28s)
really large meaningful changes to your
[16:23] (983.68s)
codebase. Uh, finally, let me just talk
[16:25] (985.68s)
about work trees because, uh, Anthropic
[16:27] (987.84s)
talks about this quite a bit. The best
[16:29] (989.68s)
analogy that I have for work trees would
[16:31] (991.76s)
be multitabling and poker. You know, you
[16:34] (994.00s)
start playing online poker on a single
[16:35] (995.76s)
table and then you realize you're just
[16:37] (997.12s)
kind of clicking buttons every once in a
[16:38] (998.64s)
while. you could probably play two table
[16:40] (1000.08s)
at a time and then at some point you've
[16:42] (1002.00s)
bought a bigger monitor and you're like
[16:44] (1004.00s)
playing four or eight tables at a time.
[16:46] (1006.56s)
That's sort of what running clawed work
[16:49] (1009.04s)
trees feels like. Uh instead of
[16:51] (1011.68s)
different poker tables up, you're just
[16:53] (1013.36s)
tabbing between different tabs in the
[16:55] (1015.44s)
terminal. And generally I think that the
[16:58] (1018.40s)
industry as a whole is excited about uh
[17:01] (1021.52s)
running coding agents in parallel or in
[17:03] (1023.76s)
the background. And work trees is the
[17:05] (1025.68s)
method that you can use with GitHub to
[17:08] (1028.00s)
run multiple instances of Claude working
[17:10] (1030.64s)
on multiple issues at the same time. I
[17:13] (1033.68s)
personally ran into two issues with it.
[17:15] (1035.44s)
The first is because I'm just getting
[17:17] (1037.76s)
started building this app. There's so
[17:19] (1039.36s)
much work that just simply needs to be
[17:20] (1040.96s)
done iteratively. There aren't a lot of
[17:23] (1043.04s)
features that can be developed in
[17:24] (1044.48s)
parallel where the code bases don't
[17:26] (1046.40s)
touch each other. Um, I found the
[17:28] (1048.16s)
interface for working with work trees to
[17:31] (1051.44s)
be a little bit clunky. The general idea
[17:33] (1053.44s)
behind a work tree is that you create
[17:34] (1054.80s)
copies of your git repo in separate
[17:37] (1057.28s)
subdirectories and then you have one
[17:39] (1059.44s)
version of claude running in, you know,
[17:41] (1061.60s)
subdirectory A on let's just call it
[17:43] (1063.44s)
branch A and then you have another one
[17:44] (1064.72s)
running on branch B and they're running
[17:46] (1066.40s)
in parallel in two different directories
[17:47] (1067.84s)
on your computer. Um, the issue that I
[17:50] (1070.88s)
had was that when I spun up a new
[17:53] (1073.60s)
version of Claude, like a new Claude
[17:55] (1075.76s)
session, I didn't have the same
[17:58] (1078.56s)
permissions that I had already approved
[18:01] (1081.20s)
on that first session of Claude. And so,
[18:04] (1084.32s)
every time I created a new branch, I was
[18:06] (1086.40s)
having to approve all the permissions
[18:08] (1088.16s)
again. And I just felt like I was having
[18:09] (1089.92s)
to babysit it a lot more. And then what
[18:12] (1092.72s)
happens is after you have finished work
[18:15] (1095.04s)
on that issue or that branch, you're
[18:16] (1096.80s)
supposed to delete that directory and
[18:18] (1098.40s)
then create a new work tree again. And
[18:20] (1100.48s)
so every time you're creating a new work
[18:22] (1102.08s)
tree, you're reapproving those
[18:23] (1103.76s)
permissions. And it just felt like I was
[18:26] (1106.00s)
doing more babysitting and more cleaning
[18:27] (1107.68s)
up merge conflicts than it was really
[18:30] (1110.16s)
worth it. Uh I found that just working
[18:32] (1112.00s)
with a single cloud instance is
[18:34] (1114.08s)
sufficient for me. Now, if you made it
[18:35] (1115.76s)
this far, you'd probably also enjoy the
[18:37] (1117.28s)
video I did on claude code pro tips. So
[18:39] (1119.28s)
check that one out.