agentleFS
donatassimkusdonatassimkus/claude-ai-skills/skills/automation/SKILL.md

automation

Skill1 starsChanged 4 months agoMITView on GitHub

Workflow architecture and design across automation tools. Use for cross-tool decisions, multi-system integrations, and automation strategy. For deep, single-platform builds, use that tool's own dedicated skill or documentation.

14 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use refactor.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • GitHubSkill

    refactor

    Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.

    Also in 3 projects that use this

The file

Show its rules and text

We split this skill into the rules it gives an agent

18 rules. 0 are common, 17 are distinctive, and 1 is very specific to this project.

  • 0

    Common

    Most of the 11 edited versions we read keep these.

  • 17

    Distinctive

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    If not specified, ask one question to clarify before proceeding.

    line 21
  2. Distinctive:

    Deterministic inputs over AI guessing: If the data needed is structured and predictable, do not use an AI node.

    line 27
  3. Distinctive:

    Warn about downstream breakage: Every workflow has failure modes.

    line 28
  4. Distinctive:

    Simpler is better: If a 3-step workflow solves the problem, do not build a 10-step workflow.

    line 29
  5. Distinctive:

    Error handling is not optional: Every workflow that touches external APIs needs error paths.

    line 31
  6. Distinctive:

    Before building anything, run this check.

    line 38
  7. Distinctive:

    Prefer Code nodes over complex node chains when logic is conditional.

    line 66
  8. Distinctive:

    Use Set node for data normalization before passing to external services.

    line 67
  9. Distinctive:

    Always test with real data, not mock data.

    line 70
  10. Distinctive:

    Use data stores for state that needs to persist between runs.

    line 76
  11. Distinctive:

    No native integration exists and you would otherwise write custom code

    line 96
  12. Distinctive:

    When analyzing data from any platform, flag repeatable judgment calls that could become automated rules

    line 111
  13. Distinctive:

    Look for patterns across data sources the user may not have connected yet (e.g.

    line 112
  14. Distinctive:

    If a manual review process follows the same decision tree every time, propose turning it into an automation

    line 113
  15. Distinctive:

    Test case: input example and expected output

    line 131
  16. Distinctive:

    When choosing between automation approaches:

    line 144
  17. Distinctive:

    Prefer the option that is easiest to debug when it breaks

    line 148
  18. Very specific:

    Default to n8n/Make.com for deterministic, scheduled data movement.

    line 149

“Common” is measured: kept by at least 6 in 10 of the 11 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Automation Skill

This skill handles cross-tool architecture and design decisions. For deep, single-platform work (node config, workflow recipes, funnel setup within one tool such as n8n or GoHighLevel), use that tool's own dedicated skill or documentation.

Automation work defaults to deterministic, simple architectures. AI is a last resort inside workflows, not a default. Every automation should be auditable, debuggable, and maintainable.

Project context is loaded from the active CLAUDE.md. Use the tech stack and tools defined in that context.


When invoked

$ARGUMENTS specifies the tool and the workflow goal or problem. If not specified, ask one question to clarify before proceeding.


Design principles

  1. Deterministic inputs over AI guessing. If the data needed is structured and predictable, do not use an AI node. Use a formula, lookup, or conditional.
  2. Warn about downstream breakage. Every workflow has failure modes. Call them out before they happen.
  3. Simpler is better. If a 3-step workflow solves the problem, do not build a 10-step workflow.
  4. One job per workflow. Monolithic automations break and are hard to debug. Keep scope narrow.
  5. Error handling is not optional. Every workflow that touches external APIs needs error paths.
  6. Test before shipping. Define the test case before building. What input produces what output?

Should you automate this?

Before building anything, run this check.

Automate when:

  • The task takes 15+ minutes AND happens weekly or more frequently
  • The process is error-prone when done manually (wrong data, missed steps, inconsistent execution)
  • It requires combining data from multiple sources before making a decision
  • A non-obvious automation could remove an entire category of work, not just speed up one instance

Skip automation when:

  • It's a one-off or happens less than monthly
  • Manual effort is under 10 minutes per occurrence
  • The setup cost exceeds 3 months of manual time saved
  • A CSV export/import or copy-paste gets the job done in one sitting

Think creatively when:

  • You're making the same judgment call repeatedly (the pattern itself can become a rule)
  • Data lives in one system but decisions happen in another (bridge them)
  • You're doing manual QA or checks against known thresholds (rule-based automation)
  • A human is acting as the "glue" between two systems (that glue is the automation)

Quick math: (minutes per occurrence × occurrences per month) vs. (hours to build + hours to maintain per month). If the ratio does not pay back in 3 months, skip it or simplify.


Tool-specific guidance

n8n

  • Prefer Code nodes over complex node chains when logic is conditional.
  • Use Set node for data normalization before passing to external services.
  • HTTP Request node for APIs without native integrations.
  • Webhook triggers for real-time flows; Cron for scheduled jobs.
  • Always test with real data, not mock data. Edge cases appear in production, not in samples.
  • For example, an SEO blog pipeline: keyword list input node → content QA checklist node → internal linking targets check → publish.

Make.com (Integromat)

  • Routers over separate scenarios when flows share a trigger.
  • Use data stores for state that needs to persist between runs.
  • Watch the operation count. Loops inside loops kill your quota.
  • Error handlers on every module that calls an external API.
  • Filters at the router level, not inside individual modules.

GoHighLevel

  • Pipeline stages should map 1:1 to a real buying stage, not internal team stages.
  • Automation triggers: be explicit about what fires them. Ambiguous triggers cause duplicate actions.
  • Workflow branching: test every branch. Default paths should handle the unexpected case.
  • CRM segmentation: tag-based systems break at scale. Use contact fields for permanent attributes, tags for temporary states.
  • Sub-accounts: keep automations at the sub-account level unless there is a clear reason to use agency-level triggers.

Claude (API + MCP)

Claude can act as an automation layer by calling APIs directly, using MCP connections, or receiving webhooks. Use this when the automation requires judgment, analysis, or context-aware decisions rather than simple data movement.

When to use over n8n/Make.com:

  • The "what to do" decision requires analyzing the data, not just routing it
  • One-off or low-frequency tasks where building a full workflow is overkill
  • No native integration exists and you would otherwise write custom code
  • Chaining multiple API calls with conditional logic based on returned data

How it works:

  • Direct API calls to any REST API (ad platforms, CRMs, analytics, etc.)
  • MCP connections to pull and push data from connected services
  • Webhook receivers to process inbound data and act on it
  • The pattern: pull data → analyze → decide → push changes back

Where it fits in the stack:

  • n8n/Make.com: scheduled, high-frequency, deterministic workflows (move data A to B on a timer)
  • GHL: CRM-triggered automations (contact enters stage → fire sequence)
  • Claude via API/MCP: analysis-heavy tasks, irregular cadences, decisions requiring context or judgment

Non-obvious opportunities:

  • When analyzing data from any platform, flag repeatable judgment calls that could become automated rules
  • Look for patterns across data sources the user may not have connected yet (e.g. ad spend data + CRM close rates = automated budget reallocation logic)
  • If a manual review process follows the same decision tree every time, propose turning it into an automation

Constraints:

  • Auth tokens and API keys must be managed securely. Do not store credentials in plain text.
  • Rate limits apply to every API. Build in handling for 429 responses.
  • For high-frequency scheduled jobs (every 5 min, every hour), n8n or Make.com is still the better choice. Claude is better for on-demand or weekly cadence tasks.

Output formats

Workflow design

  1. Goal: what problem does this solve?
  2. Trigger: what starts the workflow?
  3. Steps: numbered, one action per step
  4. Data: what goes in, what comes out at each step
  5. Error handling: what happens when a step fails?
  6. Test case: input example and expected output
  7. Edge cases to handle

Workflow review

  1. What it does (confirm understanding)
  2. Failure modes identified
  3. Simplification opportunities
  4. Missing error handling
  5. Recommended changes, prioritized

Architecture recommendation

When choosing between automation approaches:

  • State the options clearly, including Claude via API/MCP when analysis or judgment is required
  • Give a verdict with reasoning
  • Flag cost implications (API calls, operations, time, token usage for Claude-based automations)
  • Prefer the option that is easiest to debug when it breaks
  • Default to n8n/Make.com for deterministic, scheduled data movement. Default to Claude for tasks where the action depends on interpreting the data.

Common automation patterns

Content publishing pipeline Keyword input → content brief generation → draft creation → QA checklist → internal link injection → CMS publish → tracking setup

Lead intake and routing Form/ad submit → dedup check → lead scoring → pipeline stage assignment → owner assignment → follow-up sequence trigger → notification

Reporting pipeline Data pull from source → transformation → aggregation → push to spreadsheet or dashboard → notification (Slack, email, etc.)

Outreach sequence Lead list import → dedup → sequence enrollment → touchpoint 1 → wait → reply check → touchpoint 2 or remove → conversion tracking

API-driven performance optimization Pull platform report via API (ad spend, search terms, pipeline data) → analyze against targets → flag anomalies or waste → push changes back (negative keywords, bid adjustments, status updates) → log actions taken

Cross-platform data sync with analysis Pull data from source API → compare against second source (e.g. ad platform vs CRM) → identify discrepancies → reconcile or flag → push corrections

Ad creative production line (Claude Code as orchestrator) Performance data import (CSV or API/MCP pull from Meta, Google Ads) → analyze against targets (CTR, CPA, ROAS, frequency) → flag underperformers → sub-agent 1 generates headline variants (matched to the audience's awareness level) → sub-agent 2 generates description/body copy variants → output structured creative brief (CSV, JSON, or direct push to design tool API like Figma) → optional: MCP connection pulls live platform data to close the feedback loop → log all variants and performance deltas for next iteration

Why this works: Claude Code runs sub-agents in parallel, so headline and description generation happen simultaneously. One person can produce 10x the creative volume in a fraction of the time. The loop closes when live platform data feeds back into the next analysis cycle.

Requirements: ad platform API credentials (or CSV exports as a simpler start), MCP server for live data pull (optional), design tool API or template system for final asset production (optional). Start with CSV in, CSV out. Add MCP and design tool connections as the workflow proves value.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.