Using Claude Code for Python Development

Every lesson in the Python with AI section — Generation, Refactoring, Debugging, Documentation, Test Generation, Code Review, Performance Optimization — operated within the same conversational model: you provide context (pasted code, a traceback, a description), the assistant reasons about that provided text and responds, and you apply the result yourself. This model is genuinely powerful, but it has a specific structural limit: the assistant's knowledge of your actual system is bounded entirely by what you explicitly pasted into that specific conversation.

Agentic tools like Claude Code represent a structurally different collaboration model: rather than reasoning only about pasted text, an agent can directly *read* files from your actual repository, *execute* shell commands, and — critically — *run your actual test suite* and observe the real, genuine results, not a description or a guess about what those results might be. Asked to 'fix the failing test in test_orders.py', an agentic tool doesn't need you to paste the test, the function it tests, and the traceback — it reads all of that directly, runs pytest itself to see the actual current failure, proposes a change, and can run pytest again afterward to directly verify whether its own fix actually resolved the failure.

This closes a real gap the conversational model has: in the conversational model, verifying whether an AI-suggested fix actually works requires *you* to apply it and test it yourself, entirely after the conversation. In the agentic model, the tool itself can close that loop — propose, execute, observe the real result, and iterate — before ever presenting a result to you at all. This is a genuine, structural expansion of what's possible, not merely an incremental speed improvement on the conversational model.

The specific mechanism that makes agentic tool use meaningfully more powerful than the conversational model is the ability to close a feedback loop entirely within a single agentic session: propose a change, execute it, run the actual test suite to observe whether the change genuinely works, and — if it doesn't — iterate again based on that real, observed failure, repeating until the actual, verified result is achieved, or until the agent determines it needs your input to proceed further.

This directly mirrors, in an automated form, the exact human debugging and development workflow this curriculum has covered throughout its own sections — the Profiling lesson's 'measure, don't guess' discipline, the AI Debugging lesson's emphasis on actual tracebacks over paraphrased descriptions, the AI Test Generation lesson's warning against trusting a claim without verification — an agentic tool performing this loop itself means it's applying exactly this same discipline (propose, verify with real execution, iterate) autonomously, rather than requiring you to manually perform the verification step after every suggestion.

This is genuinely valuable specifically because it means an agentic tool's *final* proposed result, by the time it's presented to you, has often already been verified against your actual codebase's real behavior — a meaningfully stronger starting point than an unverified conversational suggestion. But — and this is the critical caveat the next section addresses — 'already verified by the agent's own test run' is not the same as 'reviewed and approved by you', and conflating the two is exactly the risk this lesson's discipline exists to prevent.

Greater agentic capability requires a correspondingly greater review discipline, not less — the fact that an agent has already run your test suite and observed a passing result doesn't mean the change is correct in every dimension that matters (architectural fit, following your project's actual conventions from earlier lessons in this curriculum, not introducing a security issue the test suite doesn't happen to cover) — it means specifically that the change passes the *tests that exist*, which is a real but bounded guarantee, not a comprehensive one.

git status and git diff, run after any agentic session, show precisely what files were actually touched and exactly what changed in each — the *actual* modification, not a natural-language summary of it. Reviewing this actual diff, file by file, mirrors precisely the same discipline this curriculum's AI Code Reviews lesson established for reviewing any AI-generated output: a confident, well-written summary of what happened is a *claim*, and the actual diff is the *ground truth* that claim needs to be checked against, exactly the same distinction that applies to reviewing a human colleague's pull request description versus their actual code changes.

This is the throughline connecting this lesson to everything the Python with AI section established: greater AI capability and greater apparent autonomy do not reduce the need for human review and verification — if anything, they raise the stakes of skipping it, since an agent that can directly modify your actual repository, not just suggest text in a chat window, has a correspondingly larger potential blast radius if its changes go unreviewed and turn out to be wrong in some dimension its own test run didn't happen to catch.

A chat assistant reasons about the code you paste it. An agentic tool reads your actual repository, runs your actual tests, and sees the actual results — a structurally different, more powerful, and differently-risky mode of collaboration.

A conversational assistant reasons about whatever code you paste it -- it has no independent access to your actual repository or its current, real state.

An agentic tool like Claude Code can directly read files, run shell commands, and execute your ACTUAL test suite -- then iterate based on REAL results, not just reasoning.

Checkpoint: What is the fundamental structural difference between a conversational assistant and an agentic tool like Claude Code?

• →An agentic tool can directly read files, run commands, and execute your actual test suite, iterating based on real results -- not just reasoning about text you've pasted into a conversation
• →The only difference is that agentic tools respond noticeably faster to the same kind of requests

This power requires a matching discipline: reviewing what the agent actually DID (via git diff), not just accepting a final summary of what it claims to have done.

Checkpoint: Why is reviewing git diff after an agentic session essential, even if the agent provides a confident summary of what it did?

• →A summary is a claim about what happened; git diff shows the ACTUAL changes made, which is what genuinely needs review -- exactly like reviewing any contributor's real changes, not just their description of them
• →Agent-provided summaries are typically inaccurate and should generally be disregarded entirely

Claude Code demonstrates agentic tool use directly; MCP is the next lesson, covering the protocol that lets agentic tools connect to external systems in a standardized way.

Run a Real Closed Feedback Loop. Finish run_until_tests_pass(): try, run the real tests, and keep iterating until they actually pass.