Code Snippet Syntax Repair Prompt

This prompt is designed for a specific, narrow job in a production pipeline: repairing a single code snippet that has failed a syntax check. The ideal user is an AI engineer or developer who has already generated code with an LLM and received a concrete error message from a linter, compiler, or interpreter. The core assumption is that the model's initial attempt was structurally close but contains a language-specific syntax error, a missing import, or a minor structural mistake that a targeted few-shot pattern can correct. This is a tactical repair step, not a general-purpose code generator or a debugging assistant.

To use this prompt effectively, you must provide three concrete inputs: the original code snippet, the target programming language, and the exact error message. The prompt's few-shot examples are specifically calibrated for Python, JavaScript, SQL, and shell, making it most reliable for these languages. It is not designed for complex logical bugs, algorithmic errors, or security vulnerabilities. It also assumes the error is resolvable within a single snippet; it will not fetch missing dependencies, refactor large modules, or reason about a codebase's broader architecture. The output is a corrected code block, not an explanation, making it suitable for automated retry loops where the repaired code is immediately re-validated.

Do not use this prompt as a replacement for a full linter, a static analysis security testing (SAST) tool, or a human code review. It is a probabilistic repair step that can introduce new errors, especially if the original error message is ambiguous or the code is highly complex. The workflow must include a validation gate: the repaired output should be immediately tested against the original syntax checker. If the repair fails, the system should either retry with a different strategy or escalate for human review. This prompt is a high-utility, low-cost first line of defense against trivial syntax failures, not a guarantee of correctness.

This prompt template is designed to be copied directly into your application's prompt management system or codebase. It accepts a code snippet that has failed syntax validation, along with the target language and the specific error message, and instructs the model to produce a corrected version. The template uses few-shot examples to demonstrate common repair patterns across Python, JavaScript, SQL, and shell, teaching the model to fix issues like missing imports, incorrect delimiters, and language mismatches without altering the intended logic.

textCopy
You are a precise code syntax repair agent. Your task is to fix syntax errors in the provided code snippet without changing its intended logic or behavior. You will be given the target programming language, the original code, and the specific error message from a syntax validator.

Follow these rules:
- Only fix the syntax error described. Do not refactor, optimize, or add new functionality.
- If the fix requires adding a missing import or dependency declaration, add it at the top of the file.
- If the code appears to be in a different language than stated, rewrite it in the target language while preserving the logic.
- Return ONLY the corrected code inside a fenced code block with the appropriate language identifier. Do not include explanations.

Here are examples of correct repairs:

[EXAMPLES]

Now, repair the following code:

Target Language: [TARGET_LANGUAGE]
Error Message: [ERROR_MESSAGE]

Code to Repair:
[CODE_SNIPPET]

To adapt this template for your environment, replace the square-bracket placeholders with actual values before sending the request to the model. The [EXAMPLES] placeholder is critical: you must populate it with 3-5 few-shot demonstrations that are specific to the languages and error types you expect in production. Each example should follow a consistent format showing the target language, the error message, the broken code, and the corrected code. Start with high-frequency errors from your own logs. The [TARGET_LANGUAGE] should be a precise identifier like Python 3.11, JavaScript ES2022, or PostgreSQL 15. The [ERROR_MESSAGE] should be the raw output from your syntax validator or linter. The [CODE_SNIPPET] is the full code block that failed validation. After receiving the model's response, always run the corrected code through the same syntax validator before accepting it. If the repair fails validation again, increment a retry counter and re-invoke the prompt with the new error message, up to a maximum of 3 attempts before escalating to a human reviewer or logging the failure for analysis.

The Code Snippet Syntax Repair Prompt is designed to sit inside a post-generation repair loop, not as a standalone chat interface. After a model generates code—whether from a coding agent, a documentation tool, or an API response—the raw output passes through a syntax validator (e.g., ast.parse for Python, acorn for JavaScript, or language-specific linters). If validation fails, the malformed snippet and the error trace are fed into this repair prompt as [MALFORMED_CODE] and [ERROR_MESSAGE]. The prompt's few-shot examples teach the model to map common error patterns to corrected code, but the harness must enforce that the repaired output is structurally valid before it reaches the user or downstream system.

Wire the prompt into your application with a validate → repair → re-validate loop. On first failure, call the repair prompt with the original snippet and the validator's error output. Parse the model's response, extract the code block (handling inconsistent markdown fences with a robust extraction function), and run the same validator again. If it passes, return the repaired code. If it fails, retry once with the new error appended to [ERROR_MESSAGE]. After two repair attempts, escalate to a human review queue rather than looping indefinitely—repeated repair attempts on fundamentally broken code risk hallucinated fixes that introduce logic errors. Log every repair attempt with the original code, error trace, model response, and validation result for observability. For high-risk environments (production deployments, customer-facing code execution), add a sandbox execution check: run the repaired code in an isolated container with a timeout and flag any runtime errors, infinite loops, or unexpected side effects before accepting the repair.

Model choice matters here. Use a model with strong code understanding (GPT-4o, Claude 3.5 Sonnet, or equivalent) and set temperature=0 to minimize repair variance. The prompt's few-shot examples cover Python, JavaScript, SQL, and shell; if your pipeline handles additional languages, extend the example set with language-specific syntax error pairs. Store these examples in a version-controlled example library so they can be updated when language versions or common failure patterns change. Avoid using this prompt for logic errors or semantic bugs—it repairs syntax, missing imports, and language mismatches, not algorithmic correctness. For those cases, route to a separate debugging prompt or a human reviewer.