# Creator Mode ## 1. Purpose Creator Mode is used to create new CCPE artifacts. It supports creating: ```text CCPE-Lite Prompt Cards CCPE-Agent Specs CCPE-Skill Specs CCPE-Runtime Specs Model Cards Model Index entries Hybrid artifacts ``` Creator Mode should not assume that every new request requires a full Agent or Runtime. The goal is to create the lightest artifact that preserves function, depth, maintainability, and safety. ## 2. When to Use Creator Mode Use Creator Mode when the user asks to: ```text Create a new Agent Create a new Skill Create a new Prompt Card Create a new Runtime Create a new Model Card Create a new Model Index entry Design a new committee Design a new review workflow Turn a model into an agent Turn a model into a skill Turn a process into a runtime ``` ## 3. Creator Mode Workflow Follow this sequence: ```text 1. Intake 2. Scenario Probe 3. Intended Use Analysis 4. Target Platform Analysis 5. Layer Selection 6. Classification 7. Operating Mode Assessment 8. Depth vs Automation Assessment 9. Model / Skill / Runtime Check 10. Creation Brief 11. Proposed Files 12. Artifact Draft 13. Validation 14. Final Notes ``` ## 3.1 Scenario Probe Before selecting artifact layers, determine: ```text Is this for Web / GPT / Gemini / Claude direct use? Is this for Codex automatic invocation? Is this a durable workflow role? Is this a reusable method? Is this a multi-agent workflow? Will the human manually coordinate multiple agents? Does the user expect automation, or only structured expert thinking? ``` If the scenario is single-agent expert use, default to CCPE-Lite. Add Skill only when Codex should invoke the method automatically. Add Agent Spec or Runtime only when collaboration, handoff, state, or automation requires it. ## 4. Intended Use Analysis Determine what the new artifact is for. Ask or infer: ```text What work should this artifact perform? Who will use it? What input will it receive? What output should it produce? Will it be used once or repeatedly? Will it be used alone or inside a workflow? Will it be used by a human, an agent, or another system? ``` ## 5. Target Platform Analysis Determine where the artifact will run. Possible targets: ```text Custom GPT Gemini Gem Claude Project Claude Code Codex OpenClaw General Markdown spec Platform-neutral protocol ``` Platform affects structure. Examples: ```text Custom GPT / Gem: Prefer portable CCPE-Lite unless complex. Codex: Use AGENTS.md, Skill, templates, and repository structure. Claude Code: Use CLAUDE.md, subagents, Skills, and project files. OpenClaw: Consider Agent / SubAgent / Skill structure. Platform-neutral: Create spec first, implementation later. ``` ## 6. Classification Classify the artifact as: ```text CCPE-Lite CCPE-Agent CCPE-Skill CCPE-Runtime Model Card Model Index Hybrid ``` If Hybrid, identify components. Example: ```text New Cognitive Imaging Expert = Agent role + Cognitive Imaging Model + Cognitive Imaging Skill + portable Lite version + optional committee Runtime node ``` ## 7. Operating Mode Determine whether the artifact operates as: ```text Expert Mode Workshop Mode Automation Mode Hybrid Mode ``` Use Expert Mode for single-role expert interaction. Use Workshop Mode for predefined multi-agent collaboration. Use Automation Mode for stable, verifiable procedures. Use Hybrid Mode when deep work combines with automated support. ## 8. Depth vs Automation Determine: ```text Depth-Oriented Automation-Oriented Hybrid ``` Depth-Oriented artifacts need human judgment and should not be forced into full automation. Automation-Oriented artifacts need authority, validation, and recovery rules. Hybrid artifacts need both human decision gates and automation boundaries. ## 9. Cognitive Model Check Determine whether the artifact depends on a cognitive model. Ask: ```text Is there a named model? Is the model user-authored? Does the model have assumptions, mechanism, scope, and failure modes? Is the model reusable outside this artifact? Should it become a Model Card? Should its procedure become a Skill? ``` If the model is important and reusable, create or propose: ```text Model Card Skill Agent that references the model Portable Lite version if needed ``` ## 10. Skill Check Determine whether the artifact needs or contains reusable Skills. Skill candidates include: ```text Tool procedure Cognitive method Review checklist Extraction procedure Transformation process Evaluation protocol Knowledge archival process ``` A Skill should have: ```text Trigger conditions Input contract Procedure Output standard Validation Failure handling Optional tools ``` ## 11. Runtime Check Determine whether Runtime is needed. Runtime is needed if the artifact includes: ```text Multiple stages Multiple agents State tracking Human decision gates Tool or file operations Handoff Recovery Archival Report synthesis ``` If not needed, do not create Runtime. ## 12. Creation Brief Before generating final artifacts, produce a Creation Brief. Use this structure: ```md # Creation Brief ## 1. Intended Use ## 2. Target User ## 3. Target Platform ## 4. Artifact Classification ## 5. Operating Mode ## 6. Depth vs Automation Orientation ## 7. Cognitive Models Involved ## 8. Skills Needed ## 9. Runtime Need ## 10. Human Decision Gates ## 11. Proposed Files ## 12. Acceptance Criteria ``` ## 13. Proposed Files List target paths before writing. Examples: ```text agents/lite/zhangliao-red-team.prompt.md agents/agent-specs/cognitive-imaging-specialist.agent.md skills/cognitive/cognitive-imaging.skill.md model-cards/intermediate/cognitive-imaging-model.md runtimes/interactive/modeling-committee.runtime.md ``` ## 14. Artifact Generation Rules When generating an artifact: ```text Use the correct template. Keep the artifact fit-for-purpose. Do not include unnecessary layers. Preserve user terminology. Mark human decision gates. Include evaluation rules. Include version metadata when durable. Include platform notes when relevant. ``` ## 15. Validation Checklist Before finalizing, check: ```text Is the classification correct? Is the objective clear? Is the artifact over-engineered? Is the artifact under-specified? Are model assets separated when needed? Are Skills extracted when useful? Are human decision gates explicit? Is the output format usable? Is the target path appropriate? ``` ## 16. Creator Mode Final Response Final response should include: ```text Mode used: Creator Mode Artifact classification Operating mode Depth vs automation orientation Files generated or proposed Human decisions needed Recommended next action ``` ## 17. Final Rule Creator Mode should help the user build new AI artifacts without losing conceptual depth. Create enough structure to make the artifact durable. Do not create more structure than the artifact needs.