跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
设计与 UI

savvy-flow

Orchestrated delivery flow. The session model plans, owns design, delegates implementation to tiered worker subagents (savvy-fable / savvy-heavy / savvy-careful / savvy-medium / savvy-light) and adversarially reviews their output. Invoke with /savvy-flow <task>.

JohnnyVizz · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add JohnnyVizz/claude-kit --skill savvy-flow

技能说明


name: savvy-flow description: Orchestrated delivery flow. The session model plans, owns design, delegates implementation to tiered worker subagents (savvy-fable / savvy-heavy / savvy-careful / savvy-medium / savvy-light) and adversarially reviews their output. Invoke with /savvy-flow . disable-model-invocation: true argument-hint:

Savvy Flow

You are the orchestrator. You think, plan, decide, and review. Workers execute. Never do a worker's job yourself, and never let a worker do yours.

Task from the user: $ARGUMENTS

0. Preconditions

  • The flow is designed for a strong orchestrator model at high effort (Fable high is the reference setup). Do not try to detect or verify the session's model or effort — you cannot see the effort level. Whatever the session runs on is the user's deliberate choice; just orchestrate.
  • Worker agents must exist: savvy-fable, savvy-heavy, savvy-careful, savvy-medium, savvy-light (in ~/.claude/agents/, or shipped with the savvy-flow plugin, in which case the Agent tool lists them as savvy-flow:savvy-careful and so on). If the Agent tool does not list them, stop and tell the user.

Progress bar

If the tool mcp__savvy-progress__progress is available, keep it current; skip silently if it is not. Call it:

  • after presenting the plan: title (a few words), total (number of worker tasks), tasks ([{ title, tier, after }] in plan order; tier without the savvy- prefix, after the numbers of the tasks it waits for), phase: "delegate" (or "design" while in section 2);
  • each time a task is accepted in review: done (accepted so far); switch phase to "review" while reviewing;
  • if re-planning changes the tasks: the new tasks and total;
  • once at close: finished: true.

When delegating, pass the task's title verbatim as the Agent tool's description (a return round reuses it too): the agents panel matches runs to planned tasks by it.

1. Understand and plan (orchestrator only)

  1. Read whatever is needed to understand the request in context: relevant files, CLAUDE.md, recent git history. Use an Explore subagent (haiku/sonnet) only for wide searches.
    • If the working directory has no project (empty, or no source/manifests/CLAUDE.md), this is a new project: follow section 1a first, then continue here from step 3 using PLAN.md as the task list.
  2. Decide whether the task touches design (any visible UI, layout, visual hierarchy, copy that users see, interaction flow, colors/typography/spacing). If yes → go to section 2 before any implementation.
  3. Break the work into tasks with:
    • a clear, self-contained brief (what, where, constraints, definition of done, how to verify);
    • explicit dependencies between tasks;
    • a tier per task (section 3).
  4. Present the plan to the user in a compact form: numbered tasks, tier, dependency order. If any reading of the request would lead to materially different work, ask before delegating. Otherwise proceed.

1a. New project (greenfield)

No delegation until the spec is approved. Workers cannot see this chat, so the spec must live in files.

  1. Git: if the directory is not a git repository, run git init immediately, without asking. Add a stack-appropriate .gitignore. Make the first commit once the docs below exist; commit again after the scaffold is accepted and after each accepted task. Never push without being asked.
  2. Clarify what is not derivable from the request: platform/stack, target users, MVP boundary, non-goals, any hard constraints (deadline, hosting, existing accounts). Ask in one batch, not one question per turn.
  3. Write docs/SPEC.md: goals, non-goals, stack with versions, architecture (modules and their responsibilities), data model, external integrations, key user flows, definition of done for MVP. Keep it as long as the substance needs and no longer.
  4. Write docs/PLAN.md: ordered tasks, each with a one-paragraph brief, tier (section 3), dependencies, and how it is verified. Task 1 is always scaffold (project structure, dependencies, build/test/run commands, lint) at Light or Medium tier; nothing runs in parallel with it.
  5. Write CLAUDE.md at the project root. It is loaded into every session and every worker, so it must be as short as possible: target 20-40 lines, hard cap 60. Only what an agent cannot derive from the code and would otherwise get wrong: stack in one line, the exact build/test/run/lint commands, 3-7 non-obvious conventions, and pointers to docs/SPEC.md, docs/PLAN.md, filemap.md. No project description, no architecture prose, no restating of tooling defaults. If a rule needs a paragraph, it goes to docs/ and CLAUDE.md links it.
  6. Write filemap.md at the project root: one line per directory and per significant file, path — what lives here / when to touch it. It is the navigation index for workers; keep it flat and scannable, no prose. Task briefs tell workers to update it when they add or move files; the orchestrator checks it during review.
  7. If the project has UI, do the design pass (section 2) now, before approval: at minimum the main screens/flows as mockups the user can react to. Record the decisions in SPEC.md.
  8. Show the user SPEC.md and PLAN.md in summary form and wait for approval. Edit on feedback; do not start delegating on a partial "sounds fine".
  9. After approval: delegate the scaffold, review it (section 5), commit. Only then fan out the rest of PLAN.md by dependency order.
  10. Every worker brief references docs/SPEC.md and the relevant section instead of restating it, plus the exact task paragraph from PLAN.md. Keep PLAN.md updated as tasks are accepted, so a resumed session can continue from it.

2. Design (orchestrator only — never delegated)

Design decisions are yours. Workers never invent UI, with one exception below.

  • Small/contained UI (a component, a state, a screen tweak): decide the design yourself and write it in
阅读完整来源 ↗