AI Skill Report Card
Designing Atomic Task Workflows
YAML--- name: designing-atomic-task-workflows description: Decomposes complex processing goals into atomic, sequentially-dependent text transformation tasks and assembles them into linear, code-free workflows/pipelines. Use when a user needs to break down a messy domain (research archives, crafting patterns, admin logs, planner design, etc.) into reusable step-by-step prompt templates, or when organizing many small extraction/transformation tasks into coherent end-to-end pipelines. ---
Quick Start14 / 15
Given a domain and a goal, produce a 3-step atomic pipeline:
Workflow: [Domain] [Goal] Pipeline
* Step 1: [Extract/Isolate/Deconstruct] — raw input → structured intermediate
* Step 2: [Filter/Verify/Convert] — intermediate → refined intermediate
* Step 3: [Generate/Compress/Audit] — refined intermediate → final deliverable
Example:
Workflow: Nursing Shift Timeline Extraction
* Step 1: Parse shift sign-in metrics from nursing work logs.
* Step 2: Filter operational metrics from chaotic shift records.
* Step 3: Isolate care ratios from schedule text snippets.
Recommendation▾
Add a 'bad example' showing a poorly-scoped workflow (e.g., merged transformations or non-sequential steps) to reinforce the pitfalls section with concrete contrast.
Workflow14 / 15
Progress:
- Step 1: Identify the domain(s) and end-user goal (what final artifact is needed?)
- Step 2: Enumerate atomic tasks — each task must take one clear input format and produce one clear output format, doing exactly one transformation (extract, filter, convert, verify, audit, generate, compress, strip, isolate, cross-check)
- Step 3: Order atomic tasks into a linear chain where each step's output is the next step's input
- Step 4: Group chains into named workflows (3 steps is the sweet spot — more becomes hard to follow, fewer isn't a "pipeline")
- Step 5: Cluster related workflows into "Phases" by shared domain or shared raw-material type
- Step 6: Validate each workflow is code-free (pure text/prompt transformations, no scripting required) and privacy-aware (no external calls, local-first assumptions)
- Step 7: For the selected workflow, write a concrete prompt template with placeholder input and expected output shape
Recommendation▾
The taxonomy table examples are somewhat domain-scattered (crochet, ASCII, CSS) — consider tying them to a consistent running example for clarity.
Atomic Task Taxonomy
Use these verb categories to classify or generate atomic tasks:
| Verb | Purpose | Example |
|---|---|---|
| Deconstruct/Parse | Break raw source into structured pieces | "Deconstruct a Craft Pattern PDF into raw state coordinates" |
| Isolate/Extract | Pull a specific subset out of noise | "Isolate pure numeric arrays from amigurumi row patterns" |
| Filter/Strip | Remove unwanted noise/wrappers | "Filter out non-printable ASCII characters" |
| Convert/Translate | Change representation/format | "Convert an unformatted list of vector points into a clean markdown path" |
| Verify/Audit | Check consistency or correctness | "Verify math totals for spherical crochet row growth" |
| Cross-check | Compare against a second source for gaps | "Cross-check public data index files for missing gaps" |
| Generate/Format | Produce final structured output | "Generate clean CSS code for a ruled-paper journal layout" |
| Compress/Derive | Reduce complexity to a single actionable unit | "Compress multi-node goals into a single next-step fork" |
Every atomic task description should follow the pattern: [Verb] [specific object] from/into [specific source/target format].
Building a Concrete Prompt Template
Once a workflow is selected, expand each step into an executable prompt:
### [Workflow Name]
**Step 1 — [Task Name]**
Input: [describe raw input format, give a short sample]
Instruction: [imperative one-sentence transformation instruction]
Output: [describe expected structured output, give a short sample]
**Step 2 — [Task Name]**
Input: [output of Step 1]
Instruction: ...
Output: ...
**Step 3 — [Task Name]**
Input: [output of Step 2]
Instruction: ...
Output: [final deliverable]
Examples16 / 20
Example 1: Input: Domain = "Craft patterns", Goal = "Digitize a legacy PDF pattern" Output:
Workflow: Legacy Pattern Digitalization Pipeline
Step 1: Deconstruct a Craft Pattern PDF into raw state coordinates.
Input: PDF text dump of a crochet pattern
Output: raw row/stitch coordinate list
Step 2: Filter out non-printable ASCII characters from raw text blocks.
Input: raw coordinate list (with OCR artifacts)
Output: clean plain-text coordinate list
Step 3: Isolate pure numeric arrays from amigurumi row patterns.
Input: clean coordinate list
Output: array of [row, stitch_count] pairs
Example 2: Input: Domain = "Local commerce audits", Goal = "Extract mystery shopping assignment data" Output:
Workflow: Field Audit Assignment Extraction
Step 1: Extract performance metrics from mystery shopping briefs.
Step 2: Extract business address data from assignment proofs.
Step 3: Identify time-critical assignments from local platform notifications.
Recommendation▾
Clarify what happens when a goal requires more than one Phase or when workflows must branch rather than stay linear, since the skill insists on strict linearity.
Best Practices
- Keep each atomic task to one input format → one output format → one transformation verb.
- Prefer 3-step chains; split anything requiring 4+ steps into two linked workflows.
- Reuse atomic tasks across workflows when they share input/output shape (e.g., "Verify sequence alignment" appears in many phases) — this signals a well-factored taxonomy.
- Group workflows into Phases by domain (e.g., "Legacy Craft", "Deep Archive Research", "Clinical Logs") to keep a large toolkit navigable.
- Always confirm the pipeline is code-free — every step must be executable by prompting an LLM on text, not by running a script.
- Favor local-first / privacy-aware framing: no step should assume cloud sync, external APIs, or persistent server storage.
- When presenting options to the user, end with a short numbered menu of 3-5 candidate workflows to concretize next, rather than all 30 at once.
Common Pitfalls
- Don't merge two transformations into one step (e.g., "extract and verify" should be two atomic tasks).
- Don't leave a step's input/output format implicit — always state the shape explicitly.
- Don't create workflows where step order doesn't matter — atomic tasks must be sequentially dependent (output N feeds directly into input N+1).
- Don't reuse the same atomic task twice within one workflow as if it were a different step — reuse across workflows is fine, duplication within one is a sign of a mis-scoped pipeline.
- Don't let phases balloon past 4-6 workflows each — split into a new phase instead.