The Claude Code Workflow That Runs My Business Without Me

Added: 2026-05-05

[00:00:00]There's a reason that you can't make successful automations with Claude code, and it's not your prompt. In this video, I'll take you through the most important step to automating with your coding agents. By the end, you'll have the tools to actually run automations that don't break the second you take yourself out of the loop. I'm Roman. I published a top 3% paper at NeurIPS, the largest AI conference in the world. Now, I'm focused on pushing agentic coding to its limits. Most people try to make agents reliable enough to run unsupervised by loading rules into the prompt or their claude.md. For example, asking it no font under 22 pixels, only palette colors, or other dozens of constraints.

[00:00:42]This quickly results in the agents having a decreased performance and eventually ignoring your rules if you stack too many.

[00:00:48]When the agent ignores your rules, you have to go back to babysitting the model, and the cycle continues. This is why I highly suggest do not put rules in your claude.md.

[00:00:59]Here's the core insight that actually lets you step away, which was mathematically proven in a recent paper by OpenAI called YLMN solutioning. Turns out that generation is at least two times more difficult than classification. This is because the generator agent has to make thousands of branching decisions and trajectories, and verification just has to make one.

[00:01:20]But, a separate verifier doesn't always have to be another LLM. Many people get so into AI usage that they forget that they can do tests and scripts to check exactly the type of behavior they want without an LLM call. This means that you can stack many, many of these scripts and check a lot of different behaviors.

[00:01:39]You can build these scripts with AI into your pipelines, and they run instantly and cheaply. So, once you start implementing this at scale and stacking these deterministic checks, you will be well on your way to taking yourself out of the loop. The way that you can achieve taking yourself out of the loop is that when the generation agent finishes its task, we have what we call a verification gate, which can either be triggered by a hook or some other type of behavior.

[00:02:04]In this case on the screen, it's just a bash script checking if the font size is greater than 22 pixels. This is easy, deterministic, and binary.

[00:02:12]Then, step two is that if the verification gate fails, we launch another generation agent with the issue or we give it back to the same generation agent. The second agent can easily clean up the mess from the first one, and you continue with no human intervention.

[00:02:29]True automation is just the process of adding as many of these quality verification gates and healing cycles as possible until you get a task to run end-to-end with no human intervention.

[00:02:40]Now, let me motivate this with an example of how internalizing this flow changed my work.

[00:02:45]Some of you may know that all of my videos are created in a software that I built, and I code all of my slides.

[00:02:51]After I storyboard and come up with the design for the slides, I have some pipelines that build them. However, I noticed that the same issues would consistently pop up even if I put rules in. Specifically, overlapping components were a consistent pain point where I would have to manually rearrange them.

[00:03:09]So, I implemented an LLM reviewer to verify and fix these issues, but continued to notice that the overlapping wasn't fixed.

[00:03:17]Then, I came to the realization that this issue could be measured deterministically in a bash script, which I call a slide linter.

[00:03:24]So, I created a 50-line bash script that checks for violations in my slides and then automatically spawns a reviewer agent if something is wrong.

[00:03:33]This bash script simply triggers after my slide builder agent completes, and boom, I didn't have to play the game of going in and cleaning up all the work from my agents anymore. So, in summary, after every step in any sort of automated pipeline, we want to add a verification gate. Specifically, I follow this hierarchy directly. Starting from the top, if I can do a verification higher up in the list, I will. For example, if you have an automated pipeline writing blog posts, you can't afford human review, you can't turn the check into a script since it's based on unclear writing principles, and you can't apply rules, but you can bring in LLM as a judge. And better yet, if you have clear criteria like patterns you explicitly don't want to see such as m dashes, you can have an LLM as a judge with a clear grading criteria, and it can fix the issues.

[00:04:24]One thing I'll note is that sometimes it can be good to give the model rules in its prompt.

[00:04:30]This is because if it's an easier task, you might as well give those rules, and it'll listen to you. But, you use the LLM as a judge when your agent starts forgetting your rules and ignoring you.

[00:04:41]Now, if I were to walk back through the hierarchy with my actual linter, we would have the script handles it with the font being size greater than 22 pixels, uh if a certain color is in the palette, or if interpolation is clamped.

[00:04:55]We can deterministically check this easily with a script. But, I also have an LLM review step for my slides, where the LLM has to judge is the layout balanced? Is the visual hierarchy right?

[00:05:07]Is the animation timing good? These are more subjective and harder to measure.

[00:05:12]But, it does clean up and do the job.

[00:05:15]Now, let's think about this hierarchy in Claude code specifically for how to actually start using Claude code properly.

[00:05:22]Well, first, you want to use hooks all the time because hooks are these deterministic gates while you're writing code, and these allow you to properly trigger these verification gates after something gets done.

[00:05:35]Well, then down the hierarchy, we have path-scoped rules, which in this case, many people don't know, but is a.claude/rules folder, where if you put the rule in there, it will only dynamically load according to if the agent is working within a path. This is much better than claude.md.

[00:05:54]Then, we have skills or sub-agents.

[00:05:57]Putting some rules in a specific skill and expecting the agent to trigger the skill and follow. Well, we want to be careful here because we're putting it in the hands of the agent. And then, all the way down at the bottom is claude.md.

[00:06:10]Many people, most people actually flip this and put most of their rules in claude.md specifically. Do not do that.

[00:06:19]It will get particularly ignored because the system prompt says that not all things in claude.md are relevant. So, if you end up putting rules in your claude.md, they'll just get ignored. So, at least move them out of it and preferably into hooks.

[00:06:35]Now, I'm going to motivate all of this with a real-time demo, where I'm going to be building a slide using a linter and a verification gate, and show you in real time how I actually use this flow in my own day-to-day work.

[00:06:49]All right, so we're going to jump in to the live demo and start by just opening up Claude in the directory which I am currently making one of my videos.

[00:06:59]So, once we're in, I'm going to paste in this prompt.

[00:07:03]Basically, what this prompt is doing is that we're creating a sub-agent stop hook that runs slide-lint.sh, which is a bash script that checks for stuff such as m dashes and font size less than 22 pixels. Those are two things that I personally do not want to see in my video.

[00:07:24]So, once it goes ahead and checks those, we actually also want to specify that the linter will only run the slide that the sub-agent just fixed. The way I'm currently doing that now is I actually use git diff in order to check what slides were edited, but there's also ways to parse the JSON logs from the agent itself.

[00:07:45]So, let's go and enter that in.

[00:07:49]And then, we can see here that it finally loaded.

[00:07:53]And let's see what happens. So, first, we're going to go ahead and clear context.

[00:07:58]And then now, we're going to go ahead and create the prompt for the actual slide population so that I can show you the right side of the slide getting filled in and then edited in real time.

[00:08:13]So, let's see what happens when that finishes.

[00:08:16]So, now you can see that the slide builder has been launched, and now we just have to wait for it to go ahead and finish. And boom, the slide is populated. But, you can notice that there are m dashes, and there is really small font size. So, these are two clear violations of the rules of the slides.

[00:08:35]So, what are we going to do in this case? Well, we have the linter, which is currently triggering, and it's you can see in real time it's updating those m dashes and turning them into hyphens instead of m dashes. You know, obviously, instead of replacing it with hyphens, we should probably be replacing it with better NLP such as colons or commas or parentheses.

[00:09:00]And then, we're also going to scale up the font size.

[00:09:04]And boom, there it is. We have the thing fully finished, and the slides look super good, way better than when they first started. Now, here's the thing.

[00:09:14]Every automation is only as good as its verification. So, you got to fix the verification, then you can go ahead and take yourself out of the loop. In the case shown in this video, 50 lines of bash script outperformed an entire LLM reviewer. Just remember that, and it's instant, meaning you can stack as many of these as you want. And this allows you to stack many, many gates, which prevents many, many errors, right? So, you want to push determinism up. There's a rule that I stand by, determinism over probabilism. So, once you fix this verification issue, you are well on your way to being able to take yourself out of the loop in your Claude code automations.

[00:09:57]Link below is the number one agentic coding community on school. I just released my free Claude code course in there, so I'll see you in there. Go get it now. Thank you for watching.