This prompt is for AI coding agents that operate within a limited context window and need a compressed, high-signal overview of a repository before executing a task. The primary job-to-be-done is to produce a dense, structured summary covering the architecture, tech stack, key modules, and conventions of a codebase so that a downstream agent can make accurate decisions without loading every file into its working memory. The ideal user is an AI engineer or platform developer building a coding agent harness where context budgets are tight—typically under 128k tokens—and where every token spent on orientation must earn its place through downstream task accuracy.

Use this prompt when an agent first enters a repository, when it needs to refresh its understanding after a significant number of changes, or when a new sub-agent is spawned to handle a specific domain within a monorepo. The required inputs include a structured file inventory, key configuration files, a dependency manifest, and a directory tree. The prompt is not a replacement for targeted file retrieval during task execution; it is a pre-computed or just-in-time memory artifact. Do not use this prompt when the agent already has a fresh, task-specific context assembled, or when the repository is small enough to fit entirely in the context window without compression.

The prompt is designed to be paired with a validation harness that checks the summary against a set of downstream task-completion metrics. If the summary omits a critical module, misidentifies the primary language, or hallucinates a build command, the agent will fail silently on subsequent steps. Before relying on this prompt in production, run it against a golden set of repositories where you know the correct answers for architecture, entry points, and conventions. Measure whether agents using the summary complete representative tasks—such as adding a feature, fixing a bug, or writing a test—at an acceptable accuracy rate. If accuracy drops, the summary is either too compressed or contains errors that must be caught by the harness before the summary is committed to agent memory.

The following prompt template is designed to produce a compressed, structured overview of a codebase that an AI coding agent can store in its working memory. It forces the model to prioritize architectural patterns, key modules, and critical conventions over exhaustive file listings, making it suitable for agents with tight context windows. The template uses square-bracket placeholders that you must replace with concrete values from your agent's discovery phase before execution.

textCopy
You are an expert software architect creating a dense, high-signal summary of a codebase for an AI coding agent with a limited context window. Your summary will be the agent's primary memory of the repository. It must be accurate, concise, and structured for rapid retrieval.

## Repository Context
- Repository Path: [REPO_ROOT]
- Primary Language(s): [LANGUAGES]
- Build System(s): [BUILD_SYSTEMS]
- Framework(s): [FRAMEWORKS]

## Input Data
You are provided with the following pre-assembled context from the repository exploration phase:
- A directory tree of the top [MAX_DEPTH] levels: [DIRECTORY_TREE]
- Key configuration file contents: [CONFIG_FILES]
- A list of discovered entry points: [ENTRY_POINTS]
- A dependency graph summary: [DEPENDENCY_SUMMARY]
- A symbol index of major public interfaces: [SYMBOL_INDEX]

## Output Schema
Produce a JSON object conforming to this exact structure:
{
  "architecture_overview": "A single paragraph describing the high-level architecture, main components, and data flow.",
  "tech_stack": {
    "languages": ["string"],
    "frameworks": ["string"],
    "databases": ["string"],
    "message_brokers": ["string"],
    "key_libraries": ["string"]
  },
  "top_level_modules": [
    {
      "name": "string",
      "path": "string",
      "responsibility": "string",
      "public_interfaces": ["string"]
    }
  ],
  "critical_conventions": {
    "naming": "string",
    "error_handling": "string",
    "testing": "string",
    "dependency_injection": "string"
  },
  "entry_points": [
    {
      "type": "http_server | cli | worker | cron",
      "file": "string",
      "description": "string"
    }
  ],
  "anti_patterns_and_risks": ["string"],
  "agent_guidance": "A paragraph with specific advice for an AI coding agent working in this codebase, including files to avoid modifying, required review processes, and common pitfalls."
}

## Constraints
- The entire output must not exceed [MAX_OUTPUT_TOKENS] tokens.
- Prioritize information that would be most useful for an agent planning a code change.
- If you are uncertain about a field, mark it explicitly with "UNCERTAIN: <your best guess>" rather than omitting it.
- Do not invent libraries, frameworks, or modules not present in the input data.
- For the `agent_guidance` field, be specific and actionable. Avoid generic advice like "follow best practices."

To adapt this template for your agent harness, replace the placeholders with values gathered during the repository exploration phase. The [DIRECTORY_TREE], [CONFIG_FILES], [ENTRY_POINTS], [DEPENDENCY_SUMMARY], and [SYMBOL_INDEX] placeholders should be populated by upstream tool calls—such as list_files, read_file, and search_symbols—before this prompt is assembled. Set [MAX_OUTPUT_TOKENS] based on your agent's remaining context budget after accounting for system prompts and other memory. A typical value is 1500-2500 tokens. If your agent uses a model with strong JSON mode, append a final instruction to enforce the schema strictly; otherwise, include a retry harness that validates the JSON structure and requests corrections for missing or malformed fields.

The repository summary prompt is not a one-off query; it is a memory injection step that runs before task execution and after repository discovery. The harness must call this prompt when the agent's context window is too small to hold the full codebase map, typically after the initial scan and symbol indexing steps have completed. The prompt consumes a structured inventory of files, directories, and key symbols and compresses it into a dense summary that fits within a predefined token budget. The output becomes part of the agent's persistent working memory for the session, so the harness must store it, version it, and invalidate it when the repository state changes.

Wire the prompt into a pipeline with these stages: input assembly, token budget enforcement, model invocation, output validation, and memory injection. For input assembly, collect the outputs from upstream discovery prompts—directory tree, entry points, build system, language map, and dependency graph—and serialize them into a single structured [CODEBASE_INVENTORY] block. Truncate or summarize the inventory if it exceeds the model's context limit before adding the prompt template. Set a hard [TOKEN_BUDGET] constraint in the prompt (e.g., 2000 tokens) and enforce it post-generation by counting tokens and rejecting summaries that exceed the budget. Use a mid-tier model like GPT-4o or Claude 3.5 Sonnet for this task; smaller models often omit critical architectural details when forced to compress. Implement a retry loop with a stricter budget on failure: if the first attempt exceeds the budget, retry with a 20% lower token limit and an explicit instruction to cut redundant descriptions. Log every attempt, the token count, and the validation result for debugging compression failures.

Validation must check three things before the summary enters agent memory. First, completeness: verify that the summary mentions every top-level directory and build system identified in the discovery phase. A simple keyword match against directory names catches most omissions. Second, hallucination: check that every file path, module name, and technology claim in the summary appears in the source inventory. Flag any invented paths or frameworks for human review. Third, downstream task accuracy: run a lightweight eval where the agent, armed only with the summary, must answer a set of pre-written questions about the codebase (e.g., 'Where are tests located?' or 'What is the primary language?'). If accuracy drops below 90%, the summary is too lossy and needs regeneration with a higher token budget or a different compression strategy. For high-risk repositories where incorrect architecture understanding could cause destructive edits, require human approval of the summary before the agent proceeds to any file modification tasks. Store the approved summary alongside the session ID and git commit hash so future debugging can correlate agent behavior with its compressed worldview.