Using ChatGPT for Coding: Generation, Review, and Debugging

Write a TypeScript function with the following specification:

Name: validateEmail
Input: email: string
Output: { valid: boolean; normalizedEmail?: string; error?: string }

Behavior:
- Trim whitespace from input before validation
- Validate format against RFC 5322 simplified pattern
- Normalize to lowercase if valid
- Return error message if invalid: "Invalid email format"
- Return normalizedEmail if valid

Constraints:
- No external libraries
- Use TypeScript strict mode compatible types
- No regex more complex than necessary
- Include JSDoc comment

Here is an existing service function in our codebase:
[paste getUser function]

Following the exact same pattern — same error handling, same return type
structure, same logging approach — write a getProject function.

The projects table has these columns: id, name, owner_id, created_at,
settings (jsonb). The function should accept projectId: string and
return the project or null if not found.

I need to implement the parseDateRange function.
Here are the tests it must pass:

[paste test file]

Implement parseDateRange in TypeScript to pass all of these tests.
Do not modify the tests. If a test seems incorrect, flag it but
still write implementation that passes it.

Review this code for security vulnerabilities.

Focus on:
1. SQL injection or query injection risks
2. Authentication and authorization gaps
3. Insecure handling of user input
4. Exposed secrets or credentials
5. Unsafe operations on user-supplied data

Format: [CRITICAL/HIGH/MEDIUM/LOW] Line number: Description of vulnerability.
For CRITICAL and HIGH: suggest the specific fix.

[paste code]

Review this TypeScript code for type safety issues.
The project uses strict mode: no any, no unknown without narrowing,
no non-null assertions without justification.

List all type issues as: [File:Line] Current type: [type] — Issue: [description]
Suggest the correct type for each.

[paste code]

You are reviewing a pull request for architectural coherence.
Our conventions: [describe your conventions briefly]

The PR adds: [describe what it does]

Review for:
- Consistency with existing patterns
- Separation of concerns
- Any coupling that will create maintenance problems
- Missing abstractions that will be needed immediately

Do not flag style issues. Flag only structural concerns.

[paste changed files]

This code throws an error. Identify the root cause and the minimal fix.

Error:
[exact error message and stack trace]

Relevant code:
[paste the relevant functions/files]

Context:
- This error occurs when [describe when it happens]
- It does not occur when [describe when it doesn't]

Do not refactor unrelated code. Minimal change only.

This function produces incorrect output. Find the bug.

Function: [paste function]
Input: [paste example input]
Expected output: [describe what it should return]
Actual output: [paste what it actually returns]

Explain the root cause in one sentence. Show the fixed function.

Review the code you just wrote. Check for:
1. Any TypeScript strict mode violations
2. Edge cases you didn't handle (null inputs, empty arrays, invalid types)
3. Any potential runtime errors

List issues if found. If none, say "No issues found."

Write the validateEmail function AND a test file covering:
- Valid emails
- Invalid format emails
- Emails with leading/trailing whitespace
- Disposable domain emails
- Edge cases: empty string, null-like inputs