Aradhye.com

Agentic LLMs Can Ship Code, But Debugging Is Still Very Human

Yogiraj Aradhye -

Agent talk is everywhere. In client meetings and hallway conversations, the theme keeps coming up. Social media can make it feel like agents will soon be serving your next coffee. Maybe one day. Today, we are not there yet. Over the last few months, I have been experimenting heavily on a passion project and studying the inner workings through Purdue and Microsoft’s Applied Generative AI Specialization. What follows comes from wiring Claude, Gemini, and GPT into a real Python app that plans, acts, and reflects with tools and memory.

TL;DR

  • Great at: scaffolding new modules, wiring boilerplate, drafting first cut tests, stitching common patterns
  • Weak at: classic debugging; models hallucinate paths or data, patch the wrong spot, loop on the same failing tests, or generate duplicate code
  • Reality: without a human in the loop, bug fixes tend to thrash; use agents as fast copilots for creation and treat debugging as an engineering discipline where you apply models sparingly and surgically

What I Mean by Agentic LLM

Agents combine an LLM with planning, tool use, memory, and feedback loops. They do more than answer a prompt. They decide and they do.

Why Agent Loops Shine at New Code but Stumble on Debugging

Writing new code is pattern completion. Give a clear spec, such as build a FastAPI endpoint with JWT auth, and agents can plan, fetch snippets, and compose a working baseline for happy paths.

Debugging is a diagnosis under uncertainty. You need ground truth from runtime state, failing inputs, and logs. Root cause often hides at boundaries such as fixtures, environment variables, data shapes, and timeouts. Good fixes restore invariants across files and modules, and that work needs restraint and judgment.

Failure Modes I Saw in a Real App

  1. Hallucinated file paths and phantom tables where a fix referenced resources that did not exist.
  2. Patching the wrong place, such as editing a helper instead of the call site where the contract was broken.
  3. Duplicate code blocks even after clear instructions not to repeat a function.
  4. Test thrash where an environment or fixture issue led to minor rewrites that never addressed the cause; several times, the pragmatic move was to delete the test and rewrite it from the spec.
  5. Runaway loops where a function ended up calling itself because control flow was misread.

Takeaway: polished demos do not show these edges, real apps do.

A Human in the Loop Debugging Playbook

Use agents with a short leash and strong guardrails.

1) Reproduce and Minimize

  • Capture the exact failure, including command, input, stack trace, and logs.
  • Create the smallest repro file or failing test you can.
  • Keep the agent’s world small to reduce guessing.

2) Ask for Root Cause First

Prompt for analysis without a patch:

You are debugging a Python bug.
Given the failing test, stack trace, and code, do three things only:
1) Identify the most likely root cause and cite specific lines.
2) State the invariant that is currently broken in one sentence.
3) List the minimal change location as file and line to restore the invariant.
Do not write code yet.

3) Constrain the Edit

Once the diagnosis makes sense:

Produce a unified diff that changes one file only.
Keep edits under 25 lines.
Do not modify tests.
Include a two line rationale at the top of the diff.

If the test is the problem and is flaky or outdated, ask for a rewrite with justification:

Rewrite the failing test to reflect the intended contract.
Keep the test name stable.
Explain why the previous test failed including fixtures, data, or environment.
Make inputs deterministic and assertions explicit.

4) Verify Locally

  • Run the suite, type checks, lints, and any contract tests.
  • Inspect the diff for unrelated changes.
  • If it fails, iterate on diagnosis rather than random edits.

5) Document the Invariant

Add a short comment or docstring stating the invariant you restored so future maintainers and future agents have a clear breadcrumb.

Prompt and Policy Patterns That Reduce Chaos

  • Plan then patch, require a brief plan and an invariant statement before any code.
  • Single file diff only to prevent sweeping and brittle changes.
  • Impact analysis that lists affected callers and expected side effects.
  • Error first prompts that always include logs, trace, and the exact failing input.
  • Spec over vibes, decide explicitly whether tests or code are the source of truth, and do not let the agent decide silently.

System Design and Tooling That Help

  • Deterministic harness with fixed seeds, pinned dependencies, and stable fixtures.
  • Tight CI gates that block merges on coverage drop, new warnings, or widened types.
  • Small PRs by policy to make human review easier and model patches safer.
  • Static analysis and type hints to reduce the search space for the agent.
  • Diff review bots that flag unrelated or duplicated code in generated patches
  • Trace capture that persists failing inputs and stack traces, so you feed the same truth back to the agent

When to Rewrite Tests Versus Fix Code

  • Rewrite the test when it encodes an outdated contract, uses flaky timing or IO, or relies on incidental structure with no guarantee.
  • Fix the code when the test clearly expresses intended behavior and production logic drifted.
  • Do both when the spec evolved. Update the test to the new contract and patch the code to match, and include a migration note in the pull request.

Metrics That Keep Your Agent Honest

  • Mean time to fix for agent assisted pull requests versus human only baselines.
  • Reopen rate and revert rate for agent patches.
  • Test flakiness before and after policy changes.
  • Diff size and file count per fix since smaller is usually better.
  • Coverage trend and type error counts over time.

What This Means for Teams

Product leaders can expect acceleration in creation and exploratory coding. Do not plan on autonomous bug fixing without human capacity in the loop.
Tech leads should treat agents like junior developers who need crisp specs, guardrails, and reviews. Invest in determinism, test clarity, and telemetry.
Developers can use agents to scaffold and to propose minimal diffs while owning diagnosis, invariants, and final verification.

Closing

Agentic LLMs such as Claude, Gemini, and GPT turn ideas into working code quickly. Debugging remains deeply human and depends on evidence, invariants, and judgment. Keep a serious human in the loop, constrain edits, and demand explainability. You will get fast creation without shipping a brittle product. If your only exposure is playground demos, wire agents into a real app and a real test suite, and the lessons will arrive quickly and stick.