DEBUGGING PROMPT TEMPLATE (Python)
text
DEBUGGING PROMPT TEMPLATE (Python)
new_line
Please reply one by one without assumptions and fix code accordingly.
text
Please reply one by one without assumptions and fix code accordingly.
new_line
1. Core Functionality Check:
text
1. Core Functionality Check:
new_line
   For each main function/view:
text
   For each main function/view:
new_line
   - What is the entry point?
text
   - What is the entry point?
new_line
   - What state management is required?
text
   - What state management is required?
new_line
   - What database interactions occur?
text
   - What database interactions occur?
new_line
   - What UI elements should be visible?
text
   - What UI elements should be visible?
new_line
   - What user interactions are possible?
text
   - What user interactions are possible?
new_line
new_line
2. Data Flow Analysis:
text
2. Data Flow Analysis:
new_line
   For each data operation:
text
   For each data operation:
new_line
   - Where is data initialized?
text
   - Where is data initialized?
new_line
   - How is it transformed?
text
   - How is it transformed?
new_line
   - Where is it stored?
text
   - Where is it stored?
new_line
   - How is it displayed?
text
   - How is it displayed?
new_line
   - Are there any state updates?
text
   - Are there any state updates?
new_line
new_line
3. UI/UX Verification:
text
3. UI/UX Verification:
new_line
   For each interface element:
text
   For each interface element:
new_line
   - Is it properly initialized?
text
   - Is it properly initialized?
new_line
   - Are all buttons clickable?
text
   - Are all buttons clickable?
new_line
   - Are containers visible?
text
   - Are containers visible?
new_line
   - Do updates reflect in real-time?
text
   - Do updates reflect in real-time?
new_line
   - Is feedback provided to user?
text
   - Is feedback provided to user?
new_line
new_line
4. Error Handling:
text
4. Error Handling:
new_line
   For each critical operation:
text
   For each critical operation:
new_line
   - Are exceptions caught?
text
   - Are exceptions caught?
new_line
   - Is error feedback shown?
text
   - Is error feedback shown?
new_line
   - Does the state remain consistent?
text
   - Does the state remain consistent?
new_line
   - Can the user recover?
text
   - Can the user recover?
new_line
   - Are errors logged?
text
   - Are errors logged?
new_line
new_line
5. State Management:
text
5. State Management:
new_line
   For each state change:
text
   For each state change:
new_line
   - Is initialization complete?
text
   - Is initialization complete?
new_line
   - Are updates atomic?
text
   - Are updates atomic?
new_line
   - Is persistence handled?
text
   - Is persistence handled?
new_line
   - Are race conditions prevented?
text
   - Are race conditions prevented?
new_line
   - Is cleanup performed?
text
   - Is cleanup performed?
new_line
new_line
6. Component Dependencies:
text
6. Component Dependencies:
new_line
   For each component:
text
   For each component:
new_line
   - Required imports present?
text
   - Required imports present?
new_line
   - Database connections active?
text
   - Database connections active?
new_line
   - External services available?
text
   - External services available?
new_line
   - Proper sequencing maintained?
text
   - Proper sequencing maintained?
new_line
   - Resource cleanup handled?
text
   - Resource cleanup handled?
DEBUGGING PROMPT TEMPLATE (Python)
Please reply one by one without assumptions and fix code accordingly.
1. Core Functionality Check:
   For each main function/view:
   - What is the entry point?
   - What state management is required?
   - What database interactions occur?
   - What UI elements should be visible?
   - What user interactions are possible?

2. Data Flow Analysis:
   For each data operation:
   - Where is data initialized?
   - How is it transformed?
   - Where is it stored?
   - How is it displayed?
   - Are there any state updates?

3. UI/UX Verification:
   For each interface element:
   - Is it properly initialized?
   - Are all buttons clickable?
   - Are containers visible?
   - Do updates reflect in real-time?
   - Is feedback provided to user?

4. Error Handling:
   For each critical operation:
   - Are exceptions caught?
   - Is error feedback shown?
   - Does the state remain consistent?
   - Can the user recover?
   - Are errors logged?

5. State Management:
   For each state change:
   - Is initialization complete?
   - Are updates atomic?
   - Is persistence handled?
   - Are race conditions prevented?
   - Is cleanup performed?

6. Component Dependencies:
   For each component:
   - Required imports present?
   - Database connections active?
   - External services available?
   - Proper sequencing maintained?
   - Resource cleanup handled?
👀
John6666