Workflows

A curated collection of development, data science, writing, workshop, legal, and research workflows for Claude Code.

# 1. Install the plugin
/plugin marketplace add edwinhu/workflows

# 2. (Optional) Install CLI dependencies for knowledge management, email, and calendar
bash ~/.claude/plugins/cache/edwinhu-plugins/workflows/*/bin/install-deps.sh

# 3. (Optional) Live marimo kernel work — only needed by the `marimo` skill
claude plugin marketplace add marimo-team/marimo-pair
claude plugin install marimo-pair@marimo-pair

marimo-pair is a separate upstream plugin, deliberately not declared as a hard dependency: an uninstalled dependency stops the whole plugin from loading, and one skill should not be able to take the other sixty with it. The marimo skill routes live-kernel work to Skill(skill="marimo-pair:marimo-pair") and works for notebook authoring without it.

The install script is only needed for skills that use the external tools below. The plugin's own TypeScript hooks and JavaScript/TypeScript workflow runners use Bun; the core workflows do not require the optional CLIs installed by this script.

The script recognizes macOS, Linux, and Windows-like environments on x64 or arm64 and attempts to download matching pre-built binaries from GitHub Releases. If a tool does not publish an asset for the detected platform, the script warns and skips it:

Requires gh (GitHub CLI). Tools already on your $PATH are skipped.

These are the skills you invoke directly with /name:

/craft is the spine: clarify with the user, draft a plan they edit and approve, self-set a goal, run workflow.js to implement and independently verify, then put the result in front of a human in tuicr. Human rejection routes back to CLARIFY. The domain workflows dispatch through it and add their own computed gate.

Plan review is computed and happens before dispatch: plan-lint.ts over the built args and plan-preflight.ts executing their commands at baseline, enforced by craft-dispatch.sh while the run is still armed. No agent reads the plan markdown looking for defects.

Part of the document skill group — one pipeline (extract → create → repair → build → render → verify) bundling the Anthropic Office skills with this project's repair/build/render tooling.

Office format skills sourced from anthropics/skills via git submodule. Shared converters + the Google-export OOXML package repair (scripts/docx_repair.py) live in scripts/. See references/document-skills.md for the full group and how the stages decouple.

These skills have user-invocable: false — Claude loads them automatically when relevant or a workflow dispatches them internally. You don't call them directly.

bluebook, bluebook-audit, docx-repair, source-verify

wrds, lseg-data, gemini-batch

nlm, google-scholar, readwise, readwise-chat, readwise-search, readwise-docs, readwise-prune

consensus, research

marimo, jupytext, notebook-debug

farm-out, look-at, visual-verify, visual-mockup, data-context, continuous-learning, pattern-capture, ai-anti-patterns, obsidian-organize, pptx-render, headline-card

farm-out is the dispatcher craft runs its agents through — craft-dispatch.sh uses the sibling copy by default, so the plugin dispatches without an outside install. It fetches its own SDK on first run.

None. The craft spine has no sub-skills: the phases are beats inside skills/craft/workflow.js, dispatched as agents, so there is nothing to invoke by name and nothing to keep in sync.

Specialized subagents auto-discovered by Claude Code from agents/:

The craft spine's implementers, verifiers and reviewers are dispatched from skills/craft/workflow.js with the prompt the run needs; they are not named subagent types, so the per-role agent files the beat spine required are gone.

Every workflow runs the same loop, in skills/craft/workflow.js. The plan's <!-- craft:dispatch --> block is the sole authority and its canonical specHash is verified by each dispatched agent; the gate is computed in JS from raw counts, fails closed on a dead agent, and returns the selector that drives the fix loop. A domain workflow contributes its own mechanical checks and review lenses — it does not get its own lifecycle.

Hooks auto-run at specific lifecycle events. The table has one row per command target registered in hooks/hooks.json:

A craft run keeps two records, one owner each: the approved plan at .claude/plans/<slug>.md is the run's authority and the file craft hashes in place, and .craft/<run-id>/ holds the args, the verdict JSON and the plan bytes each round actually ran under. Project auto-memory retains reusable facts; project directories retain real inputs and deliverables.

For cross-session task persistence, set CLAUDE_CODE_TASK_LIST_ID in .envrc:

export CLAUDE_CODE_TASK_LIST_ID="my-project"

workflows/
├── .claude-plugin/             # Plugin manifest
│   ├── plugin.json             # Version and metadata
│   └── marketplace.json        # Marketplace listing
├── agents/                     # Specialized subagents
├── skills/                     # User-facing and internal skills
│   ├── craft/                  # The spine: workflow.js, plan-lint, dispatch, gate
│   ├── dev/, ds/, writing/, workshop/, workflow-creator/  # Domain workflows
│   ├── farm-out/               # The dispatcher craft farms agents out through
│   ├── docx, pdf, pptx, xlsx  # Document formats (symlinks)
│   └── ...                     # Internal phases and auto-invoked skills
├── bin/                        # Optional dependency installer
├── docs/                       # Architecture and investigation records
├── hooks/                      # Hook scripts
│   ├── hooks.json              # Hook configuration
│   └── *.ts                    # Hook implementations run with Bun
├── references/                 # Shared constraint and reference docs
├── scripts/                    # Compilers, checks, renderers, and support tools
├── tests/                      # Contract and regression tests
├── workflows/                  # Shared and domain workflow runners
│   ├── lib/                    # Runner libraries and task contracts
│   └── templates/              # Dynamic workflow templates
├── external/
│   └── anthropic-skills/       # Git submodule for document skills
└── PHILOSOPHY.md               # Workflow design philosophy

Key Points:

• skills/ contains both user-facing and internal phase skills (auto-discovered; internal skills use user-invocable: false)
• agents/ contains specialized subagents, auto-discovered by Claude Code
• hooks/ contains TypeScript hook entry points called directly by hooks.json
• workflows/ contains the shared runner plus writing, workshop, and workflow-creator adapters
• scripts/ contains deterministic compilers, validation checks, renderers, and support tools
• references/ contains shared constraint and enforcement docs

The office format skills come from Anthropic's official skills repo. To update:

git submodule update --remote external/anthropic-skills

This project was heavily inspired by obra/superpowers, particularly:

• The SessionStart hook pattern for injecting meta-skills
• The "using-skills" approach that teaches HOW to use skills rather than listing WHAT skills exist
• The philosophy that skills should be invoked on-demand, not dumped into every session

Office format skills (docx, pdf, pptx, xlsx) are from anthropics/skills.

MIT

Edwin Hu