ultracode-workflows

A plugin marketplace for discovering, sharing, and exploring the powerful, portable functionality provided by Claude Code ultracode workflows.

Workflows represent an advanced pattern for multi-agent orchestration that enables Claude to perform complex engineering and product work across fleets of subagents with deterministic control flow. They are not just: "Fable makes a plan and then Opus or Sonnet fan out and execute it." They are executable scripts that you can have Claude create on demand, and then store in your own setup for repeated use.

This repo is a place for Claude Code users to share these workflow files with their peers, and it aims to provide a venue for discovering powerful new ways to solve problems using this highly effective and adaptable feature - happy ultracoding!

Quick Start

Claude Code plugins now support workflows as first-class components. To get started:

claude plugin marketplace add hesreallyhim/ultracode-workflows

claude plugin install ultracode-workflows

After installing the plugin, you will immediately have access to all of the workflows in the plugin's workflows directory. You can then invoke the workflow either by asking Claude to use it by referring to it in plain language, or by directly invoking it, in the same way you would a slash command:

/ultracode-workflows:deep-code-review

You can customize the specific behavior of a pre-scripted workflow by passing in arguments, or by talking it over with Claude. You can also ask Claude to explain how the workflow is structured (/ultracode-workflows:wf-explain), or to show you a diagram of the workflow graph.

Currently, the plugin ships with a comprehensive suite of scripts that provide a wide breadth of coverage over the full Software Development Lifecycle. Each of these workflows was authored by Claude Fable 5, and they can be used individually as is, adapted to your specific needs or preferences, or composed to automate larger sections of the development process.

Contributing

This plugin marketplace strongly welcomes workflows from additional contributors. If you use ultracode and you find a workflow that performs particularly well, you are invited to share it with other Claude Code developers. For information about workflows and how to save them, see the Claude Code documentation. See CONTRIBUTING for more information about how to submit an entry to this marketplace. Due to the highly elevated level of access that a workflow exposes, submissions will be carefully inspected for any overt or indirect security vulnerabilities.

What a workflow script is

A workflow script is written in a dialect of JavaScript and executed by the Claude Code harness via the Workflow tool. A workflow script deviates from vanilla JavaScript in a few ways: because the harness wraps the script body in an async function, workflows permit top-level async-await usage, as well as a return statement outside of a function body; certain functions like Date.now() are prohibited because they interfere with the resumability of a workflow that is paused in the middle; in addition, the harness injects orchestration primitives:

Primitive	Role
agent(prompt, opts)	Spawn a subagent; with opts.schema it returns a validated object
pipeline(items, ...stages)	Run items through stages independently - no barrier between stages
parallel(thunks)	Run tasks concurrently and wait for all (a barrier)
phase(title) / opts.phase	Group agents in the live progress display
log(msg)	Narrate progress to the user
args	The invocation's input value
budget	The session's token target (total, spent(), remaining())
workflow(ref, args)	Run another workflow as a sub-step (one level deep)

The script's return value is the workflow's result. Scripts are deterministic orchestration; all model judgment lives in the subagents.

Why Workflows Matter

Workflows represent a significant step forward over previous orchestration techniques, and are a natural progression in the advancement of agents to perform long-horizon tasks. Whereas plugins provide valuable tools and raw materials, they still require significant reasoning on the part of the agent, their effectiveness can be difficult to evaluate, and they are still subject to a considerable degree of human error. Like hooks, workflows operate outside of the agent's sometimes faulty or unpredictable decision-making processes, and, once the plan has been written, the arduous task of orchestration is mostly offloaded to the harness itself. Coupled with a design that ensures resumable execution over long-horizon tasks, and an interface that permits chaining and composition, workflows have the potential to provide a structure that would enable reliable, measurable, and repeatable performance over indefinitely large problem spaces. Given the current capabilities of advanced models like Claude, workflows strike a nice balance between agent autonomy and the kinds of controls needed for tackling very large tasks.

Workflow Authoring

The plugin's workflow-authoring skill can be invoked with /ultracode-workflows:workflow-authoring (or let Claude reach for it). It treats the catalog as a casebook: it selects structural, trust, and scale precedents, then composes their invariants. When invoked directly it acts as a small design studio — showing candidate shapes and quick/balanced/deep cost envelopes, generating a static diagram, and explaining the patterns enabling more fine-grained control over the budget, expected duration, and trust posture before accepting the plan.

Workflow Runtime Observation

Status Line

The plugin also includes a status line for an easy way to track the progress of a workflow from the TUI. (Claude Code also exposes this sort of capability in the CLI, but most of the useful details are in a secondary panel.) The status line tracks the progress of the workflow phases and provides updates as it proceeds. Because status lines are not officially integrated with plugins, the workflow status line can be set up by prompting Claude, who will take care of the messy bits of wiring it together in a way that is compatible with your existing configuration, and allows you to choose whether to install it at the user or project level.

Web-UI Observer

The plugin also offers a rich and detailed observation Web-UI. When a workflow starts, Claude will ask if you want to open the observer in the browser. The Web-UI provides a visualization of the workflow that gives you clear insight into its structure, the topology of the different phases and components of the workflow, and realtime updates via polling, in order to avoid the need for a special-purpose server.

Additional Commands

Command	What it does
/ultracode-workflows:wf-list [keyword]	List the plugin's workflows along with what each one does
/ultracode-workflows:wf-watch [run-id]	Watch a run in a self-contained HTML window - topology + live agent states, no server. Also previews a plan before you run it
/ultracode-workflows:wf-statusline	Wire the live progress statusline into your settings (project or user level - it asks)
/ultracode-workflows:wf-new <description>	Author a brand-new workflow via the authoring skill (draft → self-review → diagram)
/ultracode-workflows:wf-explain <path>	Explain any workflow script: control flow, inputs, cost, and what it will do to your repo
/ultracode-workflows:wf-diagram <name|path>	Render a workflow's terminal structure diagram; Mermaid remains available for documents
/ultracode-workflows:wf-export	A convenience if you want to export the raw workflow files out of the plugin and store them in your local directory for inspection or revising

Passing input

Workflows read their input from a global args. You supply it in plain language - Claude extracts it as structured data (strings, lists, objects), so the script uses it directly without parsing:

run the ultracode-workflows dependency-upgrade to bump express          → args = { package: "express" }
review only correctness and security in my staged changes with deep-code-review   → args = { dimensions: ["correctness","security"] }
turn docs/notes.md into a PRD with requirements-to-prd                   → args = { input: "docs/notes.md" }

The following workflows require input (invoking them bare returns a usage error telling you what's missing). Quick reference:

Needs input	Workflow(s)
input (raw notes)	requirements-to-prd
prd	prd-to-spec · prd-decompose · feature-factory
spec	roadmap-plan
criteria / tickets	acceptance-qa-deep / acceptance-qa-batch
from and to	api-migration
package	dependency-upgrade
brief	design-tournament
source	feedback-synthesis
incident	incident-investigation
since	release-notes
question	research-synthesis
goal (first call)	sdlc-orchestrator

The other workflows run with sensible defaults and take optional args to narrow scope. You can always review the available workflows via /ultracode-workflows:wf-list.

Catalog

The plugin currently ships with workflow scripts that aim to provide good coverage of key aspects of the SDLC. Since ultracode workflows can be resource-intensive, you may wish to try them out in well-scoped situations before attempting further experiments. However, they were authored by a highly capable Workflow user (Claude Fable 5), and you can discuss modifications with Claude after selecting one.

Tip

Unless instructed otherwise, subagents will be launched using the same model as the main session. Keep this in mind when planning your budget, and feel free to instruct Claude to use different models.

Code quality & review

Workflow	Use case	Signature patterns
deep-code-review	Pre-merge review of a change set	Dimension fan-out → dedupe barrier → adversarial verify → ranked report
bug-hunt	Exhaustive bug discovery with no natural stopping point	Loop-until-dry, rotating lenses, majority-vote skeptic panels, budget-aware rounds
security-audit	Defensive audit of your own code	Recon-then-sweep, severity-scaled refutation panels, fully pipelined

Product inception & planning

Workflow	Use case	Signature patterns
requirements-to-prd	Raw notes/briefs → an honest PRD	Four extraction lenses, ambiguity/scope/feasibility critic attack, unknowns surfaced not invented
prd-to-spec	PRD → implementable technical spec (the middle step)	Codebase grounding, five technical lenses, optional design-tournament child, implementability + fidelity verify
roadmap-plan	Spec → sequenced milestone roadmap	Three competing sequencing strategies, panel pick, critical-path + risk stress-test
prd-decompose	PRD/spec → implementation-ready backlog	Five-lens document reading, judgment-merge, reverse-direction coverage critic

Environment & build

Workflow	Use case	Signature patterns
project-bootstrap	Stand up toolchain, tests, CI from a spec	Detect-then-plan (idempotent), independent-concern fan-out, prove-by-running the pipeline green
feature-factory	PRD → reviewed working code, end to end	Conductor: composes prd-decompose + per-module deep-code-review around a parallel implementation stage

Understanding & documentation

Workflow	Use case	Signature patterns
codebase-atlas	Onboarding map of an unfamiliar repo	Survey-then-fan-out, justified barrier at synthesis, completeness critic + repair round
docs-drift-audit	Do the docs still tell the truth?	Claim decomposition, per-doc batched verification, pure pipeline (zero barriers)

Migration & maintenance

Workflow	Use case	Signature patterns
api-migration	Many call sites, each needing judgment	Disjoint file-group sharding (no worktrees needed), wave batching, single global verify
dead-code-sweep	Remove dead code without breaking dynamic consumers	Multi-modal sweep, default-to-keep skeptics (asymmetric risk), report-only default
dependency-upgrade	Major-version bumps of load-bearing deps	Parallel research + impact analysis joined into a plan, bounded verify/fix loop
refactor-campaign	Behavior-preserving technical-debt paydown	Characterization-net-first safety gate (no green net → no blind refactor), pipeline net→refactor→verify

Testing & QA

Workflow	Use case	Signature patterns
test-gap-filler	Coverage where it matters, not where it's easy	Dual-modality gap discovery, blast-radius ranking, mutation-checked self-verifying writers
flaky-test-hunt	Replace flake rumor with evidence	Suspect sweep → empirical stress runs → mechanism-taxonomy diagnosis
acceptance-qa-batch	Batch QA: a whole "done" column against its ACs	Per-ticket demonstrate-with-evidence → feature-level adversarial break (breadth)
acceptance-qa-deep	Deep gate: one ticket must be airtight	Criterion decomposition + implied-criteria, per-check verify, letter-vs-spirit skeptic (depth)

(acceptance-qa-batch ↔ acceptance-qa-deep are the breadth/depth pair for "is it really done?")

Design & product

Workflow	Use case	Signature patterns
design-tournament	Architecture/product decisions with a wide option space	Forced-diverse philosophies, anonymized judge panel, synthesis with grafts + dissent
feedback-synthesis	1000 tickets → ranked product themes with quotes	Calibrate-then-shard, provable coverage, severity-weighted ranking

Release & operations

Workflow	Use case	Signature patterns
release-gate	Evidence-based go/no-go before shipping	Six evidence-gathering readiness dimensions, adversarial blocker confirmation, structural decision under a rubric
release-notes	Notes that are readable and provably true	Diff-reading summarizers (messages lie), bidirectional fact-check
incident-investigation	Root-cause analysis that resists the first plausible story	Hypothesis-free evidence collection, competing hypotheses, one falsifier per hypothesis

Research

Workflow	Use case	Signature patterns
research-synthesis	Cited answers to "should we adopt X?" questions	Leads-then-reads, credibility ranking, per-claim citations, critic-driven round two

Composition & the SDLC chain

Workflow	Use case	Signature patterns
sdlc-orchestrator	Drive a feature from requirements→release, with human checkpoints	Resumable driver: runs leaf stages inline, hands off conductor stages, pauses at every checkpoint with full state
feature-factory	PRD → reviewed working code, end to end	Conductor: composes prd-decompose + per-module deep-code-review as workflow() children around a parallel implementation stage

Workflows compose: workflow(name, args) runs a saved workflow inline and returns its structured result (nesting is one level - conductors call leaves). See the composition section of docs/PATTERNS.md for the conductor rules, session-level chaining, and runtime-generated children.

The full lifecycle in one script

sdlc-orchestrator chains the plugin's workflows together into one resumable drive from requirements to a gated release. Currently, this is only an aspirational attempt to illustrate the potential power of workflows, and workflow composition - it should not be confused with a "battle-tested" method to "ship while you sleep."

flowchart TD
  G([goal]) --> I{{Intake · tailor the plan}}
  I --> R[requirements-to-prd]
  R -. openQuestions ↩ answers .-> R
  R --> S[/prd-to-spec - HANDOFF/]
  S --> RM[roadmap-plan]
  RM --> B[prd-decompose]
  B --> BS[project-bootstrap<br/>if greenfield]
  BS --> IM[/feature-factory - HANDOFF/]
  IM --> QA[acceptance-qa-batch]
  QA --> RG{release-gate<br/>go / no-go}
  RG -->|go| RN[release-notes]
  RN --> FB[feedback-synthesis]
  FB -. next iteration .-> R
  RG -->|no-go| STOP([checkpoint: fix & resume])

  classDef run fill:#e6f0ff,stroke:#4a78c2;
  classDef handoff fill:#fff0e6,stroke:#d98a3a,stroke-width:2px;
  class R,RM,B,BS,QA,RN,FB run;
  class S,IM handoff;

Loading

• Runs (blue) are leaf workflows the driver executes inline via workflow().
• Handoffs (orange) - prd-to-spec and feature-factory are themselves conductors; nesting is one level, so the driver returns a directive for the session to run them as their own top-level workflow, then resumes. Each handoff is also a natural human checkpoint.
• Every arrow is resumable. The driver runs until it hits a checkpoint - open questions, a failed gate, a handoff, or a low budget - then returns its full state. You resolve it and re-invoke with that state plus args.answers / args.completed; it skips completed stages and continues. Run with { plan: true } for a dry, tailored plan with no execution.

Workflows can't ask questions mid-run. There is no interaction primitive - log() is one-way. The idiom is the checkpoint pattern: a workflow returns openQuestions / assumptions / decisions as structured output, you (or the session) resolve them, and answers come back as args on a re-run - where resume caching makes the second pass cheap. requirements-to-prd, prd-to-spec, and the orchestrator itself are built around this.

Design principles

The Workflow tool's primitives each have their own tradeoffs and are suited for different sorts of tasks or constraints. These constraints should inform the design of any given workflow, and can affect cost, reliability, runtime, etc. Claude is generally quite knowledgeable about these different factors, but having an understanding of the "vocabulary" of the Workflow tool will help you understand the design and retrospect on it with clarity.

1. Pipeline by default, barrier by argument. A barrier appears only where stage N genuinely needs all of stage N−1 (dedupe before expensive verification, judges needing all proposals). Each barrier in the library has a comment defending it.
2. Verification is adversarial. Finders never grade their own findings. Skeptics are prompted to refute, with default-to-refuted bias - and the bias flips to default-to-keep when the risk is asymmetric (dead-code-sweep).
3. Schemas at every boundary. Downstream stages consume validated structure, never re-parse prose. Schema fields do design work - predictions makes hypotheses falsifiable, prdAnchor makes tickets traceable, support makes claims citable.
4. Coverage is arithmetic, not vibes. Sharding runs over explicit manifests so "we read everything" is sum(itemsRead) == totalItems. Caps are never silent - dropped work is logged and returned.
5. Judgment in agents, mechanics in code. Counting, deduping by natural key, ranking by formula, and tallying votes happen in plain JavaScript. Merging tickets or naming a storyline - where identity itself requires reading - goes to an agent.
6. Destructive actions are opt-in and verified after. apply/fix flags default to report-only; deletions funnel through a single sequential agent; build/tests run once, globally, afterward.
7. Honest exits. Loops are bounded; non-convergence returns status: 'unstable' with the remaining failures rather than churning or pretending.

See docs/PATTERNS.md for the full pattern language with library cross-references, and docs/AUTHORING.md for the API contract when writing new scripts.

Structure diagrams

Every workflow's orchestration shape is visualized in docs/DIAGRAMS.md - one Mermaid flowchart per script (GitHub renders them inline), generated by statically parsing each script into an AST. The analyzer does not evaluate the workflow body. It recognizes phases, barriers vs. per-item pipelines, vote panels, loop back-edges, and fan-outs; multiplicities are reported as exact counts when statically knowable, bounded ranges when only limits are knowable, and unknown when they depend on runtime data.

To view the workflows rendered as plan previews in the style of the Web-UI, instead of Mermaid, see docs/GALLERY.md.

Note

To avoid remote code execution, the diagram tool only parses source code; it does not execute the inspected script. Runtime args are neither required nor consumed, because data-dependent branches and fan-outs are represented conservatively as optional, ranged, or unknown topology.