Przejdź do treści
Biblioteka skilli
Marketing i treści · Planowanie

develop-content-ideas

/develop-content-ideas

Generuje do wyboru pomysły na treści z tytułami i hakami, na podstawie badań twórcy, podanego tematu lub wcześniejszej rozmowy.

Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
29
Skrypty
13
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 13 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

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

Co robi i kiedy

Generuje do wyboru pomysły na treści z tytułami i hakami, na podstawie badań twórcy, podanego tematu lub wcześniejszej rozmowy.

Oryginalny opis (EN)

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.

Jak działa

  1. Running commands
  2. Prep
  3. Core
  4. Judgment rules
  5. Report language and conversation context
Sekcje z nagłówków SKILL.md, w oryginale · 200 linii, 2 225 słów
Podgląd SKILL.md
---
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.
Pliki w paczce (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

Wersje

W bazie nie ma innych skilli o nazwie develop-content-ideas.

Migawka bazy z 13.11.2026 · wersja paczki 8dc677c8907e (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100analyze-creator-competitors
    Wyszukuje i porównuje konkurentów twórcy lub marki na Instagramie i YouTube, pokazując luki w pozycjonowaniu i powtarzające się schematy treści.
  • 100topic-finder
    Zamienia wyniki z referencji w pomysły na filmy dla twórcy z jego niszy, gdy pyta o tematy lub plan treści.
  • 100idea-generation
    Generuje i ocenia pomysły na filmy YouTube: burza mózgów tematów, punktacja istniejących pomysłów, walidacja wyboru tematu i seryjne tworzenie konceptów treści.
  • 100topic-generator
    Proponuje 3 do 4 kierunków tematów treści z konkretnymi tytułami, kątami, zarysami i ocenami pracy oraz wad i zalet.
  • 100content-ideas
    Śledzi wskazanych konkurentów i twórców w mediach społecznościowych, ocenia wyniki ich postów i zamienia je w pomysły na treści oparte na danych o zaangażowaniu.
  • 100ext-bw-content-idea-generator
    Generuje pomysły na treści zakorzenione w pozycjonowaniu marki: co opublikować, tematy na bloga i posty na LinkedIn.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.