I need to learn how to use the browser console and terminal for debugging. Given that I'm working on [DESCRIBE YOUR PROJECT TYPE - e.g., "React app", "vanilla JavaScript", "Node.js backend"], teach me:

**Browser Console:**
1. How to open DevTools in different browsers
2. Reading error messages and stack traces
3. Finding the exact line causing errors
4. Using console.log() effectively for debugging
5. Inspecting variables and state
6. Network tab for API debugging
7. How to copy error messages to get AI help

**Fixing Bugs:**
8. How to interpret common error types
9. Copy-pasting errors to AI for solutions
10. Testing fixes without breaking more things

Give me a cheat sheet format with screenshots descriptions and real examples.

Role-Play as a Meticulous Senior Code Reviewer & Architect:
Act as an extremely critical and experienced senior developer. Review every line of code, every function, every file.
Identify all errors and inconsistencies, no matter how minor.
Pinpoint what parts don’t follow a known good implementation or industry-standard best practices.
Clearly articulate what parts we are doing wrong according to professional standards and established architectural patterns.
Ensure everything related to good code etiquette is perfect: naming conventions, comment quality, documentation, code formatting, modularity, separation of concerns, DRY principles, etc. This is crucial to avoid "getting in trouble" during review.
Surface not only immediate bugs but also other potential issues like missing null checks, inefficient algorithms, security vulnerabilities, or scalability concerns.
Build a Full Mental Map of the Codebase & Interconnections:
Go through and make a detailed list of where things are connected when you reason out their relationships.
Understand how the codebase operates fully. Trace data flow, dependencies, and communication channels between components.
Review how each function works with the other functions to understand its role in the larger system.
Build a comprehensive mental map of the purpose of each file and their linkages, using your best judgment to infer intent.
Identify all external services, APIs, databases, or third-party libraries involved and how they integrate.
Understand User Story & Functional Experience:
Infer what each thing does functionally for the user. Trace the code path that creates the user story experience of the website (or application) correctly.
Make sure you understand all the functionality, where everything is going, and how it creates the user story experience accurately.
Articulate this understanding clearly. This mapping of code to user experience is vital.
Initial Report & Prioritization:
Based on your deep dive, provide a detailed report outlining:
All identified issues (categorized: architectural, best practice, potential bugs, readability, performance, security).
Deviations from good implementations or standards.
Specific instances of poor code etiquette.
A summary of the codebase's architecture and how its components interlink.
Your inferred user story flow and how the code supports it.

I got an error and need help fixing it. 

**My Setup:**
- Coding tool: [INSERT YOUR CODING AGENT]
- Project type: [DESCRIBE PROJECT]

**The Error:**
[PASTE COMPLETE ERROR MESSAGE FROM CONSOLE HERE]

**What I was trying to do:**
[DESCRIBE WHAT YOU WERE DOING WHEN ERROR OCCURRED]

Please:
1. Explain what this error means in simple terms
2. Identify the root cause
3. Provide step-by-step fix instructions
4. Give me the exact code changes needed
5. Explain how to verify the fix worked
6. Teach me how to avoid this error in the future

Show me both the broken code and fixed code side-by-side.

My Action: Provide Code & Context:
I will provide the code (files, snippets, or project description) and any specific issues I'm already aware of, or the problematic behavior I'm observing.
I will articulate my current understanding of the problem or a specific function.
My Action (Optional but Encouraged - "Ask the Rubber Duck"):
"I will explain what this function/module is doing and how I think it leads to the problem: [Your detailed explanation here]."
"Given that explanation, is my reasoning correct, and does it reveal where the bug is? Please critique my understanding."
Your Action: Deep Debugging & Root Cause Analysis:
For any identified bug or reported issue, ask for potential causes.
If stumped or if the issue is complex, broaden the question: "What are some possible reasons for a [Specific Error Type, e.g., TypeError: cannot read property 'foo' of undefined] in this code?"
List a few potential scenarios (e.g., object wasn’t initialized, a race condition, wrong variable scoping, incorrect API response, asynchronous timing issues, data corruption, misconfiguration, missing error handling). This will give me angles to investigate that I hadn't considered, acting as a brainstorming colleague.
Work through the potential causes methodically, eliminating possibilities based on provided context or further questions.
Your Action: Test Case Generation:
"Can you provide a couple of test cases (inputs) that might break this function/component, or expose the identified vulnerabilities/edge cases?"
Suggest edge cases I might not have considered (e.g., empty arrays, null values, extreme numbers/strings, invalid input formats, boundary conditions, concurrent access scenarios, maximum load conditions). These are useful for both debugging and for generating robust tests for future development.

Once issues are understood, you will formulate a concrete plan for correction and improvement.
Detailed Debugging and Fixing Steps:
For each identified issue (from audit or specific bug), provide clear, step-by-step instructions to debug and fix it.
Don't try to change everything at once. Break down complex fixes into smaller, manageable, and logical steps.
Prioritize fixes based on severity, impact, and ease of implementation.
Code Suggestions & Best Practice Implementation:
Generate concrete code suggestions to address each point.
Utilize best practices in all suggestions. The logic implemented must be bona fide and will not break.
Make sure that all of the functionality stays throughout the website. Guarantee that no functionality is broken during the proposed changes. Any refactoring or improvements must preserve the existing user experience and system behavior.
Ensure the suggested code aligns perfectly with the inferred user story and functional requirements.
Execution Readiness:
Once I approve a set of suggestions or a specific fix, you must be ready to execute all suggestions from this. This means you will provide the modified code or specific code changes as requested.