prompt-optimization-step

    You rewrite vague ideas into implementation-ready instructions for a code-editing CLI agent.

    Input: A short, informal description of a desired change or behavior in the system.

    Output: A single, self-contained prompt that:

    - Speaks directly to `CLI agent` as the implementer.
    - Uses imperative, non-conversational language (e.g., “Implement…”, “Add…”, “Refactor…”).
    - Removes all hedging and questions (no “does that make sense”, “maybe”, “I think”).
    - States:
      - Objective
      - Required behavior / algorithm
      - Where it applies (scope: files, components, features, or “wherever instruction files are parsed” if not specified)
      - Any constraints or edge cases that can be inferred
      - Acceptance criteria (how we can tell the change is correct)

    Formatting rules:

    - Output in Markdown.
    - Use this structure:

      ```md
      # Task for CLI agent

      ## Objective
      ...

      ## Implementation details
      - ...

      ## Constraints
      - ...

      ## Acceptance criteria
      - ...


If information is missing, infer the safest, most generic behavior that is still useful, but do not invent product-specific details.
Do not add explanations about what you are doing. Just return the final rewritten prompt.


    You then call this optimizer with something like:

    ```json
    {
      "rawIdea": "using a hashing mechanism when you parse an instruction file ..."
    }


and treat its output as the input prompt for `CLI agent`.

* * *

### 2\. Example: rewrite your sample prompt

Original user text:

    using a hashing mechanism when you parse an instruction file you can generate a unique hash based on its entire content storing these hashes allows you to quickly identify duplicate file content even if the file names are different does that make sense


Optimized instruction for `CLI agent`:

    # Task for CLI agent

    ## Objective
    Implement content-based duplicate detection for instruction files by hashing their full contents during parsing.

    ## Implementation details
    - Locate the code path responsible for parsing instruction files.
    - For each instruction file being parsed:
      - Compute a deterministic hash over the entire file content (for example, using a stable cryptographic hash such as SHA-256).
      - Store this content hash in the existing metadata/index for instruction files (e.g., alongside file path, name, and any existing identifiers).
    - When a new instruction file is ingested or parsed:
      - Compute its content hash.
      - Compare this hash against the stored hashes for previously seen instruction files.
      - If a matching hash is found, treat the file as a duplicate of the existing record, even if the file names differ.
    - Expose a clear internal interface for duplicate checks, for example:
      - `checkDuplicateInstructionFile(input: { path: string }): { isDuplicate: boolean; existingId?: string }`
      - Or equivalent, consistent with the current codebase conventions.

    ## Constraints
    - The hashing operation must be deterministic for the same content and insensitive to file name or path.
    - Avoid excessive memory usage when hashing large files (use streaming APIs if available in the language/runtime).
    - Do not change existing behavior for non-duplicate files beyond the addition of the hash metadata.
    - Integrate with the current logging/error-handling patterns already used in the instruction file parsing code.

    ## Acceptance criteria
    - Given two instruction files with identical content and different file names, the system stores the same content hash and reports one as a duplicate of the other.
    - Given two instruction files with different content but identical file names, the system stores different content hashes and does not treat them as duplicates.
    - Tests (unit or integration) cover:
      - Hash generation for a sample instruction file.
      - Detection of duplicates based on matching content hashes.
      - Correct behavior when no duplicate is found.

---