ChatGPT Prompts for Developers

Review this {{language}} code specifically for security vulnerabilities:

```
{{paste your code}}
```

Check for:
1. Injection attacks (SQL, XSS, command injection, path traversal)
2. Authentication/authorization flaws
3. Sensitive data exposure (logging secrets, hardcoded credentials)
4. Insecure deserialization
5. Missing input validation at trust boundaries

For each vulnerability found:
- Name the vulnerability type (e.g., "CWE-89: SQL Injection")
- Show the vulnerable line
- Explain the attack scenario
- Provide the fixed code

If no vulnerabilities are found, confirm the code is clean and note what was checked.

Analyze this {{language}} code for performance issues:

```
{{paste your code}}
```

Context: This code runs {{frequency}} (e.g., "on every API request", "in a batch job processing 1M records", "on page load").

Check for:
- Unnecessary allocations or copies
- N+1 query patterns
- Missing caching opportunities
- Algorithmic complexity issues (O(n^2) when O(n) is possible)
- Blocking operations that could be async

For each issue, estimate the impact (high/medium/low) and provide an optimized version. Only flag issues that matter at the stated scale — don't micro-optimize code that runs once.

I'm debugging a {{language}} issue in a {{framework}} app.

**Symptom:** {{describe what's happening}}
**Expected:** {{describe what should happen}}
**Environment:** {{dev/staging/prod, OS, versions}}

**Error message (if any):**
```
{{paste error}}
```

**Relevant code:**
```
{{paste code}}
```

**What I've tried:**
- {{attempt 1}}
- {{attempt 2}}

Walk me through debugging this systematically:
1. What are the most likely root causes? (ranked by probability)
2. How to confirm which cause it is (specific commands or logs to check)
3. The fix for each possible cause

Analyze this stack trace and help me fix the issue:

```
{{paste full stack trace}}
```

The application is {{brief description of what the app does}}.

1. Explain in plain English what happened (one paragraph)
2. Identify the line in MY code (not library code) that triggered the issue
3. What is the root cause vs. the symptom?
4. Provide the fix with code
5. How to add error handling to prevent this from crashing in the future

Help me write an Architecture Decision Record (ADR) for this decision:

**Decision:** {{what you're choosing}} (e.g., "Use PostgreSQL over MongoDB for the user service")
**Context:** {{why this decision came up}}
**Constraints:**
- {{constraint 1}} (e.g., "Team has strong SQL experience")
- {{constraint 2}} (e.g., "Budget: $500/month for database costs")
- {{constraint 3}} (e.g., "Must support full-text search")

Write the ADR with these sections:
1. **Status:** Proposed
2. **Context:** The business/technical context (2-3 sentences)
3. **Decision:** What we decided and why
4. **Alternatives considered:** What else we evaluated (pros/cons table)
5. **Consequences:** What changes as a result (both positive and negative)
6. **Review date:** When to revisit this decision

Design a database schema for {{feature_description}}.

Requirements:
{{list your requirements}}

Constraints:
- Database: {{PostgreSQL/MySQL/MongoDB}}
- Expected data volume: {{e.g., "10K users, 1M records"}}
- Key query patterns: {{e.g., "filter by date range", "full-text search on title"}}

Provide:
1. Table definitions with column types, constraints, and indexes
2. Relationships (foreign keys, junction tables for many-to-many)
3. Indexes optimized for the stated query patterns
4. Migration SQL that can run directly
5. One thing I might need to change as the app scales

Generate tests for this {{language}} code using {{test_framework}}:

```
{{paste your code}}
```

Requirements:
- Cover the happy path with realistic data
- Test edge cases: empty input, null/undefined, boundary values, very large input
- Test error paths: invalid input, network failures, permission errors
- Use descriptive test names that explain the expected behavior: "should return empty array when user has no orders"
- Arrange-Act-Assert pattern
- No mocks unless the dependency is external (database, API, filesystem)

For each test, add a brief comment explaining WHY this case matters — what bug would it catch?

Generate API documentation for this endpoint:

```
{{paste your route handler code}}
```

Format as a markdown section with:
1. **Endpoint:** METHOD /path
2. **Description:** One sentence explaining what it does
3. **Authentication:** Required / Optional / None
4. **Request:**
   - Headers (if any)
   - URL parameters
   - Query parameters
   - Request body (JSON schema with types and examples)
5. **Response:**
   - Success response (status code + JSON example with realistic data)
   - Error responses (each possible error code with example)
6. **Example:** Complete curl command that works

Use realistic data in examples (not "string" or "example"). For a user endpoint, use "jane.doe@company.com", not "user@example.com".

Generate a README.md for this project based on these files:

**package.json / pyproject.toml / go.mod:**
```
{{paste dependency file}}
```

**Project structure:**
```
{{paste directory tree}}
```

Include these sections:
1. Project name + one-line description
2. Quick start (3-5 commands to get running locally)
3. Prerequisites (with version numbers)
4. Environment variables (table: name, description, required/optional, example value)
5. Available scripts/commands (table: command, description)
6. Project structure (brief explanation of key directories)
7. Contributing (how to submit changes)

Tone: Technical, concise, no marketing language. Write for a developer who just cloned the repo and wants to get it running in 5 minutes.