agentleFS
myclaude-shmyclaude-sh/myclaude-creator-engine/.claude/skills/fill/SKILL.md

fill

Skill25 starsChanged 8 months agoMITView on GitHub

Guide content filling for scaffolded products. Walks sections, asks domain questions, writes expertise into files. Use after /create in 'scaffold' state, or when the creator says 'fill', 'add content', or 'help me complete this'.

2 other projects use a version of this.

Adopted by

Most recently taken up by

  • Other versions2 projects use a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 2

    1. leanEthereum/leanSpec★ 143same name
    2. askoulwassim/perfect-placement★ 3same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

  • In this repository17 other files it gives its agents.

The file

Show its rules and text

We split this skill into the rules it gives an agent

35 rules. About 0 are common, 17 are distinctive, and 18 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈17

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 18

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When to use: After /create has generated a scaffold.

    line 21
  2. Distinctive:

    When NOT to use: If the product doesn't exist yet (use /create first).

    line 23
  3. Very specific:

    If $ARGUMENTS provided, use as product slug → look in workspace/{slug}/

    line 34
  4. Very specific:

    If workspace/{slug}/ does not exist → "Product {slug} not found in workspace/.

    line 35
  5. Very specific:

    If not, glob workspace/*/ and list products in scaffold/content state

    line 36
  6. Very specific:

    If no products in scaffold/content state found → "No products ready to fill.

    line 37
  7. Very specific:

    If multiple products found, ask which one to fill 1b.

    line 38
  8. Very specific:

    Read .meta.yaml from product directory → get type, state, mcs_target, AND the intent_declaration block if present.

    line 43
  9. Very specific:

    Intent-aware calibration: If intent_declaration is present, extract engine_parsed.{depth, nature, delivery_mechanism}.

    line 44
  10. Very specific:

    Legacy fallback: If intent_declaration is absent (legacy product) OR if intent_declaration.mode == legacy_fallback with all engine_parsed …

    line 45
  11. Very specific:

    Maintain creator persona: Read creator.yaml → adapt language, depth, and examples to profile.type and technical_level throughout this …

    line 46
  12. Very specific:

    Load scout report: if .meta.yaml has intent_declaration.scout_source field (canonical location) OR .meta.yaml root-level scout_source field …

    line 76
  13. Very specific:

    Read the most recent sibling's .meta.yaml → intelligence and state.overall_score

    line 78
  14. Distinctive:

    If sibling substance_score < 50: "Your last product in {domain} scored {substance}% substance.

    line 79
  15. Distinctive:

    If sibling substance_score >= 70: "Your {domain} products have strong substance ({substance}%).

    line 80
  16. Very specific:

    Intelligence gap check: If .meta.yaml has NO scout_source AND product targets MCS-2+:

    line 83
  17. Distinctive:

    If creator continues without scout, skip research injection steps in section walker

    line 87
  18. Very specific:

    Structured input for choices: If creator.yaml → preferences.workflow_style = guided, use AskUserQuestion for all choice points …

    line 88
  19. Very specific:

    Read fill-protocol.md: Read ${CLAUDE_SKILL_DIR}/references/fill-protocol.md now — it contains the full execution protocol for all phases …

    line 89
  20. Distinctive:

    Follow the content pack's walker entry point (§1) which handles:

    line 94
  21. Distinctive:

    After the SELF-CLONE walker completes, skip to Completion (step 13 standard flow is bypassed)

    line 103
  22. Very specific:

    Ask archetype if not in .meta.yaml: Sequential Pipeline / Parallel Fan-Out / Conditional Router / Iterative Refinement / Hierarchical …

    line 111
  23. Very specific:

    Role-aware composition (entity-ontology.md §AGENT_ROLES): Instead of generic "how many specialists?", present the 7 functional roles: "Each …

    line 112
  24. Distinctive:

    Ask: "Name each specialist, their domain, and their role.

    line 114
  25. Distinctive:

    Ask entity lifecycles: "What objects flow through this squad?

    line 116
  26. Very specific:

    If agent has a mind-clone source in minds/: load minds/{name}/cognitive-model.md and use as knowledge substrate

    line 129
  27. Distinctive:

    Ask per agent: "What are the 3-5 most important things {agent_name} does?

    line 135
  28. Distinctive:

    Ask: "Walk me through the main workflow from start to finish.

    line 139
  29. Distinctive:

    If any component is missing, flag it: "Your squad is missing {component}.

    line 157
  30. Very specific:

    Completion: After all phases, update .meta.yaml with fill_metrics and transition state to content.

    line 158
  31. Distinctive:

    Use the selected role to determine:

    line 163
  32. Distinctive:

    If evidence suggests LLM judgment needed → surface heuristic from §HEURISTICS as coaching

    line 175
  33. Distinctive:

    Before promoting to "content" state:

    line 202
  34. Distinctive:

    Auto-validate honesty rule: When the silent MCS-1 check at completion finds failures, the creator-facing message MUST name them.

    line 208
  35. Distinctive:

    When context is compressed, preserve:

    line 227

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Content Filler

Extract domain expertise from creator conversation and inject into product files.

When to use: After /create has generated a scaffold. Product state should be "scaffold" or "content".

When NOT to use: If the product doesn't exist yet (use /create first). If the product is already validated (edits will regress state).

Full protocol details (section walker, sparring, extraction modes, type-specific coaching, research injection, progress tracking, completion flow) are in: ${CLAUDE_SKILL_DIR}/references/fill-protocol.md — Read this file before executing the section walk.


Activation Protocol

  1. Shared preamble: Load references/quality/activation-preamble.md — context assembly, persona adaptation, deterministic routing rules.
  2. Identify target product:
    • If $ARGUMENTS provided, use as product slug → look in workspace/{slug}/
    • If workspace/{slug}/ does not exist → "Product {slug} not found in workspace/. Run /create first or check workspace/ for available slugs."
    • If not, glob workspace/*/ and list products in scaffold/content state
    • If no products in scaffold/content state found → "No products ready to fill. Run /create {type} to scaffold one first."
    • If multiple products found, ask which one to fill 1b. Mode selection (Express vs Guided). Read creator.yaml → preferences.workflow_style. Resolve the flow mode:
    • --express flag OR workflow_style == "autonomous" → Express mode. Skip the three Discovery front-loaded questions, skip the Pitfall Check interactive prompt, skip Extraction Mode menu (default to Standard), skip the Deepening menu after each section, run the section walker with type defaults, and fall straight through to Completion. Interactive prompts are replaced by type-based defaults + one-line advisory notes. Proactive brainstorm prompts are suppressed.
    • workflow_style == "guided" or missing → Guided mode (default). Run the full protocol as documented in fill-protocol.md. Record fill_config.mode: express | guided in .meta.yaml so later skills can reason about the creator's chosen rhythm.
  3. Read .meta.yaml from product directory → get type, state, mcs_target, AND the intent_declaration block if present.
    • Intent-aware calibration: If intent_declaration is present, extract engine_parsed.{depth, nature, delivery_mechanism}. These three fields drive section walker routing, tone calibration, and question shape — see fill-protocol.md → INTENT-AWARE CALIBRATION for the full rubric. Record fill_config.intent_aware: true in .meta.yaml when the calibration fires.
    • Legacy fallback: If intent_declaration is absent (legacy product) OR if intent_declaration.mode == legacy_fallback with all engine_parsed fields null, fall back to type-based defaults. Emit one advisory line: "This product lacks intent metadata — /fill will use type-based defaults. Re-run /create to unlock intent-aware filling." Record fill_config.intent_aware: false.
  4. Maintain creator persona: Read creator.yaml → adapt language, depth, and examples to profile.type and technical_level throughout this skill's execution. A developer gets code examples; a domain expert gets plain language.
  5. Load UX stack (in order):
    • references/quality/engine-voice-core.md — the micro voice contract carried through every question, section signal, and sparring line in /fill. This is where the Creator spends the most time; the voice cannot drift.
    • references/ux-experience-system.md §1 Context Assembly (build creator context), §2.2 Archetype-Aware Insights (adapt emphasis to creator goals), §2.3 Moment Awareness (mid-fill coaching)
    • references/ux-vocabulary.md — translate terms in any creator-facing output Vocabulary enforcement (mandatory): Every question, section signal, sparring challenge, and progress message passes through ux-vocabulary.md translation before reaching the creator. Internal terms (Sparring, Pitfall, MCS, DNA tier, extraction mode) are replaced for non-dev creators. For dev/hybrid creators, terms may appear but always with context ("MCS-2 quality checks — these verify craft and expertise depth").
    • references/quality/engine-voice.md — full voice substrate. Load when composing section quality signals, sparring pressure, milestone celebrations, or brand moments.
    • references/quality/exemplar-outputs.md sections E4 and E5 only — the section question and sparring exemplars. These show the exact visual rhythm and warmth your questions must carry: progress sandwich (bar → celebration → question → escape hatch), warm framing, 💡 scaffolding offers.
    • references/ux-experience-system.md §11 Deep Elicitation Protocol — MANDATORY for all AskUserQuestion calls. Apply: experience-based questions (not abstractions), one question at a time, mirror to confirm, escalate progressively, offer scaffolding when stuck, celebrate depth. /fill is where the creator spends the MOST time. The experience must be warm coaching, not interrogation. Adapt: beginners get encouragement + examples. Experts get peer-level sparring. Celebrate section completions with progress visibility ("4/7 sections filled. Core identity locked in."). Hyper-personalize using creator.yaml fields — name, goals, expertise areas. 4b. Load proactives: Load references/engine-proactive.md — wire #1 (pipeline guidance: after fill completes, guide to /validate), #17 (lost creator: if stuck on a section for 3+ questions, offer /think or skip), #19 (error recovery: if fill encounters malformed scaffold, suggest re-scaffolding).
  6. Load product spec from references/product-specs/{type}-spec.md
  7. Load product DNA from product-dna/{type}.yaml 6b. Load entity ontology (squad/system/agent/workflow/minds): If type ∈ {squad, system, agent, minds, workflow}, read references/entity-ontology.md. This substrate drives semantic elicitation:
    • §AGENT_ROLES: suggest specific roles during composition discovery, adapt questions per role (EXECUTOR gets tool/output questions, ADVISOR gets reasoning questions, VALIDATOR gets criteria questions)
    • §SQUAD_ANATOMY: verify all 8 components are addressed during fill — flag any missing component before completion
    • §COMPOSITION: know what this type can compose with and what's forbidden — guide toward valid compositions
    • §HERITAGE: explain to the creator why certain DNA patterns apply (squad inherits from agent lineage)
    • §INTELLIGENCE_GRADIENT: calibrate autonomy level in routing questions — workflows get deterministic, squads get judgment-based
    • §WORKFLOW_VS_SQUAD: when filling a workflow, enforce YAML-decides (not LLM routing). When filling a squad, surface LLM judgment points
    • §HEURISTICS: if evidence suggests wrong type (e.g., squad with 1 useful agent), surface demotion heuristic as coaching
    • §RUNTIME_BEHAVIOR: calibrate token budget expectations and explain context isolation to the creator
    • §ISOMORPHIC: use human cognitive analogies to explain product role to non-dev creators
    • For type=system ONLY: §SYSTEM_ENGINES — the 13 functional gears. Walk each active gear during fill, ask for concrete implementation decisions, verify counterpart coupling
    • §INTELLIGENCE_PIPELINE — governs how scout research ACTIVELY enters product content (not passively). For EVERY section: check if scout report has relevant findings → propose content from research → creator validates/refines → sparring challenges generic answers. This is the soul of the Engine — condensing intelligence, not just filling templates.
    • §FOUNDATIONAL_THESIS — for EVERY product, ask: "What should this NEVER be able to do?" The answer generates the intelligence flow. Use to guide frontmatter restrictions (denied-tools, paths: scoping).
    • §TRANSVERSAL_AXES — calibrate Nature (procedural/advisory/executive/orchestrative) and Depth (surface/functional/cognitive) during fill. A skill CAN be cognitive-depth. Don't assume type=depth.
    • §CONSTITUTIONAL_PRIMITIVES — for agents and minds, suggest criticalSystemReminder when the product must maintain identity over long conversations (50+ turns). Especially for cognitive minds.
    • §COMPOSITION_PRINCIPLES — when filling a squad or system, apply convergence-by-independence (specialists don't see each other's work until synthesis) and symbiosis rules.
  8. Load domain-map.md if it exists (from /map) → use as knowledge source
  9. Load scout report if .meta.yaml has intent_declaration.scout_source field (canonical location) OR .meta.yaml root-level scout_source field (legacy fallback) → read workspace/{scout_source} for research context. Extract: baseline (Section 1), gaps (Section 2), research findings (Section 4). This intelligence drives research injection in the section walk. 8b. Domain intelligence back-reference: Read STATE.yaml → workspace.products[]. Find products in the same intelligence.domain as the current product. If any exist with intelligence.value_score populated:
    • Read the most recent sibling's .meta.yaml → intelligence and state.overall_score
    • If sibling substance_score < 50: "Your last product in {domain} scored {substance}% substance. Focus on depth and real examples this time."
    • If sibling substance_score >= 70: "Your {domain} products have strong substance ({substance}%). Maintain this depth."
    • This closes the feed-back loop: /validate's output informs /fill's approach.
  10. Scan product files for template placeholders and WHY comments
  11. Intelligence gap check: If .meta.yaml has NO scout_source AND product targets MCS-2+:
    • Show: "No scout report found. Without baseline intelligence, /fill works in creator-knowledge-only mode — no research proposals, no baseline comparison."
    • Suggest: "Run /scout {inferred_domain} first for research-backed filling. Or continue with your expertise."
    • Record fill_config.scout_available: false in .meta.yaml
    • If creator continues without scout, skip research injection steps in section walker
  12. Structured input for choices: If creator.yaml → preferences.workflow_style = guided, use AskUserQuestion for all choice points (enhance/replace/skip, deepening method selection, continue/save progress). Use plain text only for open-ended domain knowledge extraction.
  13. Read fill-protocol.md: Read ${CLAUDE_SKILL_DIR}/references/fill-protocol.md now — it contains the full execution protocol for all phases below. 12b. SELF-CLONE branch (cognitive minds with sub_type=self only). If .meta.yaml.type == "minds" AND .meta.yaml.minds_sub_type == "self":
    • Load the SELF-CLONE content pack: Read references/fill-content-packs/self-clone.md
    • The content pack replaces the standard Discovery, Extraction Mode, and generic Section Walk phases
    • Follow the content pack's walker entry point (§1) which handles:
      • Mode selection (distillation vs elicitation based on corpus density)
      • Distillation pass (if applicable) with creator confirm/refine/reject per entry
      • Gap elicitation with the ordered question sequences per dimension
      • Dimensional routing (primary + secondary tagging)
      • Typology mirror (post-elicitation, three-step protocol)
      • Coherence diff generation
      • Honesty floor gates (counter-proofs, signed incaptable list, uncapturable decisions)
      • Writing populated content into the cognitive mind layer files
    • After the SELF-CLONE walker completes, skip to Completion (step 13 standard flow is bypassed)
    • The Sparring, Checkpointing, and Progress phases from the standard flow still apply during the walker — checkpoint after every two dimensions
    • Record fill_config.self_clone: true in .meta.yaml
    • Do not run this branch for non-SELF cognitive minds or non-minds products — all other types continue to step 12c or 13 12c. SQUAD ORGANISM branch (type=squad only). If .meta.yaml.product.type == "squad":
    • This branch replaces the standard section walker. Squads are organism-level products — the standard single-file walk is insufficient. The squad walker iterates across the full directory tree.
    • Phase 1 — Composition Discovery (if not already answered in /create):
      • Ask archetype if not in .meta.yaml: Sequential Pipeline / Parallel Fan-Out / Conditional Router / Iterative Refinement / Hierarchical Delegation
      • Role-aware composition (entity-ontology.md §AGENT_ROLES): Instead of generic "how many specialists?", present the 7 functional roles: "Each specialist has a functional ROLE that determines tools and output. Select from: EXECUTOR (acts on files), SPECIALIST (deep analysis, read-only), ORCHESTRATOR (coordinates agents), ROUTER (classifies + directs), ADVISOR (thinks, never acts), VALIDATOR (checks quality), TRANSFORMER (converts formats)." Ask: "Name each specialist, their domain, and their role. Example: 'researcher=SPECIALIST, strategist=ADVISOR, executor=EXECUTOR, reviewer=VALIDATOR'." Record role assignment per agent for Phase 3 frontmatter generation.
      • Ask entity lifecycles: "What objects flow through this squad? (e.g., a CAMPAIGN, a LEAD, an EXPERIMENT). Describe the lifecycle stages."
    • Phase 2 — Orchestrator Layer (kernel/):
      • Walk kernel/orchestration.md — fill orchestration protocol. Ask: "How does the coordinator decide what to do? Describe its decision cycle step by step."
      • Walk kernel/elicitation-engine.yaml — fill progressive elicitation rules. Ask: "What questions does the squad ask the user before acting? How does it adapt based on answers?"
      • Walk kernel/intelligence-matrix.yaml — fill scoring/routing intelligence. Ask: "How does the squad score which agents are most relevant for a given request?"
    • Phase 3 — Specialist Agents (agents/):
      • For EACH agent file in agents/*.md:
        • Walk identity, role, tools, escalation rules
        • Map to AGENT ROLE from entity-ontology.md §AGENT_ROLES. The role assigned in Phase 1 determines:
          • Tool boundary: EXECUTOR=Write/Edit/Bash, SPECIALIST/VALIDATOR=Read-only, ORCHESTRATOR=Agent-only (no Write/Edit), ADVISOR=denied-tools
          • Handoff format: EXECUTOR→artifacts, ADVISOR→judgment, ORCHESTRATOR→routing decisions, VALIDATOR→score+verdict, TRANSFORMER→converted output
          • Frontmatter: set allowed-tools or denied-tools per role mapping in the agent .md file
          • Question shape: EXECUTOR→"What does it produce?", ADVISOR→"What reasoning framework?", VALIDATOR→"What criteria?", TRANSFORMER→"What's the input/output format?"
        • If agent has a mind-clone source in minds/: load minds/{name}/cognitive-model.md and use as knowledge substrate
        • Apply D1 (activation protocol), D2 (anti-patterns ≥5), D14 (graceful degradation) per agent
        • Sparring: "What would this specialist REFUSE to do? What's outside its boundary?"
    • Phase 4 — Task Registry (tasks/):
      • Walk tasks/task-registry.yaml — for each specialist, define 3-10 granular tasks with:
        • task_id, description, assigned_agent, input_schema, output_schema, quality_gate
      • Ask per agent: "What are the 3-5 most important things {agent_name} does? For each, what input does it need and what output does it produce?"
    • Phase 5 — Chains & Workflows (chains/, workflows/):
      • Walk chains/chain-registry.yaml — define micro-workflows (2-4 agent sequences with cadences)
      • Walk workflows/*.md — define full pipelines mapping lifecycle stages to agents
      • Ask: "Walk me through the main workflow from start to finish. Which agent handles each step? What passes between them?"
    • Phase 6 — Routing & Handoff (config/):
      • Walk config/routing-table.md — fill declarative routing rules (IF intent → agent)
      • Calibrate routing per §WORKFLOW_VS_SQUAD: Squad routing involves LLM judgment — the orchestrator reads rules BUT interprets contextually. Ensure routing questions surface the judgment points: "When the input is ambiguous, how does the orchestrator decide?" This is what makes it a squad, not a workflow.
      • Use §INTELLIGENCE_GRADIENT to calibrate autonomy: "How much should the orchestrator decide autonomously vs. escalate to the human? Where on the deterministic↔autonomous spectrum should routing sit?"
      • Walk config/handoff-protocol.md — define handoff envelope format (XML or structured)
      • Sparring: "What happens when the input doesn't match any route? What's the fallback?"
    • Phase 7 — Quality & Testing (tests/):
      • Walk test scenarios: happy path, edge case, adversarial, agent failure recovery
    • Anatomy completeness check (entity-ontology.md §SQUAD_ANATOMY): Before transitioning to content state, verify all 8 squad anatomy components have been addressed:
      1. Agent Roster — at least 2 agent files in agents/ with substantive content
      2. Routing Table — config/routing-table.md has routing rules (not just placeholder)
      3. Handoff Protocols — config/handoff-protocol.md has envelope format
      4. Workflows — at least 1 workflow with steps defined in workflows/
      5. Skills-as-Instruments — skills/ directory exists (advisory — some squads don't need shared skills)
      6. Checklists — SQUAD.md has quality/checklist section with ≥2 items
      7. Templates — kernel/ has output format standards
      8. Escalation — SQUAD.md has escalation section with confidence thresholds If any component is missing, flag it: "Your squad is missing {component}. Without it, {consequence}. Want to add it now or defer?"
    • Completion: After all phases, update .meta.yaml with fill_metrics and transition state to content.
    • Record fill_config.squad_organism: true in .meta.yaml 12d. Agent ontology-aware elicitation (type=agent only, non-squad). If type == "agent" AND branch 12c did NOT fire:
    • Entity ontology already loaded at step 6b
    • At the START of the section walk, ask the role question: "What functional role does this agent fill? EXECUTOR (acts on files), SPECIALIST (analysis only), ADVISOR (thinks, never acts), VALIDATOR (checks quality), TRANSFORMER (converts formats)?"
    • Use the selected role to determine:
      • Which tools to suggest in the frontmatter section (EXECUTOR→Write/Edit/Bash, SPECIALIST→Read-only, ADVISOR→denied-tools)
      • What output to expect (artifacts vs reports vs reasoning)
      • What questions to emphasize (EXECUTOR→"What does it produce?", ADVISOR→"What reasoning framework?", VALIDATOR→"What criteria does it check?")
    • Record role in .meta.yaml → agent_role for /validate consumption 12e. Workflow ontology-aware elicitation (type=workflow only). If type == "workflow":
    • Entity ontology already loaded at step 6b
    • Enforce §WORKFLOW_VS_SQUAD: workflows use SKILLS (not agents), have FIXED sequences (not LLM routing), are DETERMINISTIC (same input → same execution path)
    • During the section walk, ask:
      • "What skills does each step invoke?" (NOT "what agents" — workflows don't use agents)
      • "Is the sequence always the same regardless of input?" (If answer is "it depends" → suggest squad: "This sounds like it needs contextual routing — that's a squad, not a workflow. Want to switch?")
      • "What are the gate conditions between steps?" (pass/fail criteria for proceeding)
    • If evidence suggests LLM judgment needed → surface heuristic from §HEURISTICS as coaching
  14. Begin section-by-section guided extraction (see fill-protocol.md → DISCOVERY PHASE)

Core Flow (routing table — details in fill-protocol.md)

PhaseWhat happensProtocol section
Discovery3 front-loaded questions (audience, differentiator, use case)DISCOVERY PHASE
Acceptance CriteriaDefine 3 machine-verifiable criteria before section walkACCEPTANCE CRITERIA CAPTURE
Extraction ModeSelect mode (Standard/Socratic/Adversarial/Archaeological/Council) for MCS-2+EXTRACTION MODE SELECTION
Pitfall CheckLoad meta/pitfalls/pitfalls.json, surface type-relevant warningsPITFALL CHECK
Type CoachingPlatform-specific coaching (claude-md, minds, hooks, skill/agent, system/bundle)TYPE-SPECIFIC COACHING
Section WalkPer-section: read WHY, check existing, inject research, ask, write, quality signalSECTION WALKER
Sparring3 challenges per major section (Generic Test, Inversion, Proof) — mandatory MCS-2+SPARRING PROTOCOL
Deepening5 elicitation methods offered as optional menu after each major sectionELICITATION DEEPENING
CheckpointingWrite fill_progress to .meta.yaml after every section (compact-safe)MID-FILL STATE PERSISTENCE
ProgressPulse every 2-3 sections: filled/total + live MCS estimatePROGRESS TRACKER
ConversationalNarrative extraction mode for non-dev creatorsCONVERSATIONAL MODE
Size CheckAuto-split primary file if >4K chars; suggest @include for claude-md; enforce calibration budget — if intent-aware calibration set a size target, warn when exceededINSTRUCTION SIZE OPTIMIZATION
CompletionPromote to content, auto-validate MCS-1, report result honestly (pass → celebrate; fail → name the failures), clear fill_progressAFTER ALL SECTIONS FILLED

Quality Gate

Before promoting to "content" state:

  • Primary file has at least 3 sections with substantive content
  • No sections contain ONLY placeholder/template text
  • README.md follows templates/readme/README.md.template structure: Hero (problem hook), Install, "Is this for me?", Quick Start, Features (with depth — heading + what + why per feature), Use Cases (scenario table), How It Works, type-specific section, Requirements, Compatibility, Language, License, Footer. Trilingual (EN, PT-BR, ES) with anchor navigation. Each language block has FULL content — not just translated headers.
  • At least one domain-specific insight encoded (not generic)

Auto-validate honesty rule: When the silent MCS-1 check at completion finds failures, the creator-facing message MUST name them. "Looking good" is forbidden when checks fail. Use: "Content captured. {N} structural items need attention before validation passes: {list}. Run /validate --fix to resolve."


Anti-Patterns

  1. Robotic Q&A — Don't be a questionnaire. Be conversational. Reference previous answers. Connect dots between sections.
  2. Overwriting creator edits — If creator has already manually edited a section, don't overwrite. Ask: "This section has content. Enhance, replace, or skip?"
  3. Generic fill — If a section reads like any AI could write it, push: "What's YOUR specific approach here? What would surprise someone reading this?"
  4. Section overload — Don't try to fill everything in one session. After 5-6 sections, offer: "We covered the core. Want to continue or save progress and come back?"
  5. Ignoring domain-map — If domain-map.md exists, USE it. Don't re-ask questions already answered there.
  6. Thin sections without flagging — Never leave a <50 word section without telling the creator it's thin. Section quality signals are mandatory.
  7. Skipping acceptance_criteria — Must-have capture is NOT optional. Without acceptance criteria, /validate has nothing goal-backward to check.
  8. Forgetting persona mid-fill — Re-read creator.yaml persona BEFORE each major section. A developer gets different questions than a marketer, even for the same section.

Compact Instructions

When context is compressed, preserve:

  • Target product slug, type, current phase (scaffold/content)
  • fill_progress.last_completed_section and fill_progress.sections_filled
  • Active extraction mode (fill_config.extraction_mode)
  • Sparring state: sparring.sections_challenged, sparring.skipped
  • Scout availability (fill_config.scout_available)
  • Any blocking issues found during mid-fill quality signals
  • Next section to fill (resume from last_completed_section + 1)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.