pi-glossary generic shared workflow glossary

pi-glossary-generic-workflows.json

[
  {
    "term": "tophat",
    "definition": "Manual integration test. Test the system like the final user would, but locally."
  },
  {
    "term": "pbcopy",
    "pattern": "\\bpbcop(?:y|ied|ying)\\b",
    "definition": "Used as a verb: send the relevant part of the work to pbcopy (the macOS CLI tool that copies stdin to the clipboard). The 'relevant part' is the final product, stripped of meta-commentary. Examples: during a proofread, pipe only the rewritten message (no notes about the changes) to pbcopy; when iterating on a prompt, pipe only the latest version of the prompt itself (no commentary about it). If unsure what counts as the final product, ask before copying."
  },
  {
    "term": "clarask",
    "pattern": "\\bclarask(?:ed|ing)?\\b",
    "definition": "Ask clarifying questions using the 'ask' tool before starting the task. Used as a verb (e.g. 'clarask this', 'clarasked', 'clarasking'). If the request is already unambiguous, skip the questions and continue."
  },
  {
    "term": "explore-plan",
    "aliases": [
      "explore and plan",
      "e&p",
      "EP"
    ],
    "definition": "A workflow pattern: [[orchestrate]] explore and plan only; do not modify files, run migrations, or create commits. Explore — spawn focused scout [[subagent]]s in parallel to gather context, read their artifact paths, and require evidence-backed findings. Plan — spawn one planner with the original request plus scout artifact paths; the planner must produce a step-by-step plan, risks, validation strategy, and open questions. Run independent scouts in parallel, preserve user constraints (read-only/no-modify/no-commit) in every subagent prompt, and synthesize artifact results while citing paths. [[lapture]] the plan. Ask the user only for decisions that cannot be resolved from code, docs, or history."
  },
  {
    "term": "explore-plan-execute-review",
    "aliases": [
      "EPER"
    ],
    "definition": "A workflow pattern: [[orchestrate]] a task end to end through explore → plan → execute → review. Scout [[subagent]]s explore and write evidence-backed artifacts. A planner builds a plan from the request plus scout artifact paths; a pragmatic plan-reviewer reviews it, looping with the planner until no blocking findings remain or two iterations fail to converge. [[lapture]] the plan. Executors implement the accepted plan in parallel where independent. A pragmatic reviewer checks the result; executors and reviewer loop once more for blocking findings. Preserve user constraints (read-only/no-modify/no-commit) in every subagent prompt. If reviewers conflict, requirements are ambiguous, or the task would violate a user constraint, stop and ask the user."
  },
  {
    "term": "execute-review-loop",
    "aliases": [
      "execute-review"
    ],
    "definition": "A workflow pattern: implement the requested change, then [[orchestrate]] reviewer [[subagent]]s. Always run Alboto; for code changes also run Laputan and Kent/code-smell if available. Address only actionable findings with severity or concrete failure modes; do not churn on style-only feedback unless it affects maintainability. Re-run the same reviewers after fixes and cite artifact paths. Stop when every reviewer has no blocking findings. If reviewers conflict or two loops do not converge, stop and summarize the disagreement for the user instead of continuing indefinitely."
  },
  {
    "term": "gubmit",
    "definition": "Commit the current execution (new commit), then push via Graphite `gt submit`. Default flag: `--stack --update-only` (only updates existing PRs, will not create new ones — the safe default for a normal save-and-push). Switch to `--no-interactive --branch <branch>` (or drop `--update-only`) when the context is creating a draft PR for a brand-new branch — e.g. when the user just asked to create a new branch on top of the stack and gubmit it. If unsure which mode applies, prefer the default and ask."
  },
  {
    "term": "grill",
    "pattern": "\\bgrill(?:ed|ing)?\\b",
    "definition": "Interview the user relentlessly until reaching shared understanding. Used as a verb (e.g. 'grill this', 'grilled', 'grilling'): walk down each branch of the decision tree one at a time, resolving dependencies between decisions before moving on. For each question, provide your recommended answer. If a question can be answered by exploring the codebase, the web, or local files, investigate first instead of asking. Default to one question at a time conversationally; use the 'ask' tool only when the question has a clean set of predefined options. Continue until every branch is resolved.",
    "source": "https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md"
  },
  {
    "term": "rapid fire",
    "definition": "The user is aligning understanding through a quick back-and-forth: they will ask short questions one after another. Answer each one with a short, focused, grounded reply. No preamble, no hedging, no exploring tangents — just the direct answer to the specific question asked. Wait for the next question instead of expanding scope.",
    "aliases": [
      "rapid-fire",
      "rapidfire"
    ]
  },
  {
    "term": "worchestrate",
    "aliases": [
      "worchestrates",
      "worchestrating",
      "worchestrated",
      "worchestrator"
    ],
    "definition": "A script-first evolution of [[orchestrate]]. The main agent creates a shell script that owns the orchestration: spawning [[subagent]]s, collecting artifact paths, asking evaluator subagents to return machine-readable labels/scores/decisions, parsing those outputs, and using them in shell conditionals or loops to choose the next step. The script parallelizes independent subagent work as much as possible and chains dependent steps through artifact paths. The main agent designs this control flow by identifying task dependencies and coding the script so workflow state, branching logic, fan-out/fan-in coordination, and repeatable control flow live outside the main context."
  },
  {
    "term": "orchestrate",
    "pattern": "\\b(?:orchestrat(?:e[ds]?|ing|or)|team of (?:sub-?)?agents)\\b",
    "aliases": [
      "orchestrated",
      "orchestrating",
      "orchestrator",
      "team of agents",
      "team of subagents",
      "team of sub-agents"
    ],
    "definition": "Spawn one or more [[subagent]]s to execute the request — never do the delegated work directly. The main agent acts as orchestrator only: decompose the request into focused tasks, list available user agents with `subagent-cli --list`, choose the most appropriate agent from `~/.pi/agent/agents` (prefer specialists such as `code-explorer`, `slack-explorer`, `gus`), run `subagent-cli --artifact auto <agent> \"<task>\"` for each task, then read the printed artifact paths and synthesize the results. Spawn agents in parallel when tasks are independent or parallelism materially reduces elapsed time by backgrounding each `subagent-cli --artifact auto ...` command and `wait`ing; chain dependent work by passing prior artifact paths into the next task."
  },
  {
    "term": "subagent",
    "aliases": [
      "subagents",
      "sub-agent",
      "sub-agents"
    ],
    "definition": "A non-interactive Pi process spawned to execute one focused task with isolated context. List available user agents with `subagent-cli --list`; use `subagent-cli --scope both --list` only when trusted repo-local `.pi/agents` should be eligible. Use [[subagent-cli]] instead of manually parsing frontmatter or composing `pi -p` arguments: `subagent-cli --artifact auto <agent> \"<task>\"`. The CLI selects the agent definition, applies its `model`/`tools`/`skills` frontmatter, appends the prompt body, runs `pi -p --no-session`, and in artifact mode writes `/tmp/subagent-<main-session-uuid>-<agent>-<slug>.md`. Reference artifact paths in subsequent prompts instead of pasting full outputs. Keep each subagent task focused and include any user constraints explicitly."
  },
  {
    "term": "dapy",
    "definition": "Do not change anything; just answer what the user asked."
  }
]