Structured Prompts with XML Tags

<context>
You're building a user management API for a SaaS application.
The tech stack is Node.js, Express, and PostgreSQL.
</context>

<task>
Create an endpoint to update user profiles.
</task>

<requirements>
- Accept PATCH requests
- Validate all inputs
- Return updated user object
</requirements>

<constraints>
- Use Zod for validation
- Don't expose password field
- Follow REST conventions
</constraints>

<input>
const data = [1, 2, 3, 4, 5];
const doubled = data.map(x => x * 2);
</input>

<expected_output>
Explain what this code does in plain English.
</expected_output>

<existing_code>
// Current implementation
export const fetchUser = async (id: string) => {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
};
</existing_code>

<task>
Add error handling and TypeScript types to this function.
</task>

<examples>
  <example>
    <input>snake_case_name</input>
    <output>snakeCaseName</output>
  </example>
  <example>
    <input>SCREAMING_SNAKE</input>
    <output>screamingSnake</output>
  </example>
</examples>

<task>
Convert this variable name using the same pattern:
<input>user_profile_data</input>
</task>

<role>
You are a senior code reviewer focusing on quality and maintainability.
</role>

<code_to_review>
export async function processOrder(order) {
  const user = await db.users.find(order.userId);
  if (user.balance >= order.total) {
    user.balance -= order.total;
    await db.users.update(user);
    await db.orders.create(order);
    return { success: true };
  }
  return { success: false };
}
</code_to_review>

<review_criteria>
- Error handling
- Type safety
- Transaction safety
- Edge cases
- Naming conventions
</review_criteria>

<output_format>
For each issue found:
1. Location (line/section)
2. Severity (Critical/High/Medium/Low)
3. Description
4. Suggested fix
</output_format>

<error_message>
TypeError: Cannot read property 'map' of undefined
at UserList (UserList.tsx:15)
</error_message>

<relevant_code>
const UserList = ({ users }) => {
  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
};
</relevant_code>

<context>
- Component receives users from parent via props
- Parent fetches users from API on mount
- Error occurs on initial render
</context>

<task>
1. Explain why this error occurs
2. Provide a fix
3. Suggest preventive measures
</task>

<feature_description>
Add a "save draft" feature to the blog post editor that auto-saves
every 30 seconds and allows manual save with keyboard shortcut.
</feature_description>

<existing_architecture>
- React 18 with TypeScript
- Zustand for state management
- React Query for server state
- API endpoint: POST /api/posts/drafts
</existing_architecture>

<requirements>
- Auto-save every 30 seconds when content changes
- Manual save with Cmd/Ctrl + S
- Show save status indicator
- Handle offline scenarios
- Debounce auto-save to prevent excessive API calls
</requirements>

<constraints>
- Must integrate with existing PostEditor component
- Must not block UI during save
- Must handle concurrent save attempts
</constraints>

<output>
1. Updated component code
2. New hooks if needed
3. API integration
4. Brief explanation of approach
</output>

<instructions>
Analyze the following SQL query for potential performance issues.
Check for missing indexes, full table scans, and N+1 patterns.
</instructions>

<sql_query>
SELECT * FROM users
WHERE created_at > '2024-01-01'
ORDER BY last_login DESC;
</sql_query>

<table_info>
users: 2.5M rows, indexes on (id), (email)
</table_info>

<task>
  <objective>
  Create a REST API for a todo application.
  </objective>

  <endpoints>
    <endpoint>
      <method>GET</method>
      <path>/todos</path>
      <description>List all todos with pagination</description>
    </endpoint>
    <endpoint>
      <method>POST</method>
      <path>/todos</path>
      <description>Create a new todo</description>
    </endpoint>
  </endpoints>

  <tech_stack>
    <runtime>Node.js 20</runtime>
    <framework>Express</framework>
    <database>PostgreSQL</database>
    <validation>Zod</validation>
  </tech_stack>
</task>

<workflow>
  <step number="1">
    <action>Analyze the current code structure</action>
    <output>List of files and their purposes</output>
  </step>

  <step number="2">
    <action>Identify areas needing refactoring</action>
    <output>Prioritized list of improvements</output>
  </step>

  <step number="3">
    <action>Implement the top priority refactor</action>
    <output>Refactored code with explanation</output>
  </step>
</workflow>

<code_to_analyze>
[your code here]
</code_to_analyze>

<response_format>
Respond using this exact structure:

## Summary
[One paragraph overview]

## Issues Found
[Bulleted list]

## Recommendations
[Numbered list with priority]

## Code Changes
[Code blocks with before/after]
</response_format>

<task>
Review this code and respond according to findings.
</task>

<if_no_issues>
Respond with: "Code looks good! No issues found."
</if_no_issues>

<if_issues_found>
List each issue with:
- Description
- Severity
- Fix suggestion
</if_issues_found>

<code>
[code to review]
</code>

<a>Review this code</a>
<b>function add(x, y) { return x + y; }</b>

<task>Review this code</task>
<code>function add(x, y) { return x + y; }</code>

<prompt>
  <greeting>Hello</greeting>
  <request>
    <main_request>Please review</main_request>
    <sub_request>this code</sub_request>
  </request>
</prompt>

<task>Please review this code</task>
<code>[code here]</code>

<code>
const x = 1;
</code>  <!-- Don't forget this -->

<examples>
  <example>
    <input>getUserById</input>
    <output>get_user_by_id</output>
  </example>
</examples>

<task>
Convert to snake_case: fetchOrderDetails
</task>

<task>
Debug this function step by step.
</task>

<reasoning_steps>
1. Identify the expected behavior
2. Trace the actual execution
3. Find the discrepancy
4. Propose a fix
</reasoning_steps>

<code>
[buggy code]
</code>