How AI Assists in Debugging Code

𝗜 𝗴𝗮𝘃𝗲 𝗺𝘆 𝗔𝗜 𝗰𝗼𝗱𝗶𝗻𝗴 𝗮𝗴𝗲𝗻𝘁 (𝗖𝗹𝗮𝘂𝗱𝗲) 𝗲𝘆𝗲𝘀 𝗶𝗻𝘁𝗼 𝗺𝘆 𝗔𝗻𝗱𝗿𝗼𝗶𝗱 𝗲𝗺𝘂𝗹𝗮𝘁𝗼𝗿 👀 When debugging Android UI issues, context is everything. An AI agent can read your code but it can’t see what’s actually happening on screen. Until now. I built a simple Claude Code slash command called /screen-debug that: • Captures a screenshot via ADB • Dumps the view hierarchy (uiautomator XML) • Extracts the current Activity / Fragment • Lets Claude visually inspect the screenshot • Combines everything into a single structured analysis All of it lives in one markdown file inside .claude/commands Within minutes, it spotted that my toolbar was rendering behind the status bar — a classic fitsSystemWindows issue — and pointed me directly to the root cause. Here’s the key insights - Structured data alone isn’t enough. - Visual inspection alone isn’t enough. - Together? 𝗩𝗲𝗿𝘆 𝗽𝗼𝘄𝗲𝗿𝗳𝘂𝗹. If you're building Android apps with Claude Code, try creating your own ADB-powered commands. 👇 I’ve added the full /screen-debug command in the first comment. #AndroidDev #AI #ClaudeCode #MobileEngineering #DevTools

I’ve been using AI-assisted coding for the last 15 months, and here’s my honest take on where it truly shines — and where it still falls short: Where AI makes life easier: • 🚀 Kicks off projects fast with reliable boilerplate • 🐞 Great at spotting and debugging tricky issues • ⚡ Smart auto-completion that saves hours • 📚 Helps explore and learn new techniques quickly • 🔁 Handles repetitive patterns like a champ • 🧹 Cleans, refactors, and organizes code beautifully Where it still gets challenging: • ✏️ Sometimes writes more code than needed • 🔍 Often fixes the symptom, not the root cause • 🔗 System-level integrations can confuse it • 🧩 Needs clear prompts for modular, reusable architecture • 📦 If not reviewed, redundant code sneaks in At its best, AI is an incredible co-pilot — fast, helpful, and tireless. But it still needs our direction, our architectural judgment, and our eyes for quality. The magic happens when humans bring intent and AI brings acceleration. What’s your take on vibe coding?

Legacy PLC code can finally get the documentation it deserves — thanks to MCP + AI. Most factories are running PLC projects that have been patched, extended, and “quick-fixed” for years — often with minimal comments and unclear logic. With the MCP Server CODESYS, an AI assistant can load the entire project, scan every POU and variable, and instantly highlight issues: magic numbers, duplicated logic, inconsistent naming, missing comments. Even better — it can auto-generate a Markdown report describing each POU, summarize logic flows, suggest better variable names, and insert comments where context is missing. For maintenance and modernization work, this is huge: instead of spending days trying to “decode” legacy logic, engineers start with clarity, structure, and a guided refactoring path. This is what AI-supported engineering actually looks like in practice — not replacing engineers, but giving us back the time we lose understanding old code.

A few months ago, I was stuck on a bug that shouldn’t have existed. The logic looked right. The logs looked clean. The issue folder? Hundreds of files deep. Old me would’ve spent hours scrolling, grepping, re-running, second-guessing. Instead, I asked AI. In seconds, it pointed me to the exact pattern, the likely root cause, and even suggested where similar issues had appeared before. Not magic. Just smart, optimized search + context. That’s when it hit me. We were told AI would replace developers. But in reality, it’s quietly becoming the best debugging partner we’ve ever had. It scans massive issue folders faster than we can blink It highlights edge cases we might miss on tired days It helps us reason, not just code It turns “I’m stuck” into “oh, that’s why” The fear came from imagining AI as a decision-maker. The value comes from using it as a multiplier. The developer still thinks. AI just removes the noise. I don’t write less code because of AI. I write better code, faster, with more confidence. Now I’m curious 👇 Has AI made your development workflow easier—or are you still on the fence about trusting it? #AI #SoftwareDevelopment #Developers #Debugging #Productivity #TechCareers #EngineeringLife #Coding #FutureOfWork #AIForDevelopers

🔬 #AI #Education: 𝗩𝗶𝗯𝗲 𝗖𝗼𝗱𝗶𝗻𝗴'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗶𝘀 𝗗𝗘𝗕𝗨𝗚𝗚𝗜𝗡𝗚! Vibe coding is incredible for speed, but when an error pops up in a block of code you didn't actually write, tracking down the bug can quickly turn into a nightmare. Vibe coding is fast. Debugging vibe code is... not. When AI writes the logic, finding the flaw can feel like a guessing game. You don't have the muscle memory of writing the code line-by-line. Here is how to make debugging your AI-generated code actually manageable: ▶ 𝗞𝗲𝗲𝗽 𝘀𝗰𝗼𝗽𝗲𝘀 𝘁𝗶𝗻𝘆: Only prompt for one function or component at a time. ▶ 𝗖𝗼𝗺𝗺𝗶𝘁 𝗿𝗲𝗹𝗶𝗴𝗶𝗼𝘂𝘀𝗹𝘆: Save a working state before asking for the next "vibe." ▶ 𝗗𝗲𝗺𝗮𝗻𝗱 𝘃𝗲𝗿𝗯𝗼𝘀𝗲 𝗹𝗼𝗴𝗴𝗶𝗻𝗴: Instruct the AI to print the state at every major step. ▶ 𝗙𝗼𝗿𝗰𝗲 𝗶𝗻𝗹𝗶𝗻𝗲 𝗰𝗼𝗺𝗺𝗲𝗻𝘁𝘀: If the AI writes it, the AI must explain it line-by-line. ▶ 𝗗𝗼𝗻'𝘁 𝗷𝘂𝘀𝘁 𝗿𝗲𝗮𝗱, 𝗶𝗻𝘁𝗲𝗿𝗿𝗼𝗴𝗮𝘁𝗲: Paste the error and ask the AI, "Walk me through why this failed." ▶ 𝗩𝗶𝗯𝗲 𝘁𝗵𝗲 𝘁𝗲𝘀𝘁𝘀 𝗳𝗶𝗿𝘀𝘁: Have the AI write unit tests before it writes the actual code. ▶ 𝗞𝗻𝗼𝘄 𝘄𝗵𝗲𝗻 𝘁𝗼 𝗿𝗲𝘀𝗲𝘁: Sometimes it's faster to revert and re-prompt than to untangle a hallucination. You have to manage the AI, not just prompt it. How are you handling the debugging phase when coding with LLMs? - T. Scott Clendaniel

1/ The first time I saw a red error message, I thought I broke everything. Turns out — it was just the computer trying to help me. 2/ Starting out, I panicked at every error. Now I see them for what they are: computers trying to talk to us. And now, AI can translate that conversation. 3/ Most errors are simple to fix: Missing library? Install it. Version mismatch? Update. Syntax error? Fix the typo. These are mechanical. And this is exactly where AI agents shine. 4/ I use Claude Code daily now. When it hits a red error in the terminal, it reads the traceback, figures out what went wrong, and fixes it — often before I even finish reading the message. Missing dependency? Installed. Wrong argument? Corrected. It self-corrects faster than I can type. 5/ But here's the catch. Some errors don't scream. They whisper. Your script runs clean, no red text, exit code 0. But the output is wrong in ways only someone with domain knowledge would notice. AI won't flag those. You will. 6/ A VCF file with 10,000 "variants" that are all in homopolymer regions. A DESeq2 result with 8,000 DEGs from 3 replicates. Code ran perfectly. Results are garbage. No error message will save you here — only experience. 7/ So the new debugging workflow looks like this: Let the AI agent handle the mechanical errors — the typos, the missing packages, the version conflicts. Save your brain for the errors that don't throw exceptions. 8/ Pro tip still holds: Stop. Breathe. READ the error carefully. 90% of the time it tells you exactly what's wrong. And now you can paste it into Claude Code and watch it fix itself in real time. 9/ When asking for help (human or AI), include: OS, exact command, full error message, and what you expected to happen. Context is currency in debugging. Good questions get good answers — from people and from agents. 10/ Key takeaways: - Errors are maps, not walls. Read them. - AI agents fix mechanical errors faster than you can. Let them. - The dangerous errors are the ones that don't look like errors. - Domain knowledge catches what no agent can. - Learn to debug with AI, but never stop understanding why things break. I hope you've found this post helpful. Follow me for more. Subscribe to my FREE newsletter chatomics to learn bioinformatics https://lnkd.in/erw83Svn

Everyone’s using GenAI to write code, but most are leaving its fixing power on the table. Two ways GenAI should enter your fix toolbox 👇 1) Always-on sub-agents Most developers use coding assistants linearly: one prompt, one task. But bug fixing does not have to be linear. Why rely on a single assistant when you could: • spin up multiple agents • powered by different LLMs • each investigating the issue from a different angle Here is my OSS debugging stack: 𝗦𝘂𝗽𝗲𝗿𝗽𝗼𝘄𝗲𝗿𝘀 →  /𝘴𝘶𝘱𝘦𝘳𝘱𝘰𝘸𝘦𝘳:𝘥𝘦𝘣𝘶𝘨 gives you structured, multi-step debugging inside your coding assistant (Claude, Codex, OpenCode).(https://lnkd.in/gWhx6eAp) 𝗣𝗮𝘁𝗰𝗵𝘄𝗼𝗿𝗸 →  feed it a GitHub issue and let it attempt a fix. Run it on a cron job and you’ve got an always-on bug fixer. (https://lnkd.in/gZqdEP9R) 𝗖𝗹𝗮𝘂𝗱𝗲 → supports sub-agents (plugins) specialized in narrow tasks. (https://lnkd.in/gk-XcSVu) 2) Let GenAI troubleshoot incidents for you When things break, opening dashboards won’t be the first step anymore. A new category is emerging: AI SREs (yes, the name is questionable). They plug into your existing stack, analyze signals faster than us, and correlate: • observability data • recent code changes • past incidents • internal knowledge They won’t solve complex incidents (yet). But they will eliminate search time, resolve simple issues, and kickstart every investigation. We built one at Rootly and cannot get enough of it. I've got a long list of other tools I want to try, but for now, those are the ones I recommend!

This weekend, AI was finally more than a task taker. It was a great team mate. I was hitting a pretty stubborn bug in my code that I couldn't crack. The service was failing in a pretty opaque way. So instead of chasing ghosts, I asked Claude to help debug. It had just as hard of a time. And it started to make things worse real quick. So I stopped it fast, and added verbose logging and retry logic, wired into CloudWatch. And I was going to give up on Claude, but then I had the idea to ask Claude to debug using this approach. I also put Claude Code into (mostly) “YOLO mode”, letting it dig through the telemetry directly to debug and fix without my intervention and approval. I did this for fun (and probably out of exhaustion), just to see what Claude Code would do. (I do not recommend "YOLO mode" for experienced or inexperienced developers as a rule - this was a one time thing). And sure enough, the culprit surfaced quickly: I had inconsistencies in KMS key usage between two services. Once the signal was there, the fix was obvious. A bonus: unprompted, Claude even wrote a debug function specifically for this bug, which I've reconfigured a bit and I'm now re-using to neatly summarize call stacks in the developer console. Takeaways: - Visibility beats guesswork, every time. More signal in your logs often solves the problem faster than clever debugging. It was also a good reminder for me from the days of being a full time dev of how important it is to log consistently as I code. - Agentic based AI is trained to retry and rewrite. Until you engineer it to do other things, and ask it to do those things specifically, you're just going to get the same results, burn through tokens, and get frustrated. - (mostly for vibe coders and those new at this): devote time to learning debugging and using what's available to you. There's so much more to being a developer than writing prompts (obviously) - AI isn’t just code generation and code rewriting. With the right instructions, guidance, and AI can and will act like a good engineer who knows how to instrument, observe, and debug right alongside you. In the end, what impressed me most wasn’t that Claude Code “found the bug.”This wasn’t about AI “replacing” debugging: it was about AI becoming a debugging partner. If you give it the right visibility and direction, it can be a teammate that doesn’t just write code, but helps you see through complexity and move much faster than you would on your own. At enterprise level (or any level), that's the true power of AI we need to unlock. #AI #AgenticAI #SoftwareEngineering #Debugging #Observability

I spent 200+ hours testing AI coding tools. Most were disappointing. But I discovered 7 techniques that actually deliver the "10x productivity" everyone promises. Here's technique #3 that’s saved me countless hours: The Debug Detective Method Instead of spending 2 hours debugging, I now solve most issues in 5 minutes. The key? Stop asking AI "why doesn't this work?" Start with: "Debug this error: [exact error]. Context: [environment]. Code: [snippet]. What I tried: [attempts]" The AI gives you: → Root cause → Quick fix → Proper solution → Prevention strategy Last week, this technique saved me 6 hours on a production bug. I've compiled all 7 techniques into a free guide. Each one saves 5-10 hours per week. No fluff. No theory. Just practical techniques I use daily. Want the guide? Drop “AI” below and I'll send it directly to you. What's your biggest frustration with AI coding tools? Happy to try and help find a solution.

Last week I spent 6 hours debugging with AI. Then I tried this approach and fixed it in 10 minutes The Dark Room Problem: AI is like a person trying to find an exit in complete darkness. Without visibility, it's just guessing at solutions. Each failed attempt teaches us nothing new. The solution? Strategic debug statements. Here's exactly how: 1. The Visibility Approach - Insert logging checkpoints throughout the code - Illuminate exactly where things go wrong - Transform random guesses into guided solutions 2. Two Ways to Implement: Method #1: The Automated Fix - Open your Cursor AI's .cursorrules file - Add: "ALWAYS insert debug statements if an error keeps recurring" - Let the AI automatically illuminate the path Method #2: The Manual Approach - Explicitly request debug statements from AI - Guide it to critical failure points - Maintain precise control over the debugging process Pro tip: Combine both methods for best results. Why use both?  Rules files lose effectiveness in longer conversations.  The manual approach gives you backup when that happens.  Double the visibility, double the success. Remember: You wouldn't search a dark room with your eyes closed. Don't let your AI debug that way either. — Enjoyed this? 2 quick things: - Follow along for more - Share with 2 teammates who need this P.S. The best insights go straight to your inbox (link in bio)