AI-Driven Debugging: Enhancing Debugging Skills with AI

AI isn’t magic. Garbage in, garbage out.
If you dump code with no context, you get vague answers.

This lesson shows you how to feed AI the right info:

• Problem in one sentence.

• What you expected.

• What actually happened.

• The exact code that matters.

• Your setup and what you already tried.

It’s not about “secret prompts.” It’s about clarity.
Treat AI like a smart intern, not a mind reader.

By the end, you’ll know how to write prompts that cut through noise, save you follow-ups, and turn AI from a random guesser into a real debugging partner.

Template for debugging prompt.

AI can read a lot of code. Fast.
But it can’t guess where in your project a change should happen.

You’ll see why context matters when you ask AI to edit files without direction, AI might touch the wrong file, or even create new ones you never wanted.

In this lecture, you’ll learn how to:

• Point AI to the right file (mobile, dark, light, base).

• Isolate changes so edits land where they should.

• Avoid wasted fixes that break unrelated parts of your code.

Big codebase? Many files? No problem.
Once you know how to give AI context, it works with you, not against you.

Now it’s your turn. Hands on.
You’ll take a real bug from your project and try two versions:

• A lazy prompt (quick, vague, “fix please”).

• A sharp prompt using the full template: problem, expected, actual, context, code, error, environment, already tried.

You’ll see the difference instantly.
Messy prompt? Confusing tips.
Clean context? Real help.

By the end, you’ll know how five minutes of effort upfront saves thirty minutes of back-and-forth.
This template is your cheat code for faster, smarter debugging with AI.

AI reads code fast.
But it doesn’t know what matters unless you guide it.

In this lecture, you’ll learn how to use AI as a reading partner for messy, old, undocumented code. We’ll break the process into three layers:

• Surface – map what the code is and where it starts.

• Flow – trace the journey step by step.

• Deep – uncover intent, tradeoffs, and risks.

You’ll see how to ask better questions, move from vague answers to real insight, and spot what could go wrong before it bites you.

By the end, you’ll know how to pair your brain with AI’s speed — so you get clarity without losing control.

In this lecture, you get three prompts you can reuse:

• Code tour – ask AI to explain a new codebase like a walkthrough, showing what’s clever, what’s confusing, and what questions to ask the team.

• What breaks if removed – a different angle that often gives clearer insights than simply asking “how does this work.”

• Scenarios – test normal inputs, edge cases, and what happens if something is missing.

You’ll also see why it’s better to ask about edge cases first, then move to unit tests. Giving AI that thinking time makes the answers sharper and more useful.

Printable prompts for analyzing code

We’ll recap the essentials: isolate first, give clean context, and use AI as a tool for understanding - not a crutch for thinking. These principles are your foundation for the rest of the course.

AI might "solve" a bug by masking it instead of fixing it. This could mean removing error messages, adding unnecessary try-catch blocks, or altering logic so the real issue is harder to find. You’ll learn how to spot these quick patches before they cause bigger problems later.

In this lecture, you learn how AI can hide problems instead of solving them.
AI often patches symptoms — the crash, the error message — while the deeper cause remains. That leads to hidden bugs, silent failures, and bigger issues later.

You’ll see examples like:

• Membership levels missing, fixed with a quick default instead of fixing the data source.

• Strings in prices, converted to numbers instead of cleaning the input.

• Returning None when the real issue is missing validation or authorization.

You also get a checklist to use after every AI fix:

• What’s the root cause?

• What’s the proper long-term fix?

• What tradeoffs am I making?

• How do I test it?

• What’s the impact later?

The main idea: AI can help, but only if you keep asking why. A good fix doesn’t just remove the error — it makes the system stronger and more transparent.

AI fixes bugs fast, but without understanding the reason, you don’t really learn. This lecture shows how relying on quick fixes can weaken your debugging skills over time.

You’ll see how to spot shallow explanations, ask AI the right follow-up questions, and test fixes with scenarios like modification, edge cases, and analogies. The goal is clear: stop outsourcing your thinking, and use AI to actually grow your debugging brain.

1. AI can hide bugs without solving them

2. Always ask for explanations

3. Use verification tools before trusting any AI-generated fix

AI writes code by patterns, not by threat modeling. That means it can copy insecure habits from public examples — like building SQL queries with strings, skipping validation, or outputting raw user input in HTML. The code runs, but it may quietly open security holes.

In this lecture, you’ll see concrete examples of how AI “fixes” can introduce SQL injection, cross-site scripting, or data leaks, and why vague prompts like “make this faster” are risky. You’ll also learn how to guide AI with security-aware prompts, treat it like a junior developer, and double-check with static analysis tools (Bandit, Safety, Semgrep). The key lesson: a slow secure app is better than a fast broken one — AI won’t worry about risk, so you must.

AI can also be a security ally if you prompt it to look for vulnerabilities. We’ll practice scanning code for injection points, authentication flaws, and unsafe input handling.

In this lecture, you’ll learn how to use ready-made prompts for scanning codebases for security issues.
We walk through running these prompts in Google AI Studio (free option) and explain the trade-offs:

• Free means data can be used for training.

• Company projects should always use API keys or paid tiers with data-safety guarantees.

• API routes (OpenAI, Gemini, Claude) don’t train on your code, which makes them safer.

You’ll also see a trick with Code WebChat extension:

• Copy whole folders (ignores files in .gitignore).

• Paste entire context at once.

• Run a full scan for vulnerabilities like hardcoded credentials, PHP error display in production, or insecure file permissions.

We compare this brute-force full-context method with agent models that only read part of the code.
You’ll understand when it makes sense to paste everything, even if it costs more tokens, and when agents are enough.

Key point:

• Don’t paste sensitive company code into free chat modes.

• Use API keys and secure plugins instead.

• Always remember: you are the brain — AI shows potential issues, but you decide what’s real and how to fix it.

By the end, you’ll know how to safely combine prompts, tools, and context size to make AI an effective security helper without risking your codebase.

Sometimes AI removes key security checks in the name of "simplifying" the code. We’ll see real examples where AI’s fixes made apps more vulnerable, and learn how to spot and prevent these mistakes.

1. AI can both help and harm security

2. Always double-check authentication, boundary checks, and async flows

3. Use AI as a security reviewer, not as the sole decision-maker

Codex isn’t just for writing code.
You can connect it to your GitHub repo and let it review every pull request.

You’ll see:

• How Codex flags problems.

• How to apply its fixes with quick commands.

• How to merge changes safely.

It won’t catch everything.
But it does spot critical issues fast.

That makes it great for prototypes and small projects.
Less noise. More signal.

By the end, you’ll know how to:

• Set up Codex as a reviewer.

• Act on its suggestions.

• Keep your repo safer without slowing down.

In this lecture, you’ll see exactly how to turn on automatic reviews with Codex.

Step by step:

• Go into Codex settings.

• Open the code review section.

• Pick the repo you want reviewed.

• Enable reviews on every pull request.

That’s it. Switch on, and Codex checks your code for you.
Switch off, and it stops.

Simple. Clear. Repeatable.

Qudo is another option for code reviews.
You connect it to GitHub, GitLab, or Bitbucket.

You’ll see how it:

• Reviews selected repos (so you stay in control).

• Adds clear commit descriptions.

• Builds diagram walkthroughs of changes.

• Suggests areas to focus on in your PRs.

The big win?
It takes care of the boring part - documenting what changed and where.
That means you and your team can focus on fixing, not writing summaries.

But keep in mind:

• It’s great at spotting structure and flow.

• It’s not always right about business logic.

• You still decide what gets merged.

By the end, you’ll know how to use Qudo as a reviewer, apply its suggestions, and speed up pull requests without losing control of your code.

Sometimes you don’t want to wait for a pull request.
You want to catch issues before they hit the repo.

With the Qudo VS Code extension, you can:

• Run a review locally on staged or unstaged changes.

• See a summary of edits plus direct findings.

• Spot security gaps early (like missing CSRF protection).

This saves your team time.
No waiting for PR comments.
You decide what to fix, what to ignore, and how to repair it.

By the end, you’ll know how to use Qudo for offline reviews inside your editor — turning debugging into a faster, safer step before you ever push code.

Code Rabbit is another reviewer you can run locally or online.
You connect it to your GitHub repo and it checks your pull requests.

What makes it stand out?

• You can tune the rules — decide what it should flag.

• It shows the exact lines with problems. No hunting, no guessing.

• It gives you clear suggestions on how to fix them.

You can ignore a warning, fix it yourself, or hit “fix with AI”.
And you choose which AI does the work — Copilot, Client, or even free models via OpenRouter.

That means you stay in control.
You know what changed, what it cost, and what the fix actually did.

It’s a bit slower than Qudo, but the line-by-line review makes debugging easier.
You see the issue, the suggestion, and the diff right away.

By the end, you’ll know how to use Code Rabbit as a practical debugging partner, especially when you want offline checks before pushing code.

You've heard of Jira. Maybe Linear.

They're tools for managing projects. For tracking work. For getting things done.

But what if you could connect that work directly to the code? What if creating a task could also create the plan to solve it? Automatically.

In this video, I'll show you exactly that. We're connecting Linear to a tool called Code Rabbit. It's more than just an integration. It's a new workflow.

I'll walk you through it.

Step by step.

From connecting the accounts to creating a rule that watches for new issues. Then we'll see it in action. An issue goes in. A complete, multi-phase coding plan comes out. Ready for your IDE.

This changes the game. It automates the thinking *before* the coding. It's fast. It's powerful. Let's get started.

• Integrating Linear with Code Rabbit allows you to automatically generate detailed coding plans for new issues.

• You can create custom rule sets in Code Rabbit to control exactly which issues trigger the automated planning process.

• The generated coding plan is broken down into phases and includes prompts you can directly use in your IDE.

• This automation drastically speeds up the development process by handling the initial planning phase for any developer on the team.

• The integration provides a two-way connection, with Code Rabbit commenting back on the Linear issue with a summary of the plan.

We broke a rule. We worked on the main branch. That's not the best way.

So we're going to fix it. I'll show you how to create a pull request, the right way. How to get your code checked. Automatically.

We'll use AI tools. Codex. Code Rabbit. You'll see them find bugs I missed. Real bugs. Major ones. And they do it in minutes, while we do something else.

This is the new workflow.

It's not about just writing code anymore. It's about creating a system. A system where AI reviews, suggests fixes, and lets you focus on the big picture. You become the final check. The last bastion.

I'll show you how to manage this process. When to use auto-fix. When to do it yourself. And how to stay productive while the bots do the heavy lifting.

This is how you get 10 times faster. Let's begin.

• Create a new branch and pull request for every feature to ensure proper code review.

• AI tools like Code Rabbit can automatically review your code, finding subtle but critical bugs that human reviewers might miss.

• The modern development workflow is asynchronous; you can work on other tasks while AI tools process your code.

• You are the final reviewer. AI assists you, but the ultimate responsibility for code quality rests with the developer.

• Iterative fixing is key: push a fix, let the AI review it again, and repeat until the code is clean and ready to merge.

• Integrate Cloud Code with tools like Code Rabbit to fully automate the process of applying code review suggestions.

• Cloud Code's 'auto fix' feature actively monitors a pull request for new comments and applies valid fixes for you.

• This workflow saves significant time by removing the need to wait for reviews and then manually implement changes.

• Cloud Code intelligently validates suggestions, only applying fixes for issues that are still relevant in the code.

• Integrate your development environment with tools like CodeRabbit to fully automate the process of optimizing and reviewing game code.

• CodeRabbit's 'Change Stack' feature categorizes pull request modifications and provides intelligent, contextual AI suggestions directly within the review panel.

• This workflow saves significant time by removing the manual back-and-forth between GitHub and the editor when addressing code feedback.

CodeRabbit can become your AI Agent in Slack. You can delegate work directly to Notion/Jira/Linear etc. without switching context.

Take an app with a real bug and:

• Use AI to locate the issue

• Get AI to propose a fix

• Review and verify every step before finalizing

1. Use AI at every stage, not just the end

2. Treat AI like a junior teammate that needs review

3. Break prompts into smaller tasks for better results

Learn how to prompt AI to write unit tests quickly and accurately. We will cover how to guide it so the tests are relevant, runnable, and fit your project’s structure.

AI can uncover the weird scenarios you didn’t think about. You will see how to prompt for edge cases and create fuzz tests that hit unusual inputs, helping you find hidden bugs before they find you.

Practise your knowledge and create unit tests on your own.

Use AI to write tests, find gaps, and push coverage higher. But always review its work — automated tests are only as strong as the human guiding them.

AI can speed up your workflow, but it cannot replace real debugging skills. We’ll discuss how to blend AI assistance with your own expertise so you stay in control of the process.

1. AI is most effective when guided by a clear process

2. Your checklist should evolve with experience

3. Consistency is the key to catching more bugs in less time

CheckList for you when you are gonna debug your program.

Summary of entire course