home / skills / partme-ai / full-stack-skills / skill-sop-creator

skill-sop-creator skill

safe

This skill helps you design and validate multi-step SOPs by chaining atomic skills into reliable, repeatable workflows for complex business goals.

npx playbooks add skill partme-ai/full-stack-skills --skill skill-sop-creator

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.0 KB

---
name: skill-sop-creator
description: Guide for creating Standard Operating Procedures and SOPs and composite workflows by combining atomic Agent Skills. Use when users want to design, structure, or implement multi-step workflows that orchestrate multiple skills for complex business goals. Transforms loose tool collections into reliable, repeatable business processes.
---

# skill-sop-creator

Guide for creating Standard Operating Procedures (SOPs) and composite workflows by combining atomic Agent Skills. Use this skill when users want to design, structure, or implement multi-step workflows (SOPs) that orchestrate multiple skills to achieve complex business goals. This skill transforms loose collections of tools into reliable, repeatable business processes.

## Parameters

| Name     | Type   | Required | Description |
|----------|--------|----------|-------------|
| action   | string | true     | The action to perform. One of `search_skills`, `draft_sop`, `validate_sop`. |
| context  | string | false    | Context for the action (e.g. business goal for drafting, search query for searching). |

## Actions

### 1. Search Atomic Skills
Finds available atomic skills to include in your SOP.
- **Command**: `skill-sop-creator(action="search_skills", context="pdf processing")`
- **Output**: List of relevant atomic skills (e.g., `pdf-split`, `pdf-merge`, `ocr-extract`) that can be steps in your SOP.

### 2. Draft SOP Structure
Generates a draft `SKILL.md` for a composite skill (SOP) based on a business goal.
- **Command**: `skill-sop-creator(action="draft_sop", context="Daily Competitor Analysis Report")`
- **Output**: A structured markdown template defining the workflow steps, required atomic skills, and decision logic.

### 3. Validate SOP
Checks if a proposed SOP structure is valid and if referenced skills exist.
- **Command**: `skill-sop-creator(action="validate_sop", context="<sop_content>")`
- **Behavior**: Verifies that steps are logical and dependencies are met.

## SOP Design Principles

1. **Atomic Foundation**: SOPs should rely on small, single-purpose skills (e.g., `pencil-draw-rect` not `draw-entire-ui`).
2. **Deterministic Flow**: Define clear steps: Step 1 -> Step 2 -> Decision -> Step 3.
3. **Human-in-the-loop**: Include checkpoints where the Agent should ask for user confirmation.

## Example SOP Structure

```markdown
# Daily Competitor Analysis SOP

## 1. Information Gathering
- **Skill**: `web-search`
- **Action**: Search for "competitor name" + "news"
- **Output**: List of URLs

## 2. Content Extraction
- **Skill**: `web-scraper`
- **Input**: URLs from Step 1
- **Output**: Raw text

## 3. Analysis
- **Skill**: `llm-summarize`
- **Input**: Raw text
- **Prompt**: "Identify key pricing changes and feature launches."

## 4. Reporting
- **Skill**: `pdf-generator`
- **Input**: Summary
- **Output**: PDF Report
```

## Notes

- An SOP is essentially a "Composite Skill" that acts as a conductor for other "Atomic Skills".
- This skill helps you *design* that conductor.

Overview

This skill guides creation of Standard Operating Procedures (SOPs) and composite workflows by combining atomic Agent Skills. It helps transform loose tool collections into repeatable, testable business processes for multi-step automation. Use it to search for available skills, draft structured SOPs, and validate workflow logic and dependencies.

How this skill works

You tell the skill an action: search for relevant atomic skills, draft a SOP from a business goal, or validate an existing SOP. For searches it returns candidate atomic skills that match your context. For drafting it generates a step-by-step SOP template specifying steps, inputs, outputs, and decision points. For validation it checks step order, required skills, and dependency consistency.

When to use it

Designing a multi-step automation that must orchestrate several atomic agent skills
Converting ad hoc scripts or tools into a reliable, documented business process
Finding appropriate atomic skills to solve a specific subtask (e.g., OCR, web-scrape)
Drafting a clear SOP template for handoff to engineers or operators
Validating that an SOP references existing skills and has deterministic flow

Best practices

Build SOPs from single-purpose atomic skills to keep each step testable and replaceable
Define explicit inputs, outputs, and acceptance criteria for every step
Add human-in-the-loop checkpoints where ambiguity or critical decisions exist
Model decision branches clearly (conditions and next-step targets) to ensure determinism
Keep steps small and sequential; prefer a sequence of focused actions over large monolithic steps

Example use cases

Daily competitor analysis: search, scrape, summarize, and export a PDF report
Invoice processing: PDF ingestion, OCR extraction, field mapping, and accounting entry
Marketing campaign workflow: collect leads, enrich data, score, and push to CRM
Document pipeline: split PDFs, run OCR, classify pages, and store to archive
Customer onboarding: validate identity docs, extract fields, and trigger approval

FAQ

What inputs does the skill expect?

Provide an action (search_skills, draft_sop, validate_sop) and optional context describing the business goal, search query, or SOP content to validate.

How detailed is the drafted SOP?

Drafts include step names, suggested atomic skills, inputs/outputs, and decision points. You should refine prompts and acceptance criteria for production use.

Can it verify that referenced skills exist?

Yes — the validate action checks that referenced atomic skills appear available and that step dependencies are consistent.