Extract Code Blocks and Generate File Tree Prompt Template

This prompt is designed for developers and platform engineers building project scaffolding tools that consume AI-generated code. The core job is to take a raw model response containing multiple fenced code blocks with file path annotations, extract each block, and reconstruct the intended project directory structure. Use this when your application needs to turn a single AI response into a set of files ready for disk write operations, version control staging, or downstream CI/CD processing. The ideal user is integrating a coding agent, documentation generator, or tutorial builder where the model produces multi-file output in one turn.

Do not use this prompt when the AI response contains only a single file, when file paths are already known and managed by an external orchestrator, or when the primary need is streaming partial blocks for real-time rendering. This prompt assumes batch processing of complete responses. It is also inappropriate for responses where code blocks represent examples or alternatives rather than a cohesive project—using it there will produce a nonsensical file tree with conflicting or orphaned files. The prompt requires that the input model response uses fenced code blocks with explicit file path annotations, either as language tag suffixes or as preceding markdown comments.

Before implementing, ensure your application layer can handle the output: a validated file tree object with directory nodes, file leaf nodes, and content payloads. You must also implement safety checks for path traversal attacks, duplicate file targets, and missing parent directories. If the model response is ambiguous—for example, two blocks claim the same file path or a file has no parent directory—the prompt should flag these for human review rather than silently overwriting or creating orphaned files. Wire the output into a validation step that confirms file count consistency, checks for circular references, and verifies that every code block maps to exactly one file path before any disk write occurs.

This prompt template is the core instruction set for a project scaffolding tool. It directs the model to parse a raw AI response, extract all fenced code blocks with their associated file paths, infer a complete directory structure, and output a validated file tree. The template is designed to be copied directly into your application's system prompt or a dedicated extraction step. It uses square-bracket placeholders for all dynamic inputs, ensuring you can adapt it to different source materials and output requirements without rewriting the core logic.

textCopy
You are a precise code block extraction and file tree generation engine. Your task is to process the provided [INPUT_TEXT] and produce a structured output.

[INPUT_TEXT]:
"""
[RAW_MODEL_RESPONSE]
"""

[OUTPUT_SCHEMA]:
You must output a single valid JSON object conforming to this structure:
{
  "project_name": "string", // inferred from context or 'extracted-project'
  "file_tree": [
    {
      "path": "string", // relative file path, e.g., 'src/utils/helpers.py'
      "content": "string", // the exact code block content
      "language": "string" // the language tag from the fenced code block
    }
  ],
  "warnings": ["string"] // list of any issues found, e.g., orphaned files, missing parent directories
}

[CONSTRAINTS]:
1. Parse all fenced code blocks (```) in [RAW_MODEL_RESPONSE].
2. A code block's file path is determined by the first line immediately preceding the opening fence, which must match the pattern: `// File: [FILE_PATH]` or `# File: [FILE_PATH]`.
3. If a code block has no valid file path comment, add a warning to the "warnings" array and skip the block.
4. Infer the full directory tree from all extracted file paths. Create a flat list of file objects in "file_tree".
5. Detect and report any conflicting path assignments (two blocks for the same file) in "warnings".
6. Do not create content for missing parent directories; just note them in "warnings".
7. The output must be strictly valid JSON with no additional text outside the JSON object.

To adapt this template, replace the [RAW_MODEL_RESPONSE] placeholder with the actual text output from your primary coding agent or LLM call. You can tighten the [CONSTRAINTS] by adding rules for specific language tags, handling nested fences, or enforcing a maximum file count. For high-risk operations where the file tree will be written directly to disk, always add a validation step in your application harness to check for path traversal attacks (e.g., paths containing ../) and to confirm that the target directory is within an allowed project boundary before any file write occurs.

Integrating the extract-code-blocks-and-generate-file-tree prompt into an application requires treating the LLM call as one step in a deterministic pipeline. The prompt itself is designed to produce a structured JSON output containing a fileTree object and a validation report. Your application code, not the model, must own the final file-system writes. Before any disk operation, parse the model's JSON output and run the following application-level checks: reject any file path that contains .. traversal sequences, absolute paths, or characters outside the allowed set for your target operating system. The model's validation.orphanedFiles and validation.conflictingPaths arrays are advisory signals—your harness must treat them as blocking errors that prevent file creation until resolved, either by re-prompting with the specific conflict details or by surfacing the ambiguity to a human reviewer in the scaffold review UI.

Build a retry loop around the prompt call that catches JSON parse failures and schema validation errors. If the model returns malformed JSON, feed the raw output and the parse error message into a repair prompt from the Output Repair and Validation Prompts pillar, requesting a corrected JSON object conforming to the original schema. Set a maximum of two repair attempts before surfacing the failure to the user. For model choice, prefer models with strong JSON mode and structured output guarantees (e.g., GPT-4o with response_format set to json_schema, or Claude 3.5 Sonnet with tool-use extraction). Avoid models with known weaknesses in nested bracket balancing for this task. Log every extraction attempt—including the raw model response, the parsed file tree, validation warnings, and any repair steps—to an observability store keyed by a scaffold_run_id. This trace becomes essential for debugging silent failures where a file is created in the wrong location or with truncated content.

Before integrating this prompt into a production coding agent, implement a dry-run mode that performs all extraction, validation, and conflict detection but writes the proposed file tree to a review artifact instead of disk. This allows you to measure extraction accuracy against a golden dataset of AI-generated project structures. Track precision (did we create only intended files?), recall (did we miss any files the model described?), and path assignment accuracy (did every code block land in its declared directory?). If your application allows users to edit the proposed file tree before confirming, capture those corrections as preference data that can inform future fine-tuning or prompt adjustments. Avoid the common failure mode of trusting the model's file count without cross-referencing: always compare the number of extracted code blocks against the count of files in the generated tree and flag discrepancies for review.