Skill = Agent + Workflow
On December 19, 2024, Anthropic published an article: “Building effective agents.”
This article categorizes agentic systems into two types: Workflow and Agent. It also clearly defines the use cases for each:
- Workflow: Provides predictability and consistency for well-defined tasks.
- Agent: Handles open-ended problems where the number of steps cannot be predicted in advance and no fixed path can be predefined.
This came at a time when tools like n8n and dify were exploding in popularity. The five Workflow patterns described in the article resonated perfectly with the use cases of these tools at the time.
Based on the article’s content, it clearly separates these two technical approaches while affirming the simplicity and power of the Agent construction pattern.
Two months later, Anthropic released Claude Code.
For a while afterward, Agents were all the rage, but the Workflow development philosophy didn’t die. Instead, it merged with Agent to form Anthropic’s next concept: Skill.
Regarding the core ideas of Skill (see my December 28 post for details), I won’t elaborate here. Today, I’ll walk you through the Workflow use cases discussed in Anthropic’s article. After reading, you’ll discover that these are precisely the underlying logic indispensable for writing Skills.
1. Prompt Chaining
Idea: Break a task into consecutive steps, where each step’s output becomes the next step’s input.
Suitable for: Any task that can be clearly decomposed into fixed subtasks.
Use cases: Generate marketing copy, then translate it into other languages; write a document outline, check if it meets requirements, then write the body based on the outline.
2. Routing
Idea: Classify inputs and distribute them to different specialized tasks.
Suitable for: Clear categorical categories where different categories require different handling.
Use cases: Customer service systems route general questions, refund requests, and technical support to different flows.
3. Parallelization
Idea: Split a task into independent subtasks running simultaneously, or run the same task multiple times, then aggregate results.
Suitable for: Subtasks that can be parallelized for speed, or multiple perspectives needed to improve accuracy.
Use cases: During code review, multiple prompts check for vulnerabilities from different angles; one model handles user queries while another simultaneously screens for inappropriate content.
4. Orchestrator-Workers
Idea: A central LLM dynamically decomposes tasks, assigns them to Worker LLMs, then aggregates results.
Suitable for: Complex tasks where you cannot predict which subtasks will be needed.
Use cases: Code modifications affecting multiple files, where the number of files to change and their content are both uncertain.
5. Evaluator-Optimizer
Idea: One LLM generates results, another evaluates and provides feedback, with iterative optimization.
Suitable for: Clear evaluation criteria where iteration brings noticeable improvement.
Use cases: Refining literary translations; complex search tasks requiring multiple rounds of searching and analysis.
Ten months after this article was published, Skill was officially released in Claude Code.
This shows that the Workflow development philosophy wasn’t replaced by Agent—it was merely internalized.
Workflow provides constraints; Agent provides reasoning. Their union becomes Skill, something anyone can build.
Tools change, but the logic for decomposing complex problems never becomes obsolete.
