Home » AI Prompts Tutorial

AI Prompts for Debugging

Debugging is the process of identifying, understanding, and fixing problems in software. AI can help developers analyze error messages, inspect source code, understand unexpected behavior, identify possible causes, and suggest debugging approaches.

In this chapter, you will learn 51 practical AI prompts for debugging. These prompts cover syntax errors, runtime errors, logical errors, exceptions, API problems, database issues, frontend problems, performance issues, test failures, and other common debugging tasks.

1. Explain an Error Message

Error messages often contain useful information, but they may not always be easy to understand. AI can explain the meaning of an error, identify the likely source, and suggest what should be investigated.

Example

Explain the following error message in simple English.

Error:
[Paste error message here]

Also provide:
- What the error means
- Common causes
- Where to look in the code
- Recommended debugging steps

2. Find the Bug in Code

When a program does not behave as expected, AI can review the source code and identify suspicious sections. Providing the expected and actual behavior makes the analysis more useful.

Example

Review the following Python code and identify the bug.

Expected behavior:
The function should return the largest number in a list.

Actual behavior:
It sometimes returns the wrong value.

Identify:
- Possible bug
- Why it occurs
- Corrected code
- Explanation of the fix

[Paste code here]

3. Debug a Syntax Error

Syntax errors prevent a program from being parsed or compiled correctly. AI can identify missing characters, incorrect syntax, and other structural problems in the source code.

Example

Debug the following Java code for syntax errors.

Provide:
- The line containing the problem
- Explanation of the syntax error
- Corrected code
- Brief explanation of the correction

[Paste code here]

4. Debug a Runtime Error

Runtime errors occur while a program is executing. AI can help analyze the error message, execution flow, and relevant code to identify possible causes.

Example

Debug the following Python runtime error.

Error:
[Paste error message]

Code:
[Paste code]

Explain:
- What caused the runtime error
- Which line is likely responsible
- How to fix it
- How to prevent similar errors

5. Debug a Logical Error

Logical errors occur when a program runs successfully but produces an incorrect result. AI can compare the intended behavior with the actual implementation and identify where the logic differs.

Example

Find the logical error in the following code.

Expected result:
The discount should be 20% when the purchase amount
is greater than or equal to 5000.

Actual result:
The discount is not calculated correctly.

Review the conditions and calculations and explain the issue.

[Paste code here]

6. Debug an Infinite Loop

An infinite loop occurs when a loop does not reach its termination condition. AI can inspect the loop condition and variables that control the loop to identify why it does not terminate.

Example

Debug the following code for an infinite loop.

Identify:
- Loop condition
- Variable controlling the loop
- Why the loop does not terminate
- Corrected implementation

[Paste code here]

7. Debug a Null or None Error

Null-related errors occur when code attempts to access or operate on a value that is missing. AI can trace where the value is created, assigned, and used to identify possible causes.

Example

Debug the following code for a null or None-related error.

Error:
[Paste error message]

Identify:
- Where the null value originates
- Where it is used incorrectly
- Why it can become null
- Recommended fix

[Paste code here]

8. Debug an Index Error

Index errors occur when code attempts to access an element outside the valid range of an array, list, or other indexed structure. AI can inspect the indexing logic and identify incorrect assumptions about collection size.

Example

Debug the following code for an index out-of-range error.

Explain:
- Which index is invalid
- Why the index becomes invalid
- Corrected code
- How to safely handle different list sizes

[Paste code here]

9. Debug a Type Error

Type errors occur when an operation is performed on an incompatible data type. AI can identify the conflicting types and suggest appropriate conversions or changes to the program logic.

Example

Debug this Python TypeError.

Error:
[Paste error message]

Code:
[Paste code]

Identify:
- Conflicting data types
- Where the mismatch occurs
- Why it happens
- Corrected code

10. Debug a Compilation Error

Compilation errors prevent source code from being successfully compiled. AI can analyze compiler messages and source code to identify syntax, type, declaration, or dependency-related problems.

Example

Analyze the following C++ compilation error.

Compiler output:
[Paste compiler output]

Source code:
[Paste relevant code]

Identify:
- Root problem
- Error location
- Corrected code
- Explanation of the compiler message

11. Debug a Failed Unit Test

A failed unit test indicates that the actual behavior does not match the expected result defined by the test. AI can compare the test, implementation, and failure output to identify possible causes.

Example

Debug the following failed Python unit test.

Test:
[Paste test]

Implementation:
[Paste implementation]

Failure:
[Paste failure output]

Determine whether the problem is likely in:
- Test logic
- Application code
- Test data
- Environment

Explain your reasoning.

12. Debug Multiple Test Failures

When many tests fail at the same time, the failures may share a common cause. AI can group related failures and help identify whether they may originate from the same component or recent change.

Example

Analyze the following test failures.

Group failures that may have a common cause.

For each group provide:
- Related tests
- Common component
- Error pattern
- Possible root cause
- Recommended investigation steps

[Paste test failure results here]

13. Debug a Failing API Request

API failures can result from incorrect URLs, request methods, headers, authentication, parameters, or server-side errors. AI can compare the request and response details to identify likely issues.

Example

Debug the following REST API request.

Request:
Method: POST
URL: [URL]
Headers: [Headers]
Body: [Request body]

Response:
Status: [Status code]
Body: [Response body]

Identify the most likely cause of the failure and
provide debugging steps.

14. Debug a 400 Bad Request

A 400 response generally indicates that the server could not process the request because of a problem with the request. AI can inspect the request structure and response details to identify potential validation or formatting issues.

Example

Debug this HTTP 400 Bad Request response.

Request:
[Paste request]

Response:
[Paste response]

Check:
- Request body
- Required fields
- Data types
- Parameter names
- Headers
- JSON formatting

Explain the likely issue.

15. Debug a 401 Unauthorized Error

Authentication problems can cause an API to return a 401 response. AI can help review the authentication flow, token handling, headers, and request configuration.

Example

Debug this API 401 Unauthorized error.

Review:
- Authentication method
- Authorization header
- Token format
- Token expiration
- Login flow
- Environment configuration

Do not expose or reproduce any real credentials.

[Paste sanitized request and response details here]

16. Debug a 403 Forbidden Error

A 403 response generally means that the request was understood but access was not permitted. AI can help identify potential authorization, permission, or access-control issues from sanitized request details.

Example

Analyze this HTTP 403 Forbidden response.

Context:
[Describe the authorized application]

Request:
[Paste sanitized request]

Response:
[Paste response]

Check possible causes related to:
- User permissions
- Roles
- Authorization rules
- Resource access
- Application configuration

17. Debug a 404 Not Found Error

A 404 error can occur when a requested resource or route does not exist. AI can compare the requested URL with the available routes and configuration to identify possible mistakes.

Example

Debug the following HTTP 404 error.

Requested URL:
[URL]

Expected endpoint:
[Expected endpoint]

Available routes:
[Paste routes]

Identify:
- URL mismatch
- Incorrect route
- Missing resource
- Configuration issue

Suggest the most likely correction.

18. Debug a 500 Server Error

A 500 error indicates that the server encountered an unexpected condition. AI can analyze server logs, stack traces, and relevant source code to help narrow down the cause.

Example

Analyze this HTTP 500 error.

Server log:
[Paste sanitized log]

Stack trace:
[Paste stack trace]

Relevant code:
[Paste code]

Identify:
- Likely failure point
- Possible root causes
- Information needed for confirmation
- Recommended debugging steps

19. Debug Database Connection Errors

Database connection problems can prevent applications from reading or writing data. AI can help analyze connection errors and configuration information without requiring sensitive credentials.

Example

Debug the following database connection error.

Database:
MySQL

Error:
[Paste error]

Configuration:
- Host: [host]
- Port: [port]
- Database name: [database]
- Username: [username]

Do not include the password.

Identify possible causes and recommended checks.

20. Debug a SQL Query

SQL queries can fail because of syntax errors, incorrect joins, invalid column names, or incorrect filtering logic. AI can review the query and database schema to identify possible problems.

Example

Debug the following MySQL query.

Query:
[Paste SQL query]

Expected result:
[Describe expected result]

Actual result:
[Describe actual result]

Schema:
[Paste relevant table definitions]

Identify the problem and provide a corrected query.

21. Debug Incorrect SQL Results

A SQL query may execute successfully while returning incorrect results. AI can compare the query logic with the expected business rule to identify issues with joins, filters, grouping, or aggregation.

Example

The following SQL query executes successfully but returns
incorrect results.

Expected:
One row per customer showing total order value.

Query:
[Paste query]

Tables:
[Paste relevant schema]

Explain why the result may be incorrect and provide
a corrected query.

22. Debug a JOIN Problem

Incorrect joins can create missing records, duplicate rows, or incorrect totals. AI can inspect table relationships and join conditions to identify the likely issue.

Example

Debug this SQL JOIN.

Tables:
customers(id, name)
orders(id, customer_id, amount)

Query:
[Paste query]

Expected:
Every customer with their total order amount.

Actual:
Some customers appear multiple times.

Explain the cause and provide a corrected query.

23. Debug a Frontend JavaScript Error

Frontend errors can prevent user interface functionality from working correctly. AI can analyze browser console errors and related JavaScript code to identify possible causes.

Example

Debug this JavaScript browser error.

Console error:
[Paste error]

Relevant code:
[Paste code]

Explain:
- What the error means
- Which line is responsible
- Why it happens
- Corrected code

24. Debug a React Component

React components can fail because of incorrect state management, props, effects, rendering logic, or event handling. AI can review the component and its error output to identify possible issues.

Example

Debug this React component.

Problem:
The component does not display updated user information
after the API request completes.

Code:
[Paste component]

Explain:
- What causes the problem
- How state or props are involved
- Corrected implementation
- Why the fix works

25. Debug a CSS Layout Problem

CSS layout problems can result from conflicting styles, incorrect dimensions, positioning, flexbox, grid, or responsive rules. AI can review the HTML and CSS to identify likely causes.

Example

Debug the following CSS layout problem.

Problem:
The two cards should appear side by side on desktop,
but they appear vertically stacked.

HTML:
[Paste HTML]

CSS:
[Paste CSS]

Identify the cause and provide corrected CSS.

26. Debug Responsive Design

Responsive problems occur when a webpage does not adapt correctly to different screen sizes. AI can analyze media queries, layout rules, and element dimensions to suggest improvements.

Example

Debug this responsive design problem.

Problem:
The navigation menu overflows horizontally on mobile devices.

HTML:
[Paste HTML]

CSS:
[Paste CSS]

Target:
- Desktop navigation
- Mobile-friendly navigation

Identify the issue and provide a corrected approach.

27. Debug an Async/Await Problem

Asynchronous code can produce unexpected behavior when promises are not awaited correctly or errors are not handled. AI can inspect the asynchronous flow and identify possible timing or error-handling problems.

Example

Debug this JavaScript async/await code.

Problem:
The API result is undefined even though the request succeeds.

Code:
[Paste code]

Explain:
- Where the asynchronous flow is incorrect
- How the return value is handled
- Corrected code

28. Debug a Promise Error

Promise-related problems can occur when promises are not returned, resolved, or rejected as expected. AI can trace the promise chain and identify where the behavior differs from the intended flow.

Example

Debug the following JavaScript Promise code.

Problem:
The final result is never printed.

Code:
[Paste code]

Identify:
- Where the promise chain breaks
- Whether return statements are missing
- How errors should be handled
- Corrected code

29. Debug a Memory Leak

Memory leaks can cause an application to consume increasing amounts of memory over time. AI can review code for common patterns that may prevent objects or resources from being released.

Example

Review the following code for possible memory leaks.

Application:
Node.js server

Look for:
- Unreleased listeners
- Growing collections
- Timers
- Caches
- Resources that are not closed

Identify suspicious areas and suggest ways to investigate them.

[Paste code here]

30. Debug High CPU Usage

High CPU usage can be caused by inefficient algorithms, excessive loops, repeated calculations, or unexpected workloads. AI can review the code and suggest areas for profiling and optimization.

Example

Analyze the following Python code for possible causes
of high CPU usage.

Identify:
- Expensive loops
- Repeated calculations
- Inefficient algorithms
- Unnecessary processing

Suggest profiling steps before recommending optimizations.

[Paste code here]

31. Debug Slow Application Performance

Slow applications can result from problems in code, databases, network requests, rendering, or infrastructure. AI can organize the available evidence and suggest a systematic debugging approach.

Example

Help debug slow performance in a web application.

Symptoms:
- Page load time: 5 seconds
- API response time: 2 seconds
- Database query time: 1.5 seconds

Analyze the information and identify:
- Possible bottlenecks
- Additional metrics to collect
- Recommended debugging order
- Potential optimization areas

32. Debug Slow SQL Queries

Slow database queries can affect the performance of an entire application. AI can review query structure, filters, joins, and available indexes to identify possible areas for investigation.

Example

Analyze the following PostgreSQL query for performance problems.

Query:
[Paste query]

Table information:
[Paste schema]

Existing indexes:
[Paste indexes]

Execution time:
[Time]

Suggest:
- Potential bottlenecks
- Indexes worth investigating
- Query improvements
- Additional information needed before changing the query

33. Debug an API Timeout

API timeouts can be caused by slow application processing, database operations, network issues, or upstream dependencies. AI can help organize the investigation based on timing information.

Example

Debug an API timeout.

Endpoint:
GET /api/orders

Observed behavior:
Request times out after 30 seconds.

Timing:
- Application processing: 5 seconds
- Database query: 22 seconds
- External API: 1 second

Identify the likely bottleneck and recommend
a debugging sequence.

34. Debug a Race Condition

Race conditions can occur when multiple operations access or modify shared state in an unpredictable order. AI can inspect concurrent code and identify areas where execution order may cause inconsistent results.

Example

Review the following code for a possible race condition.

Environment:
Multi-threaded application

Problem:
Occasionally two requests update the same record incorrectly.

Code:
[Paste code]

Identify:
- Shared state
- Possible concurrent operations
- Why the result may vary
- Defensive approaches to investigate

35. Debug a Concurrency Problem

Concurrency issues can result in deadlocks, inconsistent state, unexpected ordering, or resource contention. AI can help analyze the synchronization logic and identify suspicious areas.

Example

Analyze the following Java concurrency code.

Problem:
The application occasionally hangs.

Check for:
- Deadlocks
- Lock ordering
- Shared mutable state
- Thread synchronization
- Resource contention

Explain the most likely causes and suggest debugging steps.

[Paste code here]

36. Debug a Deadlock

A deadlock occurs when two or more processes or threads wait indefinitely for resources held by each other. AI can analyze lock acquisition order and resource dependencies to help identify possible deadlocks.

Example

Analyze this thread dump and code for a possible deadlock.

Thread dump:
[Paste sanitized thread dump]

Relevant code:
[Paste code]

Identify:
- Threads involved
- Locks involved
- Dependency cycle
- Evidence of deadlock
- Recommended investigation steps

37. Debug a File Handling Problem

File-related errors can occur because of incorrect paths, permissions, missing files, encoding problems, or file locks. AI can review the code and error information to identify possible causes.

Example

Debug this file handling error in Python.

Error:
[Paste error]

Code:
[Paste code]

Check:
- File path
- File existence
- Permissions
- File mode
- Encoding
- Resource cleanup

Provide corrected code where appropriate.

38. Debug an Environment Configuration Problem

Applications may behave differently across development, testing, and production environments because of configuration differences. AI can compare sanitized configuration information and identify possible inconsistencies.

Example

Compare these development and production configurations.

Development:
[Paste sanitized configuration]

Production:
[Paste sanitized configuration]

The application works in development but fails in production.

Identify configuration differences that could explain the behavior.
Do not include or expose secrets.

39. Debug an Environment Variable Problem

Missing or incorrectly configured environment variables can cause applications to fail during startup or runtime. AI can help identify expected variables and compare them with the available configuration.

Example

Debug this application startup error.

Error:
"Database URL is undefined"

Expected environment variables:
- DATABASE_URL
- APP_PORT
- NODE_ENV

Available configuration:
[Paste variable names and non-sensitive values]

Identify the likely configuration problem.
Do not request or display secret values.

40. Debug a Dependency Problem

Software dependencies can cause compatibility problems when versions change or packages conflict. AI can review dependency files and error messages to identify possible version or compatibility issues.

Example

Debug the following dependency problem in a Node.js project.

Error:
[Paste error]

package.json:
[Paste package.json]

Node.js version:
[Version]

Identify:
- Possible conflicting dependencies
- Version compatibility issues
- Recommended investigation steps
- Safe update or rollback options

41. Debug a Version Compatibility Problem

Different versions of programming languages, frameworks, libraries, and databases can behave differently. AI can compare the application requirements with the installed versions and identify potential compatibility concerns.

Example

Analyze this compatibility problem.

Application:
Spring Boot application

Current versions:
- Java: 21
- Spring Boot: [Version]
- Maven: [Version]

Error:
[Paste error]

Identify possible compatibility issues and suggest
what documentation or configuration should be checked.

42. Debug a Deployment Failure

Deployment failures can result from build errors, missing configuration, dependency issues, permissions, or environment differences. AI can organize deployment logs and identify likely areas for investigation.

Example

Analyze the following deployment failure.

Environment:
[Environment]

Build output:
[Paste build output]

Deployment log:
[Paste sanitized deployment log]

Identify:
- First significant error
- Possible cause
- Related errors
- Recommended debugging sequence

43. Debug a Docker Container

Containerized applications can fail because of incorrect images, ports, environment variables, file paths, or startup commands. AI can review the Docker configuration and logs to identify potential issues.

Example

Debug this Docker container startup problem.

Dockerfile:
[Paste Dockerfile]

docker-compose.yml:
[Paste relevant configuration]

Container log:
[Paste log]

The container exits immediately after startup.

Identify the likely cause and suggest a corrected configuration.

44. Debug a CI/CD Pipeline

CI/CD pipelines can fail because of dependency installation, tests, environment variables, build configuration, or deployment steps. AI can analyze the pipeline configuration and failure logs to identify possible problems.

Example

Debug this GitHub Actions workflow failure.

Workflow:
[Paste YAML]

Failure log:
[Paste relevant log]

Identify:
- Failed step
- Error cause
- Required configuration changes
- Corrected workflow section

Do not expose secret values.

45. Debug a Build Failure

Build failures prevent an application from being packaged or compiled successfully. AI can analyze build logs, configuration files, and dependency information to identify the earliest meaningful failure.

Example

Analyze this build failure.

Build tool:
Maven

Build output:
[Paste output]

Project configuration:
[Paste relevant pom.xml section]

Identify the first significant error and explain
the most likely cause.

46. Debug a Git Problem

Git errors can occur during commits, merges, rebases, pulls, pushes, and branch operations. AI can explain Git messages and suggest safe steps based on the current repository state.

Example

Explain and help resolve this Git error.

Command:
[Paste command]

Error:
[Paste error]

Repository state:
[Describe current branch and recent operation]

Provide:
- What the error means
- Safe next steps
- Commands to verify the state

Do not suggest destructive commands unless their consequences
are clearly explained.

47. Debug a Merge Conflict

Merge conflicts occur when Git cannot automatically combine changes from different branches. AI can explain conflicting sections and help developers understand how the alternatives differ.

Example

Help me understand this Git merge conflict.

Current branch version:
[Paste code]

Incoming branch version:
[Paste code]

Explain:
- What differs
- What each version does
- Possible correct resolution
- What should be verified after resolving

48. Debug a Memory or Resource Error

Applications may fail when they run out of memory, file descriptors, connections, or other resources. AI can analyze error messages and runtime information to help identify possible causes.

Example

Analyze this application resource error.

Error:
[Paste error]

Runtime information:
- Memory usage: [Value]
- CPU usage: [Value]
- Active connections: [Value]
- Application uptime: [Value]

Identify possible causes and recommend additional metrics
or profiling information to collect.

49. Debug Code Without Changing Its Logic

Sometimes a developer wants to correct an error without changing the intended behavior or overall structure of the program. AI can focus on identifying and fixing the specific problem while preserving the existing logic.

Example

Debug the following code without changing its intended logic.

Requirements:
- Fix only the identified errors.
- Preserve the existing structure where possible.
- Do not add unnecessary features.
- Explain every change.

[Paste code here]

50. Perform a Complete Code Debugging Review

A complete debugging review examines source code, error messages, expected behavior, and runtime information together. AI can help organize potential issues and prioritize the areas that should be investigated first.

Example

Perform a complete debugging review of the following code.

Expected behavior:
[Describe expected behavior]

Actual behavior:
[Describe actual behavior]

Error messages:
[Paste errors]

Code:
[Paste code]

Analyze:
- Syntax issues
- Runtime errors
- Logical errors
- Edge cases
- Error handling
- Performance concerns

For each issue provide:
- Problem
- Evidence
- Likely cause
- Suggested fix
- Verification step

Do not claim a root cause without sufficient evidence.

51. Create a Step-by-Step Debugging Plan

A structured debugging plan helps developers investigate problems systematically instead of making random changes to the code. AI can organize the available evidence into a sequence of checks, tests, and observations.

Example

Create a step-by-step debugging plan for this problem.

Application:
[Describe application]

Problem:
[Describe problem]

Expected behavior:
[Describe expected behavior]

Actual behavior:
[Describe actual behavior]

Available logs:
[Paste sanitized logs]

Relevant code:
[Paste code]

Create a debugging plan that:
1. Reproduces the problem.
2. Identifies the first observable failure.
3. Narrows down the affected component.
4. Tests possible causes.
5. Applies the smallest appropriate fix.
6. Verifies the fix.
7. Checks for regressions.

Clearly explain what evidence should be collected at each step.

General AI Prompt Template for Debugging

A reusable debugging prompt can help developers provide the AI model with enough information to analyze a software problem. The template can be adapted for application errors, test failures, API problems, database issues, frontend bugs, performance problems, and deployment failures.

Example

Role:
Act as a senior software debugging engineer.

Programming Language:
[Language]

Framework or Technology:
[Framework or technology]

Problem:
[Describe the problem]

Expected Behavior:
[Describe what should happen]

Actual Behavior:
[Describe what actually happens]

Error Message:
[Paste error message]

Relevant Logs:
[Paste sanitized logs]

Relevant Code:
[Paste code]

Environment:
[Development, testing, staging, production, etc.]

Analyze:
- Likely causes
- Evidence supporting each possibility
- Relevant code or configuration
- Recommended debugging steps

Expected Output:
- Problem summary
- Possible causes
- Recommended investigation
- Suggested fix
- Verification steps

Additional Instructions:
- Do not invent missing information.
- Clearly distinguish confirmed findings from assumptions.
- Preserve existing behavior unless a change is required.
- Do not include secrets, passwords, API keys, or private credentials.