you2idea@video:~$ watch AO5aW01DKHo [21:40]
// transcript — 413 segments
0:01 AI automation is about to change forever. Most workflows today only do
0:04 exactly what you tell them, nothing more. But Agentic workflows are
0:07 different. You basically give them an outcome, not just a flow, and they
0:11 figure out the steps by themselves. So, in this video, I'm going to explain the
0:13 shift, and then I'm going to build one live so you can see just how practical
0:16 it already is. So, let's first take a look at the difference between the new
0:20 Aentic tech versus the old way of doing things. So, what does Agentic actually
0:23 mean? Well, if you've been building an Enten for a while, you know the drill.
0:26 You drag a node, you configure it, you connect it [music] to the next one, you
0:29 test the flow, you hit an error, you read the error message, you figure out
0:32 what went wrong, you fix it, and then you test it again. Which means every API
0:35 connection, every variable, every condition, that's all on you. But with
0:38 Aentic, it's a bit different. Instead of telling the system how to do something,
0:41 you just tell it what you want in plain English. [music] So you explain where
0:44 the data is coming from, what needs to happen, and then where it should end up.
0:48 The agent then figures out the rest. So just think about it like you're hiring
0:51 an actual human developer. You wouldn't go in there and explain every single
0:54 line of code. You would just explain the outcome that you're looking for, what
0:56 problem you're trying to solve, what tools you're working with, and what the
0:59 end result should look like. And then they'd go build it for you. So, here's
1:02 the thing. If you can't explain clearly what you want, then how could you expect
1:06 a human or an AI agent to actually build that? So, there has to be a clear scope.
1:09 You don't need to know how to code, but you do need to know how to communicate
1:12 your plan clearly. And the good news is you can actually use the agent to just
1:15 brainstorm. So, if you tell it roughly what you're trying to do, and it will
1:17 ask you all the questions that it needs answered in order to actually build a
1:20 robust solution. And that's the huge shift because you can go from being the
1:23 person who constructs every piece of the puzzle to being the person who just
1:26 defines what do you want the puzzle to look like. So there are four main
1:29 changes that I need you to understand in order to build an agentic workflow with
1:32 me. So the first one is self-healing. This is probably the biggest and one of
1:35 the coolest ones because if you build something in Nitn when the workflow
1:38 breaks you read the error message you tweak the node you test it again and if
1:41 it breaks again you repeat. So that whole debugging loop eats up a lot of
1:45 time. Now if you're building an agentic workflow the agent handles that loop for
1:48 you. Imagine every time your workflow broke, a smart assistant was sitting
1:51 right there next to you just reading the error, testing a fix, and only calling
1:54 you in if it was really, really stuck. So, the agent tries something, runs it,
1:57 checks what happens. And if something broke, it figures out why, edits its own
2:01 code, edits its own instructions, and updates everything so that it doesn't
2:03 make that mistake again. And here's what's really wild. You don't have to
2:07 read or write any of that code yourself. You just explain what good looks like,
2:10 and when you need to approve the changes that it suggests. All right, number two
2:14 is natural language control, but for real this time. Because you've probably
2:16 seen tons of tools that let you build with natural language. Lovable, Bolt,
2:20 Lindy, even Nadn has an AI workflow builder. You basically type in a prompt,
2:23 it spits out a workflow or a website. But if you've actually tried using these
2:26 for productionready systems, you know that usually they require a lot of
2:29 manual cleanup or a lot of back and forth. They'll get you maybe 60 or 70%
2:32 of the way there. But this new generation, it feels a lot different.
2:35 Instead of just taking your prompts and building, it first interviews you to
2:38 make sure that it knows everything it needs. So, it'll ask you clarification
2:42 questions like we talked about before it tries to write a single line of code.
2:44 It'll ask you questions like who are the users? How many times should this run?
2:47 What tools are you using? What happens if X happens? What should happen if Y
2:50 happens? A lot of times when I'm working with these agents, they're asking me
2:53 questions that I wouldn't have even thought of until a month later when we
2:56 run into a problem. And then once it has all that information, it builds the
2:59 systems and it wires it right into your own text stack already. So once that's
3:02 built, natural language becomes the remote control that you can use for the
3:05 whole automation. So you can have V1 ready and you can say h actually can you
3:08 make that a little bit faster or can you make it cheaper or can you add a manual
3:11 review step right here or can you log all of those outputs in this Google
3:14 sheet and it will just go ahead and do it. Now of course you can't just
3:17 completely like vibe code these automations. You still have to do a
3:19 little bit of thinking but it will ask you the right questions and guide you.
3:22 Now something else I think is really cool is that you can have multiple
3:25 agents running simultaneously. [music] So if I asked 10 of the best AI
3:28 engineers that I knew to build me a solution, I'd probably get 10 different
3:31 versions even though all 10 of them work. And sometimes the only way to know
3:34 which one's best is just by testing them all [music] out. So you could be
3:36 brainstorming a process with an agent and you could say, "Please suggest the
3:40 five best approaches for this, you know, workflow." And then instead of having to
3:43 like guess which one you think you should try, just say, "Okay, cool. Agent
3:46 one, try a method number one. Agent two, try two, three, try three," and so on.
3:49 And then you can step away, grab a cup of coffee, come back when they're all
3:53 done, and then stress test all of those solutions to see which one's like the
3:56 cheapest, the fastest, and the highest quality. Number three is about security.
3:59 So, when you think about the fact that you're building code that you don't
4:01 really know what it's doing, you have to think about security. And these agents
4:04 are writing and editing real code. And I know that a lot of you don't want to
4:07 know how to read that or don't know how to read that. And I don't either. Just
4:10 don't worry, you don't have to. Because these same large language models that
4:12 are generating that code can also constantly review it for security
4:16 problems and vulnerabilities. And they can do that on every single change, not
4:19 just once. So, think about it like you're having a security obsessed
4:21 developer sit right next to you while you're building your automation. And
4:24 every time something changes, they double check. Are the API keys hidden?
4:27 is sensitive data being logged somewhere that it shouldn't be. This can happen
4:29 automatically as part of that self-healing loop. So, every time the
4:33 agent proposes an edit, it reviews its own work, it makes the changes, and then
4:35 it makes sure that everything's still secure. And of course, you can build in
4:38 all of these guard rails with natural language. So, you can just say something
4:41 like, "Never send customer phone numbers to any third party tool or always make
4:45 sure to stop this workflow if you ever exceed $5 of usage with this API."
4:49 Things like that. Your job is just to say what must never happen. And then the
4:52 system's job is to actually enforce that. All right. Fourth is instant API
4:56 and MCP integrations. So if you've built workflows in Naden, you know the pain of
5:00 API authentication, headers, JSON bodies, query parameters. You spend half
5:04 your time just reading API documentation and then getting the shape of the
5:07 request to be right. With Aentic Workflows, that pain pretty much
5:10 disappears because you just say what tool you want to connect to. So, you
5:13 know, get my Fireflies transcripts and then push that into ClickUp and then
5:17 send me a Gmail summary. All you have to do then is go in and grab your API keys
5:20 and then the agent figures out the rest because instead of you having to read
5:23 those, you know, 10 pages of API documentation, the agent can just search
5:26 the web or even go to the URL you give it and research it on its own. Now, MCP
5:30 is basically like an app store for these agents. They're tools that are
5:33 pre-wrapped up and documented so that agents know what's available and how to
5:36 use each of them correctly. And if a tool doesn't have an MCP yet, then the
5:39 agent can just once again go to the API documentation and then make the right
5:42 request there. And because it's all code based, it can handle things like
5:46 retries, rate limits, pagenation, web hooks, all of that stuff that can
5:48 definitely be a bit of a pain to build in manually in a workflow builder like
5:52 Naden. Of course, you still need to go grab your API keys, but you won't
5:55 wrestle with like low-level technical details anymore because your energy now
5:58 is going towards what actually happens, not how to configure the API call. All
6:01 right, so now that you know the four main changes, let's actually just go
6:04 ahead and build a super quick agentic workflow together. Okay, so for the
6:08 actual live build of an agentic workflow, I thought that we would do a
6:11 lead generation automation because it's one of the most common types of
6:15 automations that I get requests for and you're going to see how easy it is to
6:17 actually spin up. So before we actually hop into Cloud Code, which is what we're
6:20 going to be using today, I just wanted to familiarize everyone with what we're
6:23 actually going to be looking at because otherwise I know it seems a little
6:25 intimidating. So basically, we're going to be in VS Code using Cloud Code, but
6:28 we're not going to be coding at all, right? We're going to be using natural
6:31 language talking to an agent that's going to live on the main section of the
6:34 screen. And this is where we're going to be able to do our planning. It's going
6:37 to ask us questions and it will start executing, you know, writing code and
6:40 taking action. On the lefth hand side is where we're going to see essentially our
6:43 project. So inside of our project, we're going to have different files. We're
6:45 going to have a system prompt. We're going to have different workflows. We're
6:48 going to have different tools. So very similar to like what you were used to,
6:50 but it just looks a little bit different. In order to do all this,
6:53 we're going to be using a framework called the WAT framework, which
6:57 basically just stands for workflows, agent, and tools. So in formal software
7:00 engineering or different types of vibe coding, you may hear it be called
7:02 different things, but essentially it's the same concept. Workflows, agent,
7:06 tools. The agent is the brain that we talk to that helps us figure out what
7:09 workflows are we going to be looking at. So in this case, the workflow is lead
7:12 generation, but within that lead generation workflow, there's lots of
7:15 different actual actions and tools that the agent needs to use in order to
7:19 scrape the leads, put them into a Google sheet, do analysis, things like that. So
7:22 just like in any how you have your workflows, there's tons of different
7:25 actions and tools within that workflow that make it up. So, same thing here. It
7:28 just looks a little bit different, like I said. All right. So, now here we are
7:31 in VS Code. This is the agent. You can see I'm having a conversation with it
7:34 here. And on the lefth hand side is our files. I know there's a few more than
7:37 what I had in the Excal, but really the key ones to look at are tools folder,
7:40 our workflows folder, and then our claw.md file. And you can see right
7:44 here, it already set up our project. And this is what we have inside of the
7:49 structure. We've gotten files. I'm not going to explain that right now. We've
7:51 got tools, which will be our Python scripts for deterministic execution.
7:55 We've got our workflows which will be markdown SOPs defining what to do and
7:59 how. We've got env.get ignore. Just ignore that stuff for now. And then
8:02 we've got claw.md which are our agent instructions. So basically the system
8:06 prompt for this whole project. What are we doing here? How do the folders work?
8:09 How do you execute actions? So like I said, this section is not going to be a
8:11 full tutorial. I just wanted to familiarize us all so that we can see
8:15 what's actually going on. So down here you can see that I just put the Claude
8:18 agent on plan mode so that I can actually talk to it and have it ask us
8:21 questions so we can make really really clear instructions before we actually
8:24 start automating anything. Hey Claude, I need you to help me build a lead
8:27 generation automation. I want to scrape tons of different dentists in Chicago,
8:31 Illinois so that I can reach out to them and ask them if they want my AI
8:35 automation services. My agency is called UpAI. We provide custom AI consulting
8:40 and implementation. and I need you to do research about these people, scrape the
8:43 leads, write them a personalized outreach message, and then put all of
8:46 this data in a Google sheet for me so that I can just start going to work. So
8:49 that request that I just shot off is something that 100% of you guys could do
8:53 and probably want to do. So now that I've shot that off, basically what we're
8:56 seeing here is we are watching Claude think about what to do. So it's going to
8:59 look through our files. It's going to see what exists already just to
9:02 familiarize itself with its environment. And then it's going to start creating a
9:05 plan. And as it's creating this plan, once again, we can watch and look at
9:08 everything that it's doing. But what you're going to see is it's going to
9:10 come back to us with some questions. And then once we provide those answers, we
9:13 can actually just let it start going. So now we're at the question phase. You can
9:16 see it just said, "I have a draft plan, but I need to ask you some questions."
9:19 So first it says, "What data source should we use for scraping dentist
9:22 leads?" I'm going to go ahead and just use the recommended Google Places API.
9:25 For enrichment, it says, "How deep should we go?" Let's just go with basic.
9:28 For message tone, we can be professional, friendly, or premium.
9:30 Let's just go ahead and be friendly. And then for API setup, it says, "Do you
9:33 already have the required API keys set up?" So it'll either help you get that
9:37 all set up, or you can say, "Yes, I have them." them. So, I'm just going to go
9:39 ahead and say yes. And once I submit those answers, it's right back to work.
9:41 It's going to keep working on the plan. If it has any more questions, it will go
9:44 ahead and ask us. Okay. So, now we have our full plan done. Chicago dentist for
9:48 UPAI. We've got an objective. We have our preferences. It goes through the
9:51 full architecture as you can see. So, it's basically going to create a Chicago
9:54 dentist leads workflow and that will be shown over here in the workflows folder.
9:57 It's going to create three different tools. So, one to scrape dentists, one
10:01 to generate outreach, and one to export to sheets. And those will all show up in
10:04 the tools folder. Over here, you've got implementation steps. It's going to add
10:08 our API keys in AENV. It's going to build the tools and then it's just going
10:10 to keep going on. And obviously what you would do is you'd read all this and you
10:14 would say yes, I accept or I'm going to keep planning and things like that. But
10:16 we're just going to go ahead and auto accept what it came up with. And so when
10:19 it starts to implement, it builds a to-do list. As you can see, it's got
10:22 these five tasks. And then we're going to go ahead and be able to watch it
10:26 execute across these to-do tasks. At this point, you can see it's created the
10:28 files we need. So it went ahead and created three different tools. Export to
10:32 sheets, generate outreach, and scrape dentist. You can see all of these are
10:35 actual Python scripts that it wrote in code and then it created the workflow
10:39 file which is Chicago dentist leads. So now anytime that I ask this claude agent
10:43 to find me some Chicago dentist leads it will basically come reference this
10:46 workflow understand what it needs to do and how it works and then it will just
10:49 go do it for me. So the last thing that I need to do here is give it my actual
10:52 API keys so that it can use Google places, use OpenAI and then use my
10:55 Google Sheets. So just like that in a matter of minutes I have an automation
10:59 built here in cloud code that I can continuously hit and get as many leads
11:02 as I want. If we go look at the actual output that it gave us when it was just
11:05 testing out 10 leads to see if it worked, we can see that each of these
11:08 have a name, an address, a phone number, a website. They've got rating, reviews,
11:12 neighborhood, subject line, and then we have our actual outreach message, which
11:16 is personalized for them and for us. You can see that they mention things like
11:19 the fivestar rating or the 4.9 star rating from 714 reviews. And so
11:23 obviously, this was basically very minimal prompting. So what we would do
11:26 now is we would come back with natural language and say, "Okay, you know what?
11:28 I don't actually want to limit it to just Chicago. Let's also search in
11:31 California." Or we' say, "The outreach messages aren't super personalized." Or
11:34 you could say, "The outreach messages aren't really custom enough. Let me drop
11:38 in a PDF of all the information about my business up at AI and incorporate that
11:41 in all of your outreach messages." You could say, "Hey, I'm realizing that we
11:44 don't have any emails. Could you actually incorporate emails into this
11:47 automation as well?" And so all of those changes that I ask it to make, it would
11:50 actually go ahead and it would change the workflow file. It would change the
11:54 tool files so that next time it does all of this automatically. And so of course
11:56 you can see already there's a lot of power in just being productive by making
12:00 Claude Code essentially an executive assistant having different workflows and
12:03 different tools for everything that you do on a daily basis. You can go ahead
12:06 and trigger Claude code to do work on something else on your other monitor and
12:09 come back and it will be done for you. But if you need to have an automation
12:12 that triggers based on some sort of event or goes off once a day. You don't
12:16 have to be here watching Cloud Code to make it go off. You could of course
12:19 publish these scripts and the workflows onto something like Modal in order for
12:22 them to actually run without you being around at all. So, I know that I went
12:25 pretty fast through this demo, but that's exactly what this was, just a
12:28 demo. I'm going to obviously be making full tutorials and deep dives on how you
12:31 can actually do all of this stuff yourself. But really, I just wanted to
12:34 give you a taste of what this is like and show you in a matter of minutes what
12:37 I was able to do in here, which would have taken me at least an hour or so in
12:40 eden. And remember that I didn't have to set up any sort of API calls or look
12:44 through any documentation on my own. Cloud code handled all of that
12:47 messiness. So, now that we've talked about those big shifts and you've seen
12:50 me build one right in front of you guys, let's talk about what the future's going
12:52 to look like with this stuff. So, I've got four main topics to hit on here.
12:55 Fully autonomous workflows, agents managing other agents, protocols like
13:00 A2A, and then longunning project agents. So, starting off here with fully
13:03 autonomous workflows. Right now, most workflows are reactive. They wait for
13:06 something to happen. So, their trigger can be like a web hook, a schedule
13:09 trigger, a form submission, and then they go ahead and they take the steps
13:12 that are in the workflow. But the next generation of these agentic systems,
13:15 they're not going to wait around. They're going to be proactive. So,
13:17 they're going to constantly scan your tools like your CRM, your inbox, your
13:20 project management software, and they're going to look for inefficiencies or
13:24 roadblocks or risks. They'll spot things like deals going cold before you even
13:27 notice. [music] They can flag projects that are falling behind before anyone
13:30 misses a deadline. And they're not just going to alert you, but they might
13:33 actually propose fixes or even just take action on their own. So, Deote predicts
13:37 that 25% of enterprises using generative AI will deploy agentic pilots this year,
13:43 jumping to 50% by 2027. By 2028, agents will act as autonomous partners handling
13:46 complex multi-step problems and proactively influencing decisions. So,
13:50 we're talking about proactive teammates that look ahead and say, "Hey, here's
13:53 what stuck and here's what I already did to help you unblock it." And the market
13:55 is starting to reflect that. The AI agent market is projected to grow from
14:00 roughly 8 billion in 2025 to high 40 or low 50 billion range by 2030, which is a
14:05 43% compound annual growth rate, which is of course driven by workflow
14:08 automation use cases. Next, agents managing other agents. So, instead of
14:11 just one giant all-purpose agent, we're moving towards teams of specialized
14:14 agents. An email agent, a research agent, a reporting agent, a data cleanup
14:18 agent, and a manager agent that can delegate the work, review output, and
14:20 stitch everything together. Think of it like a project manager with a remote
14:23 team, spinning up the right specialist to fix problems without waiting for you
14:26 to kick anything off. Now, these multi-agent systems are under
14:29 development with the first pilot starting in late 2024 and probably even
14:32 earlier. And I know this is stuff that's kind of been around already for a while,
14:35 but research is showing that multi-agent setups often outperform a single model
14:39 by distributing tasks among specialists. So big companies are starting to prepare
14:42 for this pattern. So it's not just one bot per workflow, but it's agent teams
14:46 embedded across, you know, sales, support, operations, finance, and
14:48 they'll coordinate with each other. Like I said, we've been seeing this in NN,
14:51 you know, sub agents or ultimate assistants that manage different agents.
14:54 And we can see that we're getting better results when each agent has a
14:57 specialized task. But that was just a preview of what's to come with agents
15:00 managing teams of agents. All right. Third, we've got protocols like ATA. So
15:04 MCP is how agents talk to tools. A toa or agent to agent is how agents talk to
15:09 other agents. In April of 2025, Google Cloud announced A2A as an open standard
15:13 so that AI agents from different vendors can communicate, share context, and
15:17 coordinate across, you know, different systems. And that was huge because we
15:20 know in business processes, it's rare that like one department never has to
15:24 talk to multiple other departments in the process to get certain things done.
15:28 So this protocol defines agent carts basically describing what each agent can
15:32 do, a shared life cycle of tasks and how agents share context securely. So one
15:35 agent can say something like find me candidates, another handle scheduling.
15:38 Another one does background checks and they coordinate without you playing
15:42 middleman between all of them. So Google launched the ATA with support from firms
15:46 like Salesforce, SAP, Service Now, Workday, and over 50 other enterprise
15:50 partners. And that level of coordination around a standard is a loud signal.
15:53 We're definitely heading toward an agent mesh where everything [music] plugs into
15:56 everything. And last but not least, we've got longunning project agents. So,
15:59 this is the one that I'm really excited about because right now agents are
16:02 really good sprinters, but they're not good long-distance runners because they
16:06 can crush a one-off task or deliverable, but if you ask them to manage a project
16:09 for weeks, then they start to forget things, repeat themselves, hallucinate,
16:12 drift off the rails. And we actually have benchmarks proving this. So,
16:15 there's a vending bench, which basically asks LLM to run a vending machine
16:19 business over a long simulated period. And even the really strong reasoning
16:23 models show high variance and they get worse over time. They do things like
16:26 forgetting orders, mistracking inventory, and falling into repetitive
16:29 loops. So, why do I think the future is different? Because we're starting to see
16:32 techniques that solve [music] this. So, one of those is continuous loops. So,
16:36 there's a plugin called Ralph Wiggum for Claude Code that keeps looping tasks
16:40 back to the agent until certain success conditions are met. It adds guard rails
16:44 like max iterations and explicit done signals. So, it's not perfect by any
16:46 means because there's still a lot of elements we need like human in the loop
16:50 and midexecution course correction, but it's moving in the right direction and
16:52 it's evolving really fast. We've also got stuff like agent harnesses with
16:56 shift based work. So, Enthropic is developing effective harnesses for
16:59 longrunning agents. One agent works for a while then leaves structured artifacts
17:03 like notes, to-dos, differences, what changed, what broke, what's next. Then
17:06 the next shift picks up from there and looks at all that kind of stuff. So,
17:09 instead of keeping everything in a huge giant context window, which is where we
17:12 start to see issues, it has more of a notebook and a checklist. So, if you
17:16 think about it like an actual human, if it was to sit there and code for, you
17:19 know, 72 hours straight, the human would get tired and the work would get sloppy.
17:22 But if the human was able to just work for 10 hours and then another one takes
17:25 over after a fresh night's sleep, it can read all of the documentation about
17:28 what's happened and what it needs to do and then that human just picks up on a
17:32 new shift. Now, we're not fully there yet, of course. It's not perfect, but
17:35 the fact that we have benchmarks that are measuring this and we have, you
17:37 know, longunning harnesses being developed and techniques like the Ralph
17:41 Wigum loop, this tells you exactly where the industry [music] experts want this
17:44 to go and expect it to go. agents that stick with a goal for days or weeks,
17:47 maybe even months, and they keep track of what they've done and they keep
17:50 improving your systems while you sleep. So, here's the bottom line. Analysts and
17:53 experts are saying that within a few years, half of companies using
17:57 generative AI will have deployed agentic systems. Google and others are already
18:01 standardizing how agents talk to tools and to each other. If you've been
18:03 building an end to end and you understand how to map out processes,
18:06 you're exactly the person who can step into this next layer because again, the
18:09 skill isn't coding. The skill is designing what agents should actually
18:11 do, where they should be proactive, and how they should all work together.
18:14 That's where the value is going. And that brings me to what's going to be
18:17 changing with this channel. So you're going to be seeing me doing a lot more
18:20 audentic workflows. So diving into things like cloud code, anti-gravity,
18:23 and more IDE based tools as they come out. But my mission hasn't changed. I'm
18:26 here to bring you the most valuable skills to learn and practice how to
18:30 actually make money, improve a business, improve your own business. Now, you guys
18:32 know I don't come from a technical background, and I know that most of you
18:35 don't either. So I'm never going to dive into something if I don't think that I
18:38 can explain it clearly and I'm never going to cover anything if I don't think
18:40 it's worth your time learning. That's my promise. None of us know exactly where
18:43 the space is going, but I promise that I will stay as close to it as possible and
18:46 bring you what's most important because there is a lot of noise and a lot of
18:50 changes out there. And I know it may seem right now intimidating to look at
18:53 something like a cloud code environment, but I also know that the IDEs are going
18:56 to get simpler and easier to use over time as well. Now, I know that some of
18:59 you might be thinking, does this mean that all of the time I just spent
19:02 learning noden was a waste? No, do not think like that. The opposite, actually.
19:05 If you've been building an end, you're ahead of the curve. And I've got some
19:07 reasons why. The first one is process decomposition. You've already learned
19:10 how to break business processes into discrete steps, handle edge cases, think
19:14 about what happens when things fail. And that's exactly what agentic systems need
19:17 from you. The next one is because you have systems vocabulary, so you now
19:20 actually know what's a web hook, what are triggers, what's API authentication,
19:24 data transformation, conditional logic, so that once again, when you're
19:26 directing an agent, you can speak precisely about what you want. If
19:29 someone doesn't have that foundation and they jump straight into Agentic
19:31 Workflows, they'll be able to get stuff to work, but they probably won't be able
19:34 to prompt it as efficiently and they'll just say things like make it work with
19:38 my CRM rather than you being able to say trigger this on the deal stage change,
19:41 then pull the contact object and transform these fields, make a post
19:44 request to my endpoints, blah blah blah, which in turn will have the agents
19:47 building things faster and better because your instructions were better.
19:50 You also have some more intuition about failure. So, you've seen so many things
19:54 break in. who understand how debugging works, which means you know the patterns
19:58 that typically cause errors like rate limits or malformed JSON or token
20:02 expiration or weird edge cases that you may not have thought of if you hadn't
20:05 built automations in NN already. So I've obviously poured in like the past full
20:08 year of my life into Nodn but Naden wasn't a detour. It was something that I
20:12 wanted to go through because now like I think about that like learning to ride a
20:15 bike. I've got balance. I know how to steer. I know how to pedal. But now
20:17 we're going to be hopping on to like a motorcycle where we don't have to pedal
20:20 necessarily but we still have to learn how to balance and steer. So yes, the
20:24 barrier to entry to building all of these agents and AI systems is dropping.
20:28 But what businesses actually pay for is not just the actual build itself. They
20:31 want someone who can understand their problem, which most clients can't always
20:34 articulate what they need. They need someone who can integrate with their
20:37 existing mess. Legacy systems, weird edge cases, compliance requirements,
20:40 things like that. And of course, someone who can keep optimize, iterating based
20:43 on real usage, expanding the scope, maintaining systems over time. So yeah,
20:46 the implementation layer is getting easier. Everything else that you do
20:49 after that is getting way more valuable because more people will attempt
20:52 automation and fail at the parts that aren't implementation. User tooling
20:56 expands the market, which means more businesses can actually access the stuff
20:59 because it's not as expensive as it used to be. But they'll still need someone
21:02 who knows how it works and knows how to use it. So your job essentially shifts
21:05 from just being a builder to more of an architect and a manager and once again,
21:08 like I've been saying, a consultant. So if you want to stay tapped into all of
21:11 this, then check out my free community of over 230,000 members. I'm always
21:14 dropping free resources and templates in there. And if you're looking to dive
21:17 deeper, then I've got a paid community of over 3,000 members who are building
21:20 businesses around this kind of stuff every single day. And that's where I'll
21:23 be diving a lot deeper into this kind of stuff, too. So, the link for those are
21:25 in the description. But that's going to do it for this one. I know that this was
21:28 a ton of information. So, I threw all of this into a resource guide, which you
21:31 can access for completely free in my free school community. And if you
21:33 enjoyed or you learned something new, please give it a like. It definitely
21:35 helps me out a ton. And as always, I appreciate you guys making it to the end
21:38 of the video. I'll see you on the next
$

Agentic Workflows Just Changed AI Automation Forever! (Claude Code)

[AI agents and automation][productivity and workflows][open source and self-hosting]
// description

Full courses + unlimited support: https://www.skool.com/ai-automation-society-plus/about All my FREE resources: https://www.skool.com/ai-automation-society/about Work with me: https://uppitai.com/ My Tools💻 14 day FREE n8n trial: https://n8n.partnerlinks.io/22crlu8afq5r Code NATEHERK to Self-Host n8n for 10% off (annual plan): http://hostinger.com/nateherk Agentic Workflows Just Changed AI Automation Forever! (Claude Code) In this video, I break down how agentic workflows just changed AI autom

now: 0:00
// tags
[AI agents and automation][productivity and workflows][open source and self-hosting]