Skip to content
Skills Library
Marketing & content · Planning

develop-content-ideas

/develop-content-ideas

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.

Licence
MIT
Last repository change
13.11.2026

Assessment and security

100/ 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.
Content35 / 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
29
Scripts
13
HTML comments
0
URLs in SKILL.md
1
Deprecation

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

Licence

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

What to check before installing
  • 13 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/build_idea_request.py, scripts/deliver_ideas.py, scripts/idea_batches.py, scripts/persist_envelope.py, scripts/prepare_conversation_inputs.py, scripts/project_account_context.py, scripts/project_comments.py, scripts/render_idea_report.py, scripts/render_selection.py, scripts/report_language.py, scripts/run_ideas_stages.py, scripts/static_host.py, scripts/validate_ideas.py

What it does and when to use it

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.

Original author description

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.

How it works

  1. Running commands
  2. Prep
  3. Core
  4. Judgment rules
  5. Report language and conversation context
Original SKILL.md headings · 200 lines, 2,225 words
SKILL.md preview
---
name: develop-content-ideas
description: "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."
license: MIT
compatibility: "Requires Python 3 and read and write access to a local workspace. Fetching a video's comments also requires the Kabo MCP server at https://kabo.sh/mcp-pub and network access from scripts to kabo.sh and to the signed storage.googleapis.com download links that Kabo tool results return (without it, a host that can save a tool's complete result to a file). Kabo permission, for comments only: data."
allowed-tools: get_research_capabilities get_research_data_job get_research_data_download youtube_list_comments tiktok_discovery_list_comments tiktok_discovery_list_comment_replies start_skill_run
---

# 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.

**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:

```sh
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:

   ```sh
   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):

   ```sh
   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:

   ```sh
   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.
- `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.
When no explicit topic or usable evidence exists, 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.
Files in this package (29)
  • SKILL.md 17 KB
  • references/batched-authoring.md 4 KB
  • references/comment-evidence.md 8 KB
  • references/core-generation.md 12 KB
  • references/delivery-state.md 2 KB
  • references/delivery.md 5 KB
  • references/evidence-acquisition.md 7 KB
  • references/idea-request.schema.json 15 KB
  • references/idea-set-rules.md 6 KB
  • references/idea-set.schema.json 18 KB
  • references/personal-facts.md 3 KB
  • references/prep.md 12 KB
  • references/report-language.md 3 KB
  • references/report-locales-es.json 6 KB
  • references/report-locales.json 15 KB
  • references/request-boundaries.md 4 KB
  • scripts/build_idea_request.py 16 KB
  • scripts/deliver_ideas.py 4 KB
  • scripts/idea_batches.py 14 KB
  • scripts/persist_envelope.py 41 KB
  • scripts/prepare_conversation_inputs.py 7 KB
  • scripts/project_account_context.py 11 KB
  • scripts/project_comments.py 11 KB
  • scripts/render_idea_report.py 23 KB
  • scripts/render_selection.py 3 KB
  • scripts/report_language.py 14 KB
  • scripts/run_ideas_stages.py 41 KB
  • scripts/static_host.py 56 KB
  • scripts/validate_ideas.py 81 KB

Versions

The database has no other skills named develop-content-ideas.

Database snapshot: 13.11.2026 · package version 8dc677c8907e (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

  • 100analyze-creator-competitors
    Discover and compare Instagram or YouTube competitors from a creator, product, niche or Instagram seed post: comparable accounts, positioning gaps, recurring content mechanisms and same-account outliers. Use for competitor discovery, account comparisons and evidence about…
  • 100topic-finder
    Use when the creator asks for video ideas, topics, what to film next, or a content plan. Turns outliers from references/ into ideas for their niche.
  • 100idea-generation
    When the user wants to brainstorm YouTube video ideas, score existing ideas, validate topic choices, or batch-generate content concepts. Also use when the user says 'give me video ideas,' 'brainstorm topics,' 'what should I make a video about,' 'rate this idea,' 'score my video…
  • 100topic-generator
    Generate 3-4 content topic directions with concrete titles, core angles, outlines, workload estimates, and honest pros/cons. Use when the user asks for content ideas, topic brainstorming, blog post ideas, video topics, newsletter themes, or says "what should I write about" /…
  • 100content-ideas
    Your For You page for content creators. Scrapes tracked competitors across social media platforms, scores what's performing, and turns it into actionable, differentiated content ideas backed by real engagement data. Use this whenever the user wants competitor/creator research, a…
  • 100ext-bw-content-idea-generator
    Generate content ideas rooted in positioning. Use when someone needs "content ideas," "what should I post," "blog topics," "LinkedIn ideas," or is stuck on what to create.

Feedback and reports

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