YT YouTube2Text

YouTube2Text → Transcripts → Claude Code + Linear = An ENTIRE AI Team

Claude Code + Linear = An ENTIRE AI Team — Transcript

by Owain Lewis · 4,667 words · 646 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00If you want AI agents to actually
0:01[music] help you inside your business,
0:02you need to be able to delegate real
0:03work to them. In this video, I'll show
0:05you how to systemize and automate
0:06operations with inside your business,
0:07[music] I'll walk you through the three
0:09levels of delegation and show you how
0:10you can go from chatting with agents to
0:12[music] delegating complex multi-step
0:14work to them. By the end of the video,
0:15you'll know how to delegate work to AI
0:17agents in the same way you delegate work
0:18to anyone else in [music] your team. If
0:19you're new to this channel, my name's
0:20Owen. I've been a software engineer and
0:22engineering leader for the past 20
0:23years, and I use this exact [music] same
0:24method inside my own business. All of
0:26the resources are linked for free in the
0:28description below. So, let's get into
0:30it. So, in this video, we're [music]
0:31going to focus on building a shared
0:33system where we can hand off tasks
0:34directly to AI agents. These could be
0:36simple tasks with inside your business,
0:38but they could also be much more complex
0:40multi-step processes like onboarding a
0:42new client. And that may contain like
0:44multiple different steps in order to
0:46complete that task. So, we want to get
0:48to a point where we can create a task
0:49and then just give it to an agent and
0:51have confidence that the agent is
0:53actually going to be able to do that
0:54work correctly. So, I think about two
0:56different things when it comes to
0:58working with agents. I think a lot of us
0:59are in the terminal, chatting with our
1:01agents, going back and forth, correcting
1:03them when they make mistakes. And I
1:05think about this like micromanagement.
1:06So, I've been a manager for a long time.
1:08And one of the problems with this method
1:10of working is it's not very repeatable
1:12and you're still kind of just doing the
1:14work yourself. [music] So, if you think
1:16about the three levels of delegation,
1:17you can just do the work yourself. You
1:19can do it with an agent where you're
1:21just chatting back and forth correcting
1:23the agent, [music] having a
1:24conversation, or you can just delegate
1:26the task and trust that the AI is going
1:28to do it. And if you were working with
1:29someone in your business, you wouldn't
1:31sit next to them and kind of constantly
1:32correct them and have a conversation
1:34while doing the task because that would
1:36consume most of your time. It wouldn't
1:38really give you any leverage and it
1:39would be a terrible way to, [music] you
1:41know, delegate work. It would be
1:42micromanaging essentially. So we really
1:44want to move to this shared workspace
1:46where we can move away from chat [music]
1:47into proper delegation. So we're going
1:49to be using linear for these examples.
1:51So the idea behind Linear is it's a task
1:53management system. [music] You could
1:55track all of your work that you're
1:56doing, your team are doing, but also
1:58your agents are doing as well. So what
2:00we can do is create a task. And what I
2:02really like about Linear is you can have
2:04complex multi-step tasks via [music]
2:05templates. So imagine we're trying to
2:08onboard a client into our business. If
2:10you think about the steps we need to go
2:11through, you need to create a Google
2:14Drive folder. You need to add the client
2:16to your CRM. You need to draft a welcome
2:18email. Maybe you need to create a linear
2:20project. Maybe you need to do multiple
2:21other things. And the really great thing
2:24about linear is you can define [music]
2:25these multi-step tasks. And the goal
2:27here is to basically hand this off to an
2:29agent to do the client onboarding. So
2:31this is the kind of thing that you might
2:33do often with inside your business. So
2:34what I'm doing here is I'm just giving
2:35the agent some instructions. So, we're
2:37going to onboard this new client called
2:39Global Recruitments. And we've defined
2:40the project and when they're going to
2:42start and we've given a bit of
2:44information like the contact email
2:45address and what we're trying to do is
2:48basically just onboard this client.
2:49[music]
2:50So, I'm going to go ahead and create
2:52this issue. And then also what I can do
2:54is assign it to Claude. So, Claude is an
2:56agent with inside linear. And whenever I
2:58assign something to Claude inside this
3:00project, it will basically invoke the
3:03Claude cloud routine [music] via a web
3:05hook and get the agent to start working
3:07on it. So let's go ahead and create that
3:08issue. And then what should happen is
3:11pretty much immediately we should get a
3:12response from Claude. [music] So you can
3:14see here now that the agent is already
3:16started started working on this task.
3:18And what happens here is we're
3:20triggering a routine in in Claude
3:22[music] in the cloud and it's running
3:24inside a shared repository. So it's
3:26using all of my context. So it's running
3:29inside this project. So Claude has
3:31access to, you know, context about my
3:34business. It has a list of jobs it can
3:36do, standard operating procedures and it
3:38also has a bunch of skills that allow it
3:41to do repeatable tasks. So for example,
3:43client onboarding
3:45is just a skill or a standard operating
3:47procedure. So we have, you know, inputs
3:49like the client name. We have the steps
3:52we need to take. So we can walk through
3:54step by step how to do this specific
3:55task and then the agent is basically
3:57just going to follow these instructions.
3:58So you can see here there's quite a lot
4:00of detail even down to like the folder
4:01structure in Google Drive. And for me to
4:04do this myself obviously I could do it
4:06but it's quite manual. It's quite you
4:08know errorprone to do this kind of
4:10repeatable task. So it's really nice to
4:12be able to hand off this kind of thing
4:13directly to an agent. So Claude has now
4:16finished with this task. You can see
4:17here it's updated in real time. It's
4:19marked all of these subtasks as done. So
4:21this is a relatively simple task, but
4:23you could imagine a much more
4:24complicated multi-step task. You could
4:26also within linear assign some of the
4:28tasks to an agent and some of the tasks
4:30to yourself if you wanted to. I use this
4:32pattern quite often, but in this
4:34example, the agent has done everything
4:35for us and the agent has then commented
4:37back on the ticket. So it's created the
4:39Google Drive folder. So if you click in
4:41here, we get a link to the folder. So
4:43it's created all of these basic
4:45structures in Google Drive. It's created
4:47the linear project so we can manage the
4:49project. It's added the clients to our
4:51CRM and it's drafted a welcome email.
4:54So, this is just going to be really
4:55useful. This is very different to
4:57chatting with Claude, you know, in in
4:59the in like the terminal or in the
5:01Claude desktop app. We're just giving
5:03Claude the actual task and it's going to
5:04do the work. Another example of a task
5:06you might do often with inside your
5:08business would be generating client
5:09proposals. So, you can see here we've
5:11generated a proposal document for Global
5:14Recruitment. We're building them a lead
5:15generation platform priced at $10,000
5:18and we're going to deliver this in two
5:19weeks. And what we're doing is we're
5:21referencing some maybe like meeting
5:22notes, something like that. And then
5:24Claude has gone ahead, it's commented on
5:25the ticket. You can see here Claude's
5:27done a pretty good job. It's built out
5:28the first version of the proposal. So
5:30it's written out the situational
5:32appraisal, the current challenges, the
5:34objectives of the project, the scope of
5:36what we're building, the delivery plan.
5:38So basically Claude has written the
5:40entire first draft of the proposal. You
5:42know the pricing, the payment
5:43information and this is just really
5:46really useful. It eliminates the
5:47friction of doing this kind of work with
5:49inside your business. You can basically
5:51just ask an agent to do this for you.
5:53Obviously as a human then you can go and
5:55edit and review it. But this is going to
5:56save you so much time if you're able to
5:58do these kind of jobs repeatedly. Here's
6:00another example where the agent has done
6:02some repurposing work for me. So
6:04basically taking a YouTube video
6:05transcript and turning it into a first
6:07draft of a newsletter or a LinkedIn
6:09post. So you can click on this. You can
6:11see the agent did the work and then it's
6:12linked the document. So this is the kit
6:15email draft and we can kind of open this
6:18up and you can see it's written out the
6:20you know like the first version.
6:21Obviously as a human we're going to edit
6:23this ourselves but it's just going to
6:24save you loads of time if you have this
6:26kind of repeating work inside your
6:27business. So in order to do this
6:29effectively you're going to need to
6:30define the jobs really clearly. So
6:32unlike when we're working with an agent
6:33in a chat window, we can be quite loose
6:36with our instructions, but when we're
6:38delegating the work to an agent in this
6:40this way that we're doing right now, you
6:42need to make sure that you've clearly
6:44articulated the job so the agent can do
6:46it without you having to be in the mix.
6:48Most of the time, if we're working in a
6:49chat window, if the agent does something
6:51incorrectly, if it has a question, we're
6:53kind of in the loop responding to the
6:55agent. But in this model, we're fully
6:57delegating the task. So we need to be
6:59quite detailed about the the steps
7:01involved in the particular process. So
7:02for example, client onboarding might be,
7:05you know, create the Google Drive
7:06folder, create the initial document,
7:07send a welcome email, draft a first
7:10version of the proposal, prepare the
7:12invoice, you know, draft a reminder in
7:14case the client hasn't paid, stuff like
7:16that. Basically like repeatable jobs,
7:17you want to break break them down into a
7:19list of steps like this. So step one,
7:21step two, step three, step four, step
7:23five. And then you can save these into
7:26skills with inside some kind of you know
7:29project repo. So for example the
7:31proposal generation [music] is here as a
7:34skill. So this is how we generate a
7:36proposal fill in this template. You can
7:38see the templates here. So the agent is
7:40basically just following the
7:41instructions of how to fill in this
7:43template and you know basically step by
7:46step copy the template fill in the
7:48details uh you know trim it down check
7:50for all of the accuracy and then hand it
7:52over to to me to review essentially. So
7:55this is how you can systemize stuff with
7:57inside your business and then just hand
7:58it directly to agents. So the way I like
8:01to model this in linear is to define the
8:03work we do regularly and then break
8:06things down into subtasks that we can
8:07either do ourselves or assign to an
8:09agent and then define a standard
8:11operating procedure or playbook that
8:13will tell the agent how to do [music]
8:15that task. So with inside linear you can
8:17go to your project configuration
8:19settings if you go to team settings and
8:21then if you scroll down you can see here
8:23that we have this template section and
8:25so this is the onboarding template. You
8:27can see here I've listed out these
8:28subtasks and you know you can add as
8:30many subtasks as you want. You can make
8:32this as complex as you like and you can
8:36have templates for all of the kind of
8:37repeating work you do with inside your
8:39business. [music] So for example, every
8:40single week I need to create a YouTube
8:42video. So I could add another template
8:45uh which would be you know create a
8:46YouTube video. The other thing I really
8:48like about linear is this idea of a
8:50cycle. So a cycle is basically a
8:52repeating series of work with inside a a
8:55time period. So, you know, you might
8:57work in weekly intervals. So, every
8:58single week, I would create a YouTube
9:00video. I'd create seven LinkedIn posts.
9:02I'd need to send invoices. I would need
9:04to update my KPIs. I would need to do a
9:06certain amount of client outreach. So,
9:08anytime you find yourself doing the same
9:10tasks every single week, you can use
9:12cycles within side linear. So, for
9:15example, you can see here within my
9:17content project, I use this because I
9:20work in weekly cycles. So you can see
9:22here I've got cycle one, cycle two, and
9:24you know, basically planning out your
9:26week. And this is just really useful cuz
9:28then you can plan out your week and then
9:30a lot of the tasks you do on a routine
9:32basis. You can basically start assigning
9:34a lot of that work to an AI agent. And
9:36this is pretty easy to do with inside
9:38the project settings. Well, you can just
9:41click in here
9:42and you can basically configure the
9:44cycles. You can change various things
9:46about the cycles. So, if you go into the
9:48team settings into cycles, you can do,
9:51you know, if you work in 4 week periods
9:53or one week periods, this is how you can
9:55set that up. And I just find this
9:57really, really useful for staying
9:58organized. And one of the big problems
10:00when it comes to delegation is that you
10:02are going to need to do some kind of
10:03testing because in reality, the first
10:05time you do a task, the agent may get it
10:08wrong. It may not do exactly what you
10:10want. So, you probably have to do quite
10:12a lot of testing with these tasks. So
10:14for example, the first time you do the
10:16maybe client onboarding task, maybe the
10:18agent forgets one of the steps, maybe it
10:20doesn't update the task. So the way I do
10:22that is I work with Claude and then I
10:25will update the instructions. So, if you
10:28find that you're working with your
10:30agents and they're not doing the right
10:31thing, because I'm working within this
10:34operations folder, so it has access to
10:36all of my SOPs, what I would do is I
10:38would say something like, when Claude
10:41does a task in linear, can you make sure
10:44that it updates the ticket status and
10:48marks things as resolved or in review
10:52when done? So, you can basically
10:54continually iterate. So you run the
10:56task, you see if it did a good job and
10:59then you can measure that over time. So
11:01this is now going to make a rule inside
11:03my, you know, my project instructions
11:06and you can just kind of keep iterating
11:07and refining like this over the time in
11:09the same way you would if you were
11:10working with someone in your business.
11:12Whenever someone new to your business
11:13starts doing work, they're going to make
11:15a bunch of mistakes and you just want to
11:17give feedback and you want to start
11:18correcting your standard operating
11:20procedures over time. Here's an example
11:22of one I did earlier. So you can see
11:23here when generating a client proposal
11:25always make sure you update the ticket
11:27status to mark it as done. This is where
11:29I found that the agent was forgetting to
11:31do a certain step. And then what happens
11:33is the agent can then open a pull
11:35request and you know we're just making
11:37adjustments to our operating procedures.
11:39You can see here we've made a change. So
11:41make sure that when you hand over the
11:42work you you know update the ticket
11:44status etc. Another example of how you
11:46might use this approach is to generate
11:48assets for your business. So if you
11:50generate a carousel for example, this
11:52can be quite time consuming. It's the
11:54kind of task that would have taken me
11:56maybe an hour or so to do by hand a
11:59while ago. But now if I wanted to create
12:01a carousel, I would just give it the
12:02reference information. The agent will
12:05then know how to generate carousels or
12:06graphics. And then you can see here the
12:08agent now linked the you know Instagram
12:12or or LinkedIn carousel for us. So this
12:15is just really going to save you tons
12:16and tons of time. You can also see here
12:18that we can chat back and forth with
12:19Claude. So, as Claude makes progress on
12:22the task, you may need to give feedback
12:24at some point. And all you need to do
12:25here is type at Claude. So, Claude is
12:28the name of my agent. You can name these
12:29agents anything you want. Um, but I
12:31could say, "Can you create a LinkedIn
12:35infographic?" And what we're doing here
12:37is we're tagging Claude in the comment.
12:39And now Claude is already going to start
12:40picking it up. So, you can start
12:42treating these agents like anyone else
12:43in your team. You just tag them in a
12:45conversation. If the agent makes a
12:47mistake on the first time round, you can
12:49give it feedback. You can make
12:50adjustments, ask it to to do follow-on
12:53work for you as well. So, a good example
12:54of how you might use this would be if
12:56you asked Claude to draft an email. It
12:58would post the email onto the task. You
13:00can review it and then you can ask
13:01Claude to go and send that email. That
13:03would be a good example of doing this
13:04like multi-step workflow within Linear.
13:07So, let's do one more example. So, what
13:08we're going to do inside this content
13:10project is we're going to generate some
13:11LinkedIn posts. So, we're going to say
13:12generate five LinkedIn posts plus
13:16infographics.
13:17I would never do this. I don't like AI
13:19writing in general, so I'd always write
13:20the post by hand. But just to kind of
13:22show you how this might work, um,
13:24generate
13:25five infographics for LinkedIn. And
13:29we're just going to assign this then to
13:31Claude. So, this is going to be somewhat
13:32at random. And we're also going to say
13:34and then
13:36and then upload them to our content
13:39database
13:41for review. So again, you can just kind
13:43of go really really fast here assigning
13:45work to your agents as you go throughout
13:47the day. And the great thing about using
13:50a a platform like Linear is you track
13:51all of the work. So you can see, you
13:53know, as you're working on lots and lots
13:55of tasks, you don't really get lost. You
13:56know which tasks to come back to, and
13:59you can just kind of track and keep
14:00organized. All right. All right. So if
14:01you do want to set this up yourself, the
14:03way I did it, I found this was a little
14:05bit tricky to set up the first time. So
14:07what we want to do is basically within
14:09linear, we can trigger whenever we
14:10assign work to our agents, we can use a
14:13web hook to trigger a clawed code
14:15routine. But one of the things we need
14:17to do is have a cloudflare worker in the
14:19middle. And so the reason is when linear
14:21sends a web hook, it doesn't send HTTP
14:24headers that we need to invoke a clawed
14:26code routine. And so we need this
14:28Cloudflare worker in the middle. And so
14:30if you do need to set this up, I've got
14:32an example over here of how you can do
14:34that. So you can see down here we've got
14:36the somewhere down here the clawed
14:38linear agent. [music] So this runs on
14:41Cloudflare as essentially a proxy. So
14:44the linear agent will talk directly to
14:46this Cloudflare worker and then it will
14:48send a request to the a Claude code
14:50routine. And a Claude code routine is
14:52basically a scheduled job. This runs in
14:54the cloud. So this is the linear task
14:57that Claude will trigger. And whenever
14:59we run a job or whenever we trigger a
15:02run with inside linear, this is always
15:04running inside the context of my
15:06project. And you can see here we have
15:07access to all of the different tools we
15:09need to do our work. But this contains,
15:12you know, business context, wikis,
15:13knowledge bases. It contains, you know,
15:16all of the instructions, standard
15:18operating procedures and skills [music]
15:20that allow the agent to do these
15:21repeatable jobs. So the way you set this
15:23up in Linear is a little bit complicated
15:25and you might want to use your agents to
15:27help you do this. But when you scroll
15:29down here, you'll see that we can have
15:31applications inside Linear. So there's a
15:34application down here which I called
15:35Claude. You can name this anything. And
15:38when we look at the project settings,
15:39you'll see we have some OOTH
15:41credentials. And we can trigger a web
15:44hook. So whenever we assign a task to
15:46this application or this user, it will
15:49then fire off this web hook. And we can
15:51basically send this over to a Claude
15:53code routine. Another thing I really
15:54like doing when it comes to Claude is to
15:56actually use the Claude project feature.
15:58[music] So I have a single Claude
16:00project and this is basically what I use
16:02for everything right now. I just talk to
16:04a single Claude project. It then
16:06orchestrates work elsewhere. But we can
16:08also use this to create linear tasks as
16:10well. So if you need to onboard a new
16:11client, you can say um create a new
16:14client on boarding
16:17on boarding task in linear. So we can
16:20basically work with Claude locally and
16:22then have it create tasks for us. This
16:24is quite a useful thing to do. You know,
16:26maybe you want to spin up five or six
16:27tasks that you need to work on. You can
16:29do it directly from Claude. So this is
16:32the GitHub repo that I'm using. So
16:33whenever Claude is running, whenever we
16:36assign a task, Claude is always running
16:38inside this repository. So it always has
16:40access to the files here. And you can
16:43see here we have things like standard
16:45operating procedures. So when we create
16:47carousels or infographics or YouTube
16:50reels, we have these different sets of
16:53instructions. Here's an example of a
16:55standard operating procedure for an
16:56Instagram reel. You can see here we have
16:58the process. So I'll choose a topic. And
17:00then you can see here we have some
17:02structure, hook, proof, the three or
17:04four things, the CTA. So we basically
17:07have a bunch of instructions about how
17:08to write these Instagram reels. And you
17:11can define this for any process with
17:12inside your business. You can basically
17:14just document how to do these tasks and
17:16then Claude will be able to do them for
17:18you. The way I like to do this is to
17:20keep an index.md file which lists out
17:22all of the jobs that Claude can do.
17:24Because if you think about your
17:25business, you probably have a large
17:27number of tasks that you do on a daily
17:28basis. And it's really really helpful
17:30just to write down what specifically you
17:33want your agents to do. So rather than
17:35just thinking about this abstractly or
17:37vaguely, you want to be very clear about
17:40what are the specific jobs that you're
17:41going to assign to your agents. So for
17:43example, in the typical business, you
17:44might have marketing tasks like, you
17:46know, writing an uh a LinkedIn post,
17:48writing a newsletter, uh repurposing
17:51some content, making graphics. On the
17:54sales side, maybe you have things like
17:55generating proposals. On the delivery
17:57and fulfillment side, maybe you have
17:59things like onboarding a new client. But
18:00the general idea is you can just
18:02document and list out all of the jobs
18:03that you do with inside your business.
18:05And this is just a really good exercise
18:07to start getting more systematic when
18:09you come to working with these AI
18:11agents. This is an example of a task
18:13that failed that I would need to go back
18:15and iterate with the agent to make this
18:16actually work next time. You can see I
18:18was trying to create some infographics
18:20and LinkedIn posts. But when we actually
18:21go through, you can see here that the
18:23agent didn't have the right permissions
18:24to upload the files. It generated the
18:27docs, but these weren't very good. So if
18:28I go and click in one of these, the
18:30formatting is kind of really off. The
18:33the the kind of quality is not very
18:34good. So I would need to go back now for
18:36this particular task. If I wanted to do
18:38this kind of job repeatedly, I would
18:40basically go back into Claude and I
18:41would iterate a few times, give feedback
18:44to the agent on how it could improve,
18:46and then the next time it did these
18:48posts, it would be much better. So just
18:51to show you an example of how to do
18:52that. So let's copy this task. So we can
18:54say this task here. So, I'm just going
18:57to copy the URL and I'm going to go back
18:59into Claude. And then what I'm going to
19:01do is I'm going to tell Claude to go and
19:03fix this. So, we're going to go back
19:04into the operations project and I'm
19:07going to say something like, uh, this
19:08task generated
19:11badly badly formatted word docs. Can you
19:16improve
19:19the skill so that next time the docs are
19:23well formatted? Obviously, that's not
19:25very good feedback. you could give much
19:26more detailed feedback, but the idea
19:27here is that we've done a task and the
19:30next time the agent does this task, we
19:32want to make sure that we've updated our
19:34SOPs or our instructions for the agent
19:37so that it does it correctly next time.
19:38So, this is a great way of just refining
19:41continually improving your skills over
19:43time. So, if you just jump back over
19:45into the browser, you can see here now
19:46the agent has made an improvement to our
19:49essentially our operating procedure for
19:51generating these docs. You can see here
19:52the graphic generation and the claud
19:55instructions. And then if we go back
19:57into this post, if we refresh it, this
20:00should now be formatted more cleanly. If
20:03you go back and see some of these older
20:05posts, they were not as nicely
20:07formatted. So basically, we've just
20:08improved the task and then the next time
20:10we do this job, it's going to be
20:12basically do it correctly every single
20:13time. So I think this is a great method
20:15for delegating work to AI agents. And I
20:18think one of the biggest shifts you
20:18[music] want to think about is moving
20:20from this chat method where we're just
20:22talking to agents back and forth [music]
20:24to just being able to assign work to
20:25agents and be confident that they're
20:27going to do the right thing. I think a
20:28lot of the time right now we're we're
20:30[music] going back and forth with agents
20:31and that can consume a lot of your time,
20:33energy, attention, and focus. And it
20:35really doesn't feel like you're getting
20:36a lot of leverage if you're operating in
20:38that way. So the goal we want is to be
20:40able [music] to just delegate work to
20:41agents and have them run parts of our
20:43business automatically in the same way
20:45we delegate to an automation. Thanks
20:47again for watching. If you've got any
20:48questions, let me know in the comments.
20:50And I will see you in the next one.

About this transcript

This page contains the full transcript of Claude Code + Linear = An ENTIRE AI Team by Owain Lewis, generated from the public captions YouTube serves with the video. The transcript has 4,667 words across 646 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.