skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
pipefy/ai-toolkit802 installs

pipefy-process-design

Designs a Pipefy process with the user before anyone builds it. Finds the start, the end states, the steps and owners, the decision rules with exact boundary values, the exceptions and the data. Compares a native rule, an AI automation, an AI agent, an integration and human work for each step. Returns a process specification that a builder can use. Use it when the user wants to think a process through ("help me design", "how should this flow work", "I do not know who approves"). Use it also when a request to build a whole process still has an open business decision. Use it when the user wants advice and no change, or brings a specification to check. Not for one part such as a field, a phase or one automation (pipefy-building). Not for building a process that is already specified (pipefy-building). Not for diagnosing an existing pipe (pipefy-process-intelligence) or sizing the return of a change (pipefy-process-impact).

How do I install this agent skill?

npx skills add https://github.com/pipefy/ai-toolkit --skill pipefy-process-design
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    This skill is a process design consultant for Pipefy that helps users architect workflows and generate specifications. It uses read-only tools to inspect existing configurations for reuse but does not perform write operations, execute remote code, or utilize obfuscation.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

Design a Pipefy process

This skill helps the user design a process before anyone builds it. The result is a process specification: the business decisions that a builder needs to build the process.

When an organization is connected, read the MCP reference or the CLI reference for the reads in step 1. Load only the reference for your surface.


When to use

  • The user wants to think a process through. Examples: "help me design a purchasing process", "what is the best structure for incident handling", "I do not know who approves".
  • The user asks to build a whole process, and a business decision that changes the build is still open. Examples: who approves, which value routes a case, what happens on a rejection. A verb such as "create" or "build" does not close the decision.
  • The user wants advice and no change.
  • The user brings a specification and wants a check.

When not to use

Read pipefy-building for these requests. It sends each one to the skill that owns it.

  • One part, such as a field, a phase, one automation, or one agent.
  • A whole process that is already specified: every blocking field of the process specification has a value.
  • A deletion, or a change to a part that already exists.

To diagnose an existing pipe, read pipefy-process-intelligence. To size the return of a change, read pipefy-process-impact.

What this skill writes

  • This skill does not write to Pipefy. It ends with a specification.
  • A request for advice only gets advice. Write nothing and build nothing.
  • A design works without a connected organization. Design from the conversation, and say that you did not check the existing pipes for reuse.
  • When the user asks to build what you designed, read pipefy-building. It sends the build to the domain skills, or to a skill in your catalog that builds a whole process from a specification. Give that skill the specification.

Ask in proportion to what is missing

  • When the user brings a specification, do not interview. Compare it with the specification fields. Equal content in another format counts. Do not ask the user to rewrite it.
  • A default from the specification table counts as a value. Record each default that you use, and each value that you added, as an assumption. A rule that reads an assumption starts inactive until the user confirms it.
  • When every blocking field has a value, return the specification in the contract format.
  • When a blocking field has no value and no default, ask only for that field. Ask all of them in one message, with a proposed answer for each.
  • Do not ask again about a decision that the user or the specification already settled.
  • Keep the user's names for phases, fields, and roles.
  • When the user does not know the process, propose a structure and two alternatives. Ask 5 questions or fewer in a turn. Each question has a proposed answer.
  • Use documents that the user gives and the pipes you can read before you ask.

Steps

  1. Read what exists. With a connected organization, list the pipes before you propose a new one. When a pipe already does part of the work, read what runs there and propose to reuse it. Without a connected organization, skip this step.

    OperationRead-onlyPurpose
    search_pipesYesList pipes within the caller's memberships and the per-organization cap. Inspect search_limits before declaring reuse discovery complete.
    get_organizationYesRead the organization that holds the pipes.
    get_pipeYesRead the phases and fields of a pipe that you can reuse.
    get_automationsYesRead the rules that already run in that pipe.
    get_ai_agentsYesRead the AI agents that already run in that pipe (pipe uuid).
  2. Find the blocking fields. Compare the request with the process specification. Sort each field into three groups: the user gave it, you can propose it, or it stays open.

  3. Propose a structure and alternatives. When the structure is open, give one proposal and two concrete alternatives. For each one, give the cost, the risk, and the effect. The cost is the parts to build and maintain, and AI credits when known. The risk is what goes wrong, and who sees it. The effect is the work that it removes from the team or adds. Recommend one, and give the reason.

  4. Choose the Pipefy part for each step. Use the selection table.

  5. Review the specification. Use the review questions. Ask only the ones that change the build.

  6. Return the specification and the summary. Use the output format.

Read references/process-specification.md when the user asks for a written specification, or when more than three decisions stay open. It has two complete specifications in the contract format.

Read references/feature-selection.md when two Pipefy parts fit the same step, or when the user asks why you chose one part and not another.

Design principles

  • Start with the outcome. What does "done" look like for a case?
  • Name phases for states, not actions. "Under review", not "Review it".
  • Keep the start form short. Ask only for the data that the requester has on day 1.
  • Make a field required only when a decision reads it. Each required field can stop a card.
  • Plan for the exception. A rejection, a pause for a fix, and a time limit each need a path.
  • One phase is one state of the case. A participant is an owner of a phase, not a separate pipe, unless that work has its own cases.

Process specification

The specification holds business decisions, not Pipefy ids. The builder finds ids and product limits when it builds. The builder does not choose a business value and does not add assumptions. When the build needs a business value that the specification does not hold, the builder records it as a pending item and asks the user. It continues the work that does not depend on that value.

FieldWhat it holdsWho writes itBlocks the buildDefault when absent
ObjectiveThe result that "done" gives, and what is out of scope.User. The design skill writes it down.YesNone. Propose one sentence from the request and ask the user to confirm it.
Start triggerWhat creates a case: a start form, an email, another pipe, a portal page.UserYesA requester fills the start form.
End statesEach result that closes a case, with what the case must hold at that point.UserYesOne end phase for success. Add one end phase for refusal when a step can refuse.
Steps and ownersThe ordered states of a case. Each state has one owner (a role), the person who decides, and the person who handles its exceptions.Design skill proposes. User confirms.YesThe phases the user named. The owner is the role the user named, else the pipe members.
DecisionsFor each branch: the field it reads, the operator, and the value. Also the destination, the result at the exact boundary value, and the result for an empty field. When the field cannot be empty, give the reason.UserYes, but only for the branchNo automatic rule. A person in that phase decides.
Parallel workThe steps that run at the same time, and the join rule: all results, any result, or a stated combination. Also what happens to open work when one result ends the case.UserNoNo parallel work. Steps run in sequence.
ExceptionsRejection: ends the case, or pauses it until someone fixes it. Time: a reminder only notifies, a deadline moves, escalates or reassigns. Correction: return point, owner, and the condition to continue.UserNoA refusal ends the case in the refusal end phase from End states. A time limit is a reminder. A correction returns to the step that owns the missing data. No retry limit.
DataFor each field: name, type, source, author (role), the step where it is filled, and when it is required.Design skill proposes. User confirms.Yes, for a field that a decision readsOnly the fields that decisions and end states read. A field is required only when a decision reads it.
Platform choicesFor each step: the Pipefy part that does it, one alternative, the reason in one line, and the existing part to reuse. For each rule: the start state (on, off, or not created) and the reason when it is not on.Design skillNoThe least complex native option in the selection table. No AI without an explicit yes.
ConstraintsLimits the user states: no AI, no email outside the company, who may approve, data that must not leave Pipefy.UserNoNone stated.
AuthorizationOne level: advise only, build, build inactive, or publish. List each permitted external effect separately.UserNoAdvise only until the user requests a build. A build request defaults to build. No external effects.
AssumptionsValues that the design skill chose and the user did not confirm, including each default from this table.Design skillNo. A rule that reads a business assumption starts inactive and waits for the user's answer.Empty. Link each assumption to its dependent work.
Pending itemsOpen decisions, each with the work or activation that it blocks. After a build, each rule that is created inactive, skipped, or not created, with the reason and the next action.Design skill and builderOnly the named work or activationEmpty.
Acceptance examplesTwo to five cases: input, expected path, final state. Include the boundary value, the empty value when the field can be empty, and one exception.Design skill proposes. User confirms.NoOne example for each decision branch, plus its boundary value and, when the field can be empty, its empty value. The builder reports each example it did not check.

Authorization levels:

  • Advise only. No write. Use it when the user has not requested construction, or explicitly says to change nothing.
  • Build. Create the parts of a new process with its automations and AI agents on. This is the default for a build request. A new pipe starts without cards. Acceptance cards that the builder creates do not count as cards for the inactive cases below. The builder deletes them after the tests, with the usual delete confirmation.
  • Build inactive. Create the parts, and keep every automation and AI agent inactive. Use it when the user asks for it.
  • Publish. Also publish what has a draft state: a sub-portal, an integration flow. Create an HTML interface only when the user asks for one by name.

External effects are separate permissions, not a build level. Each webhook, email outside the company, and member invitation needs its own yes. Record each permitted effect without changing the build level. This permission does not activate or publish unrelated parts.

Without the publish level, a sub-portal stays unpublished and an integration flow stays a draft. Do not perform an external effect without its permission.

At the build level, the builder creates these rules inactive. In this list, a rule is an automation or an AI agent.

  • A rule that the build adds to a pipe that existed before this conversation, when the pipe has cards that the rule can match.
  • A rule that runs on a time limit or a schedule, on a pipe that has cards.
  • A rule that reads an unconfirmed business assumption (a pending item).
  • A rule that moves a card through a phase connection that the builder could not add.

For the first two kinds, read the rule again. Compare it with the specification. If it matches and no other off case applies, activate it without another yes. An inactive request, an unconfirmed assumption, or a missing connection keeps the rule off.

For traditional and AI automations, use the "Start state" section in pipefy-automations. For AI agents, use the "Active lifecycle" section in pipefy-ai-agents. Record each rule that the builder creates inactive as created inactive in Pending items, with the reason and the next action. Before the builder creates a rule that moves a card, it adds each missing phase connection with add_phase_move_targets. If a missing connection prevents creation even with active=false, record the rule as skipped in Pending items, with the same details. Never report a rejected creation as created inactive. The builder does not create a rule that needs a business value that the specification does not hold. Record that rule as not created in Pending items. Give the missing value as the reason and the user's answer as the next action.

The specification records acceptance examples and pending work. Report an unchecked example as pending. Do not declare the process ready until its acceptance examples pass and no required work remains.

Rules that connect the design skill and the builder:

  • A specification holds no ids. Do not invent an id to make a specification look complete.
  • A complete specification gets no second questionnaire. The builder asks only about pending items.
  • A pending item blocks only the dependent work or activation. The builder continues the independent work.
  • The user's confirmation of the specification also confirms each listed assumption, unless the user keeps it open. Record an assumption that stays open as a pending item, with the work or activation that it blocks.
  • If a rule reads an unconfirmed business assumption, record it as a pending item for that rule. Create it inactive. Activate it only after the user confirms the decision.
  • "No AI" in Constraints removes AI from Platform choices. AI enters Platform choices as confirmed only after an explicit yes from the user. The user's confirmation of the specification is that yes for its AI recommendations.

Specification template (one line for each field):

Objective:
Start trigger:
End states:
Steps and owners:
Decisions:
Parallel work:
Exceptions:
Data:
Platform choices:
Constraints:
Authorization:
Assumptions:
Pending items:
Acceptance examples:

Choose the Pipefy part for each step

Use the least complex part that gives the result and the controls the user needs. Before you propose a new part, check what already runs in the pipe and reuse it.

PartChoose it whenAsk before you choose itDo not choose it when
Traditional automationAn event, a test on fields, and a supported action describe the step.Does the native rule cover the whole requirement, including the exact boundary value and the empty value?The step needs judgment that no field test can express.
AI automationThe step reads card fields or an attachment on one event. It writes a fixed output: a category, a summary, or a value from a document. Recommend it for that step.Which representative examples show the quality that the team accepts? What happens when the output is wrong?A field test decides the step. Use a traditional automation.
AI agentThe step needs process context, an action that an AI automation cannot take, or a trigger that only an agent has. Actions: move a card, create a card, ask a person to review the result, call a tool on an MCP server. Recommend one agent with one responsibility and 1 to 5 behaviors.Which context, which action limits, and which human review does this responsibility need?One prompt with fixed output fields does the work. Use an AI automation. The step runs on a schedule: scheduler is never an agent trigger.
IntegrationAnother system owns the data or the action.Is one call on a card event enough (a webhook)? Or does the work need several steps, a schedule, or routing (an integration flow)?The external action happens one time only. Do not create a permanent flow for it.
Human work, field condition, or formulaA person must judge with no fixed test, or automation costs more than it returns. A field condition shows or requires a field inside a phase. A formula field calculates a value from other fields.Can a field condition, a formula, or a clear task for a named owner solve the problem?A rule with a field test does the same work with less effort.

Rules for the choice:

  • Native rule before AI. Do not stack a rule and AI on the same step. If a rule leaves manual work, describe that work as a separate step. Recommend AI for that step when the AI criteria apply and the user did not exclude AI.
  • Integration and AI are separate choices. A flow can read data from another system, an AI step can read the content, and a rule can route the result.
  • Repeated work alone does not prove a need for AI. A document to read does not prove a need for a new agent.
  • A missing automation or agent is not an improvement by itself. Some results need human work, a field condition, or a formula.
  • For each choice, write the work it removes, the alternative, and the cost: maintenance, credits when known, and the effect of an error.
  • When the user did not exclude AI and an AI row fits the step, recommend that AI part. Give the reason, the test, and what happens when the output is wrong. The user's confirmation of the specification authorizes its AI recommendations. Neither skill asks again for those parts. Until confirmation, record each AI part as recommended, not confirmed.

Review questions

Use these questions to check a specification. Ask the user only the ones that change the build, in one message. Ask the user to confirm the specification, including its AI recommendations. That confirmation authorizes those AI parts. Do not ask again before the build.

QuestionIt findsChange in the specification
What creates a case? Can a case start in another way, such as an email or another pipe?A start path with no data rulesStart trigger lists each source and the data it must bring.
For each decision, what happens at the exact boundary value, and when the field is empty?A branch with no result at the edgeDecisions get the boundary result and the empty result, or the reason the field cannot be empty. Acceptance examples test each result that can happen.
Can two conditions be true at the same time, or can a case match no condition?Overlaps and gapsDecisions get one result for each case, plus a default path.
Does work run at the same time? Does the next step need all results, any result, or a stated combination?A missing join ruleParallel work gets its join rule.
When one parallel result ends the case, what happens to the open work?Open work with no ownerParallel work gets its cancellation rule.
Is a rejection a normal end, or does it pause the case until someone fixes it?A rejection that should be an interruption, or the oppositeExceptions say "ends" or "pauses". End states or an on-hold phase change.
Does a time limit only remind, or does it move, escalate, or reassign the case?A reminder that should be a deadlineExceptions name the action and the new owner.
When work returns for correction, where does it return, who fixes it, and what lets it continue?A loop with no exitExceptions get the return point, the owner, and the exit condition. Do not invent a retry limit.
Is this the process today, the target process, or an optional improvement?Proposals recorded as factsAssumptions and Platform choices mark what the user did not confirm.
Which Pipefy part does each step? Is each activity really a phase, and is each participant really a separate pipe?Too many phases or pipesPlatform choices get one part for each step, with reuse.
Do you confirm this specification, including its AI recommendations?AI recorded without a yesConfirmation marks those AI lines as confirmed. A rejected recommendation uses its alternative.
Can a new rule match cards in a pipe from before this conversation? Does it read an unconfirmed assumption?A rule that acts before the builder checks itPlatform choices record the initial state, the reason, and when activation can proceed.

Output

End the design with the specification in the template format, then this summary:

Process: <name>
Pending items: <each open decision with the part it blocks, or "none">
Manual steps: <parts that only the Pipefy interface creates, or "none">
Impact: <one line: time this design returns to the team against a fully manual run of the same flow; if a phase exists only for human triage, what an automation or an AI agent would change there. Do not start a pipe diagnosis.>
Next step: <one offer with a one-line reason. Nothing is built until the user says yes.>
  • Say that the specification is ready to build only when every blocking field has a value. Otherwise name each field that is missing.
  • When the user wants to build next, give pipefy-building the specification. State that the build activates the new parts. Name each rule that starts inactive, stays skipped, or is not created, with its reason and next action, from Platform choices and Pending items.

Manual steps name the parts of the design that only the Pipefy UI creates:

  • Email templates (pipefy-members-email-webhooks).
  • Rules that apply a label (pipefy-automations).

Keep Impact to one line. Do not invent volume, hourly cost, or lead time; name every missing number and ask for all of them in one question. For a fuller justification, read pipefy-process-impact.

Success criteria

  • Every blocking field of the specification has a value, or it is a pending item with the part it blocks.
  • Each step has one Pipefy part, one alternative, and a reason. No AI is a confirmed choice without an explicit yes.
  • The design reuses the pipes and parts that already exist, or it says that nobody checked them.
  • The design promises only parts that Pipefy can build, and it names the manual steps.
  • Nothing was written to Pipefy.

See also

  • pipefy-building: read it when the user asks to build. It routes the build.
  • pipefy-pipes-and-cards: phases, fields, field conditions, and phase connections.
  • pipefy-automations: traditional and AI automations, and their limits.
  • pipefy-ai-agents: AI agents and their behaviors.
  • pipefy-process-intelligence: diagnose an existing pipe. This skill designs a new one.
  • pipefy-process-impact: justify a material change in full. This skill only emits the Impact line.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/pipefy/ai-toolkit/pipefy-process-design">View pipefy-process-design on skillZs</a>