Agent skill

Flowing

by oaustegard in oaustegard/claude-skills

Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past.

MITAuto-check passedAgent Workflows

Install Flowing

skills CLI
$ npx skills add oaustegard/claude-skills --skill flowing -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install oaustegard/claude-skills flowing --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/oaustegard/claude-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/flowing .claude/skills/flowing && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
flowing
GitHub stars
150
Token cost
~1.7k tokens
SKILL.md length
675 words
Files
6 (incl. scripts, references)
Skills in repo
66
Repo updated
First seen
Licence
MIT

At a glance

Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past.

  • Run these steps in order and retry the flaky one until the check passes
  • SKILL.md covers NOT SUPERSEDED BY DYNAMIC…, Quick Start, Control-Flow Primitives and Other capabilities, plus 3 more sections
  • Runs Python scripts from its folder
  • Build a pipeline that fetches

What it does

Flowing is an agent skill from oaustegard/claude-skills. Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past. Use for "run these steps in order and retry the flaky one until the check passes", "build a pipeline that fetches, validates, then skips the upload when nothing changed", "make sure these steps cannot be skipped", "resume from where it broke instead of redoing the expensive early stages", "run these independent calls at once and merge the results", or…

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including scripts and reference files (for example `CHANGELOG.md`, `README.md` and `references/reference.md`).

It sits in Agent Workflows, covering Subagents. It works with Python. The repository describes itself as: My collection of Claude skills. The licence is MIT.

When your agent uses it

  • Run these steps in order and retry the flaky one until the check passes
  • Build a pipeline that fetches
  • Then skips the upload when nothing changed
  • Make sure these steps cannot be skipped

Example prompts

  • “make sure these steps cannot be skipped”
  • “run these independent calls at once and merge the results”
  • “/flowing”

Requirements

  • Python 3

What it can do on your machine

Read from SKILL.md and the folder at commit cf49d47. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Flowing loads about 1.7k tokens when it runs, and up to ~3k if it reads all its reference files. Until then it costs about 250 tokens; SKILL.md has 675 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~250
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from oaustegard/claude-skills at commit cf49d47, republished under its MIT licence (© oaustegard). 675 words, ~1,739 tokens.

Download SKILL.mdSave it as .claude/skills/flowing/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
flowing
description
Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past. Use for "run these steps in order and retry the flaky one until the check passes", "build a pipeline that fetches, validates, then skips the upload when nothing changed", "make sure these steps cannot be skipped", "resume from where it broke instead of redoing the expensive early stages", "run these independent calls at once and merge the results", or any procedure of 3+ steps with branches, input contracts, or side effects that must not block the critical path. Primitives are depends_on, when=, validate=, retry_until=, detached= and journal_path=. Not for a single sequential call, for steps needing reasoning between them that no predicate captures, or for async and distributed work. To audit whether one verification check can actually go red, use gating. To fan work out across many subagents, use a dynamic workflow.
metadata.version
1.5.0

NOT SUPERSEDED BY DYNAMIC WORKFLOWS — read first

Claude Code's dynamic workflows orchestrate subagents (separate contexts, fan-out to 16-concurrent / 1000-agent). This skill is a different primitive: single-context control flow over YOUR OWN tool calls, with durable side-effects and checkpoint resume. The workflows runtime explicitly cannot touch the filesystem or shell directly — its agents do the work and the script only coordinates them. Flowing is the inverse: the script does the work.

Use flowing for an in-context pipeline (3+ steps, branches, retries, validation, detached side-effects). Use a workflow when you need many subagents. They compose; they do not compete. Do not abandon flowing for a workflow — you would lose the durable side-effects and the cross-session checkpoint that hub-spoke depends on.

Flowing — Control Flow in Code, Not Prose

When a procedure needs 3+ steps with branches, retries, or contracts, encode it as a DAG of Python tasks instead of prose imperatives. Prose like "first X, then Y, then if Z retry 3×" is read and generated past. A @task graph is structural: a step physically cannot run until its inputs are bound, and gates that fire on bad inputs can't be skipped.

The runner owns control flow — branching, retrying, validating, propagating failures, parallelizing. You provide judgment at the leaves. Runner: scripts/flowing.py.

Quick Start

python
from flowing import task, Flow

@task
def fetch_data():
    return {"items": [1, 2, 3]}

@task(depends_on=[fetch_data])
def process(fetch_data):          # param name must match the dep's name
    return sum(fetch_data["items"])

@task(depends_on=[process])
def store(process):
    print(f"Result: {process}")

Flow(store).run()                 # topo-sorts, runs each layer, parallel within a layer

Each task receives its dependencies as kwargs named after them. Independent tasks in the same layer run in parallel.

Control-Flow Primitives

Encode branches and contracts as graph structure, not if statements inside task bodies.

when= — conditional gate

Run the task only if the predicate (over gathered dep values) is truthy. Falsy → SKIPPED, and the skip propagates to dependents.

python
@task(depends_on=[fetch], when=lambda fetch: fetch["needs_processing"])
def process(fetch):
    return transform(fetch["payload"])
validate= — edge contract

Check gathered dep values before the body runs. Raise → FAILED with no retry (bad inputs don't fix themselves). Pass → proceed.

python
def must_have_items(fetch):
    if not fetch.get("items"):
        raise ValueError("fetch returned empty payload")

@task(depends_on=[fetch], validate=must_have_items)
def process(fetch):
    return sum(fetch["items"])
retry_until= — predicate-driven loop

Run the body, then call retry_until(value). True → done. False → retry, consuming the retry= budget. Use for self-correcting LLM steps: generate, check, regenerate.

python
@task(retry=4, retry_until=lambda r: r["valid"])
def generate_until_valid():
    candidate = llm_call(...)
    return {"valid": passes_schema(candidate), "candidate": candidate}

Distinct from retry= alone, which only retries on a raised exception.

Show full SKILL.md (348 more words)Show less

Other capabilities

  • Parallel execution — independent tasks in a layer run on a thread pool (max_workers=).
  • detached=True — side-effect tasks (memory writes, notifications) that run after the main DAG and never block it on failure.
  • In-process resume — flow.run() → fix → flow.resume() re-runs from the failure point, keeping succeeded tasks cached in memory (same process only). flow.override(task, value) injects a corrected result.
  • Durable journal (journal_path=) — opt-in content-addressed replay that survives container death. Flow(term, journal_path="/path/run.jsonl").run() appends each succeeded task's result to an append-only JSONL keyed by a step_key = SHA-256 over the task's bytecode + its when/validate/retry_until bodies + its dependencies' keys (chained, so an upstream change propagates downstream). A later run() — even in a fresh container — replays the unchanged prefix from the journal and only executes tasks whose key is absent; editing a task body busts its key and re-runs it and its dependents, while cosmetic knobs (retry=, timeout_s=, name) do not. This is the cross-session checkpoint hub-spoke work relies on. Caveat: results are pickled, so non-picklable return values simply re-run; closure-captured values are not part of the key (only the task body's own code is).
  • timeout_s=, retry= with exponential backoff, fail_fast=.

Read references/reference.md before using anything beyond the quick start and the three primitives above — it covers every @task parameter, the Flow methods, resume/override, detached auto-discovery, and the validate=/when= signature-matching gotcha.

When to use

  • A procedure has branches that matter → when= makes them structural.
  • Steps have input contracts → validate= makes them enforceable.
  • An LLM step needs to converge → retry_until= puts the check in the loop.
  • 3+ independent operations that can parallelize.
  • Multi-step pipelines where late failures shouldn't waste early work.
  • Side-effects that shouldn't block the critical path → detached=True.

When NOT to use

  • A single sequential operation — just call the function.
  • The next step needs reasoning about the prior result that can't be a predicate — use a think loop.
  • Async or distributed workflows — this is single-container, thread-pool based.

Authoring discipline

If you find yourself writing prose like "first call X, validate Y, then if Z retry up to 3 times" — that is a flowing graph. Refactor before shipping. Prose imperatives don't enforce; @task graphs do.

© oaustegard, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in flowing of oaustegard/claude-skills.

  • SKILL.md
  • CHANGELOG.md
  • README.md
  • references/reference.md
  • scripts/flowing.py
  • tests/test_flowing.py

Open the folder on GitHubat commit cf49d47

Compare with similar skills

Flowing next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Flowing compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Flowing this skilloaustegard/claude-skills150—~1.7kAutomated safety check: PassMIT
Claude Statusbarleeguooooo/claude-code-usage-bar378—~2.5kAutomated safety check: PassMIT
Migrating Claude Agent SDK To Pydantic AIpydantic/pydantic-ai20k—~1.6kAutomated safety check: PassMIT
Extracting Requirementsprime-radiant-inc/iterative-development181—~2.7kAutomated safety check: PassApache-2.0
Security Status Reportagent-substrate/substrate4.6k—~524Automated safety check: PassApache-2.0
agystack Runtime Setupjtaroreh/agystack109—~1.7kAutomated safety check: PassMIT

Similar skills

  • Claude Statusbar

    leeguooooo/claude-code-usage-bar

    Manage cs (claude-statusbar) — switch theme/style/density, override severity colors, preview combinations, run doctor, reset config, install, upgrade (cs upgrade — the only supported upgrade path)…

    378 GitHub stars~2.5k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Official

    Migrate Python applications from the Claude Agent SDK to Pydantic AI and, only when needed, Pydantic AI Harness.

    20k GitHub stars~1.6k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Extracting Requirements

    prime-radiant-inc/iterative-development

    Reads human-written spec documents and produces per-epic requirement files with proof obligations plus behavior scenarios with stable IDs, using parallel chunked extraction.

    181 GitHub stars~2.7k tokensUpdated 4 mo ago
    Agent WorkflowsAuto-check passed
  • Security Status Report

    agent-substrate/substrate

    Generates a security status report based on docs/threats.json by spinning up sub-agents for each threat to compute a quality score.

    4.6k GitHub stars~524 tokensUpdated today
    Agent WorkflowsAuto-check passed
  • agystack Runtime Setup

    jtaroreh/agystack

    Configures agystack's model tiers per role and its execution runtime, choosing between local subagents and Cloud Run jobs for large parallel swarms.

    109 GitHub stars~1.7k tokensUpdated 7 days ago
    Agent WorkflowsAuto-check passed
  • Subagent-Driven Development

    HoangNguyen0403/agent-skills-standard

    Runs a multi-task implementation plan by sending each task to a fresh implementer subagent, reviewing it independently, then reviewing the whole branch.

    571 GitHub stars~1.3k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from oaustegard/claude-skills

All 66 skills in this repo
  • Vega-Lite Interactive Charts

    oaustegard/claude-skills

    Builds interactive Vega-Lite charts from uploaded data: analyzes the fields, picks five to ten fitting chart types, and produces a React artifact with the data embedded inline.

    150 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Single-File HTML Composer

    oaustegard/claude-skills

    Builds self-contained single-file HTML pages such as reports, decks, postmortems, flowcharts and prototypes from a small spec using a bundled Python composer and templates.

    150 GitHub stars~3.2k tokensUpdated today
    Auto-check passed
  • Declauding

    oaustegard/claude-skills

    Rewrites model-sounding prose into plain technical writing and checks that every claim survives, for PR text, docs, commit messages and similar drafts.

    150 GitHub stars~5.2k tokensUpdated today
    Auto-check passed
  • Preact Developer

    oaustegard/claude-skills

    Guides building standards-based Preact apps with native-first choices, HTM syntax, import maps and vendored ESM, from single-file demos to larger builds.

    150 GitHub stars~4.6k tokensUpdated today
    Auto-check passed
  • Bluesky Zeitgeist Sampler

    oaustegard/claude-skills

    Deprecated sampler that captures short windows of the Bluesky firehose, clusters trending terms and builds an HTML report; replaced by the browsing-bluesky skill.

    150 GitHub stars~1.4k tokensUpdated today
    Auto-check passed
  • Adversarial Review Before Shipping

    oaustegard/claude-skills

    Has a fresh-context adversary attack a blog post, recommendation, analysis brief or piece of code before you ship it, using a profile suited to that kind of artifact.

    150 GitHub stars~3.4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Flowing

What does Flowing do?

Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past. Flowing is an agent skill from oaustegard/claude-skills. Runs a multi-step procedure as a Python DAG, so ordering, branching and retries are enforced by the runner rather than described in prose a model can generate past.

When should I use Flowing?

Flowing fits situations like: run these steps in order and retry the flaky one until the check passes; build a pipeline that fetches; then skips the upload when nothing changed; make sure these steps cannot be skipped.

How do I install Flowing in Claude Code?

Run `npx skills add oaustegard/claude-skills --skill flowing -a claude-code`. Or copy the skill folder (flowing in oaustegard/claude-skills) into .claude/skills/flowing in your project. Claude Code loads it when a task matches its description.

How do I install Flowing in Codex?

Run `npx skills add oaustegard/claude-skills --skill flowing -a codex`. Or copy the skill folder (flowing in oaustegard/claude-skills) into .agents/skills/flowing in your project. Codex loads it when a task matches its description.

Can I use Flowing in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add oaustegard/claude-skills --skill flowing -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/flowing, .gemini/skills/flowing, .github/skills/flowing and .opencode/skills/flowing in your project.

What does Flowing need to run?

Going by SKILL.md and its folder, Flowing needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Flowing access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Flowing safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Flowing use?

Flowing is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Flowing use?

About 1.7k tokens (SKILL.md is roughly 7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.3k tokens, read only when the agent opens those files.

What are the alternatives to Flowing?

Skills that share tags, products or a category with Flowing: Claude Statusbar (leeguooooo/claude-code-usage-bar, 378 stars), Migrating Claude Agent SDK To Pydantic AI (pydantic/pydantic-ai, 20k stars), Extracting Requirements (prime-radiant-inc/iterative-development, 181 stars) and Security Status Report (agent-substrate/substrate, 4.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Flowing?

oaustegard (a GitHub user) maintains it in oaustegard/claude-skills, which has 150 GitHub stars. The repository holds 66 skills in this directory. The repository was last updated on October 8, 2026.

Source: oaustegard/claude-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.