Coding Assistant Prompts

Write a [function name] that [what it does].

Tech: [language, framework, libraries]
Input: [parameter types and descriptions]
Output: [return type and format]
Constraints: [performance, dependencies, patterns]
Error handling: [how to handle errors]

Example usage:
[show how function will be called]

Write a validateEmail function that checks if email format is valid.

Tech: TypeScript, no external libraries
Input: email (string)
Output: boolean (true if valid, false if invalid)
Constraints: 
- Pure function (no side effects)
- Support international domains
- Reject disposable email providers
Error handling: return false for invalid input, don't throw

Example usage:
validateEmail("user@example.com") // true
validateEmail("invalid") // false

This code has a bug: [describe symptom]

[paste code]

Expected behavior: [what should happen]
Actual behavior: [what's happening]
Error message (if any): [paste error]

Find the bug and explain the fix.

This code has a bug: user data tidak tersimpan ke database

async function saveUser(data) {
  const user = await prisma.user.create({ data });
  return user;
}

Expected: user data tersimpan dan return user object
Actual: function return user object tapi data tidak ada di database
Error: tidak ada error message

Find the bug and explain the fix.

Refactor this code to [improvement goal].

[paste code]

Requirements:
- [maintain backward compatibility / breaking changes OK]
- [preserve existing tests / update tests]
- [specific patterns to follow]

Constraints:
- [no new dependencies]
- [maintain performance]

Refactor this code to improve readability and type safety.

function processData(data) {
  const result = [];
  for (let i = 0; i < data.length; i++) {
    if (data[i].status === 'active') {
      result.push({
        id: data[i].id,
        name: data[i].name,
        value: data[i].value * 2
      });
    }
  }
  return result;
}

Requirements:
- Convert to TypeScript with proper types
- Use modern array methods (filter, map)
- Maintain backward compatibility (same input/output)

Constraints:
- No external libraries
- Keep function pure (no side effects)

Review this code for [focus areas].

[paste code]

Check for:
- [security issues]
- [performance problems]
- [code smells]
- [best practices violations]

Provide: issue description, severity (high/medium/low), suggested fix.

Review this API endpoint for security and performance issues.

app.post('/api/users', async (req, res) => {
  const { email, password } = req.body;
  const user = await db.query(`SELECT * FROM users WHERE email = '${email}'`);
  if (user) {
    return res.status(400).json({ error: 'User exists' });
  }
  const newUser = await db.query(`INSERT INTO users (email, password) VALUES ('${email}', '${password}')`);
  res.json(newUser);
});

Check for:
- SQL injection vulnerabilities
- Password security issues
- Error handling gaps
- Performance bottlenecks

Format: [SEVERITY] Issue: ... | Fix: ...

Write tests for this function using [test framework].

[paste function]

Test cases to cover:
- [happy path]
- [edge cases]
- [error cases]

Test style: [unit / integration]
Mocking: [what to mock, what to test real]

Write tests for this function using Jest and React Testing Library.

function calculateDiscount(price, discountPercent) {
  if (price < 0 || discountPercent < 0 || discountPercent > 100) {
    throw new Error('Invalid input');
  }
  return price * (1 - discountPercent / 100);
}

Test cases to cover:
- Normal discount (price=100, discount=20 → 80)
- Zero discount (price=100, discount=0 → 100)
- Full discount (price=100, discount=100 → 0)
- Invalid price (negative → throw error)
- Invalid discount (>100 → throw error)

Test style: unit tests
Mocking: none (pure function)

Write documentation for this [function/class/module].

[paste code]

Include:
- Purpose and use case
- Parameters with types and descriptions
- Return value with type
- Example usage
- Edge cases and gotchas

Format: [JSDoc / TSDoc / docstring / markdown]

Write JSDoc documentation for this function.

async function fetchWithRetry(url, options = {}, maxRetries = 3) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, options);
      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      return await response.json();
    } catch (error) {
      lastError = error;
      if (i < maxRetries - 1) await sleep(1000 * (i + 1));
    }
  }
  throw lastError;
}

Include:
- Purpose: retry failed HTTP requests with exponential backoff
- Parameters: url, options, maxRetries
- Return: parsed JSON response
- Throws: error after all retries exhausted
- Example usage

Format: JSDoc with @param, @returns, @throws

I need to implement [feature]. Break it down into steps.

Requirements: [list requirements]
Tech stack: [list tech]

For each step, provide:
1. What to build
2. Files to create/modify
3. Code snippets
4. Testing approach

I need to implement user authentication with email/password.

Requirements:
- Sign up with email verification
- Login with JWT tokens
- Password reset flow
- Protected routes

Tech: Next.js 14, Prisma, PostgreSQL, NextAuth.js

Break down into steps with code for each step.

Step 1: "Write initial implementation of [feature]"
→ AI generates code

Step 2: "This code has issue: [describe]. Fix it."
→ AI fixes

Step 3: "Add error handling for [edge case]"
→ AI adds error handling

Step 4: "Optimize for performance: [specific concern]"
→ AI optimizes

Step 5: "Write tests for this implementation"
→ AI writes tests

// Function to validate credit card number using Luhn algorithm
// Returns true if valid, false otherwise
function validateCreditCard(cardNumber: string): boolean {
  // Copilot will autocomplete the implementation