Skip to main content
skill CX Codex

pipefy-process-impact — Claude Code skill: how it works and setup

pipefy-process-impact pinpoints the single repetitive step in a Pipefy process that returns the most hours and calculates the arithmetic for automation ROI.

Apache-2.0 313 installs ★ 54 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pipefy/ai-toolkit --skill pipefy-process-impact -a claude-code
Open on GitHub

What pipefy-process-impact does

The skill evaluates a Pipefy process to find one manual hop where automation saves the most effort. It targets the single bottleneck with the highest weekly volume. No need to walk the entire workflow. The agent calculates returned hours directly from your numbers.

When given a pipe name, it checks active rules using get_pipe, get_automations, and get_ai_agents. It skips steps already covered by existing automations. Cycle times and phase durations come from a timed card GraphQL query. The cards_count field reflects only current cards, not duration.

Traditional rules take precedence over AI agents, reserving AI strictly for unstructured text and document parsing. Calling get_ai_agents requires the pipe uuid from get_pipe; numeric IDs trigger permission errors.

What it helps with

  • calculate hours returned by automating a Pipefy workflow
  • identify the highest-volume manual bottleneck in a pipe
  • verify existing automation coverage before adding new rules
  • generate a four-line ROI justification for team review

Example prompts for the agent

  • Is it worth automating the triage phase in the Hiring pipe?
  • Show the arithmetic on how much time an AI agent saves on invoice approvals.
  • Where should I start automating in my customer onboarding pipe?

How to install pipefy-process-impact

1Skills CLI (Vercel)

npx skills add pipefy/ai-toolkit --skill pipefy-process-impact -a claude-code

2Manually: put the files in place

~/.claude/skills/pipefy-process-impact/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/pipefy-process-impact/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about pipefy-process-impact

How to install pipefy-process-impact in Claude Code?

Run npx skills add pipefy/ai-toolkit --skill pipefy-process-impact -a claude-code. The skill will be placed in ~/.claude/skills/pipefy-process-impact/SKILL.md.

What does pipefy-process-impact do?

It finds the single most profitable step in a Pipefy workflow to automate. The skill produces a concise four-line response containing time-saved formulas based on case volume and duration.

Why does the skill query GraphQL instead of using cards_count?

The cards_count metric only reveals how many cards sit in a phase right now without dates. The skill executes a GraphQL query on card phase history to determine actual durations and lead times.

Source text

SKILL.md · Apache-2.0
---
name: pipefy-process-impact
description: >
  Use this skill when the user asks whether an automation or AI agent would
  pay off, where to start automating a process, how much time a change gives
  back, or for a short internal justification. Answers from the conversation
  first; when the user names a pipe, reads what already runs there before
  pointing at a step. Not for diagnosing a whole pipe
  (pipefy-process-intelligence), designing one (pipefy-process-design),
  building (pipefy-building), or what a change breaks elsewhere.
tags: [pipefy, process-impact, impact, automation]
---

# Process impact

Help the user find the one step in their process where an automation or an AI agent returns the most time, and show the arithmetic. One hop, one formula, one question per turn. The next hop comes after they have the first number.

Read the [MCP reference](references/mcp.md) or [CLI reference](references/cli.md) only when the user names a pipe, and only for the reads listed there.

## When to use

- "Is it worth automating X?" / "Where do I start?" / "What is the ROI?" / "How much time does this give back?"
- "Help me justify this internally."
- The user wants more than the `Impact:` line that `pipefy-process-design` or `pipefy-process-intelligence` already emitted.

Not for designing a process (`pipefy-process-design`), a full pipe diagnosis or implementation (`pipefy-process-intelligence`), building the step (`pipefy-building`, then the domain skill), or finding what a change breaks elsewhere.

## How to answer

1. **Pick the hop.** From the conversation, name the one manual, repetitive step with the best return: a move someone does by hand, a triage, a copy-paste, a chase. With several candidates, take the one with the most cases per week. Do not walk the whole process.
2. **Check coverage when a pipe is named.** Run the reads in the reference: `get_pipe`, `get_automations`, `get_ai_agents`, then `get_ai_agent` for each active agent. If an active automation or agent already does the hop, say so, size that coverage, and move to the next uncovered hop, restating what the agent or rule already does there. Do not propose a second one. With no pipe in view, say coverage was not checked instead of claiming nothing covers the hop. `cards_count` is what sits in a phase now, not volume or duration, and `get_cards` selects no dates; when the answer needs time, use the timed card read under Measuring.
3. **Show the arithmetic**, with the user's numbers or the gaps named:

```text
hours returned per week ≈ minutes per case × cases per week / 60
cost avoided per week ≈ hours returned per week × hourly cost   (only if the user gave an hourly cost)
```

   Never fill a gap yourself. Lead time and time per phase come from the timed card read, weekly volume from the user or a pipe report export (see Measuring), never from `cards_count` or an undated sample.
4. **Name the cheapest step that removes the hop.** A traditional automation when the decision reads from fields ("if value > X, move"). An AI agent or AI automation only when the hop needs reading free text, documents, or a conversation. iPaaS when the work lives in another app. One sentence on which and why. Do not stack rule and AI as "do both now"; mention the AI step as optional when a rule leaves part of the hop manual.
5. **End with one thing**: the missing numbers in one short question, or the next step (the next hop, a measured export, or building it with the domain skill).

## Output

In the user's language, four lines, under 150 words unless they asked for a written case:

```text
Where it pays: [hop], [what covers it today, if anything]
Arithmetic: [formula with numbers or named gaps] = [hours per week, or the gap]
Step: [automation | AI agent | iPaaS], [one sentence on why this one]
Next: [one question, or one offer]
```

For a written case, expand each line into a short paragraph and add an "Assumptions" line. Money only with an hourly cost. Lead time only from the timed card read, an export, or a cycle the user stated.

## Rules

- Report time returned to the team on repetitive hops. Asked how many people the change removes, answer in hours and say that decision is theirs.
- Do not recommend deleting a pipe, cutting seats or credits, or moving work off Pipefy. A quiet pipe is a process with no trigger or a duplicate: ask which, then cover its hops. Delete only when the user asks for that pipe by name, and then move the work into the pipe that remains.
- Rule before AI. Existing coverage is value already delivered: size it, do not replace it. Credits an active agent spends are the cost of work it already does, not a line to cut.
- `get_ai_agents` takes the pipe `uuid` from `get_pipe`, not the numeric id; a numeric id returns a permission error. With the uuid and still a permission error, say agent coverage is unknown and do not call the hop manual on that basis.

## Measuring

Lead time, age, and time per phase come from a timed card read: one `execute_graphql` query on the pipe's cards that selects `createdAt`, `finished_at`, `started_current_phase_at`, `current_phase_age`, and `phases_history` (`firstTimeIn`, `lastTimeOut`, `duration` in seconds per phase). The document is in the reference. It is a read, runs with no confirmation, and returns 25 cards per page (up to 50); say how many cards the numbers come from, and page with `after` when the pipe has more. Lead time is `finished_at` minus `createdAt` on done cards; time in a phase is the `duration` of its `phases_history` entry.

Weekly volume for a whole pipe comes from the user or from a pipe report export (`created_at` per card), which is the better path when the pipe has more cards than a few pages. The export works on an existing report (`get_pipe_reports`); when the pipe has none, `create_pipe_report` is a write, so ask first. Pass the date columns by `name` from `get_pipe_report_columns`; `pipefy-reports` has the export and polling steps. The export ends in an XLSX link, so use it for volume, not for a number the user wants in the chat.

## Tools

| Operation | Read-only | Purpose |
|-----------|-----------|---------|
| `search_pipes` | Yes | Pipe id when only the name is known |
| `get_pipe` | Yes | Phases, `cards_count`, and the pipe `uuid` |
| `get_automations` | Yes | Hops an active rule already covers (`active` and `actionEnabled`) |
| `get_ai_agents` | Yes | Agents on the pipe; active when `disabledAt` is null |
| `get_ai_agent` | Yes | Behaviors with `active: true` and the phase each acts on |
| `execute_graphql` | Yes, for a query | Timed card read: the dates and time per phase that `get_cards` leaves out |
| `get_pipe_reports` | Yes | Existing reports to export for whole-pipe volume |
| `get_pipe_report_columns` | Yes | Column `name` values for the export |
| `export_pipe_report` | No | Start the export; changes no card |
| `get_pipe_report_export` | Yes | Poll until the file is ready |
| `create_pipe_report` | No | Only when the pipe has no report and the user agreed |

## See also

- `pipefy-process-design`: new process architecture (emits an Impact line).
- `pipefy-process-intelligence`: diagnose and improve a pipe (emits an Impact line).
- `pipefy-building`: route the chosen step to a domain skill.
- `pipefy-automations`, `pipefy-ai-agents`, `pipefy-ipaas`: build the step.
- `pipefy-reports`: pipe report exports for lead time and weekly volume.

© pipefy · Apache-2.0 · pipefy/ai-toolkit

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

From the same set19

The whole set →
pipefy-members-email-webhooks pipefy-members-email-webhooks is a Claude Code skill for managing Pipefy pipe members, card inbox email, and webhooks. It handles user invitations, email sending, and endpoint registration. CX Codex +1 782installs pipefy-attachments pipefy-attachments uploads a file into a Pipefy card or table-record attachment field from disk or a URL, with a presigned-URL route for files over 100 MiB. CX Codex +1 782installs pipefy-ai-agents pipefy-ai-agents — a skill that walks you through creating, updating and debugging conversational AI agents in Pipefy, behaviors included. CX Codex +1 781installs pipefy-database-tables A skill for managing Pipefy Database Tables, letting agents inspect schemas, query records, update column values, and preview destructive changes. CX Codex +1 780installs pipefy-toolkit-setup pipefy-toolkit-setup guides you through the initial Pipefy AI toolkit setup across Claude Code or Cursor. It helps pick the right integration path and finishes authentication. CX Codex +1 717installs pipefy-ipaas A Claude Code skill for building and testing Pipefy iPaaS flows. It assembles multi-step integrations with Slack, Gmail, Google Sheets, webhooks and schedules. CX Codex +1 707installs pipefy-building pipefy-building is a Claude Code skill that routes a Pipefy request to the relevant domain skill for pipes, automations, AI agents, iPaaS or portals. CX Codex +1 510installs pipefy-html-interfaces A Claude Code skill for creating, reading, and rewriting Pipefy HTML interfaces. It runs on requests for a standalone page, optionally connected to pipe or table data. CX Codex +1 106installs

Project sponsors

Companies that keep this analytics open