Skip to content
Skills Library
AI & agents · Planning

flowstate-delegate

/flowstate-delegate

Use when choosing which model, effort level, or subagent should do a Flowstate task, before delegating work, escalating a stuck problem, or spending on a review.

Repository
flowstate ↗
Licence
MIT
Last repository change
23.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when choosing which model, effort level, or subagent should do a Flowstate task, before delegating work, escalating a stuck problem, or spending on a review.

Original author description

Use when choosing which model, effort level, or subagent should do a Flowstate task, before delegating work, escalating a stuck problem, or spending on a review.

How it works

  1. Pick the model
  2. Pick the effort
  3. Keep context cheap
  4. Brief the subagent
  5. Review by risk
Original SKILL.md headings · 77 lines, 640 words
SKILL.md preview
---
name: flowstate-delegate
description: Use when choosing which model, effort level, or subagent should do a Flowstate task, before delegating work, escalating a stuck problem, or spending on a review.
---

# Delegating by model and effort

Spend follows the cost of being wrong, not the size of the task. Every turn
resends the conversation, and a subagent pays for its own tokens, so
delegating saves money only when the work is read-heavy or output-light, or
when it keeps bulk output out of the lead's context.

## Pick the model

| Work | Model |
| --- | --- |
| Lookups, "where is this defined", CI and log triage (`flowstate-scout`) | Haiku |
| A well-scoped slice with a runnable check, tests, verification, review | Sonnet |
| Planning, multi-file design, final judgment, any `AGENTS.md` invariant | Opus (the lead) |
| A design fork with no precedent, or a problem Opus has failed twice | Fable, as an advisor |

- The lead is Opus. A Sonnet lead suits a thread whose spec and proving
  command are already written. Choose the lead at session start: switching it
  mid-session breaks the prompt cache, while changing effort does not.
  Subagents are separate contexts, so their model costs the lead nothing.
- A subagent's model comes from its definition: `flowstate-scout` is Haiku,
  `flowstate-verifier`, `flowstate-pr-tidy` and `flowstate-reviewer` are
  Sonnet. Override one call with the Agent tool's `model` parameter.
- Escalate on evidence: when Opus fails the same problem twice, ask Fable once
  with the question, the evidence, and the options already ruled out, then
  return to Opus. Fable advises on a fork; it does not draft or implement.
- Keep code edits on the model that holds the design. Hand a cheaper model an
  edit only when the spec is written and a command proves it.
- When a cheaper model fails a kind of task, move that kind up a tier.

## Pick the effort

Medium is the default for the lead; raise it to high for work on an invariant
and for verification of edge cases. Effort fixes missed edge cases, not a wrong
approach: a wrong approach calls for a better spec or a higher tier. Each
subagent role carries its own model and effort, pinned in its definition:

| Role | Model | Effort |
| --- | --- | --- |
| `flowstate-scout` | haiku | low |
| `flowstate-verifier` | sonnet | low |
| `flowstate-pr-tidy` | sonnet | low |
| `flowstate-reviewer` | sonnet | high |

The reviewer runs high because thoroughness is the product and its report is
small.

## Keep context cheap

Every turn resends the thread, so the long thread is the real cost. One
thread per pull request, `/clear` between tasks, compact at a milestone, and
push logs, test output, and review reading into subagents so only the
conclusion returns.

## Brief the subagent

- State the goal, what is ruled out, the files that matter, and the command
  whose result proves the work. A subagent starts cold.
- Give a reviewer the diff, not your conclusion, and tell it to report only
  gaps that affect correctness or a stated requirement.
- Ask for a bounded report. A claim in it is a lead to check, not evidence:
  compare any revision it names with the real head.
- Do not run what you delegated, and do not fan out agents whose work
  overlaps; agent teams cost several times a single session.

## Review by risk

Every merge keeps its one exact-head review; risk sets the reviewer, never
whether it happens. Default `flowstate-reviewer` (Sonnet). A change to
authentication, policy, secrets, durability, tenancy, or egress runs it with
`model: opus` and `flowstate-security-review`, then an adversarial pass. A
docs or comment change is a short review, not a skipped one. Any push after a
review needs a verdict on the complete base-to-head diff of the new head; a
formatting or wording fix may be a short review concentrating on the change,
as `.agents/ship.md` describes.

Versions

The database has no other skills named flowstate-delegate.

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 3924fe924c0f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100model-routing
    Pick the Claude model, effort level and subagent for a task before delegating it. Use before any Agent/subagent call, when deciding whether to delegate, when a delegated result failed and needs escalating, when switching the main session's model, or when the user asks which model or effort to use.
  • 100flowstate-plugin-author
    Use when asked to write or change a Flowstate plugin (a task provider, the executable flowstate-plugin-<name>): decide if a plugin is needed, define the schema in Protobuf, test and rehearse it locally.
  • 95flowstate-verify
    Use when choosing, running, or reporting Flowstate verification (a bounded targeted test, the diff-scoped gate, or the full CI-parity rehearsal) before a handoff, a pull request, or a merge.
  • 95agent-routing
    Decide which model, effort level, and cascade shape each subagent gets, and how to keep improvement loops safe (evaluator-as-selector, stop on regression). Routes on measured cost-per-completed-task rather than per-token price, because a tier's token count varies more by task…
  • 100claude
    Use Claude Code as an independent `claude -p` subagent when the user explicitly asks for Claude, wants a second-agent opinion from Claude, or asks to delegate a well-scoped task to Claude. Supports selecting `--model` and thinking/effort level with defaults of the current `opus` alias and `high`.
  • 100model-routing
    Pick the cheapest Claude model and effort level that can do each task well, and set it up in Claude Code (/model, /effort, subagent model and effort, opusplan, CLAUDE.md routing rules). Use when splitting work across models or subagents, when usage limits or cost are a concern,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.