Video of the Day20:40Ras Mic · Tutorial
My Complete Codex Agentic Engineering Workflow
Ras Mic walks through the seven habits, plugins to slash commands, that turn OpenAI's Codex from a prompt box into a full agentic coding workflow.
August 14thThe argument in one line.
A two-loop system that forces an AI agent to prove its fix works via recorded computer-use testing, then iterate against automated code review until a perfect score, is what let one developer ship over 75 pull requests in about a week without manually reviewing most of the code.
Read if. Skip if.
READ IF YOU ARE…
- You're already running an AI coding agent day-to-day and want a repeatable process instead of babysitting every task.
- You manage a small dev team or solo build and want agents to self-verify their work before you review it.
- You're comfortable with ticket-tracking tools like Linear or GitHub Issues and want to wire an agent pipeline on top of one.
SKIP IF…
- You're brand new to AI coding agents and haven't run one yet — this assumes you already know how a cloud agent picks up a ticket.
- You want a benchmark or feature comparison between agent tools — this is one person's specific workflow, not a tool review.
The full version, fast.
The video breaks down a two-loop workflow for shipping code with AI cloud agents. Loop 1: a ticket from Linear gets assigned to a cloud agent (Cursor Cloud or Devin), which writes code, then uses computer-use to actually operate the app and record video proof the fix works, retrying until the recorded desired state is achieved. Loop 2: once the agent opens a pull request, an automated review tool (Greptile) scores it out of 5; anything under a perfect score gets sent back to the agent to refine and resubmit until it passes, at which point a human does a final review. The core lesson: a loop only works if the success condition is unambiguous and machine-checkable — write clear expected/actual behavior into the ticket and let computer-use verify it, rather than trusting the agent's self-report.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:04
01 · Cold open — 75 PRs, Fable 5 status
States the headline number, gives a status update on Fable 5 access and weekly usage limits, promises a full breakdown of the loop.
01:05 – 03:36
02 · Loop teaser + Linear ticket tracking
Teases the loop diagram from a June 19 tweet, then introduces Linear as the system of record for feature requests and bug reports, with fields for steps to reproduce, expected behavior, and actual behavior.
03:37 – 04:12
03 · Sponsor segment — Framer agent
Demos Framer's AI agent cloning two reference sites and a design system from a single prompt each.
04:13 – 05:31
04 · Assigning a Linear ticket to a Cloud Agent
Shows clicking assign on a Linear ticket to hand it to Cursor Cloud or Devin via MCP; the cloud agent picks it up and starts working independently.
05:32 – 08:00
05 · Loop 1 — build, computer-use test, evaluate
Explains the first loop: agent builds, uses computer-use to test the app on a virtual desktop, records the result, evaluates against the ticket's desired state, and retries if not achieved.
08:01 – 09:48
06 · Loop 1 in action — two worked examples
A Google Sheets connector-permissions test (including a first attempt that correctly fails) and an agent-card onboarding flow, both verified by recorded computer-use.
09:49 – 12:13
07 · Loop 2 — PR creation + Greptile scoring
Once loop 1 closes, the agent opens a PR with an attached demo video; Greptile scores it out of 5; under 5/5 triggers refine-and-resubmit via the grep loop skill until it passes.
12:14 – 14:25
08 · Human review role + full worked example
Clarifies where the human stays involved (ticket writing, final review) and walks through a real chat-streaming bug end to end: reproduce, diagnose, fix, and re-verify by video.
14:26 – 15:54
09 · Build the loop manually before automating it
Advises building each step of a new loop by hand first, understanding what success looks like, before turning it into an automated skill.
15:55 – 17:29
10 · Recap — the master loop + outro
Recaps the two loops combined into one master loop, claims the pattern is model-agnostic, then closes with a subscribe ask.
Lines worth screenshotting.
- A two-loop system, a computer-use verification loop and an automated code-review loop, let one developer ship over 75 pull requests using an AI coding agent in about a week.
- An agentic loop only works reliably when the success condition is unambiguous and machine-checkable, not when a human has to judge if the output 'looks right.'
- Recording video proof of computer-use testing turns 'the agent says it works' into 'the agent showed it working,' which is what makes unattended retries safe.
- Automated code-review scoring gives an agent a numeric target: under 5 out of 5 forces a refine-and-resubmit cycle instead of shipping mediocre code.
- Cloud agents that run in a hosted environment rather than a local machine can safely use computer-use to test an app without tying up or overheating the developer's own hardware.
- Writing a ticket with explicit expected behavior vs. actual behavior gives an agent the context it needs to know when its fix is actually done.
- The developer stays involved only at the edges of the loop, writing the ticket and doing a final human review, not reviewing line-by-line code in the middle.
- Before automating a workflow into a loop, walk through every step manually yourself first so you understand what success looks like before asking an agent to detect it.
- A pull request that ships with an attached video of the fix working in action changes what a code review actually has to check.
- The same loop pattern is presented as model-agnostic — the creator expects it to keep working as new underlying AI models roll out.
Make the agent's exit condition a video, not a vibe.
AGENTIC WORKFLOW
An AI coding agent can safely run unattended in a loop only when 'done' is defined as a specific, machine-checkable state, a recorded successful test or a perfect review score, not a human's gut sense that the output looks right.
02Loop teaser + Linear ticket tracking
- Track feature requests and bug reports in one system with fields for summary, steps to reproduce, expected behavior, and actual behavior — that structure is what an agent needs to know when a fix is actually finished.
- Writing the bug report yourself (or having a partner write it) before assigning it to an agent front-loads the context the agent would otherwise have to guess at mid-task.
04Assigning a Linear ticket to a Cloud Agent
- A cloud-hosted agent, not one running on your own machine, can safely use a full desktop to reproduce and test a bug without tying up or overheating your personal computer.
- Once a ticket is assigned to a cloud agent, the human can close the laptop entirely — the agent keeps working independently in the background.
05Loop 1 — build, computer-use test, evaluate
- The first loop closes only when the agent uses computer-use to operate the app itself and produce a recording proving the fix works, not when it merely claims the code is done.
- If the recorded test doesn't show the desired state, the loop sends the agent straight back to rewrite and retest — no human has to intervene between attempts.
- The success condition has to be defined clearly enough that both the agent and a reviewer can check it the same way — vague tickets produce loops that never converge.
06Loop 1 in action — two worked examples
- Watching an agent's first attempt actually fail, and get correctly marked as a fail by its own test, is proof the loop's evaluation step is working, not a flaw in the process.
- The same computer-use verification pattern works for onboarding flows, permission settings, and UI bugs alike — it's a general-purpose way to confirm a feature behaves as intended.
07Loop 2 — PR creation + Greptile scoring
- A pull request that ships with a recorded video of the fix in action changes what a code reviewer actually has to check — they're confirming behavior, not just reading a diff.
- An automated review score under a perfect mark should trigger an automatic refine-and-resubmit cycle, not a manual round-trip between developer and agent.
- Different models land at different average review scores on the same task — treat that gap as a real signal of code quality, not noise.
08Human review role + full worked example
- The human's actual job in this pipeline is writing the ticket and doing a final review, not reading every line the agent produced.
- Telling an agent to reproduce a bug and experience the failure itself, before asking it to fix anything, cuts down on fixes that miss the real root cause.
- When an agent hits a blocker like a login two-factor wall, giving it the specific access needed unblocks the loop instead of forcing a full restart.
09Build the loop manually before automating it
- Walk through every step of a new loop by hand at least once before automating it — you need to know what success looks like before you can teach an agent to detect it.
- Turning a manual process into a reusable skill only makes sense after you've proven the steps work when you drive them yourself.
Terms worth knowing.
- Cloud agent
- An AI coding agent that runs in a hosted, remote environment rather than the developer's own machine, giving it safe, sandboxed access to a desktop it can operate and test against.
- Computer use
- A mode where an AI agent controls a virtual desktop, clicking, typing, navigating, the same way a human would, so it can operate and test an app rather than only reading and writing code.
- MCP (Model Context Protocol)
- A connection standard that lets an AI agent read from and act on an external tool, such as pulling a ticket's details directly from a project-tracking app.
- Desired state
- The specific, checkable outcome a ticket defines as done, used as the exit condition an agentic loop tests against before it stops retrying.
- Grep loop skill
- An add-on skill for an AI coding agent that makes it automatically wait for an automated code-review score, read the feedback, and resubmit revised code until it hits a perfect score.
Things they pointed at.
01:25toolLinear
02:18toolCursor Cloud Agent
02:18toolDevin
10:37toolGitHub
11:05toolGreptile
Lines you could clip.
01:00
“I finally have a workflow where I can literally go to bed with a defined loop and wake up with a finished PR ready to get shipped.”
02:55
“If we're gonna be honest with ourselves, most agents suck at design.”
09:10
“This loop is going to be successful all the time because the feedback loop, the success state, the desired state is not only easy to check, but easy to identify and easy to state.”
11:30
“Read the feedback you get, read the comments that you get, address those comments, push to the PR again, and wait for a review.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphor
I shipped over 75 PRs using Fable five and loops. Now it's been eight days since Fable five came back to us finally. We thank the Lord for this, and it's been extended.
As you can see here, Fable five came back July 1, and then on July 7, they extended it to July 12. Now the sad unfortunate thing for me is I've maxed out my weekly limits. I either have to wait seventeen hours for it to reset or I have to get a new subscription.
But what I'm gonna be sharing with you in this video is how I shipped over 75 PRs, and I'm going to break down the entire loop or loops that I used to make this happen. Now, originally, I wasn't really a big fan of loops, especially the way it was explained, but after building out my own loops in areas that make sense and combining them with other loops, I finally have a workflow where I can literally ready to get shipped.
I'm gonna break that down in its fullest detail. I'm gonna show you all the tools I use. I'm gonna explain the loop and I'm gonna even show you the features that we built.
Sit back, relax, let's get started. So actually before I show the entire loop, I tweeted this at June 19 and quite a lot of people had questions and today I have answers. Now first things first, the beginning of the loop starts with you describing a feature.
Now I'm gonna use a platform. I'm using a platform that I can place not only feature requests, but I can also place bug reports. And the tool I'm using, some of you might roast me for this, is I'm using Linear.
Now there was someone who said to me, why don't you use GitHub issues? And that's because it's GitHub. So I use Linear as a place to track feature requests, as a place to write a bug reports and all that type of stuff.
A great example here is I can maybe click on this right here, and this is an issue, a bug actually. UI flicker between connecting to ChatGPT and waiting for response during model provider connect.
I see a summary. I see steps to reproduce. Now this will be very important later.
We see the expected behavior, what the actual behavior is, impact analysis suggested next steps. Now I didn't write this. My business partner Musso wrote this and I'm sure he used AI to write this and this is great.
So this is where it starts. Linear is where we write our feature request or the bugs that we catch. Now through MCP, what happens is we can assign an agent to work on this specific feature or bug.
And in this case, I am using either Cursor Cloud or Devon. And the reason why I'm using either Cursor Cloud or Devon is because I need a Cloud Agent. The reason why I need a Cloud Agent is I want an agent to have full access to a computer.
So not only can it reproduce the bug, but it's going to fix the bug. It's going to record a video of the bug being fixed. It's going to test it out, and then it's going to make a PR.
And in order to do all this autonomously, but not also , I need to use the cloud. I actually got this mini PC so I can build my own cloud at home.
That's a separate video. Make sure you're subscribed. If we're gonna be honest with ourselves, most agents suck at design.
I'm talking Cloud Code, Cursor, and Codex. And even paired up with the best models, you're really getting something basic. Uh, if only there was a platform that had an agent that we could use to create beautiful websites, beautiful and saucy websites if only if only.
Well, ladies and gentlemen, because that exists and it's called Framer agent. Using the Framer agent is pretty simple.
I go to framer.com and then I have my agent tab on the right side. I have my chat box down below, and I dropped a screenshot asking it to create a clone of this site.
I really like this site, and I asked it to create the exact clone. And in one prompt, it created a perfect clone. That's how you know the AI agent's really good.
But not only did I want it to create a clone, I really like the style of this site. I wanted to create a design system so I can use this for other projects and guess what it did? It created a design system for me.
Now you might think that's luck, but then I got it to clone Vercel's hero section which I absolutely love. And all I did was again, ask it to build an exact clone, attach a screenshot, and it did it in one prompt.
But not only does Framer give me access to a powerful agent, I also have the full power and ability to make changes myself. I could change the gap here as you can see. So now you know how to build saucy websites using Framer and its new agents, so don't make the same mistake others are making.
Click the link in the description. Go build something beautiful with Framer. I'll see you back in the video.
But in order for this loop to successfully work, I'm going to need to use a Cloud Agent. Now the way I set everything up is as follows. Let's say I wanted to fix this right here.
I have this chat error right here. Now forgive me. The way this ticket is explained is pretty bad because I hand wrote this.
I would use AI to make this better. Forgive me for that. But how I would go from linear ticket to Cloud Agent or Devon running is as follows.
I click on my name and then I assign it to an agent. In this case, for example, we'll assign it to cursor. And what's going to happen here is you're going to see it says cursor started by Michael Schmullis examining issue PLO216 and I can see the cursor agent working.
Now if I go to my cursor dashboard, you can see here that the agent picked up the linear ticket and is starting to work on it. Now, this is on the cloud.
I can close this tab, I can open my computer, I can do whatever I want. So you could see here, the agent is at work. Now, this is the first part of our loop.
We haven't even got to the loop part, but the build phase has begun. Now this is where loops come to mind. The way I have my Cursor Cloud Agent or Devon set up is as follows.
Once they receive the information from the linear ticket and I want you to listen to me. I don't want you to copy my loop bar for bar, line for line, but I just want you to understand how I'm thinking about this and how these things work. So my Cloud Agent starts to work on the ticket, whether it's a feature request or a bug fix, whatever it is.
The agent's going to run code. It's going to continue to think. It's gonna plan, do all that stuff.
Once it's done, it does the following. This is where the looping begins. It starts to use computer use.
It uses the desktop. The cool thing about Cursor Cloud Agent is it has access to the desktop and so does Devin.
Devin also has access to the desktop. So both these agents have access to computer. This means they can run my app in the computer and can use computer use to test it out.
So what I want once the agent is done writing the code is I wanted to use computer use to actually test out the fix. Right? In this case, I can actually show you an example.
Let's show a Devon example. I can play a video here where it's testing out connectors. Right?
We wanted people to be able to pick different permissions. So you could see here, let me pause this real quick, you could see here that asked the agent to create a new Google Sheet titled whatever using the Google Sheets account connected. Right?
And it did that. Then it's gonna go back to connectors and check out the permissions.
The permissions to create a Google Sheet was always allowed. So we can see that this feature that I asked it to create which was managing permissions, it worked. But the way I identified that it worked is I wanted the agent to use computer use in its desktop and to actually record a video testing the feature.
And what's cool about this loop is not when things go right, but when things go wrong. For example, the feature that I showed you earlier, the first run, the agent actually got it wrong. And look, I'm gonna play this video and you're gonna see where it's testing you where it sets the connector permissions, check this out, to, uh, always allow.
So meaning when the user prompts it to do a specific thing, it should just do it. But watch what happens. It's going to ask if it can do it, and you can see here the dev and agent marks it as a fail.
So computer use with a cloud agent and the ability to record makes it so that I can tell the agent to continue to loop until the desired state is achieved, until there is a video of the agent successfully doing the thing I wanted it to do. So this loop right here makes sense now.
Right? Agent builds. It's being tested using computer use.
We evaluated. The agent checks the state, checks to see if the desired state is achieved. And remember, this ticket does a bad job of explaining how we write it, but you can see here what the expected behavior is and what the actual behavior is.
So the agent has context as to how this feature or how this bug is to be fixed, how the desired state is to be. So we keep looping. Right?
It checked if always allow worked, it didn't work, so guess what? Give it back to the agent. Agent writes code, test again.
Doesn't work? Agent write code, test again. Doesn't work?
Agent writes code, test again. Once this loop finishes, we head on to the next step. So this is how I want you to think of loops.
In order for a loop to be successful and in order for your loop to not burn your subscriptions, your tokens, the the evaluation needs to be clear and cut.
In this case, it's divined in the ticket, and not only that, the agent is using computer use. So we can see, oh, I was supposed to fix chat streaming, but chat streaming didn't work. So, therefore, this loop is going to be successful all the time because the feedback loop, the success state, the desired state is not only easy to check, but easy to identify and easy to state.
Right? I have it in my linear ticket and it has computer used to confirm this. So this is another example.
I can even go on cursor and I can show you. I wanted to build a new onboarding flow for people to create virtual cards for their agent and once it was done, I told the agent to make sure to record a video and as you could see, it created a video of it creating an agent card.
It's showing me the onboarding flow and it's also showing me the cards that exist. Right? So this is a successful run and you can only do this with cloud agents because doing this on your own machine unless you have a very, very beefed up machine.
I have a beefy machine. It will . So this is the first loop.
Using computer use in a cloud agent to verify that whatever fix or new features developed actually works. Now once we pass this step, what the agent then will do is it will create a pull request, a PR. I'm using GitHub for all this stuff.
It will create a pull request, and in the pull request, it will post a video. I'm pretty sure I have an example here where this is a merged PR, and you can see it has demo videos of success dates.
So when I'm reviewing the PR, I get a video of the fix in action. This is more just a good thing for me that review makes sense. But even though the video might work, I still use a code review agent and this is where loop number two happens.
Right? Once it creates a PR, I'm going to wait for a review or the agent's gonna wait for a review. And the tool that I use for this is Greptile.
And the reason why I love Greptile is because Greptile has the slash grep loop skill, which allows your agent to loop against its feedback until you get a perfect score.
Let me show you an example. If I go back to this merged PR, you can see here that the confidence score is a five out five. Now sometimes the agent might get a four out of five.
If you're using Fable, it's always a four out of five or a five out of five. But let's say you're using GBD 5.5 or Opus $4.08, you might get a three out of five or a four out of five. What grep loop allows you to do, I've talked about this in many videos, it's a skill that basically tells your agent, wait for the PR review from Greptile.
Once you've received the PR review, if it's a three out of five or four out of five, read the feedback you get, read the comments that you get, address those comments, push to the PR again, and wait for a review. And that's what loop number two is. I basically wait for the code review agent score.
If the score is less than five out of five, what does the agent do? It refines the code and resubmits. Wait for a new score.
If it's under five out of five, again, refine, push. Under five, refine, push. Once the score is a five out of five, we break out of this loop.
And once this loop is complete, then it's ready for human review. So even though I said I have this one giant loop, it's really a combination of two loops.
The first loop is in charge of the creation of the feature or the fixing of the bug.
And the feedback that it needs in order to break out of the loop is a video or not a video, actually, the videos for me is computer use. Right?
The agent has to use the computer and experience success, whether it be the feature working or the bug fixed. Once that happens, then we move on to step number two or loop number two where this is pushed to GitHub, a PR is created, and once this PR is created, we wait for GREPTILE to give us a score.
If it's under a five out of five, we loop. We push the feedback back to the agent. Agent addresses reptiles feedback, waits for a five out of five.
If it's not, again, we refine the code, resubmit. Refine the code, resubmit. Once we have a five out of five, then the PR is ready to be reviewed.
Now notice how I'm still involved in this process and where I'm involved is describing the feature, right, and making sure that everything is done accordingly.
So the human reviews me reviewing the entire PR, the video, and I might look at the function signatures of the code, but I'm not reviewing the entire code. Now understand this. In order for you to build this out fully, you have to be involved in each step at first.
Let me show you a perfect example. A perfect example is maybe this feature right here, chat stream and calling connectors as slow and breaks. Right?
So this was from p l o two one two, which means I use linear. Uh, the information, the bug was described in linear, and it read it and it proposed a plan. And I told it, I want you to recreate the bugs, experience them so you know exactly what's the issue.
So it reproduced the bug. Right? It I saw it use the computer and it reproduced the bug.
Now it needed to log in and 2FA blocked it. I gave it 2FA access and it finished the repro and I got a video for it. You can see here that it used the computer, recorded a video and it's going to experience an error.
So you could see here that streaming doesn't work. The the block of text just appears all at once.
So I told it to reproduce the bug so it understood the bug properly, And then I asked why is the text not being streamed instead of just showing all at once. It explained what the issue was, and I said, yeah. I want streaming to work.
It must work. What's the plan to fix this? Created a plan.
Okay. And then it brought up another issue, and then I told it to investigate. And then it it identified the issue and made a fix.
And once it made a fix, I said, me recording of this bug successfully fixed. And we can review this video and we can see that types of prompt and streaming works now.
Now the reason why I'm showing you this is before I turned this into a loop, before I created a skill for this, it's called testing Pluto PRs. Before I created this skill, want you to understand I built this loop myself, meaning I manually walked through these steps. So if you have a plan on building a loop, something similar like this or this exactly, I would say first, work with the agent and build each step yourself.
Meaning, write a description. Right? And then connect the MCP tool and then get the agent to pick it up.
And then once it's built version one, then you say, okay. Please test this out by using computer use and send me a recording of a successful run. If it's not successful, please keep building until you have a successful run.
Do not stop until you have a successful run and a recording to show me. Boom. You just built your first loop And then you do the PR part.
Okay. This is great. Please push to GitHub.
Have Greptile. Uh, you gotta set up Greptile on GitHub. And you say create this PR.
The PR is created. Greptile is running. And then Greptile gives you three out of five or four out of five.
Tell your agent, use the grep loop skill. You could pull it up from the Internet, and then get a five out of five. Right?
And then you're gonna see it work, get a five out of five. You're gonna review everything. You're gonna push this.
Ladies and gents, you have a loop to produce and generate production code. Now here's the thing. There's many places where you can stop things not going right.
In the first loop, if the recording that you get is bad because the agent hallucinated, you could stop that. If you don't get a five out of five, it doesn't get merged. You could stop that.
Right? So I believe I've built a robust loop. Let's call this master loop using two loops, and this is what allowed me to ship over 75 PRs using Fable five.
I definitely think Fable five is the reason why this works. I'm sure this could work with the GPT five five. Hopefully, we get GPT five six.
And this is my loop. This is how I've been shipping using Fable five. Let me know your thoughts in the comments down below.
Make sure to like, comment, subscribe. I have a couple new videos coming out soon, so make sure you subscribe. I'm gonna share with you the projects that I built with Fable and how I built them, and I have a a video on Cloud Agents coming soon.
It's just a great time to subscribe. We're almost at a 100 k. Thank you so much for watching.
You've been awesome. My name is Russ. I'll see you in the next one.
Peace.
The Hook
The bait, then the rug-pull.
Ras Mic opens with a number that begs a question: how does one person ship 75 pull requests using an AI agent in about a week without manually reviewing all the code? The answer, laid out over the next 17 minutes, is not a smarter model, it's two nested loops that force the agent to prove its own work before a human ever needs to look at it.
Named ideas worth stealing.
05:32model
The Two-Loop Shipping System
- Loop 1 (Build): agent picks up a ticket, writes code, then uses computer-use to actually operate the app and record video proof it works, retries until the desired state is achieved.
- Loop 2 (Review): agent opens a PR, an automated reviewer scores it out of 5, under 5/5 sends it back to refine and resubmit until it's perfect.
- Human checkpoint: only after both loops close does a person review the PR, the video, and the function signatures, not the full code.
A two-stage retry loop where the exit condition for each stage is a machine-checkable state (a recorded successful test, then a perfect review score) rather than a human judgment call.
Steal forany agentic coding pipeline where you want an AI agent to self-verify before requesting human review
11:05concept
Grep Loop Skill
A named skill that tells the agent to wait for a Greptile code-review score, read the feedback if it's under 5/5, revise the code, resubmit, and repeat until a perfect score, automating what would otherwise be manual back-and-forth PR review.
Steal forany PR review workflow using an AI code-review tool
How they asked for the click.
VERBAL ASK
03:19product
“Click the link in the description. Go build something beautiful with Framer.”
Woven into the tutorial as an in-story tangent rather than a separate ad break, presented as solving the exact pain point ('most agents suck at design') the video just raised, with a live one-prompt clone demo as proof before returning to the main tutorial.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
