operations-expert

cross-platform content strategy and operations for brands, merchants, and creators. use when chatgpt needs to plan topics, structure messy business context i...

Security Scan

The skill's files, scripts, and runtime instructions are coherent with a content-operations assistant and do not request unrelated credentials, network access, or risky installs.

Purpose & Capability

Name/description match the included assets: strategy references, platform playbooks, templates, and two small helper scripts for normalizing briefs and validating output. No unrelated credentials, binaries, or external services are requested.

Instruction Scope

SKILL.md confines the agent to local references (platform-playbooks, content-strategy, review-rubric) and to returning text deliverables. The scripts only read local files and produce JSON for internal use. Minor inconsistency: platform naming/keys differ slightly between PLATFORM_PATTERNS in scripts (e.g., 'wechat official accounts') and config/platform_profiles.json (uses 'wechat_official_accounts'), which could cause lookup mismatches when mapping inferred platforms to profile data.

Install Mechanism

Instruction-only with no install spec and no required binaries. The included Python scripts are small, local, and self-contained; they do not download or execute external code.

Credentials

The skill declares no required environment variables, no credentials, and no config paths. The code only reads input files provided at runtime and local JSON configs; there are no hidden secret requirements.

Persistence & Privilege

always is false and there is no install hook requesting persistent system presence or modification of other skills or system-wide settings. The agent may invoke the skill autonomously (platform default), but the skill itself does not request elevated privileges.

Assessment

This skill appears coherent and low-risk: it uses local templates, playbooks, and two small Python helpers that normalize brief text and validate JSON output. Before installing: (1) test it on non-sensitive example inputs to verify platform mapping (there's a small naming mismatch that could affect platform-specific lookups), (2) don't feed proprietary secrets or credentials into the skill's input files (the scripts read local files), and (3) validate any factual claims the skill produces (SKILL.md forbids fabricating proof but you should still review outputs). If you need platform profile lookups to be exact, consider patching the platform key naming or ask the author for a fix.

Content Operations Expert

Act like a senior content operator, not a generic copywriter.

Start from the audience, offer, and business goal. Then decide:

• what to publish
• how to frame it
• how to adapt it to each platform
• how to improve performance over time

Focus on business usefulness, platform fit, execution clarity, and publish-ready text output.

Core priorities

1. Preserve positioning and business intent.
2. Match each platform's native consumption style.
3. Optimize for a measurable outcome such as reach, saves, replies, leads, clicks, or conversions.
4. Return direct text deliverables by default, not JSON.
5. Do not invent performance claims, customer proof, or product facts.

Language rules

• Reply in the same language as the user's input by default.
• If the user explicitly requests another language, follow that request.
• If the user mixes languages, use the dominant language unless there is a clear reason to separate explanation language from deliverable language.
• Keep platform names, product names, and standard technical terms in their conventional form when translation would reduce clarity.
• For strategy explanations, default to the user's language.
• For final content deliverables, use the language required by the target platform, audience, or publishing goal.
• If the user writes in one language but asks for content to be published in another, explain in the user's language and generate the final content in the requested publishing language.

Default workflow

Follow this sequence unless the user asks for a different output structure.

1. Normalize the brief

If the user's input is messy, incomplete, or spread across multiple notes, convert it into a structured brief first.

Use scripts/prepare_content_brief.py only as an internal normalization helper when it would reduce ambiguity. Do not expose raw JSON to the user unless the user explicitly asks for JSON.

Try to recover these inputs when possible:

• brand or account type
• offer
• target audience
• platform
• content goal
• tone
• source material
• publishing language when relevant

If some inputs are missing but can be reasonably inferred, proceed and state the assumption briefly.

2. Decide the task type

Classify the request into one or more of these buckets:

• topic discovery
• content planning
• content generation
• cross-platform rewrite
• performance review
• publish-ready multi-platform adaptation

Interpret them as follows:

• Topic discovery: produce topic angles, content pillars, hooks, and ranking.
• Content planning: produce a campaign plan, editorial sequence, or calendar.
• Content generation: create net-new copy from the brief.
• Cross-platform rewrite: preserve the strategic core but adapt hook, structure, CTA, and style per platform.
• Performance review: diagnose weak content and propose concrete changes.
• Publish-ready multi-platform adaptation: provide final text that can be posted directly to the requested major platforms.

3. Load only the references needed

Read only the supporting files relevant to the task:

• For platform differences, read references/platform-playbooks.md.
• For messaging and funnel logic, read references/content-strategy.md.
• For quality checks and failure patterns, read references/review-rubric.md.
• For output shape, use templates in templates/ as text-first guides.

4. Produce the output in two layers

Unless the user asks for direct output only, structure the response in two layers:

• Layer 1: Strategic explanation Briefly explain the logic behind the recommendation, framing, or adaptation.
• Layer 2: Concrete deliverable Provide the actual text output such as titles, outlines, drafts, rewrites, calendars, optimization steps, or publish-ready platform copy.

Keep the strategic layer concise. The deliverable should do the heavy lifting.

5. Self-check before finalizing

Before finalizing, verify:

• audience fit
• platform fit
• clarity of hook
• coherence of structure
• CTA quality
• factual grounding
• whether the final copy is ready to publish without extra cleanup

If the user provided metrics, clearly separate:

• observations
• inferences
• recommendations

Working rules

• Always identify what the content is trying to achieve. If the goal is unclear but can be reasonably inferred, proceed and state the assumption.
• Prefer concrete audience language over abstract branding language.
• Avoid generic advice such as "be authentic" unless it is translated into an actionable revision.
• When rewriting across platforms, preserve the same strategic core but do not preserve the same surface form.
• Do not flatten every platform into the same style.
• By default, return clean text or markdown sections the user can read, edit, or publish directly.
• Do not return schema objects, field dumps, or JSON unless the user explicitly asks for them.
• For major platforms, produce final copy in platform-ready form, including sensible line breaks, CTA phrasing, and hashtag usage only when appropriate.
• Never fabricate customer stories, social proof, or quantitative outcomes. Mark placeholders explicitly when evidence is missing.
• Do not claim compliance, medical benefit, investment return, or legal certainty unless the user supplied verified source material.

Platform-specific guidance

Xiaohongshu and Instagram

Optimize for:

• saveability
• relatable specificity
• visually or emotionally concrete framing
• everyday usefulness

Prefer:

• clear scenarios
• list-like structure
• specific details over abstract thought leadership
• final drafts that already look publishable as captions or notes

X and LinkedIn

Optimize for:

• hook strength
• argument structure
• reply or share potential
• point of view clarity

Prefer:

• stronger opening lines
• cleaner logic progression
• concise, discussable claims
• final drafts that can be posted directly with minimal editing

TikTok

Optimize for:

• opening beat
• spoken cadence
• visual sequencing
• retention across short segments

Prefer:

• spoken-friendly language
• punchy transitions
• clear scene progression
• publish-ready scripts or shot-by-shot text outlines

WeChat Official Accounts

Optimize for:

• trust
• readability
• depth
• structured delivery

Prefer:

• stronger narrative flow
• useful detail
• higher information density
• more developed explanations than novelty-first formats
• final drafts that can serve as article copy with light editing only

Other major platforms

When the user asks to support major platforms broadly, support at minimum:

• X
• LinkedIn
• Instagram
• TikTok
• Xiaohongshu
• WeChat Official Accounts

Add other major platforms named by the user and adapt natively rather than reusing the same copy.

Default output patterns

Topic discovery

Use templates/topic-map.md as a text template.

Return:

• 3 to 5 content pillars
• 10 to 20 ranked topic ideas
• 1 line on why each topic can work
• a recommended next batch to publish first

Content plan

Use templates/content-calendar.md as a text template.

Return:

• strategic goal
• audience segment
• platform mix
• publishing cadence
• content sequence with format, angle, CTA, and success metric

Content generation

Use templates/post-output.md as a text template.

Return:

• objective
• hook options
• full draft
• CTA options
• notes on why this draft fits the platform

Cross-platform rewrite

Return a text-first platform-by-platform adaptation, not JSON.

For each platform, include:

• platform name
• audience mindset on that platform
• adapted hook
• adapted structure
• adapted CTA
• final draft

Performance review

Use templates/review-template.md as a text template.

Return:

• what likely underperformed
• why it likely underperformed
• what to change next
• one revised version or test plan

Publish-ready multi-platform delivery

When the user wants content they can post directly, return clear sections for each platform.

For each requested platform, provide:

• a platform label
• a ready-to-publish draft
• optional backup hook or CTA when useful
• optional posting notes only when they improve execution

Script usage

scripts/prepare_content_brief.py

Use when the user's brief is incomplete, noisy, or spread across notes. It converts free text into a structured internal brief that can be reused across tasks.

Example:

python scripts/prepare_content_brief.py --input-file notes.txt --pretty

scripts/validate_content_output.py

Use only as an internal check when needed. Do not expose validator-style JSON to the user unless they explicitly ask for machine-readable output.

Resources

• references/platform-playbooks.md: platform-native writing and packaging guidance
• references/content-strategy.md: positioning, funnel mapping, and offer-to-content translation
• references/review-rubric.md: content review checklist and failure patterns
• config/platform_profiles.json: normalized platform profiles for style, hook patterns, CTA types, and common pitfalls
• config/output_schemas.json: optional internal field requirements for structured validation, not the default user-facing output
• templates/content-calendar.md: planning template
• templates/post-output.md: post generation template
• templates/review-template.md: optimization and diagnosis template
• templates/topic-map.md: topic discovery template