# Create

> Scaffold a new product with MCS-1 valid structure and WHY comments. Supports all 13 types. Use when the creator says 'new skill', 'create', 'scaffold', 'start building', or wants to start a new product.

- Skill: `myclaude-sh/create` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add myclaude-sh/create`
- Raw SKILL.md: https://api.skillmd.com/api/skills/myclaude-sh/create/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: myclaude-sh (https://skillmd.com/u/myclaude-sh)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/myclaude-sh/create

---


# Scaffolder

Generate complete, MCS-1-valid project structure for any product type with guidance comments baked in.

**When to use:** Starting a new product — any of the 13 types.

**When NOT to use:** When the product already exists in `workspace/` and you want to add content (use `/fill`). Do not use to overwrite an existing scaffold unless `--force` is specified.

---

## Activation Protocol

0. **Shared preamble:** Load `references/quality/activation-preamble.md` — context assembly, persona adaptation, deterministic routing rules.
1. Read `creator.yaml` — load defaults. Check `schema_version`:
   - **`< 3`** → invoke `/onboard` skill to run Phase 2.5d silent migration first. Migration is atomic + backed up to `creator.yaml.bak.v2`. After migration succeeds, re-read the v3 file and continue.
   - **Missing** → **micro-onboard**: scan silently, infer defaults, ask ONE name question, generate minimal `creator.yaml` (v3). Never block.
2. **Persona**: Adapt to `profile.type` + `technical_level`. Load `references/quality/engine-voice-core.md`. Load the full `references/quality/engine-voice.md` only when composing peak moments (scaffold celebration, Step 10 proposal rendering, first-product WOW).
2c. **Exemplar load:** Load `references/quality/exemplar-outputs.md` section E3 only — the scaffold celebration reference. Your scaffold announcement MUST carry the same visual rhythm (Frame + pipeline position + portfolio context + 🎯 next action). Adapt to this creator's language and journey position.
2d. **Load proactives:** Load `references/engine-proactive.md` — wire #1 (pipeline guidance: after scaffold, guide to /fill), #18 (WOW moment for first product scaffold), #21 (portfolio pattern detection on brownfield check).
2b. **Load architectural DNA:** Read `structural-dna.md`. The 10 architectural principles and the Tier 1 DNA patterns (D1-D4, D13, D14) govern every scaffold — the skill applies them during Step 11 template generation and flags any violation before the scaffold is written to disk.
3. **Discovery Mode Routing (W3.2 — PRIMARY ROUTER):** Load `${CLAUDE_SKILL_DIR}/references/create-router.md` **Section 0** — the 12-step discovery walk. Apply the Mode Selection table (Express vs Guided) based on `creator.profile.technical_level` + `creator.preferences.workflow_style` + any `--express`/`--discovery` flag.
   - **Express mode** → run the "12 Steps — Express Mode Fast Path" section of create-router.md Section 0. Reads type + sub-type flags, applies defaults from `config.yaml routing.{type}.intent_topology`, skips interactive questions, derives the full 19-field `intent_declaration` in one pass, and writes it at Step 11 of the walk.
   - **Guided mode** → run the "12 Steps — Guided Mode Walk". Asks Q1 (verb family) interactively, reads `creator.intent_profile` silently for Steps 2/3/6, escalates at Step 6 if cognitive justification incomplete, proposes form at Step 10 with confirmation, writes `intent_declaration` at Step 11.
   - **Discovery returns unroutable (Step 9 zero-match)** → fall through to create-router.md **Section 1** legacy Q1/Q2/Q3 tree (Contract C4). The creator is never blocked. `unroutable: true` + `unroutable_reason` recorded in `intent_declaration`.
   - **Creator chose "I don't know yet" at Step 1** → route to `/scout` suggestion OR legacy tree, at creator's choice.
4. **Gates**: Read `config.yaml → gates.confirm_create`. Confirm if `true`; proceed if `false`.
5. **Brownfield check**: Glob `workspace/*/`. If same `product.type` or overlapping tags found, surface slugs and ask before continuing.
6. **Exemplar guard**: Glob `references/exemplars/{category}*`. If found: show condensed preview. If not: skip gracefully — never halt.
7. Load `product-dna/{category}.yaml` → DNA requirements.
7b. **Load entity ontology (squad/system/agent/workflow/minds):** If type ∈ {squad, system, agent, minds, workflow}, read `references/entity-ontology.md`. This substrate governs:
    - Which agent ROLES to suggest during composition discovery (§AGENT_ROLES — 7 functional archetypes with tool boundaries)
    - The heritage chain — what this type inherits from and composes with (§HERITAGE, §COMPOSITION)
    - The 8 squad anatomy components that MUST appear in the scaffold (§SQUAD_ANATOMY)
    - The intelligence gradient — where this type sits in the determinism↔autonomy spectrum (§INTELLIGENCE_GRADIENT)
    - The distinction between workflow (YAML decides) and squad (LLM decides) coordination (§WORKFLOW_VS_SQUAD)
    - Promotion/demotion heuristics — is this really the right type? (§HEURISTICS)
    - Runtime behavior — how this type activates and its token cost (§RUNTIME_BEHAVIOR)
    - For /scout-informed creates: type recommendation matrix (§SCOUT_INTELLIGENCE)
    - Isomorphic human↔CC mapping for creator-facing explanations (§ISOMORPHIC)
    - For type=system ONLY: the 13 functional gears (§SYSTEM_ENGINES) — ask which gears the creator wants active, scaffold coupling declarations
    - The intelligence pipeline that governs how scout research enters the product (§INTELLIGENCE_PIPELINE)
    - The foundational thesis: restrictions generate intelligence flow — ask "What should this NEVER do?" (§FOUNDATIONAL_THESIS)
    - Transversal axes: after type selection, calibrate Delivery × Nature × Depth (§TRANSVERSAL_AXES)
    - Composition principles: how products think together — convergence by independence, symbiosis > aggregation (§COMPOSITION_PRINCIPLES)
8. Load `${CLAUDE_SKILL_DIR}/references/discovery-questions.md` → category questions.
9. Load `references/product-specs/{category}-spec.md` + `templates/{category}/`.
10. Load `workspace/domain-map.md` if exists → prefill scaffold sections.
10b. **Link scout report** if used — `scout_source` is already recorded in `intent_declaration.scout_source` by Section 0 Step 11. No additional action needed here; the canonical home for scout_source is `intent_declaration`, not a parallel field.
10c2. **CLI contract:** Load `references/cli-contract.md` for unified error handling. This skill has minimal CLI surface — one command at Step 1.5. Severity map:
   - **Silent-skip:** `search --category {type} --sort downloads --limit 3` — marketplace scan for competitive context. Skip without warning on failure. **First-product guard:** skip entirely if `is_first_product` (already documented at Step 1.5)
   - **All queries:** append `--json 2>/dev/null`, 15s timeout
10c. **Portfolio intelligence (back-reference from /validate)**: Read `STATE.yaml → workspace.products[]` AND `STATE.yaml → mcs_results`. Group by domain. If domain has existing products:
   - Show: "Your {domain} portfolio: {slugs}. This will be product #{N}."
   - If N >= bundle threshold (`config.yaml → intelligence.portfolio.bundle_suggestion_threshold`): suggest bundling.
   - If complementary type opportunity exists: surface composition suggestion.
   - **MCS target calibration**: If domain has 0 products → default MCS-1 (ship fast, test market). If domain has 2+ validated products → default MCS-2 (quality matters, audience exists).
   - Record `intelligence.domain` and `intelligence.market_position` in `.meta.yaml`.
11. Generate scaffold in `workspace/{product-slug}/` with DNA patterns + WHY comments. The scaffold's type + structure come from the `matched_cell.canonical_form` decided at Section 0 Step 10.
    **Ontology-aware scaffold verification (requires entity-ontology.md loaded at step 7b):**
    For type=squad: verify scaffold contains all 8 anatomy components from entity-ontology.md §SQUAD_ANATOMY:
      1. Agent roster (agents/) — each specialist as separate .md file with role-appropriate frontmatter
      2. Routing table (config/routing-table.md) — IF intent → agent mapping with judgment points
      3. Handoff protocols (config/handoff-protocol.md) — structured envelope format (from, to, task, state, constraints)
      4. Workflows (workflows/) — multi-agent sequences with gates and loops
      5. Skills-as-instruments (skills/) — reusable fragments agents invoke
      6. Checklists — deterministic verification section in SQUAD.md
      7. Templates — output format standards in kernel/
      8. Escalation/quality gates — confidence thresholds and loop limits in SQUAD.md
    For type=agent or type=minds: apply §AGENT_ROLES — the role selected during discovery determines frontmatter tool boundaries (`allowed-tools`/`denied-tools`) and handoff format expectations. Generate role-appropriate frontmatter.
    For type=workflow: verify scaffold distinguishes from squad per §WORKFLOW_VS_SQUAD — workflows use skills (not agents), fixed sequence (not LLM routing), deterministic gates (not judgment). If scaffold looks like a squad, surface heuristic coaching.
    For type=system: apply §HERITAGE — system inherits all squad DNA + adds CLAUDE.md fragment, hooks, output-style, STATE.yaml. Scaffold must include provisions for all composed types per §COMPOSITION.
    For type=system: apply §SYSTEM_ENGINES — scaffold a `gears_declaration` section in the system's primary file. Ask the creator: "Which of these organism capabilities do you want active?" Present the 13 gears grouped by function:
      - Boundary: E0 (clausura) — always required
      - Metabolism: E1 (token budget), E2 (constitution re-injection)
      - Memory: E3 (triple memory), E10 (persistent state)
      - Perception-Reflex: E4 (hooks perception), E5 (cognitive reflex)
      - Judgment-Coordination: E6 (isolated judgment), E7 (coordination network)
      - Identity: E8 (external voice)
      - Integrity: E9 (recursive validation), E11 (longitudinal self-observation — advanced, MCS-3)
      - Lifecycle: E12 (reversible install/uninstall)
      For each active gear, the scaffold includes a section with WHY comment and its counterpart declaration.
11b. **Locale-adaptive clause substitution (W3.6 — MANDATORY for 6 certified types):** For each template file written (SKILL.md, AGENT.md, SQUAD.md, CLAUDE.md for system, AGENT.md for minds, OUTPUT-STYLE.md), perform placeholder substitution for `{{LOCALE_ADAPTIVE_CLAUSE}}`:
    a. Read the canonical clause block from `references/locale-adaptive-clause.md §2` (the fenced markdown block between `<<< LOCALE-ADAPTIVE CLAUSE ... >>>` and `<<< END CLAUSE >>>`, inclusive).
    b. Read the localized header from `config.yaml → routing.common.locale_adaptive_clause.localized_header_catalog.{creator.language}`. If the creator's language is not in the catalog, use the `fallback` entry and emit an advisory note.
    c. Build the substitution block: `<!-- {localized_header} -->\n\n{canonical_clause}`.
    d. Replace the literal string `{{LOCALE_ADAPTIVE_CLAUSE}}` in each written template file with the substitution block. Use a literal-string replace, not a regex — the placeholder is unique and must not be interpreted.
    e. Verify post-substitution: the forged file must contain both marker strings (`<<< LOCALE-ADAPTIVE CLAUSE (runtime contract, do not edit) >>>` and `<<< END CLAUSE >>>`). If either marker is missing after substitution, the forge fails + rollback.
    e2. **Duplication guard:** Before substitution in step (d), check if the target file ALREADY contains the marker `<<< LOCALE-ADAPTIVE CLAUSE`. If found, skip substitution for that file and emit advisory: "Locale clause already present in {file} — skipping to prevent duplication." This handles re-forge (`--force`) scenarios where the template already carried a clause from a prior run.
    f. For type `squad`, also perform the substitution on every file in `workspace/{slug}/agents/*.md` (sub-agents inherit the clause per `references/locale-adaptive-clause.md §4`).
    g. For type `system`, also perform the substitution on every sub-part file (claude-md fragment, sub-agents, sub-squads) per §4.
    h. Record `intent_declaration.language` (already populated at Section 0 Step 11) as the source language used for the lookup — this becomes the `source_language` field in vault.yaml at /package time.
12. Create `.meta.yaml` (see template below). The `intent_declaration` block is already populated from Section 0 Step 11; the rest of the template is filled by this step (product, state, history, intelligence).
13. Move `workspace/domain-map.md` → `workspace/{product-slug}/domain-map.md` if loaded.
14. **Atomic commit (Contract C5):** write order matters — `.meta.yaml` first (it is the local source of truth), then `STATE.yaml decisions_history` append.
    - If `.meta.yaml` write fails: abort, announce failure. Nothing else proceeds.
    - If `STATE.yaml` append fails after `.meta.yaml` succeeds: **do not roll back the scaffold**. The scaffold on disk is recoverable; a deleted scaffold is not. Instead: log `state.tracking_sync: false` in `.meta.yaml`, emit Engine-fault voice line — *"Scaffold forged but Engine lost tracking. Run /status to resync."* — and continue. `/status` will detect the orphan on next run and surface it for recovery.
    - Only report `forge_ready` when both writes succeed without error.
15. Engine voice: "Scaffold ready. {N} sections with WHY guidance. Run /fill to start." In Guided mode, also include one-line summary of the cell matched and why: *"Forjado como {canonical_form} — {rationale}."*

---

## Router Logic

**Read `${CLAUDE_SKILL_DIR}/references/create-router.md`** — the file has two sections:

- **Section 0 — DISCOVERY MODE (PRIMARY ROUTER, W3.2):** the 12-step decision algorithm from `references/capability-matrix.md §3`. Runs in either Express or Guided mode per Activation Protocol step 3. Writes the 19-field `intent_declaration` to `.meta.yaml`. This is the primary path for **every** /create invocation in schema v3.
- **Section 1 — LEGACY DECISION TREE (FALLBACK):** the Q1/Q2/Q3 tree preserved verbatim from pre-Wave-3. Runs when Section 0 Step 9 returns `unroutable` (Contract C4) or when the creator explicitly picks "I don't know yet" at Section 0 Step 1 or invokes `--legacy-router`. Also contains: per-category scaffold structures (Section 2), prefilling strategy (Section 3).

**Direct sub-commands** trigger Express mode (skip the interactive walk, apply type+sub-type defaults, write `intent_declaration` with `mode: express`):
`/create skill [my-tool]` | `/create agent` | `/create squad` | `/create workflow` | `/create ds` | `/create claude-md` | `/create app` | `/create system` | `/create bundle` | `/create statusline` | `/create hooks` | `/create minds` | `/create output-style`

**Depth flags** (Express mode only, pairs with type sub-command):
`--procedural` | `--advisory` | `--cognitive` | `--genius [profile_name]` (for minds)

**Mode override flags:**
`--express` — force Express mode regardless of creator profile
`--discovery` — force Guided walk (synonym: `--guided`) regardless of creator profile
`--legacy-router` — skip Section 0 entirely, go straight to Section 1 legacy tree
`--quick` — Express mode + skip marketplace scan + skip exemplar preview (legacy alias, retained for backward compatibility)

For experienced creators who know exactly what they want, Express mode + sub-command is the one-motion path. For creators discovering what to build, Guided mode walks them through. For creators in unmapped territory, Section 1 legacy fallback guarantees they always have a path forward.

---

## Universal Creation Flow

| Step | Action | Detail |
|------|--------|--------|
| 1 | Name + Description | Derive slug: lowercase, hyphens, validate `^[a-z0-9][a-z0-9-]{2,39}$`. Existing `workspace/{slug}/` → offer `/fill` or `--force`. CLI init: vault.yaml but no .meta.yaml → import into Engine workspace. Suggest `/map` if deep domain knowledge involved. |
| 1.5 | Marketplace Scan | `myclaude search --category {type} --sort downloads --limit 3 --json 2>/dev/null`. Show top 3 with downloads + "What will yours do differently?" Coaching only — never blocking. **First-product guard:** If `is_first_product`, SKIP this step — a first-timer seeing competitor data before articulating their own idea causes second-guessing. Show marketplace context AFTER scaffold, not before. |
| 2 | Discovery Questions | Load + ask from `${CLAUDE_SKILL_DIR}/references/discovery-questions.md`. Ask conversationally. `workflow_style=guided` → AskUserQuestion; `autonomous` → plain text. |
| 3 | Load Defaults | From `creator.yaml`: license, version (always 1.0.0), author, quality target. |
| 4 | Generate Scaffold | **Structure only** — files, YAML frontmatter, section headers with WHY comments, template vars for metadata. Never generate substantive prose. Leave `[To be filled — run /fill]` for expertise sections. See router.md for per-category structures. |
| 5 | MCS-1 Structural Validation | Silently verify: required files present, metadata fields populated, README.md follows `templates/readme/README.md.template` structure (Hero, Install, "Is this for me?", Quick Start, Features, How It Works, type-specific, Requirements, Compatibility, Language, License — trilingual EN/PT-BR/ES with anchor nav), no YAML/JSON syntax errors. Auto-fix and note corrections. |
| 6 | Print Next Steps — Cognitive UX | **Load full UX stack:** `references/ux-experience-system.md` (§1 context assembly, §2.3 moment awareness for "first scaffold"), `references/ux-vocabulary.md` (type naming), `references/quality/engine-voice.md` (brand DNA). Output is REASONED, not templated — adapt based on creator context. |

**Step 6 Cognitive Output Protocol:**

Assemble context from creator.yaml + STATE.yaml, then REASON about output:

```
IF is_first_product:
  → Full journey map. Warm tone. "Your first product exists."
  → Show all 4 pipeline steps explicitly.
  → Use encouraging language: "I'll guide you through each step."

IF products_published >= 5:
  → Compact. "✦ {name} scaffolded. {N} files. /fill when ready."
  → Skip journey map (they know the pipeline).
  → Surface only non-obvious: portfolio position, domain intelligence.

IF scout_source exists:
  → Reference the research: "Scaffolded from your {domain} research. {gaps_found} gaps mapped."

IF same domain has existing products:
  → Surface composition: "This joins {existing_slugs} in your {domain} portfolio."

ALWAYS:
  → Use ux_type_name from ux-vocabulary.md (e.g., "Deep Intelligence" not "minds")
  → Brand frame: ✦ marker, MyClaude Studio box (for first product or guided mode)
  → Pipeline position: "scaffold → ▸ fill → validate → test → package → publish"
  → Clear next action: "/fill" (always the next step after create)
  → VOCABULARY GUARD: Before emitting ANY creator-facing text, grep output for internal terms (MCS-N, DNA, D1-D20, scaffold, forge, substrate, habitable cell, intent_declaration, Sparring Protocol). If creator.profile.type is NOT "developer" or "hybrid", replace per ux-vocabulary.md. If "developer" or "hybrid", internal terms MAY appear but MUST be accompanied by context.
```

**Default frame (guided mode or first 3 products):**
```
┌─ MyClaude Studio ───────────────────────────┐
│  ✦ {product_name} — {ux_type_name}          │
│                                              │
│  {cognitive_insight based on context}        │
│                                              │
│  ▸ scaffold → fill → validate → test → ship │
│  Next: /fill                                │
└──────────────────────────────────────────────┘
```

**Compact frame (autonomous mode or 5+ products):**

For developers:
```
✦ {product_name} scaffolded. {N} files. {cognitive_insight}. /fill
```

For non-developers (profile.type != developer):
```
✦ {product_name} is ready. {N} files created. {cognitive_insight}. Add your expertise next → /fill
```

---

## .meta.yaml Template

Create `workspace/{product-slug}/.meta.yaml`:

```yaml
# Product metadata — not distributed, stripped during /package
product:
  slug: "{product-slug}"
  type: "{category}"               # skill|agent|squad|workflow|design-system|claude-md|application|system|bundle|statusline|hooks|minds|output-style
  created: "{YYYY-MM-DD}"
  mcs_target: "{MCS-1|MCS-2|MCS-3}"
  # NOTE: For type=minds, cap mcs_target at MCS-2 (Tier 3 DNA patterns are mostly N/A).
  # Show: "Minds ceiling is MCS-2 (Tier 3 DNA patterns not applicable). Setting target to MCS-2." (G015)
  # Minds-specific (only when type=minds):
  # minds_depth: "advisory|cognitive"
  # minds_sub_type: "self|genius|domain"  # cognitive only
  # genius_profile: "{name}"              # genius only

state:
  phase: "scaffold"                # scaffold | content | validated | packaged | published
  last_validated: null
  last_validation_score: null
  dna_compliance:
    tier1: null                    # 0-100
    tier2: null
    tier3: null
  overall_score: null
  last_tested: null
  test_result: null              # "pass" | "fail" | null
  test_scenarios: null           # "{passed}/{total}" | null

history:
  created_at: "{YYYY-MM-DD}"
  validated_at: []                 # append timestamps
  packaged_at: null
  published_at: null
  version: "1.0.0"

# Intent Declaration — the canonical record of how /create reasoned from creator intent
# to forged form. Written by /create at Step 11 of the 12-step algorithm (express or
# guided mode). Consumed by: /validate Stage 0 (Intent Coherence), /fill (natureza-aware
# section walks), /package (manifest shape), and STATE.yaml decisions_history
# (longitudinal feedback loop per capability-matrix.md §6).
#
# Schema source of truth: references/capability-matrix.md §3 Step 11 (19 fields).
# Enum sources:
#   - references/intent-topology.md §2 (delivery, nature, depth axis enums)
#   - references/intent-topology.md §4 (habitable cells v1)
#   - references/capability-matrix.md §3 Step 1 (verb_family enum)
#   - references/capability-matrix.md §3 Step 9 (unroutable_reason enum)
#   - references/capability-matrix.md §4 (mode enum: express | guided)
#
# Null-safe discipline (Contract C9): every field is populated on every forge. Fields
# not applicable to the current mode/path are set to null (single-value) or [] (list).
# Never omit a field — downstream consumers must not distinguish "absent" from "null".
#
# This block is the canonical home for scout_source (Activation Protocol step 9b).
intent_declaration:
  captured_at: null       # ISO-8601 when /create resolved the triple (Step 11)
  creator_said: null      # verbatim intent text (guided mode), or "(express mode)"
  mode: null              # express | guided (see references/capability-matrix.md §4)
  mode_switches: []       # appended by §5 transition protocol; each entry: {from, to, trigger, at_step, at_time}
  language: null          # mirror of creator.yaml → creator.language at forge time (drives locale-adaptive clause + announcements)
  scout_source: null      # "scout-{slug}.md" if a scout report informed this forge (canonical location for Activation Protocol step 9b)

  # engine_parsed — per-step outputs of the 12-step algorithm. In express mode, these
  # are populated from sub-command flags + type defaults. In guided mode, from the walk.
  engine_parsed:
    verb_family: null         # do_X | advise_on_X | coordinate_X | observe_X | enforce_X | react_to_X  (Step 1)
    continuity_bias: null     # parent | isolated | unclear  (Step 2)
    invocation_mode: null     # remembered | needs_auto  (Step 3)
    pollution_risk: null      # pollutes | safe  (Step 4)
    output_shape: null        # amplified_reasoning | structured_report  (Step 5)
    depth: null               # procedural | advisory | cognitive  (Step 6)
    nature: null              # executor | advisor | orchestrator | observer  (Step 7)
    delivery_mechanism: null  # ambient_constitutional | ambient_path_scoped | invoked_slash_command | invoked_task_spawn | reflex_hook_binding | composed_system  (Step 8 primary)
    host_set: []              # derived from (delivery, nature) per references/runtime-host-dag.md §2 — NEVER declared, always computed

  # Canonical cell lookup result (Step 9)
  matched_cell: null          # habitable cell id from intent-topology.md §4 (e.g. "reasoning_skill_cognitive"), or null if unroutable
  ranked_alternatives: []     # up to 2 alternative cell ids surfaced in the proposal

  # Creator-facing proposal (Step 10)
  proposed_form: null         # canonical_form from matched_cell, or null if unroutable
  creator_choice: null        # accepted | overridden
  override_to: null           # creator's chosen form if overridden
  override_reason: null       # creator's one-line explanation if overridden

  # Unroutable handling (Contract C4 — fall-through is a feature, not a failure)
  unroutable: false
  unroutable_reason: null     # no_habitable_cell | v2_cell_deferred | blocked_by_composition_gap | ambiguous_between_cells
  unroutable_gap_id: null     # gap marker from composition-anatomy.md (e.g. "GAP-COMPOSITION-1") when unroutable_reason == blocked_by_composition_gap

  # Audit markers for post-hoc schema evolution + default-tracking
  discriminators_applied: [] # which of [continuity, invocation, pollution, output, depth] actually fired (not just defaults)
  defaults_applied: []       # intent_profile field names that fell back to declared defaults (schema v3 gap tracking)

# Intelligence Layer fields (populated by /validate Stage 8, /scout, /package)
# Reference: references/intelligence-layer.md + config.yaml intelligence section
intelligence:
  domain: null                     # inferred from scout or content (e.g., "kubernetes-security")
  market_position: null            # blue_ocean | moderate | saturated
  value_score: null                # 0-12 composite (depth + uniqueness + coverage + market)
  value_score_breakdown: null      # { depth: N, uniqueness: N, coverage: N, market: N }
  suggested_price_range: null      # [min, max] USD
  pricing_strategy: null           # free | signal | solid | premium | rare
  distribution_channels: []       # ranked channels for this product type
  portfolio_role: null             # anchor | complement | extension | standalone
  scored_at: null                  # ISO-8601 timestamp of last intelligence computation
```

---

## Quality Gate

Generated scaffold must pass MCS-1 before being shown to the creator:
- All required files for the product type are present
- All required metadata fields are populated (even with placeholders)
- README.md skeleton follows the structure from `templates/readme/README.md.template` — required sections: Hero (problem hook + description), Install, "Is this for me?", Quick Start, Features, How It Works, type-specific section, Requirements, Compatibility, Language, License, Footer. Trilingual structure (EN, PT-BR, ES) with anchor navigation. /create scaffolds section headers with WHY comments; /fill populates content.
- No syntax errors in any generated YAML or JSON
- `.meta.yaml` is valid and contains all required fields

---

## Anti-Patterns

1. **Generating content during scaffold** — /create generates structure only. Substantive prose, domain knowledge, examples: all /fill's job. Content here bypasses the Sparring Protocol → generic latão polido.
2. **Blocking on missing creator.yaml** — Always micro-onboard and continue.
3. **Overwriting without --force** — Never touch existing workspace products without explicit flag.
4. **Skipping brownfield check** — Always check same-type products before scaffolding.
5. **Skipping portfolio intelligence (step 9c)** — Domain grouping and bundle suggestions must fire when threshold is met.

---

## Decision Notes

**CE-D12:** WHY comments (`<!-- WHY: ... -->`) explain what the creator must fill in. Stripped during `/package`. Creators should NOT remove them — harmless in workspace.

**Pre-validate at scaffold time:** Starting at MCS-1 means creators never fix basics. Scaffold failures are bugs in the Scaffolder, not creator errors.

**Sub-command routing:** `/create skill` etc. skip the menu for experienced creators. Menu exists for first-time users who don't know the vocabulary.

**Scaffold vs content separation:** Content generated by /create bypasses /fill's Sparring Protocol → zero unique expertise. Structure (scaffold) and content (expertise) must stay separate. That separation is what makes the Engine produce gold.