Turning Repetitive Work Into Reusable AI Workflows (No Prompt Engineering Required)
Claude's screen-recording Skills and the shift from prompt-first to capture-first automation
tldr: You can now build an agentic AI workflow (a repeatable, multi-step task an agent runs end-to-end with minimal human input) by demonstrating it once instead of writing prompts or code. Claude's new screen-recording Skills capture the task while you narrate why you do each step. That shift, from prompt-first to capture-first, puts workflow-building within reach of people who write for a living, not just people who code.
What is an agentic AI workflow?
An agentic AI workflow is a task an AI agent executes across multiple steps and tools, deciding how to proceed at each step rather than following a fixed script. It sits between two things people confuse it with.
It's more than a single prompt: a prompt is one request and one response, while a workflow chains several actions (read this, transform it, check it against that, write the result somewhere) and adapts based on what it finds. It's also different from classic RPA (robotic process automation), which follows brittle, hard-coded scripts that break the moment a button moves. An agentic workflow reasons about intent, so it can handle the case the script author never anticipated. The line that matters: RPA repeats actions; an agentic workflow pursues an outcome.
Capture-first vs prompt-first: the shift
Building an agentic workflow has meant translating your process into language a model could follow: writing prompts, tool definitions, sometimes code. Call that prompt-first: you describe the work in the abstract and hope your description survives contact with reality.
The new model is capture-first: you do the work once while the agent watches, and it infers the workflow from the demonstration. Anthropic's "Record a skill" feature, launched July 21, 2026 in Claude Cowork, is the clearest instance: you perform a task on screen, narrate the decisions and exceptions as you go, and Claude turns the recording into a reusable Skill.
The difference isn't only convenience. Prompt-first forces you to make your tacit knowledge explicit up front, every exception and every "except when," before you've written a line. That's the hard part of automation, and it's the thing experienced people are worst at articulating and best at demonstrating. Capture-first inverts it: you show the judgment in context and let the agent extract the rule. The reasoning you'd struggle to write down, you narrate naturally while doing.
How do screen-recording Skills work?
The mechanics, per Anthropic's description:
- In a Cowork task, open the + menu and choose Record a skill.
- Perform the workflow on your screen: the real task, in the real tools.
- Narrate as you go. This is the load-bearing step. Say why you're clicking what you're clicking, what the rules are, and when the exceptions apply. The narration is how Claude learns reasoning, not just the click sequence.
- Claude converts the demonstration into a Skill you can invoke again on new inputs.
The narration is what separates this from a macro recorder. A macro captures "click at x=340, y=190." A narrated demonstration captures "open the PR, and if it only touches tests, skip the changelog step": the why that lets the skill generalize to inputs you didn't demonstrate.
Three workflows for developers who write
Foreword's readers ship code and write about it: docs, changelogs, posts. Those content-ops tasks are the ones nobody automates, because they were too judgment-heavy for RPA and too tedious to specify as prompts. Capture-first is aimed squarely at them.
1. Changelog generation from merged PRs. Demonstrate turning a week of merged PRs into your changelog format: grouping by type, dropping internal-only changes, rewriting terse commit messages into user-facing lines. The call your narration has to carry is what counts as internal-only; that rule lives in your head, not in the diff.
2. Docs formatting and publishing. Record the path from raw draft to published: applying heading conventions, checking that code blocks render, adding frontmatter, pushing through the pipeline. The formatting rules you apply without thinking are the ones to say out loud.
3. PR triage. Capture a triage pass over incoming PRs: labeling, routing to reviewers, flagging any that touch sensitive paths. Narrate the sensitive-path exception carefully; that exception is why this counts as judgment work.
When should you use capture-first vs writing code?
Capture-first is not a universal replacement, and pretending otherwise sets you up to fail. Where it fits and where it breaks:
| Capture-first Skill | Writing code / prompts | |
| Best for | UI-driven, judgment-heavy, hard-to-specify tasks | Deterministic, high-volume, API-driven tasks |
| Setup cost | Demonstrate once | Design, write, test |
| Handles exceptions | Yes, if you narrate them | Only ones you coded |
| Auditability | Watch the recording | Read the code |
| Breaks down when | High-throughput, needs guaranteed determinism, or no UI to demonstrate | The rules are tacit and you can't articulate them |
The limit mirrors the strength: capture-first shines where explicit specification is painful, and struggles where you need guarantees. A task that must produce identical output a million times, or that runs against APIs with no screen to record, is still a coding job. Don't demonstrate what you should be scripting.
Build your first agentic workflow: step by step
Whichever tool you use, the same sequence gets you a working, trustworthy workflow:
- Pick a task you do the same way every week. Repetition is what makes the payoff real; a once-a-quarter task isn't worth capturing.
- Do it once slowly, narrating every decision, including the exceptions and the "I'd never do X here." The exceptions are what the agent can't guess.
- Run it on a fresh input and watch closely. The first real run is where you find the judgment calls you didn't narrate.
- Correct where it went wrong by demonstrating the right behavior again.
- Keep a human gate on anything irreversible: publishing, sending, deleting. The same rule holds as for any agent: never let a workflow take an unrecoverable action unreviewed. (More on that in our agent security guide.)
What tools exist for building agentic workflows?
The options, one line each:
- Claude Skills (capture-first): demonstrate a workflow, get a reusable Skill; strongest for UI-driven content-ops work where the rules live in someone's head.
- n8n and visual workflow builders: drag-and-drop nodes; great for deterministic, API-to-API integrations with branching logic.
- Agent frameworks (LangGraph, CrewAI, and similar): code-first orchestration for developers building custom multi-agent systems with full control.
- Background coding agents: an AI software factory like FactoryKit takes a whole dev task, implements it in an isolated sandbox, and opens reviewed pull requests; here the workflow is the dev loop.
- Agentic browser testing: Bug0 applies the same capture-intent-not-steps idea to QA; tests are described in plain English and self-heal when the UI changes.
- RPA platforms: mature, deterministic UI automation for high-volume enterprise processes; brittle to change, no reasoning.
They're not mutually exclusive. A realistic setup captures the judgment-heavy front end as a Skill and hands deterministic downstream steps to n8n or code.
What this means for developer content teams
A forward take, since this is Foreword's own lane: the teams that gain most from capture-first aren't ops or sales, where the automation attention usually goes. They're the small dev-content and DevRel teams where one person holds the unwritten knowledge of how docs get shipped, how the changelog gets written, how a post gets formatted, and never has time to write it down.
That knowledge has always been trapped because the act of documenting it costs more than doing the task. Capture-first drops that cost to the price of narrating a task you were going to do anyway. The second-order effect: a demonstrated-and-narrated workflow is also documentation. Record how your changelog gets made and you've simultaneously automated it and onboarded the next person who joins. For teams whose whole job is turning tacit knowledge into published words, that's the tool aimed most precisely at them, and the one they're least likely to have noticed.
FAQ
What is an agentic workflow?
A repeatable, multi-step task an AI agent runs end-to-end, deciding how to proceed at each step based on what it encounters, rather than following a fixed script. It differs from a single prompt (one request, one response) and from RPA (hard-coded, non-reasoning automation).
How do you create an AI agent without code?
Tools like Claude's screen-recording Skills let you build one by demonstration: perform the task once while narrating your decisions, and the agent infers a reusable workflow. Visual builders like n8n offer a drag-and-drop alternative. Neither requires writing code.
What's the difference between an AI agent and an AI workflow?
An AI agent is the actor: a model with tools that can decide and act. An AI workflow is the repeatable task that actor performs. One agent can run many workflows; a workflow is the "what," the agent is the "who."
Can AI automate documentation?
Increasingly, yes, especially the formatting, changelog, and publishing steps, which are repetitive but judgment-laden. Capture-first tools handle these well because you can demonstrate the judgment instead of specifying it. Keep a human review gate before anything publishes.
