claudeers.
// Claude Plugins

ultracode-workflows

A comprehensive suite of Claude Code ultracode multi-agent workflow scripts, along with a workflow-authoring skill, a live-progress statusline, enhanced obse…

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up ultracode-workflows (claude-plugin project) into my current project.
Found on https://claudeers.com/ultracode-workflows
Repo: https://github.com/hesreallyhim/ultracode-workflows
Homepage/docs: —
Detected install method: claude-plugin → /plugin install ultracode-workflows@hesreallyhim/ultracode-workflows
Category: plugins. Platforms: cli, api, web.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
unknown; community-verified: false. Confirm the source before running anything.
// or install directly (claude-plugin)

⚠ Unverified / not recently updated — review before pasting a run-this config.

/plugin marketplace add hesreallyhim/ultracode-workflows
/plugin install ultracode-workflows@hesreallyhim/ultracode-workflows
// or clone
git clone https://github.com/hesreallyhim/ultracode-workflows

// compatibility

Platformscli, api, web
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageJavaScript

Get your FREE $2.50 API credits to access TickAtlas financial data ↗
ultracode-workflows banner

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:

PrimitiveRole
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.phaseGroup agents in the live progress display
log(msg)Narrate progress to the user
argsThe invocation's input value
budgetThe 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

CommandWhat 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-statuslineWire 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-exportA 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 inputWorkflow(s)
input (raw notes)requirements-to-prd
prdprd-to-spec · prd-decompose · feature-factory
specroadmap-plan
criteria / ticketsacceptance-qa-deep / acceptance-qa-batch
from and toapi-migration
packagedependency-upgrade
briefdesign-tournament
sourcefeedback-synthesis
incidentincident-investigation
sincerelease-notes
questionresearch-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

WorkflowUse caseSignature patterns
deep-code-reviewPre-merge review of a change setDimension fan-out → dedupe barrier → adversarial verify → ranked report
bug-huntExhaustive bug discovery with no natural stopping pointLoop-until-dry, rotating lenses, majority-vote skeptic panels, budget-aware rounds
security-auditDefensive audit of your own codeRecon-then-sweep, severity-scaled refutation panels, fully pipelined

Product inception & planning

WorkflowUse caseSignature patterns
requirements-to-prdRaw notes/briefs → an honest PRDFour extraction lenses, ambiguity/scope/feasibility critic attack, unknowns surfaced not invented
prd-to-specPRD → implementable technical spec (the middle step)Codebase grounding, five technical lenses, optional design-tournament child, implementability + fidelity verify
roadmap-planSpec → sequenced milestone roadmapThree competing sequencing strategies, panel pick, critical-path + risk stress-test
prd-decomposePRD/spec → implementation-ready backlogFive-lens document reading, judgment-merge, reverse-direction coverage critic

Environment & build

WorkflowUse caseSignature patterns
project-bootstrapStand up toolchain, tests, CI from a specDetect-then-plan (idempotent), independent-concern fan-out, prove-by-running the pipeline green
feature-factoryPRD → reviewed working code, end to endConductor: composes prd-decompose + per-module deep-code-review around a parallel implementation stage

Understanding & documentation

WorkflowUse caseSignature patterns
codebase-atlasOnboarding map of an unfamiliar repoSurvey-then-fan-out, justified barrier at synthesis, completeness critic + repair round
docs-drift-auditDo the docs still tell the truth?Claim decomposition, per-doc batched verification, pure pipeline (zero barriers)

Migration & maintenance

WorkflowUse caseSignature patterns
api-migrationMany call sites, each needing judgmentDisjoint file-group sharding (no worktrees needed), wave batching, single global verify
dead-code-sweepRemove dead code without breaking dynamic consumersMulti-modal sweep, default-to-keep skeptics (asymmetric risk), report-only default
dependency-upgradeMajor-version bumps of load-bearing depsParallel research + impact analysis joined into a plan, bounded verify/fix loop
refactor-campaignBehavior-preserving technical-debt paydownCharacterization-net-first safety gate (no green net → no blind refactor), pipeline net→refactor→verify

Testing & QA

WorkflowUse caseSignature patterns
test-gap-fillerCoverage where it matters, not where it's easyDual-modality gap discovery, blast-radius ranking, mutation-checked self-verifying writers
flaky-test-huntReplace flake rumor with evidenceSuspect sweep → empirical stress runs → mechanism-taxonomy diagnosis
acceptance-qa-batchBatch QA: a whole "done" column against its ACsPer-ticket demonstrate-with-evidence → feature-level adversarial break (breadth)
acceptance-qa-deepDeep gate: one ticket must be airtightCriterion 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

WorkflowUse caseSignature patterns
design-tournamentArchitecture/product decisions with a wide option spaceForced-diverse philosophies, anonymized judge panel, synthesis with grafts + dissent
feedback-synthesis1000 tickets → ranked product themes with quotesCalibrate-then-shard, provable coverage, severity-weighted ranking

Release & operations

WorkflowUse caseSignature patterns
release-gateEvidence-based go/no-go before shippingSix evidence-gathering readiness dimensions, adversarial blocker confirmation, structural decision under a rubric
release-notesNotes that are readable and provably trueDiff-reading summarizers (messages lie), bidirectional fact-check
incident-investigationRoot-cause analysis that resists the first plausible storyHypothesis-free evidence collection, competing hypotheses, one falsifier per hypothesis

Research

WorkflowUse caseSignature patterns
research-synthesisCited answers to "should we adopt X?" questionsLeads-then-reads, credibility ranking, per-claim citations, critic-driven round two

Composition & the SDLC chain

WorkflowUse caseSignature patterns
sdlc-orchestratorDrive a feature from requirements→release, with human checkpointsResumable driver: runs leaf stages inline, hands off conductor stages, pauses at every checkpoint with full state
feature-factoryPRD → reviewed working code, end to endConductor: 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;
  • 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.

// faq

What is ultracode-workflows?

A comprehensive suite of Claude Code ultracode multi-agent workflow scripts, along with a workflow-authoring skill, a live-progress statusline, enhanced observation UI, and validator/diagram tools. It is open-source on GitHub.

Is ultracode-workflows free to use?

ultracode-workflows is open-source under the MIT license, so it is free to use.

What category does ultracode-workflows belong to?

ultracode-workflows is listed under plugins in the Claudeers registry of Claude-compatible tools.

6 views
★ 10 stars
unclaimed
updated 6 days ago

// embed badge

ultracode-workflows on Claudeers
[![Claudeers](https://claudeers.com/api/badge/ultracode-workflows.svg)](https://claudeers.com/ultracode-workflows)

// retro hit counter

ultracode-workflows hit counter
[![Hits](https://claudeers.com/api/counter/ultracode-workflows.svg)](https://claudeers.com/ultracode-workflows)

// reviews

// guestbook

0/500

// related in Claude Plugins

🔓

A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls.

// pluginsmultica-ai/★ 230,631[ claude ]
🔓

Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explainin…

// pluginsanthropics/⟨Python⟩★ 156,472[ claude ]
🔓

"CLI-Anything: Making ALL Software Agent-Native" -- CLI-Hub: https://clianything.cc/

// pluginsHKUDS/⟨Python⟩★ 58,467◷ Apache-2.0[ claude ]
🔓

financial-services — a Claude ecosystem project on GitHub.

// pluginsanthropics/⟨Python⟩★ 41,409◷ Apache-2.0[ claude ]
→ see how ultracode-workflows connects across the ecosystem