Big Idea

The argument in one line.

Modern LLMs are reliable enough to control a desktop through nothing more than a markdown skill and a small CLI, replacing dedicated computer-use products with something the user can read, edit, and fully control.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use a coding agent like Claude Code or Codex daily and want it to handle repetitive desktop setup and testing without installing a separate computer-use product.
You test self-hosted or open-source tools that have a GUI but no API and no browser-automation surface.
You want full visibility into and control over how your agent operates your screen, instead of trusting an opaque built-in tool.

SKIP IF…

You need production-grade, high-volume computer use with sandboxing, guardrails, and audit logging; the video itself says to use a dedicated harness for that.
You're not working inside a coding agent that can load skills or run local scripts.

TL;DR

The full version, fast.

The video introduces drive-screen, a Claude Code skill built instead of adopting a dedicated computer-use product like the ones built into Claude or Codex. It works by giving the coding agent a markdown ruleset plus a small Python CLI (screenctl.py, session_watch.py, autodrive.py) for window discovery, typing, clicking, and screenshotting on Windows, macOS, and Linux. The agent first checks whether screen control is even necessary before touching the mouse or keyboard. The creator uses it daily for morning setup, testing unfamiliar open-source apps, and driving other agent sessions. He argues the newest models resist prompt injection well enough that the security risk is now low for everyday, non-production use, though he still reaches for a full harness for anything production-grade.

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 →

Chapters

Where the time goes.

00:00 – 01:51

01 · My New Favorite Skill: Drive Screen

States the thesis: a lightweight markdown skill beats bloated built-in computer-use tools, shown against the SKILL.md on GitHub and competing products like ChatGPT's Computer Use docs and the TARS agent stack.

01:51 – 02:41

02 · Morning Setup With Your Coding Agent

Demo of the agent opening the right repos, terminals, and browser tabs each morning from one instruction, saving 10 to 15 minutes of manual setup.

02:41 – 03:20

03 · LLMs Can Do Way More Than You Think

Broader point that tasks written off as impossible for an LLM, like editing raw video, are now often just a direct instruction away.

03:20 – 05:34

04 · How Drive Screen Started

Origin story: testing the open-source Kestra orchestration platform by handing Claude a GitHub URL and letting it research, launch, and exercise the app unattended end to end.

05:34 – 06:46

05 · Sponsor: Plural

Sponsored segment demoing Plural Workbenches diagnosing a crash-looping Kubernetes service and opening a GitOps pull request to fix it.

06:46 – 07:41

06 · Live Demo

Sped-up live examples: arranging a VS Code window and a terminal side by side, then testing an Obsidian plugin end to end with the skill loaded.

07:41 – 08:52

07 · How the Skill Works

Walkthrough of the SKILL.md structure, including the gate question 'does this need the screen at all' before granting screen control.

08:52 – 09:57

08 · The Custom CLI Scripts

Detail on screenctl.py's commands (shot, type, paste, keys, click, scroll) and why paste and screenshot-verified targeting beat typing and window titles.

09:57 – 11:07

09 · Hard Rules, Control Loop, and Traps

The numbered hard rules, the discover-screenshot-focus-act-verify control loop, and documented traps like nested agent sessions and fullscreen apps stealing focus.

11:07 – 12:22

10 · Prompt Injection and Security

Discussion of the HiddenLayer research on indirect prompt injection against Claude computer use, and why the creator now considers the risk smaller with current models.

12:22 – 13:01

11 · Install the Skill

Closing instructions for installing the skill as a Claude Code plugin or copying the skills folder directly, plus the sign-off ask.

Atomic Insights

Lines worth screenshotting.

A coding agent can now drive an entire desktop through nothing but a markdown skill and terminal commands, with no dedicated computer-use tool installed.
The skill's first rule is to ask whether the task even needs screen control, since screen control is described as the slowest and least reliable way to make a computer do something.
On Windows the skill runs through plain PowerShell; on macOS it uses AppleScript, with no extra software installed on either.
A morning setup automated through the skill, opening repos, browser tabs, and Docker containers, saves roughly 10 to 15 minutes every day.
The skill packages hard-won failure patterns into explicit hard rules and traps, including never sending input without confirming window focus first, since a mismatched target silently corrupts whatever app happens to have focus.
The custom CLI favors pasting text over simulated typing and screenshot-verified window targeting over window titles, because typing can be intercepted by hotkeys and titles change mid-session.
A full end-to-end test of an unfamiliar open-source repo, cloning it, reading docs, launching the desktop app, exercising features, ran unattended while the creator worked on another device.
The entire skill is under 400 lines of markdown plus scripts, making it editable in a text editor instead of requiring a rebuild of a larger harness.
The creator no longer treats prompt injection during computer use as a major risk with the newest models, citing recent studies showing current LLMs resist on-screen hijack attempts far better than before.
Multi-monitor and mixed display setups were part of the testing before the skill shipped, not an afterthought bolted on later.

Takeaway

Screen control works now, but it's still the last resort.

WHAT TO LEARN

Current coding agents can reliably drive an entire desktop through nothing but a markdown ruleset and a thin CLI, but the smart approach still checks for a faster, more deterministic path before reaching for the mouse and keyboard.

01My New Favorite Skill: Drive Screen

A packaged skill, a markdown ruleset plus a few scripts, can replace a dedicated computer-use product for everyday automation, because current models are reliable enough to drive a desktop through screenshots and terminal commands alone.
Owning the automation logic yourself, instead of adopting an opaque built-in tool, means you can read, edit, and fix any failure mode the moment you see it.

02Morning Setup With Your Coding Agent

A coding agent can run a full morning routine, opening the right repos, browser tabs, and desktop apps, from a single instruction, cutting 10 to 15 minutes of manual setup out of each day.
The same automation can pull context from task-management tools via CLI or MCP first, so the agent opens what today's work actually requires instead of a fixed list.

03LLMs Can Do Way More Than You Think

Tasks written off as impossible for an LLM, like driving a GUI or editing a raw video file, are frequently possible now with nothing more than a direct instruction to a capable model.
Before building or buying a specialized tool for a task, it's worth testing whether a current-generation model can just be asked to do it directly.

04How Drive Screen Started

Computer use is a practical fallback for testing software that has no API and no browser-automation surface, such as an unfamiliar open-source desktop or web app with only a GUI.
An agent can be handed a repo URL and asked to research it, launch it, and exercise its features end to end unattended, then leave the environment open for the human to continue.

06Live Demo

Window layout and focus can be delegated entirely to the agent, down to confirming the result with its own screenshot.
The same skill generalizes across unrelated tasks, rearranging windows in one prompt and testing a plugin's chat behavior in the next, without new tooling for each.

07How the Skill Works

The first step of any screen-control workflow should be asking whether screen control is even necessary, since it is explicitly the slowest and least reliable way to make a computer do something.
A command, an API, a config file, or a log is worth checking first; only fall back to GUI control when none of those exist or the task genuinely requires clicking through a live interface.
Under 400 lines was enough to cover a full workflow across three operating systems when the instructions are organized around explicit failure modes rather than general guidance.

08The Custom CLI Scripts

Packaging the best-tested approach to each mechanical action, window discovery, typing, pasting, clicking, into a small deterministic CLI removes the need for the agent to reinvent the exact command every time.
Pasting text is more reliable than simulating keystrokes for anything non-trivial, since typed input can be intercepted by hotkeys or dropped by timing issues.
Targeting a window by its live ID is more durable than targeting by title, because titles change mid-session in ways that break a rule written against the wrong assumption.

09Hard Rules, Control Loop, and Traps

A documented control loop, discover the window, screenshot it, focus it, act, then screenshot and verify again, keeps an agent from acting on stale screen state it never actually confirmed.
Explicit handover and confirming focus before every keystroke prevents input from silently landing in the wrong application, the single most common failure mode of computer use.
Documenting specific traps as they're encountered, nested agent sessions, fullscreen apps stealing focus, shells that rewrite special characters, is what makes a skill more reliable over time, not a single upfront design.

10Prompt Injection and Security

Prompt injection, where malicious on-screen text tries to hijack an agent mid-session, is the specific security risk that comes with giving an agent screen control.
The newest generation of models is reported to resist prompt injection substantially better than earlier ones, even without additional guardrails, which changes the risk calculus for everyday use.
Production-grade or high-stakes computer use still warrants a full harness with guardrails, not a lightweight skill, even as the risk tolerance for personal daily use has gone down.

11Install the Skill

A skill this size is meant to be dropped into any coding agent's project directory directly, without requiring a plugin system or installer.
Treating a skill as a living document, where every new failure becomes one more rule, compounds its reliability over time in a way a closed tool can't.

Glossary

Terms worth knowing.

Computer use: An AI agent capability where the model views screenshots and issues mouse and keyboard commands to operate a desktop the way a person would, instead of calling an API.
Prompt injection: An attack where text an AI agent encounters, on a webpage, in a file, or on screen, contains hidden instructions meant to hijack the agent's behavior.
Claude Code skill: A packaged folder of instructions and scripts that a coding agent loads on demand to perform a specific workflow, without permanently changing its core setup.
Harness: The larger surrounding software, including sandboxing, permissions, and retry logic, that wraps an AI agent to make it safe and reliable for a specific task, as opposed to a lightweight skill.
GitOps: A workflow where infrastructure and deployment changes are made through pull requests to a Git repository rather than manual commands run against live systems.

Resources

Things they pointed at.

00:00tooldrive-screen skill (GitHub) ↗

12:22toolCole's AI Skills (GitHub repo) ↗

11:07linkHiddenLayer: Indirect Prompt Injection of Claude Computer Use ↗

03:59toolKestra (open-source orchestration platform) ↗

05:34productPlural (DevOps agent workbenches) ↗

00:00productDynamous Agentic Coding Course 2.0 ↗

Quotables

Lines you could clip.

00:00

“I have a new favorite skill that I'm using in Cloud Code and Codex every single day for everything under the sun.”

cold-open hook that states the whole thesis in one breath→ TikTok hook↗ Tweet quote

08:16

“Screen control is the slowest and least reliable way to make a computer do something.”

a counterintuitive admission from someone whose favorite tool is screen control→ IG reel cold open↗ Tweet quote

11:20

“I don't think you have to worry about prompt injection attacks that much anymore, as long as you're using the new best models.”

bold, debatable security claim that invites disagreement→ newsletter pull-quote↗ Tweet quote

The Script

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.

metaphorstory

I have a new favorite skill that I'm using in Cloud Code and Codex every single day for everything under the sun. I call it drive screen and I want to show you how this works today because I built it to be a super lightweight alternative to the really bloated and hard to manage computer use tools like what Cloud has built into their platform.

We have Codex computer use, there's a ton of open source tools out there as well and these are all powerful but I've never been a fan of using them. That's why I built my own skill and the beauty of what I built here is you just need your coding agent.

You don't have to install anything or build any kind of harness. Large language models, especially with Fable 5 .1 and GPT -6 Astro now, they're good enough where they can drive your entire screen for pretty much anything with just the command line. I didn't realize that until I just tried it out a couple of weeks ago.

And that's eventually led to building this skill, which I love because it works no matter the operating system. And now I don't have to install anything else or rely on a massive out -of -the -box computer use tool. Like I said, I've never been a fan of these.

I want to control my tooling. And with these tools, it's really hard to customize things and tweak it as little issues come up as you're incorporating it in your workflow. And so because of that, I've just always strayed away from computer use as a whole.

The problem is... Computer use is incredibly useful. And I'm realizing that more and more the last couple of weeks.

There's a reason I'm obsessed with using the skill now. So if you're not using computer use at all right now, I would encourage you to at least start dabbling with it. With a tool like Codex Computer Use, of course, I would encourage you to try out the skill that I'll link to in the description.

There's just endless possibilities, ways to boost your productivity using this kind of capability with your coding agent. Now, of course, there are some security concerns. when you're running just a skill instead of a full harness we'll definitely talk about that but there are so many quick wins i've started relying on every single day that i want to show you here i mean the most obvious one is to use your coding agent to help you get set up in the morning so you turn on your computer you open up your coding agent and you say get my morning set up right like here are the things i'm working on for today you could even go look at your task management software with the cli or mcp and then it can get things open for you in your browser tabs opening up tabs in obsidian getting desktop app started, Docker containers, whatever you need, it can set up everything.

And so like this alone saves me like a solid like 10, 15 minutes every single morning. And that adds up, especially with all the other things I'll show you here. And so it just uses the skill and simple commands to drive everything.

There is no additional tooling installed here. And I've tested this skill on each operating system, Mac, Linux, and Windows. I've tested it with multiple monitor setups and different display settings.

It's really good. adaptable. And here's the thing, even if you're not super interested in this specific skill I'm showing you right now, the big takeaway here, what really just blows my mind is how adaptable large language models have become.

There's so many tasks that I've just written off before as the LLM can't do it, or I think you need some massive tool like for computer use where now you just don't. Like you probably have a couple of ideas in your head right now for something you think an LLM can't do, like computer use or editing a video. You think you need some fancy tool, but you actually don't just like try it out right now give it an mp4 and say edit this video take out the ums add in b -roll and transitions and especially with like fable and astra like it'll knock it out and to be totally honest with you this drive screen skill has been simply born out of necessity because recently i've just been kind of overwhelmed with all the different things happening in the ai space things i got going on applications that i'm trying out especially a lot of open source projects like kestra for example i'm trying out all of these and a lot of them they have a ui or there's something where i can't

just use my browser automation. So I needed some kind of computer use to test things out. But also I wanted something super lightweight and easy for me to manage.

I didn't want to bring in a full computer use tool. And so at the time I just took this GitHub URL and all the other ones I was testing. I mean, this is just one example here.

I gave it to Claude and I said, research the web, dive into the repo to understand the features, then start the desktop app and then control my screen to test out different features and then leave it open for me at the end to continue. my own testing. And I had no idea if that would work.

I thought maybe it would go for some larger computer use tool and install it, or maybe you just say it can't do it and tell me to do things manually. But to my pleasant surprise, it was able to go through it end to end simply by running commands in the terminal. So this is about what my session logs look like, especially before I had the skill.

So it runs command after command to click around and take screenshots and analyze results. But it did the whole thing end to end. It took a while.

It's not the most efficient. I mean, computer use isn't in general, but I just let it go, take control of my computer. I worked on another device.

I came back and everything was done and everything was still up for me to continue the testing as well. It was a beautiful thing. And with all these commands, for me on Windows, it's just simply PowerShell, right?

Like there's no additional tool brought in. For Mac, you can use AppleScript. Again, I've tested this for every OS.

And so I was hooked on this right away, testing a bunch of different apps, doing my morning setup, like I showed earlier, having it set things up for... my presentations and recordings every single day. Now it didn't start as a skill.

Like I just say, like use PowerShell to drive my screen and do X, Y, Z, but it became obvious very quickly that we need a full skill because sometimes the computer use wouldn't even work through PowerShell. Like the agent would get totally tripped up or there'd be certain failure modes that I'd see come out as patterns. And so I've documented all the failure modes.

I've laid out the workflow, even built some scripts to make things more deterministic. And that is what I have packaged up as the skill for you. The sponsor of today's video is plural and they built something genuinely cool.

DevOps agents that live in your own Kubernetes clusters, figure out what's broken when something is, and then open up pull requests to fix it. They call it workbenches. So let me show you.

Right now in my own cluster, I have one of my services, the payments API that is crash looping. But all I have to do here is go to the workbench where I can send off any job. And I simply said the payments API service is crash looping, find the root cause and open up a pull request to fix it.

And here plural spins up sub -agents that each have their own context to dive really deep into the pods, the logs, the GitOps repository. A couple minutes later, it identifies the exact problem.

It gives me the diff and the evidence and even builds me a dashboard to help me understand the problem that's happening here in my cluster. And then my favorite part is it spins up a cloud code instance in my cluster to make the fix and then open up the pull request. And so the agent runs in my environment with my model keys and I still get to be the one to merge the pull request in the end.

And you can wire up that same workbench to your alerts, run it on a cron, or even trigger it by saying plural fix this in a Jira ticket. You can self -host plural or user cloud, and it's free to get started. I'll have a link to them in the description.

So of course, I want to get into how this skill works, how I've kept it simple, security considerations. We'll talk about that in a second. But what I want to do for you really quickly here is show you a live demo of this skill working.

And so I'm obviously going to speed it up a lot, but I'm going to send off this prompt so we can see it in action, loading the skill. super easily going through any kind of setup that I have for it. And so I'm going to turn off my video and then fast forward here so you can watch it happen.

So there we go. We completed everything within just a minute here. I know it's a very simple example I'm showing you here.

I don't want to do anything super comprehensive right now, but the point is that it's fast. It didn't take a lot of commands either because the skill guides it and even gives it some tooling to move faster. And by the way, what it did here even includes validating the environment to make sure it has all the tools it needs and that it has the permission it needs on the machine as well.

And so that's just a super quick example. Now let's talk more about how the skill works. So this skill as a whole, is a little under 400 lines long.

So not the longest, but also not the shortest. I wanted to have a full workflow laid out for the agent here and also make it work for every operating system. And there's a lot of nuances I wanted to build in, little failure modes that I've seen as I've tested it out.

And so the workflow starts by figuring out, do we even need screen control at all? I want the agent to have the opportunity to push back when you use this skill, because sometimes it really doesn't require computer use when you think. There's some other kind of tool like browser automation to get the job done.

Like it says right here, screen control is the slowest and least reliable way to make a computer do something. So it's the most adaptable and flexible, but it's the slowest. And there's the security issues where you can have prompt injection attacks come on your screen.

So the agent views that and does something malicious. Large language models really don't fall for that anymore, which is also a big reason why I'm trusting it with this kind of capability now, but just something to keep in mind. That's also why I stick to really simple things when I'm using this tool.

any kind of production grade computer use i'm still going to be using some kind of larger harness or tool and then going up to the top of the skill really quickly i want to call out the different scripts that ship with the skill this provides more determinism so instead of the agent having to figure out the exact commands for certain things in real time like i had to do initially i have all the best practices packaged up into these scripts now for window discovery and focusing and typing and pasting there's many different ways to do these things i figured out the best from all the testing I've done.

And let me tell you, I've done hours and hours and hours of testing and I built it into essentially this little CLI for the agent to call upon with the different commands and arguments. And so it's my own little custom CLI. We don't have to get into the details of all of this right now.

There's quite a bit here because there's so many different operations the agent can perform, but it's a big part of what makes this more reliable. And it's also very easy to customize things. If you're working on some other kind of distribution of Linux, for example, that might need things.

to operate a bit differently you can just go in and edit the skill right so like when you install the skill from my skills repository everything comes with the reference of course the skill .md and all the scripts for the cli and then scrolling back down again we have all the hard rules these are things i learned the hard way just as i was building up the skill and using it over and over again so that makes it more reliable we have the control loop like whenever you're operating in a window here's what you should do right like first discover the window with a command screenshot it so you have the lay the land, focus in on it, then you can act.

And here are the ways that you act and the CLI that you have to help you with that. So you can see everything coming together here. I don't even have to go and read through literally everything.

But there's also like a whole CLI for watching a session. Like if you have it drive another coding agent session, it needs to watch for approvals or things like that. I've done a lot of that as well.

Auto driving, we have different traps that we needed to watch out for. And so some of these things are specific to what I've been automating with, like browser tabs, desktop applications, and then other coding agent sessions. Maybe you're going to be doing the same things, maybe not.

But again, you can take this skill and customize it to your liking. So if you want to take out traps because they don't apply to you or add some in, you can feel free to do that, right? Like that's the kind of thing that you can't really do with a larger computer use tool.

Just going back to that reason again and again why I love having this flexibility so much. Now, like I mentioned a bit ago, you also... do have to be aware of prompt injection attacks for just computer use in general.

I'll link to this article in the description. It's a really good read. But also, I gotta say, and this might bite me in the butt a little bit.

I don't think you have to worry about prompt injection attacks that much anymore, as long as you're using the new best models like Fable 5 .1 and GPT -6 Astra. There are a lot of studies coming out that are showing that even without fancy guardrails or a fancy harness, these LLMs are very, very hard to prompt inject. And so I'm just not concerned about it these days, at least not nearly as much as I was before.

I don't think you have to be either. And especially if we're using this skill for simpler things like what I showed in this video. like morning setup and testing desktop apps, things like that.

You really don't have to worry about it. And so, yeah, I would say just make sure you're using the most powerful LLMs when you're using computer use, makes it the most reliable anyway. And this skill, it is pretty token efficient.

It's not the fastest, but it's because it's waiting on different inputs and things, not because it's burning through tens of thousands of tokens. And so use at your own risk, and I would encourage you to use better models, but I will say, at least for me, I don't consider it a risk for computer use anymore. especially when I have something that I can control so much like this.

So I would encourage you to install the skill, try it out. You don't have to bring in any additional tooling. It's just right here in my AI skills, GitHub repo.

So you can install it as a cloud code plugin. If you want to bring in all my skills, or you can just take that skills folder that I have linked in the description and bring it into any coding agent. And so I hope that you find this useful and even just exploring with me in general, the new capabilities of LLMs, how they're able to do these incredible things without.

additional harness anymore and so if you appreciated this video you're looking forward to more things on coding agent skills and AI coding in general I would really appreciate a like and a subscribe and with that I will see you in the next video

The Hook

The bait, then the rug-pull.

The creator opens with a claim worth testing: a single lightweight skill, not a dedicated computer-use product, is now doing desktop automation work he used to assume required a full harness.

Frameworks

Named ideas worth stealing.

07:59list

Before You Drive Anything: Does This Need The Screen At All?

Is there a command?
Is the target a terminal?
Is there an API, a config file, or a log to read?

A pre-check the skill forces before granting screen control, since screen control is presented as the slowest, least reliable way to operate a computer.

Steal forany automation skill that needs to avoid reaching for GUI control when a faster deterministic path already exists

09:57model

The Control Loop

Discover the window (list)
Screenshot, then find a title unique enough to resolve
Focus, and stop on halt
Act: type, paste, keys, click, or scroll
Screenshot again and read
Wait for real completion
Hand back

The repeatable sequence the skill drives the agent through every time it touches the screen, meant to stop it from acting on screen state it never actually confirmed.

Steal forany agent skill that needs deterministic desktop or browser control

CTA Breakdown

How they asked for the click.

VERBAL ASK

05:34product

“The sponsor of today's video is Plural and they built something genuinely cool.”

A mid-roll sponsor read folded into the same screen-recording style as the rest of the video, showing a live Plural Workbenches job diagnosing a crash-looping service and opening a real pull request, rather than a separate scripted ad break.

MENTIONED ON CAMERA