AI Prompts for Developers

You are a senior [language, e.g. Python/TypeScript] engineer. Debug the following issue using step-by-step reasoning.

Let's work through this systematically:
1. First, identify what the code is supposed to do
2. Then trace through what it actually does
3. Identify where the behaviour diverges
4. Hypothesise the root cause
5. Propose a fix and explain why it works

Code:
```
[PASTE YOUR CODE HERE]
```

Error/unexpected behaviour:
[describe what's going wrong]

Environment: [language version, framework, relevant dependencies]

Perform a thorough code review using the CO-STAR framework.

Context: This code is part of [what the system does]. It will be reviewed by [team size]-person team.
Objective: Review for correctness, performance, security vulnerabilities, readability, and adherence to [e.g. SOLID principles / our team conventions].
Style: Be direct and specific. No generic feedback — every comment must reference a line or pattern.
Tone: Constructive. Distinguish blocking issues from suggestions.
Audience: The author is a [junior/mid/senior] developer.
Response format: Structured sections — Critical Issues / Warnings / Suggestions / Positives. Include code snippets for recommended changes.

```
[PASTE CODE HERE]
```

Generate technical documentation using the ICIO framework.

Instruction: Write comprehensive developer documentation for the following code.
Context: This is a [public API / internal module / CLI tool] used by [audience]. Documentation will live in [README/Notion/Confluence/GitHub].
Input:
```
[PASTE YOUR CODE / API SPEC HERE]
```
Output format:
- Overview (2–3 sentences)
- Installation / setup
- Usage examples (at least 3, covering common cases and an edge case)
- Parameters / options table
- Return values
- Error handling
- Known limitations

Role: You are a principal software architect with experience in [domain, e.g. distributed systems / B2B SaaS / real-time applications].

Task: Help me design the architecture for [what you're building]. Consider:
- Data flow and storage
- Scalability requirements: [expected load, growth rate]
- Key constraints: [budget, team size, existing stack]
- Trade-offs between [e.g. consistency vs availability / build vs buy]

Format:
1. Recommended architecture with rationale
2. Component diagram description (text-based)
3. Top 3 trade-offs I'm accepting
4. Biggest risks and how to mitigate them
5. What I'd do differently at 10x scale

Generate production-ready code using the PACT framework.

Purpose: I need to [what the code should do] as part of [larger system context].
Action: Write the complete implementation in [language/framework].
Constraints:
- Must handle: [edge cases, e.g. null inputs, concurrent access, rate limits]
- Must NOT: [e.g. use external libraries beyond X, use global state, use any deprecated APIs]
- Performance: [e.g. must handle 10k req/s, under 100ms p99]
- Security: [e.g. sanitise all user inputs, no SQL concatenation]
Tone (code style): [e.g. functional, follows team conventions in the attached example, heavily commented for junior readers]

Also provide: unit test cases for the happy path and top 2 edge cases.

Refactor the following code. Think through it step by step before making changes.

Step 1: Identify what this code actually does (ignore variable names, understand intent)
Step 2: Identify specific problems — long functions, repeated logic, unclear naming, missing error handling
Step 3: Prioritise which issues to fix (highest value / lowest risk first)
Step 4: Provide the refactored version
Step 5: Explain each change made and why

Constraints:
- Preserve existing behaviour exactly — this is not a feature change
- Do not introduce new dependencies
- Target: [e.g. Python 3.11 / TypeScript strict mode]

```
[PASTE LEGACY CODE HERE]
```

Solve the following engineering problem using a Reason-Act-Observe approach.

Problem: [describe the engineering challenge]
System context: [relevant architecture, constraints, current state]

For each step:
Thought: What's the best next action and why?
Action: What specifically should be done?
Observation: What would the result tell us?

Continue until you have a complete solution. If multiple approaches exist, evaluate each before committing.

End with:
- Recommended solution (1 paragraph)
- Implementation steps in order
- Testing strategy

Design a REST API using the ICIO framework.

Instruction: Design a complete REST API for [what the API does].
Context: This API will be [public-facing / internal / consumed by mobile app / consumed by third parties]. Expected scale: [requests/day]. Stack: [backend language/framework, database].
Input: Here are the core entities and operations needed:
[list your entities and what operations are needed — e.g. 'User: create, read, update, delete; Post: create, list by user, delete']
Output format:
- Endpoint table: Method / Path / Description / Request body / Response
- Authentication approach
- Error response format (with example)
- Pagination strategy
- At least 2 versioning considerations

Role: You are a senior QA engineer who writes tests that actually find bugs, not just pass.

Task: Write comprehensive test cases for the following code/feature.
Cover:
- Happy path (expected inputs → expected outputs)
- Boundary conditions (empty, null, min/max values)
- Error paths (what should fail gracefully)
- Concurrency / race conditions if applicable
- Security edge cases (injection, overflow, unexpected types)

Format: Use [testing framework, e.g. Jest/pytest/JUnit] syntax. Each test should have a descriptive name that reads like a sentence. Group tests by scenario.

Code/feature to test:
```
[PASTE CODE OR FEATURE DESCRIPTION]
```

Explain a technical concept to a non-technical audience using CO-STAR.

Context: I need to explain [technical concept/decision] to [audience, e.g. 'the product team and CEO']. They understand business outcomes but not technical implementation.
Objective: Help them understand what this is, why it matters, and what decision they need to make.
Style: Use analogies. Avoid acronyms unless explained. Lead with business impact.
Tone: Confident and clear, not condescending.
Audience: [describe their background and what they care about]
Response: 3-minute verbal explanation + a 5-bullet slide summary + the one question they will definitely ask and how to answer it.

Concept to explain: [describe what you're explaining]