Interview Me
addyosmani/agent-skills
Asks one question at a time, each with a best guess attached, until the agent is about 95 percent sure what you really want, before any plan, spec or code.
Creates a structured task-by-task implementation plan for a gflow-cli feature.
Install Plan
$ npx skills add ffroliva/gflow-cli --skill plan -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install ffroliva/gflow-cli plan --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/plan .claude/skills/plan && rm -rf skills-srcUse ~/.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/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .claude/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/ffroliva/gflow-cli/tree/develop/skills/planType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add ffroliva/gflow-cli --skill plan -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install ffroliva/gflow-cli plan --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/plan .agents/skills/plan && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .agents/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add ffroliva/gflow-cli --skill plan -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install ffroliva/gflow-cli plan --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/plan .cursor/skills/plan && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .cursor/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/ffroliva/gflow-cli.git --path skills/plan--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add ffroliva/gflow-cli --skill plan -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install ffroliva/gflow-cli plan --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/plan .gemini/skills/plan && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .gemini/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install ffroliva/gflow-cli planInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add ffroliva/gflow-cli --skill plan -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/plan .github/skills/plan && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .github/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add ffroliva/gflow-cli --skill plan -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install ffroliva/gflow-cli plan --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ffroliva/gflow-cli.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/plan .opencode/skills/plan && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/ffroliva/gflow-cli/tree/develop/skills/plan into .opencode/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
plan- GitHub stars
- 264
- Token cost
- ~2k tokens
- SKILL.md length
- 687 words
- Files
- 1
- Skills in repo
- 17
- Repo updated
- First seen
- Licence
- MIT
At a glance
Creates a structured task-by-task implementation plan for a gflow-cli feature.
- Works in 5 steps: Gather inputs from context → Ask clarifying questions (only if not… → Decompose into tasks → …
- Tasks that involve Requirements gathering
- SKILL.md covers When to invoke, When not to invoke, Protocol and Output example (header only), plus 1 more section
- Calls uv and git
What it does
Plan is an agent skill from ffroliva/gflow-cli. Creates a structured task-by-task implementation plan for a gflow-cli feature. Gathers predict/scenario context, asks ≤3 clarifying questions, decomposes the feature into atomic committable tasks with step and test checklists, and writes docs/superpowers/plans/<YYYY-MM-DD-<slug/PLAN.md. Invoke after /gflow:predict returns GO or CAUTION and /gflow:scenario output is available.
Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Agent Workflows, covering Requirements gathering, Planning and AI video generation. The repository describes itself as: Drive Google Flow from the command line: Veo video and Imagen images, scripted, batched and pipeline-ready. Ships an MCP server so coding agents can drive it too, giving you and… The licence is MIT.
When your agent uses it
- Tasks that involve Requirements gathering
- Tasks that involve Planning
- Tasks that involve AI video generation
Example prompts
- “Use the plan skill to create a structured task-by-task implementation plan for a gflow-cli feature”
- “/plan”
Requirements
- Python 3
Workflow steps
5 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit cb6d501. 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
Shell commands in SKILL.md call:
uvgit
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use uv and git, which can reach the network depending on how they are called.
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
Plan loads about 2k tokens when it runs. Until then it costs about 96 tokens; SKILL.md has 687 words of instructions outside code blocks.
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); files beside SKILL.md are not scanned.
SKILL.md
The full file from ffroliva/gflow-cli at commit cb6d501, republished under its MIT licence (© ffroliva). 687 words, ~1,995 tokens.
Download SKILL.mdSave it as
.claude/skills/plan/SKILL.md (or your agent's skills folder).- name
- plan
- description
- Creates a structured task-by-task implementation plan for a gflow-cli feature. Gathers predict/scenario context, asks ≤3 clarifying questions, decomposes the feature into atomic committable tasks with step and test checklists, and writes docs/superpowers/plans/<YYYY-MM-DD>-<slug>/PLAN.md. Invoke after /gflow:predict returns GO or CAUTION and /gflow:scenario output is available.
- version
- 1.0
plan — Feature Plan Creator
Turns a feature description into a task-by-task implementation plan and writes it
to docs/superpowers/plans/<YYYY-MM-DD>-<feature-slug>/PLAN.md.
Position in the gflow-cli workflow:
/gflow:predict <proposal> → GO / CAUTION / STOP verdict
/gflow:scenario <feature> → edge cases + BDD skeleton
/gflow:plan <feature> → writes the task checklist ← this skill
/gflow:status → surfaces next task during execution
/gflow:check → before each commitWhen to invoke
- After
/gflow:predictreturns GO or CAUTION - When a backlog item in
PLAN.mdneeds a concrete task breakdown before starting work - Any feature larger than a single isolated file change
When not to invoke
- Simple bug fixes (< 10 lines, no boundary crossing) — go straight to the fix
- Pure doc changes
- A task already fully specified in a superpowers plan — use
/gflow:statusto find it
Protocol
Phase 1 — Gather inputs from context
From /gflow:predict output in context (do not ask if already present):
- Verdict (GO / CAUTION) and confidence score
- Architectural constraints and module placement
- Security risks and mandatory mitigations
- Devil's Advocate simplifications or sequencing blockers
From /gflow:scenario output in context (do not ask if already present):
- Critical and High scenarios → these become must-cover tests in the task checklist
- BDD
Scenario:blocks → seeds the BDD scaffold task
From the feature description passed to this skill:
- Feature name → derive a slug (lowercase, hyphen-separated, no dates)
- Stated goal (one sentence)
From the repo — run once:
uv run python scripts/dev/active_plan.pyNote the active phase name and its open tasks. Then read PLAN.md § "Phase status" and § "Decision log" directly to verify the proposed feature is within current scope and does not contradict an existing ADR. (The script shows the current task, not a backlog index — use PLAN.md for scope confirmation.)
Phase 2 — Ask clarifying questions (only if not answerable from context)
Ask at most 3. Focus on decisions that materially change the task breakdown:
- Scope boundary — what is explicitly out of scope for this plan?
- Module ownership — which existing module does this extend, or is a new module justified?
- Acceptance criteria — what does "done" look like from the user's perspective (command output, exit code, log event)?
Skip any question already answered by predict/scenario output or the feature description.
Show full SKILL.md (371 more words)Show less
Phase 3 — Decompose into tasks
Task rules:
- Each task must be independently committable as one atomic
git commit. - Test scaffold tasks (red tests, BDD skeleton) come before the code that makes them green.
- Tasks that create new files come before tasks that modify callers.
- Derive test requirements from scenario output: Critical → must-cover (
- [ ]), High → should-cover. - Every task lists: what it does, which files change, step checklist, test checklist.
Typical task order for a gflow-cli feature:
| # | Task | Notes |
|---|---|---|
| 1 | Unit test scaffold | Red tests only. No production code. |
| 2 | BDD scaffold | Red BDD scenarios. No production code. |
| 3 | Core implementation | Domain objects / value types / parsers. |
| 4 | Transport / API layer | FlowApiClient or UiAutomationTransport changes. |
| 5 | CLI surface | cli_*.py + Click commands + --help text. |
| 6 | MCP surface mirror | Never optional when task 5 exists. mcp/tools.py signature + docstring claims, the queued-path payload keys in worker/codec.py, tests/mcp/test_cli_parity.py for a new leaf. |
| 7 | Docs update | USAGE.md, CONFIGURATION.md (new env vars), docs/MCP.md, KNOWN_ISSUES.md if relevant. |
| 8 | Full gates + release prep | /gflow:check green; CHANGELOG updated. |
Adjust: not every task applies to every feature. Merge or split tasks as the scope demands —
except task 6. If the plan has a task 5, it has a task 6, because gflow ships every
capability twice and the automated gates cannot see the two drifting apart. A plan that
touches the CLI and has no MCP task is incomplete, not lean. The mirror axes are enumerated
once, in skills/check/SKILL.md step 1b; cite them, do not copy them.
Phase 4 — Draft the plan and show it to the user
Produce the full PLAN.md content using this schema:
# <Feature Display Name> Implementation Plan
> **For agentic workers:** Run `/gflow:status --feature <slug>` to find the next
> unchecked task. Implement one task at a time. Run `/gflow:check` before every commit.
**Goal:** <one sentence — the user-visible outcome>
**Architecture:** <2–3 sentences — which modules change, key design decisions, what stays the same>
**Predict verdict:** <GO / CAUTION — confidence N/10> (or "pending — run /gflow:predict first")
**Risk register:**
| Severity | Risk | Mitigation |
|---|---|---|
| (from predict output) | | |
---
## File structure
### New files
\`\`\`
src/gflow_cli/<module>.py
<one-line description>
tests/<module>/test_<module>.py
<one-line description>
\`\`\`
### Modified files
\`\`\`
src/gflow_cli/<existing>.py
<what changes>
\`\`\`
---
## Task 1 — <name> (test scaffold)
**What:** <one sentence>
**Files:**
- `tests/...` — <description>
**Steps:**
- [ ] <step>
**Tests created (red):**
- [ ] <test name> — <what it asserts>
---
## Task 2 — ...
(repeat for each task)
---
## Definition of done
- [ ] All task steps checked off
- [ ] `/gflow:check` green (ruff / format / pyright / pytest ≥ 80% coverage)
- [ ] `CHANGELOG.md` `[Unreleased]` section updated
- [ ] Docs updated (`USAGE.md` / `CONFIGURATION.md` as applicable)
- [ ] BDD feature file covers all Critical + High scenarios from `/gflow:scenario`
- [ ] No `# TODO` in diff without a tracked issue linkShow the drafted plan to the user. If they approve (or say "write it"), proceed to Phase 5.
Phase 5 — Write the file
mkdir -p docs/superpowers/plans/<YYYY-MM-DD>-<slug>Write the plan to docs/superpowers/plans/<YYYY-MM-DD>-<slug>/PLAN.md.
Confirm with:
Plan written to
docs/superpowers/plans/<YYYY-MM-DD>-<slug>/PLAN.md. Run/gflow:status --feature <slug>to start working on it.
Output example (header only)
# Batch Manifest Ledger Implementation Plan
> **For agentic workers:** Run `/gflow:status --feature batch-manifest-ledger` to
> find the next unchecked task. Implement one task at a time. Run `/gflow:check`
> before every commit.
**Goal:** Add a local SQLite ledger to `gflow video batch` so interrupted runs skip
already-completed items on resume.
**Predict verdict:** GO — confidence 8/10
**Risk register:**
| Severity | Risk | Mitigation |
|---|---|---|
| High | Schema migration on user's existing DB | Checksummed migration runner (already in data/) |
| Medium | Ledger path drift between runs | Normalize to absolute path at record time |Integration & Pipeline Continuation (Next Step Handoff)
- Claude Code: invoke via
/gflow:plan <feature>(thin wrapper around this skill). - Cursor / Aider / Codex: paste this file into your context and call
plan <feature>. - Antigravity (
agy): include in system context before asking for a plan. - Next step: Upon completing and user-approving
PLAN.md, proactively announce: "Implementation Plan approved. Next step: Phase 6 Task Execution (/gflow:status --feature <slug>)."
© ffroliva, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
Just SKILL.md in skills/plan of ffroliva/gflow-cli.
Open the folder on GitHubat commit cb6d501
Compare with similar skills
Plan 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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Plan this skillffroliva/gflow-cli | 264 | — | ~2k | Automated safety check: Pass | MIT | |
| Interview Meaddyosmani/agent-skills | 103k | 6 repos | ~3.8k | Automated safety check: Pass | MIT | |
| Brainstorming Before BuildingjnMetaCode/superpowers-zh | 8.3k | — | ~1.8k | Automated safety check: Pass | MIT | |
| ULW Plan Workflowcode-yeongyu/oh-my-openagent | 70k | — | ~3.9k | Automated safety check: Pass | Custom licence | |
| CE BrainstormEveryInc/compound-engineering-plugin | 25k | — | ~1.9k | Automated safety check: Pass | MIT | |
| Ask NavigatorYeachan-Heo/oh-my-claudecode | 40k | — | ~4.1k | Automated safety check: Pass | MIT |
Similar skills
Brainstorming Before Building
jnMetaCode/superpowers-zh
Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.
ULW Plan Workflow
code-yeongyu/oh-my-openagent
Explore-first planning that turns a vague or large request into one decision-complete work plan, written only after your approval and executed by a separate worker.
CE Brainstorm
EveryInc/compound-engineering-plugin
Turns a vague or ambitious feature idea into a requirements-only plan through dialogue with you, sized to the work, before any code is written.
Ask Navigator
Yeachan-Heo/oh-my-claudecode
Charts a foggy effort into a map of decision tickets on the repo's issue tracker and works through them one per session, producing decisions rather than deliverables.
Grill With UI
jasonku09/grill-with-ui
Moves a design-grilling interview from the terminal to a local web page, where each question, recommendation and discussion thread can be handled in any order.
More from ffroliva/gflow-cli
All 17 skills in this repoGflow CLI
ffroliva/gflow-cli
A skill your agent uses when the user wants to drive Google Flow (Veo image-to-video, Veo text-to-video, Imagen / Nano Banana image generation) from the terminal or a script — including…
Issue Assessment
ffroliva/gflow-cli
A skill your agent uses when triaging a GitHub issue for gflow-cli — a reporter's bug claim, a freshly-filed issue, or deciding whether and how to act on one.
Issue Resolve
ffroliva/gflow-cli
A skill your agent uses when an assessed gflow-cli issue (verdict CONFIRMED-BUG or LIKELY-BUG) has localized, verifiable scope and should be driven to a fix.
Live Verify
ffroliva/gflow-cli
Two-part gate for gflow-cli feature/fix work. An agent skill from ffroliva/gflow-cli.
Video Production
ffroliva/gflow-cli
A skill your agent uses when the user wants a finished video out of gflow rather than a single clip — a scripted scene, a talking-head or dialogue piece, an explainer, a product montage, a story…
Check
ffroliva/gflow-cli
Auto-fix lint and formatting, then report types and tests. An agent skill from ffroliva/gflow-cli.
Related
Categories
Questions about Plan
What does Plan do?
Creates a structured task-by-task implementation plan for a gflow-cli feature. Plan is an agent skill from ffroliva/gflow-cli. Creates a structured task-by-task implementation plan for a gflow-cli feature.
When should I use Plan?
Plan fits situations like: tasks that involve Requirements gathering; tasks that involve Planning; tasks that involve AI video generation.
How do I install Plan in Claude Code?
Run `npx skills add ffroliva/gflow-cli --skill plan -a claude-code`. Or copy the skill folder (skills/plan in ffroliva/gflow-cli) into .claude/skills/plan in your project. Claude Code loads it when a task matches its description.
How do I install Plan in Codex?
Run `npx skills add ffroliva/gflow-cli --skill plan -a codex`. Or copy the skill folder (skills/plan in ffroliva/gflow-cli) into .agents/skills/plan in your project. Codex loads it when a task matches its description.
Can I use Plan 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 ffroliva/gflow-cli --skill plan -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/plan, .gemini/skills/plan, .github/skills/plan and .opencode/skills/plan in your project.
What does Plan need to run?
Going by SKILL.md and its folder, Plan needs the command-line tools its instructions call (uv and git). Our summary lists: Python 3.
Does Plan access the network?
SKILL.md contains no URLs. Its commands use uv and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
Is Plan 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. Review the folder before installing.
What licence does Plan use?
Plan 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 Plan use?
About 2k tokens (SKILL.md is roughly 8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Plan?
Skills that share tags, products or a category with Plan: Interview Me (addyosmani/agent-skills, 103k stars), Brainstorming Before Building (jnMetaCode/superpowers-zh, 8.3k stars), ULW Plan Workflow (code-yeongyu/oh-my-openagent, 70k stars) and CE Brainstorm (EveryInc/compound-engineering-plugin, 25k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Plan?
ffroliva (a GitHub user) maintains it in ffroliva/gflow-cli, which has 264 GitHub stars. The repository holds 17 skills in this directory. The repository was last updated on October 7, 2026.
Source: ffroliva/gflow-cli on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.