agentleFS
kabo-shkabo-sh/kabo-mcp-plugin/skills/develop-content-ideas/SKILL.md

develop-content-ideas

Skill2 starsChanged 20 days agoMITView on GitHub

Generate one or more selectable content ideas, including candidate titles and hooks, from creator research, a stated topic or prior conversation. Use for next-topic directions, more ideas in the style of a selected earlier example, first topics for a new account, production-budget ideas or ideas from video comments. Not for a concrete next Reel draft, copy edits for an identified direction, competitor discovery or account comparisons.

The file

Show its rules and text

We split this skill into the rules it gives an agent

21 rules. About 0 are common, 8 are distinctive, and 13 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈8

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 13

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When the host supports one, run this Skill in a foreground sub-agent, because a run has several stages, and wait for its final result …

    line 15
  2. Distinctive:

    Choose delivery mode before prep: When the user asks to pick or briefly explain entries from a previously delivered validated list, read …

    line 20
  3. Very specific:

    Delivery: Read references/delivery.md.

    line 32
  4. Distinctive:

    Never replace file emission with a model-written copy.

    line 34
  5. Very specific:

    Before generating or delivering ideas, read references/personal-facts.md.

    line 46
  6. Distinctive:

    Use evidence for the same person and claim.

    line 48
  7. Distinctive:

    Deliver every part of the request: Before prep, list each deliverable the creator asked for in this message and in the request it answers: …

    line 51
  8. Distinctive:

    If no usable published source content is available, ask only for the missing script, source link or summary with the ending and stop this …

    line 72
  9. Very specific:

    Resolve follow-ups before generating: Read references/request-boundaries.md for selected examples, quantities, language changes and …

    line 78
  10. Very specific:

    Read references/prep.md whole before writing intent.json: it says where each kind of evidence comes from and its prep flag, how to choose …

    line 117
  11. Very specific:

    Read prep's status even on exit 0.

    line 138
  12. Very specific:

    Read references/batched-authoring.md.

    line 157
  13. Very specific:

    Put missing information into gates.selection_missing only when it prevents a valid choice.

    line 162
  14. Very specific:

    Put filming, editing, CTA, cadence, or other later details into gates.production_missing.

    line 163
  15. Very specific:

    Only after the batch receipt says ready_for_core, run the core stage once over the complete set (validate → render, or emit one aggregate …

    line 171
  16. Very specific:

    Read the script's structured stdout (stage, status, errors, revision_remaining) as well as its exit code.

    line 177
  17. Distinctive:

    If machine-readable JSON is requested, emit only the declared JSON object.

    line 187
  18. Very specific:

    After core returns status="ok" with actual ideas, export the final file:

    line 189
  19. Very specific:

    Follow references/delivery.md for curated requests, one emission retry and numbered follow-ups.

    line 197
  20. Very specific:

    Read references/idea-set-rules.md whole before writing idea_set.json.

    line 203
  21. Distinctive:

    Never invent numbers, URLs or metrics.

    line 206

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Develop Content Ideas

Turn validated upstream artifacts or an explicit topic into an IdeaSet of distinct, selectable ideas. The schemas, builders, validators and renderers ship in this Skill's references/ and scripts/.

When the host supports one, run this Skill in a foreground sub-agent, because a run has several stages, and wait for its final result before replying; never run it in the background and tell the user the report will come later. Without a foreground sub-agent, follow the same steps in the main thread.

Choose delivery mode before prep. When the user asks to pick or briefly explain entries from a previously delivered validated list, read that actual list, choose entries and write brief summaries; use scripts/render_selection.py as described in references/delivery.md to preserve their original numbers/titles and display that file. Stop there: do not rebuild an IdeaSet, rerank it, or run the new-generation stages below. For a numbered selection, reuse that exact entry; for a scoped edit, preserve its identity and untouched content. Only requests for new ideas or a new batch enter prep. Read references/delivery.md for these follow-up boundaries.

Finish the procedure before answering. Prep's ok means inputs are ready, not that ideas passed validation. Author every required candidate field, run core, use its one permitted revision, then export the final file. Read references/delivery-state.md before the first stage.

Delivery. Read references/delivery.md. Default to the complete validated list, exported by scripts/deliver_ideas.py and displayed unchanged using the file delivery procedure in that reference. Never replace file emission with a model-written copy. Only an explicit request to pick or briefly summarize permits a selection from that validated list. Keep the original candidate numbers. A failed/needs-revision result is not deliverable; repair within the existing budget or explain what could not be completed. If emission fails, retry once, then report the display failure.

Route by the requested deliverable: selectable topic directions stay here, including lists with candidate titles or hooks. A concrete next Reel draft or copy for an identified direction (title, opening, on-screen text or beat plan) belongs to create-script-and-packaging, even when the request includes an account or reference post. Neither an account link nor a performance adjective makes that creative request competitor research.

Before generating or delivering ideas, read references/personal-facts.md. The prohibition on invented numbers also covers personal experience and identity claims, including titles and hooks. Use evidence for the same person and claim; omit unsupported details or leave visible placeholders. Names found only in automatic transcripts remain role descriptions.

Deliver every part of the request. Before prep, list each deliverable the creator asked for in this message and in the request it answers: a short reply such as a platform name ("YouTube Shorts") completes an earlier request, it does not replace it, so user_brief.text keeps that earlier request. For "three ideas, then a script for the strongest", this Skill delivers the three ideas and names the strongest; the script is the next part (create-script-and-packaging), continued in the same turn. Record that next part in the intent as generation_basis.follow_on (deliverable: "script", quote: the creator's exact words asking for it, from user_brief.text). The export receipt then carries follow_on with the top-ranked idea: after emitting the list, load create-script-and-packaging and write that idea's complete script in the same turn, without asking the creator to choose first. Before the final reply, check the list and do not end with a part missing; if a part truly cannot be done now, say which and why.

Keep the creator's facts. Dates and relative days ("tomorrow" stays tomorrow), numbers, names, directions such as up or down and story events the creator gave are copied exactly into titles, hooks and directions. Do not add new factual premises about history, science, people, companies or events as if established; ask them as a question or leave them out.

Check the requested deliverable first. Continuing or completing an identified story, draft or published episode belongs to create-script-and-packaging, even when phrased as "how should I make part 2?"; it is not a request for a new batch of ideas. If the creator already supplied or confirmed the exact source link, packaging owns recovery of its content; do not ask for that link again. If no usable published source content is available, ask only for the missing script, source link or summary with the ending and stop this turn. Account reviews, titles and another series' characters cannot replace it. Do not start ideation or add story examples to that clarification. An already supplied selected draft can be continued through packaging without asking for it again. Requests for multiple new variations remain here.

Resolve follow-ups before generating. Read references/request-boundaries.md for selected examples, quantities, language changes and numbered follow-ups. Preserve a selected example's causal mechanism unless the user explicitly changes it; check every candidate, not only the batch introduction. A valid schema alone does not establish semantic consistency.

This Skill runs no research: it consumes validated research artifacts through upstream_sources[] and deterministic idea_context. user_brief.text preserves the user's request; it is not by itself proof that a usable topic exists. Never parse Creator-facing Markdown, search the web, use competitor outputs as hidden criteria, or infer a business domain or topic from a handle, account/display name, URL, platform or another Skill's description. Do not create a SelectedIdea until the creator explicitly chooses or edits an idea.

Running commands

<skill directory> is the folder holding this SKILL.md. Reserve exactly one run per request:

python3 '<skill directory>/scripts/static_host.py' init --workspace '<user-workspace>'

It prints the run directory (<run directory>, the --run-dir . the stage commands name). Every command that needs the run starts with cd '<run directory>' &&, exactly as written below, because hosts keep neither environment variables nor the working directory between commands. No step pauses and resumes, so no command takes --placed. Every command here is complete: do not probe scripts with --help or read their source. Quote paths and use grep rather than rg. Write intent.json and idea_set.json at the run root with a single-quoted heredoc or the host's file tool, and make model authorship and the one permitted revision between stage commands, never inside one.

A nonzero exit from a script ends the run (for core, see Core step 5), except prep's explicit invocation_error for an unreadable intent path as references/prep.md defines. Report terminal failures, and never reopen the run, repeat completed prep, reset the generation budget or start a replacement run. Do not write or claim a run-record status yourself. For ideas from a video's comments, read references/comment-evidence.md whole before the first call: it holds the calls, the save, fetch and persist commands, failure handling and the projection.

Declare the run. Right after the run directory is reserved, call the Kabo tool start_skill_run once with skill_id develop-content-ideas and run_id set to the last path segment of the run directory. It records the run once, so never call it again for the same run. If it fails with credits_exhausted, tell the user their credits are used up, give them the link in the error, and stop. If the tool is not available, continue without it.

Prep

Read references/prep.md whole before writing intent.json: it says where each kind of evidence comes from and its prep flag, how to choose task_intent and fill generation_basis, and how to handle each prep decision. Also read the fields and definitions for this task intent in references/idea-request.schema.json and references/idea-set.schema.json, and references/core-generation.md whole. In short:

  1. Copy each upstream JSON artifact into the run unchanged (cp); a trend or competitor report counts only with its *_idea_context.json projection. Never write a projection by hand.
  2. For a chat-only follow-up with no new literal topic or required external evidence, use prepare_conversation_inputs.py as Chat-only continuation inputs in references/prep.md specifies. It copies the selected visible messages and prepares valid request fields; do not hand-retype their JSON layout. For other requests, write intent.json (no upstream_sources, idea_context, continuation_context or conversation_context). For either route, run prep once with the artifact flags this run has. The chat route must include --conversation-context conversation-source.json as shown in references/prep.md; the command below is the base form for other inputs:

    cd '<run directory>' && python3 '<skill directory>/scripts/run_ideas_stages.py' prep --intent intent.json --run-dir .
  3. Read prep's status even on exit 0. needs_correction: fix every listed issue once and rerun the same prep. Then obey the decision exactly: blocked_missing_required_source (empty IdeaSet, validated by one core run), needs_selection_context (ask for a topic or evidence), or ready_for_generation (go to Core). Collection failure never authorizes brief fallback.

Core

Core starts only after prep reports ready_for_generation (prep opens stage_timing.json core.started_at at that moment). Author at most ten candidates per batch, using prep’s work plan and next command. The initial set takes ceil(idea_count / 10) authoring passes, followed by at most one aggregate revision only if final validation fails. These are not two model calls. Do not invent extra critique/rewrite loops. Record network, 5xx or truncation retries with --record-network-retry as references/core-generation.md says; they use no attempt.

  1. Apply explicit production constraints. Record only assets the user supplied or evidence shows are available. For "same style" or a numbered reference, lock the selected example's causal relationship and substitute only its open slots, keeping their kind and number. State this in overview.portfolio_logic; map every item's concrete input, progression and goal in making_direction. Follow Continuations for source binding and the per-item semantic check.
  2. Read references/batched-authoring.md. Write only the next planned batch, submit it with the batch command, then continue the returned next batch. Do not create the whole set in a single model response. While a batch returns status="awaiting_batches", the task is not finished: in the same turn, write the next batch-N.json and run its next_command. Ending the turn or telling the user a batch is still pending at that point is a failed run. The script assembles idea_set.json only after all batches exist. Author: distinct titles the Creator could publish, hooks, making direction, evidence basis, ranking, gates, and limitations. For an open batch, remove near-duplicates and rank by Creator fit, evidence strength, differentiation, timeliness, and realistic production cost. For variants of one selected example, preserve the shared scaffold and assess distinctness only in its variable slots, as above. A plain question or statement is sufficient for a title; keep teaching method detail in making_direction. Never invent loss amounts, customer outcomes, efficiency gains, market facts, policy facts, numbers, or URLs. Preserve artifact-level lineage in upstream_sources, context-level refs in source_context_refs, must_avoid as must_differ, and risk language. assets_used must stay within declared available_assets. For shortlist intents only, unconfirmed future required_assets are allowed with production_feasibility.status="requires_user_confirmation", explicit assumptions and a production_missing gate; never treat them as owned or used. Capacity plans require all resources to be available; exclusions still apply. Do not edit, patch, or replace the skill scripts, schemas, or validators; fix a rejected IdeaSet by revising only idea_set.json once.
  3. Put missing information into gates.selection_missing only when it prevents a valid choice. Put filming, editing, CTA, cadence, or other later details into gates.production_missing; these may coexist with ready_for_selection. If production_missing is nonempty, include answer_production_question in interaction.next_actions alongside the selection action; do not make later production details block topic selection. Match the request's Hook count in every item: one opening means hook_preview.progressive_line=null; two means a nonempty, distinct second line. Do not use an empty string for null. For chat-only continuations, both the set and per-item source_context_refs=[]; the conversation is bound separately, not as research evidence.
  4. Only after the batch receipt says ready_for_core, run the core stage once over the complete set (validate → render, or emit one aggregate revision brief):

    cd '<run directory>' && python3 '<skill directory>/scripts/run_ideas_stages.py' core --run-dir .
  5. Read the script's structured stdout (stage, status, errors, revision_remaining) as well as its exit code. Both ok and recoverable needs_revision exit 0; the latter keeps the run open but does not validate or render a deliverable.
    • status="ok" with report paths (exit 0): run step 7, then deliver. The --concise output is the sole Creator-facing artifact: RESULT.md. The --full output is an audit-only artifact; keep IDEA_REPORT_FULL.md in the run directory and never deliver it or copy it to RESULT.md.
    • status="needs_revision" with revision_remaining=1 (exit 0, unvalidated): do not rewrite idea_set.json. Write revision.json ({"edits": [{"idea_id", "path", "value" | "delete": true}]}, one edit per error_details entry) into the run directory and run the returned revise_command; it applies only those fields, reads them back and dry-runs validation without using a core attempt. Repeat revise until it returns ready_for_core, then run the same core command once. Do not rerun prep, resubmit batches, reset the attempt counter, use run_code on run files, or replace this runnable revision with an unvalidated prose answer.
    • status="not_met" (exit 3): stop; do not start another creative pass or loosen validation.
    • status="failed", absent/unreadable script status, or an unavailable execution tool: diagnose the specific failure. Do not infer successful validation or permission for another creative pass. If recovery cannot complete, say the draft is unvalidated rather than presenting it as the completed skill result.
  6. If machine-readable JSON is requested, emit only the declared JSON object. Creator-facing Markdown is a renderer projection and must not be appended to strict JSON.
  7. After core returns status="ok" with actual ideas, export the final file:

    python3 '<skill directory>/scripts/deliver_ideas.py' --run-dir '<run directory>'

    Require status="validated", then display the returned file using the exact path-based call in references/delivery.md. Follow references/delivery.md for curated requests, one emission retry and numbered follow-ups. needs_revision, not_met and failures never permit a final list. A validated terminal gate with no ideas is only a missing-input clarification. IDEA_REPORT_FULL.md remains audit-only.

Judgment rules

Read references/idea-set-rules.md whole before writing idea_set.json; it holds the per-intent contract and ranking rules. In short:

  • Never invent numbers, URLs or metrics; exact numbers trace to evidence.
  • source_backed only when upstream/context refs and evidence refs are present; otherwise brief_based or hypothesis. why_now is evidence-backed only when a dated source supports it.
  • A request for account performance, trends, competitors, Creator context or a specific video never silently becomes brief-only: without the evidence and without explicit fallback, return the missing-source block without ideas. An account review bound from this conversation counts as the account evidence; no review anywhere means producing one first (references/prep.md).
  • selection_status remains candidate until the user selects an idea.

Report language and conversation context

Set report_language on both IdeaRequest and IdeaSet to the language of the final report (BCP 47), separate from language_targets; read references/report-language.md whole before writing idea_set.json. Before asking for a topic, audience, goal or evidence, reuse the conversation up to the current turn. Follow Continuations in references/core-generation.md to pass an earlier IdeaSet or exact visible chat through prep, while keeping the current request unchanged. An account review delivered earlier in this conversation (standard or deep) is the account basis for "ideas based on the review": when its account_review.json is not in this workspace, bind the visible review with Account review from this conversation in references/prep.md instead of returning the missing-source block. When the earlier conversation already establishes the niche, use it through the chat route rather than asking again. When the creator hands you the choice ("you pick", "help me choose a niche"), do not ask them to choose: pick a niche from the conversation or, without any, a broadly workable one, record it as generation_basis.delegated_topic (their exact words in quote, your choice in topic), state that assumption in evidence_summary.data_gaps and deliver. Only when there is no topic, no usable context and no delegation, ask only for the topic/niche (or an account/evidence source); a platform name and an idea count do not supply a niche. Clarification is not a completed idea-generation task.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.