home / skills / laurigates / claude-plugins / blueprint-promote

This skill copies a generated rule to the custom layer, preserving modifications and preventing overwrites.

npx playbooks add skill laurigates/claude-plugins --skill blueprint-promote

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
model: opus
created: 2025-12-22
modified: 2026-02-06
reviewed: 2025-12-22
description: "Move generated artifact to custom layer to preserve modifications"
args: "[skill-name|command-name]"
allowed-tools: Read, Write, Bash, AskUserQuestion
argument-hint: "Name of the skill or command to promote"
name: blueprint-promote
---

Copy a generated rule to the custom rules layer for preservation.

**Purpose**:
- Copy generated content from `.claude/rules/` to preserve modifications
- Mark as acknowledged in manifest to prevent overwrite warnings
- Generated rules in `.claude/rules/` are the standard location (v3.0)

**Usage**: `/blueprint:promote [name]`

**Examples**:
- `/blueprint:promote testing-strategies` - Acknowledge a rule's modifications

**Steps**:

1. **Parse argument**:
   - Extract `name` from arguments
   - If no name provided, list available generated rules and ask user to choose

2. **Locate the rule**:
   ```bash
   # Check if it's a generated rule
   test -f .claude/rules/{name}.md
   ```

   If not found:
   ```
   Rule '{name}' not found in generated content.

   Available rules:
   - architecture-patterns
   - testing-strategies
   - implementation-guides
   - quality-standards
   ```

3. **Check if already acknowledged**:
   - Read manifest for `custom_overrides.rules`
   - If already in list, report "Already acknowledged"

4. **Confirm acknowledgment**:
   ```
   question: "Acknowledge modifications to {name}?"
   description: |
     This will:
     1. Mark {name} as user-modified in manifest
     2. Prevent overwrite warnings during sync
     3. Keep the rule in .claude/rules/

   options:
     - label: "Yes, acknowledge"
       description: "Mark as user-modified and preserve changes"
     - label: "No, keep as generated"
       description: "Leave as regeneratable (may show warnings)"
   ```

5. **Update manifest**:
   - Add to `custom_overrides.rules`
   - Update `updated_at` timestamp

   Example manifest update:
   ```json
   {
     "generated": {
       "rules": {
         // testing-strategies still listed
       }
     },
     "custom_overrides": {
       "rules": ["testing-strategies"]  // added
     }
   }
   ```

6. **Report**:
   ```
   Rule modifications acknowledged!

   testing-strategies.md:
   - Location: .claude/rules/testing-strategies.md
   - Status: User-modified (acknowledged)

   This rule will now:
   - Not show modification warnings in /blueprint:sync
   - Still be tracked in manifest
   - Be your responsibility to maintain

   To edit: .claude/rules/testing-strategies.md
   ```

**Architecture note (v3.0)**:
Generated content now goes directly to `.claude/rules/` instead of a separate generated layer.
The manifest tracks which rules are user-modified vs auto-generated.

**Tips**:
- Acknowledge rules you want to customize
- Unacknowledged modified rules will show warnings in /blueprint:sync
- You can regenerate by removing from custom_overrides and running `/blueprint:generate-rules`

Overview

This skill copies a generated rule into the custom rules layer and marks it as acknowledged in the manifest so your edits are preserved. It prevents overwrite warnings during sync and keeps the rule tracked as user-modified. Use it when you want to customize generated rules without losing changes on regeneration.

How this skill works

The skill locates a generated rule in .claude/rules/{name}.md, verifies whether it is already marked as a custom override in the manifest, and prompts you to confirm acknowledging modifications. When confirmed it adds the rule name to custom_overrides.rules in the manifest, updates timestamps, and reports the new status and location.

When to use it

  • You have edited a generated rule and want to keep your changes.
  • You plan to maintain a rule manually and avoid regeneration warnings.
  • Before long-term customizations to rule content in .claude/rules/.
  • When you want to prevent the sync command from flagging this rule as modified.

Best practices

  • Acknowledge only rules you intend to maintain manually to avoid cluttering manifest overrides.
  • Review the rule file in .claude/rules/{name}.md before acknowledging to ensure changes are final.
  • Keep a copy or commit changes in version control after acknowledging for auditability.
  • If you later want to regenerate, remove the rule from custom_overrides.rules and run the generation command.

Example use cases

  • /blueprint:promote testing-strategies — mark testing-strategies.md as user-modified and preserve edits.
  • When a generated implementation-guides.md needs custom company-specific steps, promote it to avoid overwrite.
  • Before a release, acknowledge architecture-patterns.md that you adjusted for your product.
  • When devs customize quality-standards.md and want to stop sync warnings during CI.

FAQ

What if I run the command without a name?

The skill lists available generated rules found under .claude/rules/ and asks you to choose which to promote.

How do I undo an acknowledgment?

Remove the rule name from custom_overrides.rules in the manifest and update the timestamp; the rule will then be treated as regeneratable.

Will promoting move the file location?

No. Generated rules are already placed in .claude/rules/ (v3.0). Promoting only marks the rule as user-modified in the manifest to preserve edits.